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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_pyLikelihood')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_pyLikelihood')
    _pyLikelihood = 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('_pyLikelihood', [dirname(__file__)])
        except ImportError:
            import _pyLikelihood
            return _pyLikelihood
        try:
            _mod = imp.load_module('_pyLikelihood', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _pyLikelihood = swig_import_helper()
    del swig_import_helper
else:
    import _pyLikelihood
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__ = _pyLikelihood.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        this = _pyLikelihood.new_IntPair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _pyLikelihood.IntPair_first_set
    __swig_getmethods__["first"] = _pyLikelihood.IntPair_first_get
    if _newclass:
        first = _swig_property(_pyLikelihood.IntPair_first_get, _pyLikelihood.IntPair_first_set)
    __swig_setmethods__["second"] = _pyLikelihood.IntPair_second_set
    __swig_getmethods__["second"] = _pyLikelihood.IntPair_second_get
    if _newclass:
        second = _swig_property(_pyLikelihood.IntPair_second_get, _pyLikelihood.IntPair_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__ = _pyLikelihood.delete_IntPair
    __del__ = lambda self: None
IntPair_swigregister = _pyLikelihood.IntPair_swigregister
IntPair_swigregister(IntPair)

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

    def iterator(self):
        return _pyLikelihood.EventVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyLikelihood.EventVector___nonzero__(self)

    def __bool__(self):
        return _pyLikelihood.EventVector___bool__(self)

    def __len__(self):
        return _pyLikelihood.EventVector___len__(self)

    def __getslice__(self, i, j):
        return _pyLikelihood.EventVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyLikelihood.EventVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyLikelihood.EventVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyLikelihood.EventVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyLikelihood.EventVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyLikelihood.EventVector___setitem__(self, *args)

    def pop(self):
        return _pyLikelihood.EventVector_pop(self)

    def append(self, x):
        return _pyLikelihood.EventVector_append(self, x)

    def empty(self):
        return _pyLikelihood.EventVector_empty(self)

    def size(self):
        return _pyLikelihood.EventVector_size(self)

    def swap(self, v):
        return _pyLikelihood.EventVector_swap(self, v)

    def begin(self):
        return _pyLikelihood.EventVector_begin(self)

    def end(self):
        return _pyLikelihood.EventVector_end(self)

    def rbegin(self):
        return _pyLikelihood.EventVector_rbegin(self)

    def rend(self):
        return _pyLikelihood.EventVector_rend(self)

    def clear(self):
        return _pyLikelihood.EventVector_clear(self)

    def get_allocator(self):
        return _pyLikelihood.EventVector_get_allocator(self)

    def pop_back(self):
        return _pyLikelihood.EventVector_pop_back(self)

    def erase(self, *args):
        return _pyLikelihood.EventVector_erase(self, *args)

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

    def push_back(self, x):
        return _pyLikelihood.EventVector_push_back(self, x)

    def front(self):
        return _pyLikelihood.EventVector_front(self)

    def back(self):
        return _pyLikelihood.EventVector_back(self)

    def assign(self, n, x):
        return _pyLikelihood.EventVector_assign(self, n, x)

    def resize(self, *args):
        return _pyLikelihood.EventVector_resize(self, *args)

    def insert(self, *args):
        return _pyLikelihood.EventVector_insert(self, *args)

    def reserve(self, n):
        return _pyLikelihood.EventVector_reserve(self, n)

    def capacity(self):
        return _pyLikelihood.EventVector_capacity(self)
    __swig_destroy__ = _pyLikelihood.delete_EventVector
    __del__ = lambda self: None
EventVector_swigregister = _pyLikelihood.EventVector_swigregister
EventVector_swigregister(EventVector)

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

    def iterator(self):
        return _pyLikelihood.BoolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyLikelihood.BoolVector___nonzero__(self)

    def __bool__(self):
        return _pyLikelihood.BoolVector___bool__(self)

    def __len__(self):
        return _pyLikelihood.BoolVector___len__(self)

    def __getslice__(self, i, j):
        return _pyLikelihood.BoolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyLikelihood.BoolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyLikelihood.BoolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyLikelihood.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyLikelihood.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyLikelihood.BoolVector___setitem__(self, *args)

    def pop(self):
        return _pyLikelihood.BoolVector_pop(self)

    def append(self, x):
        return _pyLikelihood.BoolVector_append(self, x)

    def empty(self):
        return _pyLikelihood.BoolVector_empty(self)

    def size(self):
        return _pyLikelihood.BoolVector_size(self)

    def swap(self, v):
        return _pyLikelihood.BoolVector_swap(self, v)

    def begin(self):
        return _pyLikelihood.BoolVector_begin(self)

    def end(self):
        return _pyLikelihood.BoolVector_end(self)

    def rbegin(self):
        return _pyLikelihood.BoolVector_rbegin(self)

    def rend(self):
        return _pyLikelihood.BoolVector_rend(self)

    def clear(self):
        return _pyLikelihood.BoolVector_clear(self)

    def get_allocator(self):
        return _pyLikelihood.BoolVector_get_allocator(self)

    def pop_back(self):
        return _pyLikelihood.BoolVector_pop_back(self)

    def erase(self, *args):
        return _pyLikelihood.BoolVector_erase(self, *args)

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

    def push_back(self, x):
        return _pyLikelihood.BoolVector_push_back(self, x)

    def front(self):
        return _pyLikelihood.BoolVector_front(self)

    def back(self):
        return _pyLikelihood.BoolVector_back(self)

    def assign(self, n, x):
        return _pyLikelihood.BoolVector_assign(self, n, x)

    def resize(self, *args):
        return _pyLikelihood.BoolVector_resize(self, *args)

    def insert(self, *args):
        return _pyLikelihood.BoolVector_insert(self, *args)

    def reserve(self, n):
        return _pyLikelihood.BoolVector_reserve(self, n)

    def capacity(self):
        return _pyLikelihood.BoolVector_capacity(self)
    __swig_destroy__ = _pyLikelihood.delete_BoolVector
    __del__ = lambda self: None
BoolVector_swigregister = _pyLikelihood.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 _pyLikelihood.FloatVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def iterator(self):
        return _pyLikelihood.DoubleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyLikelihood.DoubleVectorVector___nonzero__(self)

    def __bool__(self):
        return _pyLikelihood.DoubleVectorVector___bool__(self)

    def __len__(self):
        return _pyLikelihood.DoubleVectorVector___len__(self)

    def __getslice__(self, i, j):
        return _pyLikelihood.DoubleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyLikelihood.DoubleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyLikelihood.DoubleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyLikelihood.DoubleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyLikelihood.DoubleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyLikelihood.DoubleVectorVector___setitem__(self, *args)

    def pop(self):
        return _pyLikelihood.DoubleVectorVector_pop(self)

    def append(self, x):
        return _pyLikelihood.DoubleVectorVector_append(self, x)

    def empty(self):
        return _pyLikelihood.DoubleVectorVector_empty(self)

    def size(self):
        return _pyLikelihood.DoubleVectorVector_size(self)

    def swap(self, v):
        return _pyLikelihood.DoubleVectorVector_swap(self, v)

    def begin(self):
        return _pyLikelihood.DoubleVectorVector_begin(self)

    def end(self):
        return _pyLikelihood.DoubleVectorVector_end(self)

    def rbegin(self):
        return _pyLikelihood.DoubleVectorVector_rbegin(self)

    def rend(self):
        return _pyLikelihood.DoubleVectorVector_rend(self)

    def clear(self):
        return _pyLikelihood.DoubleVectorVector_clear(self)

    def get_allocator(self):
        return _pyLikelihood.DoubleVectorVector_get_allocator(self)

    def pop_back(self):
        return _pyLikelihood.DoubleVectorVector_pop_back(self)

    def erase(self, *args):
        return _pyLikelihood.DoubleVectorVector_erase(self, *args)

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

    def push_back(self, x):
        return _pyLikelihood.DoubleVectorVector_push_back(self, x)

    def front(self):
        return _pyLikelihood.DoubleVectorVector_front(self)

    def back(self):
        return _pyLikelihood.DoubleVectorVector_back(self)

    def assign(self, n, x):
        return _pyLikelihood.DoubleVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _pyLikelihood.DoubleVectorVector_resize(self, *args)

    def insert(self, *args):
        return _pyLikelihood.DoubleVectorVector_insert(self, *args)

    def reserve(self, n):
        return _pyLikelihood.DoubleVectorVector_reserve(self, n)

    def capacity(self):
        return _pyLikelihood.DoubleVectorVector_capacity(self)
    __swig_destroy__ = _pyLikelihood.delete_DoubleVectorVector
    __del__ = lambda self: None
DoubleVectorVector_swigregister = _pyLikelihood.DoubleVectorVector_swigregister
DoubleVectorVector_swigregister(DoubleVectorVector)

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

    def iterator(self):
        return _pyLikelihood.DoubleVectorPair_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyLikelihood.DoubleVectorPair___nonzero__(self)

    def __bool__(self):
        return _pyLikelihood.DoubleVectorPair___bool__(self)

    def __len__(self):
        return _pyLikelihood.DoubleVectorPair___len__(self)

    def __getslice__(self, i, j):
        return _pyLikelihood.DoubleVectorPair___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyLikelihood.DoubleVectorPair___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyLikelihood.DoubleVectorPair___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyLikelihood.DoubleVectorPair___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyLikelihood.DoubleVectorPair___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyLikelihood.DoubleVectorPair___setitem__(self, *args)

    def pop(self):
        return _pyLikelihood.DoubleVectorPair_pop(self)

    def append(self, x):
        return _pyLikelihood.DoubleVectorPair_append(self, x)

    def empty(self):
        return _pyLikelihood.DoubleVectorPair_empty(self)

    def size(self):
        return _pyLikelihood.DoubleVectorPair_size(self)

    def swap(self, v):
        return _pyLikelihood.DoubleVectorPair_swap(self, v)

    def begin(self):
        return _pyLikelihood.DoubleVectorPair_begin(self)

    def end(self):
        return _pyLikelihood.DoubleVectorPair_end(self)

    def rbegin(self):
        return _pyLikelihood.DoubleVectorPair_rbegin(self)

    def rend(self):
        return _pyLikelihood.DoubleVectorPair_rend(self)

    def clear(self):
        return _pyLikelihood.DoubleVectorPair_clear(self)

    def get_allocator(self):
        return _pyLikelihood.DoubleVectorPair_get_allocator(self)

    def pop_back(self):
        return _pyLikelihood.DoubleVectorPair_pop_back(self)

    def erase(self, *args):
        return _pyLikelihood.DoubleVectorPair_erase(self, *args)

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

    def push_back(self, x):
        return _pyLikelihood.DoubleVectorPair_push_back(self, x)

    def front(self):
        return _pyLikelihood.DoubleVectorPair_front(self)

    def back(self):
        return _pyLikelihood.DoubleVectorPair_back(self)

    def assign(self, n, x):
        return _pyLikelihood.DoubleVectorPair_assign(self, n, x)

    def resize(self, *args):
        return _pyLikelihood.DoubleVectorPair_resize(self, *args)

    def insert(self, *args):
        return _pyLikelihood.DoubleVectorPair_insert(self, *args)

    def reserve(self, n):
        return _pyLikelihood.DoubleVectorPair_reserve(self, n)

    def capacity(self):
        return _pyLikelihood.DoubleVectorPair_capacity(self)
    __swig_destroy__ = _pyLikelihood.delete_DoubleVectorPair
    __del__ = lambda self: None
DoubleVectorPair_swigregister = _pyLikelihood.DoubleVectorPair_swigregister
DoubleVectorPair_swigregister(DoubleVectorPair)

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

    def iterator(self):
        return _pyLikelihood.FloatVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyLikelihood.FloatVectorVector___nonzero__(self)

    def __bool__(self):
        return _pyLikelihood.FloatVectorVector___bool__(self)

    def __len__(self):
        return _pyLikelihood.FloatVectorVector___len__(self)

    def __getslice__(self, i, j):
        return _pyLikelihood.FloatVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyLikelihood.FloatVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyLikelihood.FloatVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyLikelihood.FloatVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyLikelihood.FloatVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyLikelihood.FloatVectorVector___setitem__(self, *args)

    def pop(self):
        return _pyLikelihood.FloatVectorVector_pop(self)

    def append(self, x):
        return _pyLikelihood.FloatVectorVector_append(self, x)

    def empty(self):
        return _pyLikelihood.FloatVectorVector_empty(self)

    def size(self):
        return _pyLikelihood.FloatVectorVector_size(self)

    def swap(self, v):
        return _pyLikelihood.FloatVectorVector_swap(self, v)

    def begin(self):
        return _pyLikelihood.FloatVectorVector_begin(self)

    def end(self):
        return _pyLikelihood.FloatVectorVector_end(self)

    def rbegin(self):
        return _pyLikelihood.FloatVectorVector_rbegin(self)

    def rend(self):
        return _pyLikelihood.FloatVectorVector_rend(self)

    def clear(self):
        return _pyLikelihood.FloatVectorVector_clear(self)

    def get_allocator(self):
        return _pyLikelihood.FloatVectorVector_get_allocator(self)

    def pop_back(self):
        return _pyLikelihood.FloatVectorVector_pop_back(self)

    def erase(self, *args):
        return _pyLikelihood.FloatVectorVector_erase(self, *args)

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

    def push_back(self, x):
        return _pyLikelihood.FloatVectorVector_push_back(self, x)

    def front(self):
        return _pyLikelihood.FloatVectorVector_front(self)

    def back(self):
        return _pyLikelihood.FloatVectorVector_back(self)

    def assign(self, n, x):
        return _pyLikelihood.FloatVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _pyLikelihood.FloatVectorVector_resize(self, *args)

    def insert(self, *args):
        return _pyLikelihood.FloatVectorVector_insert(self, *args)

    def reserve(self, n):
        return _pyLikelihood.FloatVectorVector_reserve(self, n)

    def capacity(self):
        return _pyLikelihood.FloatVectorVector_capacity(self)
    __swig_destroy__ = _pyLikelihood.delete_FloatVectorVector
    __del__ = lambda self: None
FloatVectorVector_swigregister = _pyLikelihood.FloatVectorVector_swigregister
FloatVectorVector_swigregister(FloatVectorVector)

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

    def iterator(self):
        return _pyLikelihood.SizetVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyLikelihood.SizetVector___nonzero__(self)

    def __bool__(self):
        return _pyLikelihood.SizetVector___bool__(self)

    def __len__(self):
        return _pyLikelihood.SizetVector___len__(self)

    def __getslice__(self, i, j):
        return _pyLikelihood.SizetVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyLikelihood.SizetVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyLikelihood.SizetVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyLikelihood.SizetVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyLikelihood.SizetVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyLikelihood.SizetVector___setitem__(self, *args)

    def pop(self):
        return _pyLikelihood.SizetVector_pop(self)

    def append(self, x):
        return _pyLikelihood.SizetVector_append(self, x)

    def empty(self):
        return _pyLikelihood.SizetVector_empty(self)

    def size(self):
        return _pyLikelihood.SizetVector_size(self)

    def swap(self, v):
        return _pyLikelihood.SizetVector_swap(self, v)

    def begin(self):
        return _pyLikelihood.SizetVector_begin(self)

    def end(self):
        return _pyLikelihood.SizetVector_end(self)

    def rbegin(self):
        return _pyLikelihood.SizetVector_rbegin(self)

    def rend(self):
        return _pyLikelihood.SizetVector_rend(self)

    def clear(self):
        return _pyLikelihood.SizetVector_clear(self)

    def get_allocator(self):
        return _pyLikelihood.SizetVector_get_allocator(self)

    def pop_back(self):
        return _pyLikelihood.SizetVector_pop_back(self)

    def erase(self, *args):
        return _pyLikelihood.SizetVector_erase(self, *args)

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

    def push_back(self, x):
        return _pyLikelihood.SizetVector_push_back(self, x)

    def front(self):
        return _pyLikelihood.SizetVector_front(self)

    def back(self):
        return _pyLikelihood.SizetVector_back(self)

    def assign(self, n, x):
        return _pyLikelihood.SizetVector_assign(self, n, x)

    def resize(self, *args):
        return _pyLikelihood.SizetVector_resize(self, *args)

    def insert(self, *args):
        return _pyLikelihood.SizetVector_insert(self, *args)

    def reserve(self, n):
        return _pyLikelihood.SizetVector_reserve(self, n)

    def capacity(self):
        return _pyLikelihood.SizetVector_capacity(self)
    __swig_destroy__ = _pyLikelihood.delete_SizetVector
    __del__ = lambda self: None
SizetVector_swigregister = _pyLikelihood.SizetVector_swigregister
SizetVector_swigregister(SizetVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        this = _pyLikelihood.new_AppParGroup(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_AppParGroup
    __del__ = lambda self: None

    def Prompt(self, *args):
        return _pyLikelihood.AppParGroup_Prompt(self, *args)

    def getPromptMode(self):
        return _pyLikelihood.AppParGroup_getPromptMode(self)

    def setPromptMode(self, prompt_mode=True):
        return _pyLikelihood.AppParGroup_setPromptMode(self, prompt_mode)

    def isSwitch(self, par_name):
        return _pyLikelihood.AppParGroup_isSwitch(self, par_name)

    def getCase(self, par_name, case_cont):
        return _pyLikelihood.AppParGroup_getCase(self, par_name, case_cont)

    def setSwitch(self, switch_name):
        return _pyLikelihood.AppParGroup_setSwitch(self, switch_name)

    def setCase(self, switch_name, case_name, par_name):
        return _pyLikelihood.AppParGroup_setCase(self, switch_name, case_name, par_name)

    def __getitem__(self, parname):
        """__getitem__(AppParGroup self, std::string const & parname) -> std::string"""
        return _pyLikelihood.AppParGroup___getitem__(self, parname)


    def getDouble(self, parname):
        """getDouble(AppParGroup self, std::string const & parname) -> double"""
        return _pyLikelihood.AppParGroup_getDouble(self, parname)


    def getInt(self, parname):
        """getInt(AppParGroup self, std::string const & parname) -> int"""
        return _pyLikelihood.AppParGroup_getInt(self, parname)


    def getBool(self, parname):
        """getBool(AppParGroup self, std::string const & parname) -> bool"""
        return _pyLikelihood.AppParGroup_getBool(self, parname)


    def Save(self):
        """Save(AppParGroup self)"""
        return _pyLikelihood.AppParGroup_Save(self)

AppParGroup_swigregister = _pyLikelihood.AppParGroup_swigregister
AppParGroup_swigregister(AppParGroup)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    if _newclass:
        processCommandLine = staticmethod(_pyLikelihood.StApp_processCommandLine)
    else:
        processCommandLine = _pyLikelihood.StApp_processCommandLine
    if _newclass:
        getArgc = staticmethod(_pyLikelihood.StApp_getArgc)
    else:
        getArgc = _pyLikelihood.StApp_getArgc
    if _newclass:
        getArgv = staticmethod(_pyLikelihood.StApp_getArgv)
    else:
        getArgv = _pyLikelihood.StApp_getArgv
    __swig_destroy__ = _pyLikelihood.delete_StApp
    __del__ = lambda self: None

    def run(self):
        return _pyLikelihood.StApp_run(self)

    def runGui(self):
        return _pyLikelihood.StApp_runGui(self)

    def getParGroup(self, *args):
        return _pyLikelihood.StApp_getParGroup(self, *args)

    def banner(self):
        return _pyLikelihood.StApp_banner(self)

    def getName(self):
        return _pyLikelihood.StApp_getName(self)

    def getVersion(self):
        return _pyLikelihood.StApp_getVersion(self)

    def setName(self, name):
        return _pyLikelihood.StApp_setName(self, name)

    def setVersion(self, version):
        return _pyLikelihood.StApp_setVersion(self, version)

    def getPlotFrame(self, title):
        return _pyLikelihood.StApp_getPlotFrame(self, title)

    def parGroup(appName):
        """parGroup(std::string const & appName) -> AppParGroup"""
        return _pyLikelihood.StApp_parGroup(appName)

    parGroup = staticmethod(parGroup)
StApp_swigregister = _pyLikelihood.StApp_swigregister
StApp_swigregister(StApp)

def StApp_processCommandLine(argc, argv):
    return _pyLikelihood.StApp_processCommandLine(argc, argv)
StApp_processCommandLine = _pyLikelihood.StApp_processCommandLine

def StApp_getArgc():
    return _pyLikelihood.StApp_getArgc()
StApp_getArgc = _pyLikelihood.StApp_getArgc

def StApp_getArgv():
    return _pyLikelihood.StApp_getArgv()
StApp_getArgv = _pyLikelihood.StApp_getArgv

def StApp_parGroup(appName):
    """StApp_parGroup(std::string const & appName) -> AppParGroup"""
    return _pyLikelihood.StApp_parGroup(appName)

ASTRO_D2R = _pyLikelihood.ASTRO_D2R
ASTRO_R2D = _pyLikelihood.ASTRO_R2D
ASTRO_PIOVER2 = _pyLikelihood.ASTRO_PIOVER2
ASTRO_4PI = _pyLikelihood.ASTRO_4PI

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def dot(self, other):
        return _pyLikelihood.SkyDir_dot(self, other)
    __swig_destroy__ = _pyLikelihood.delete_SkyDir
    __del__ = lambda self: None
SkyDir_swigregister = _pyLikelihood.SkyDir_swigregister
SkyDir_swigregister(SkyDir)

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 _pyLikelihood.JulianDate_getGregorianDate(self, *args)

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

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

def JulianDate_missionStart():
    return _pyLikelihood.JulianDate_missionStart()
JulianDate_missionStart = _pyLikelihood.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 = _pyLikelihood.SolarSystem_MERCURY
    VENUS = _pyLikelihood.SolarSystem_VENUS
    EARTH = _pyLikelihood.SolarSystem_EARTH
    MARS = _pyLikelihood.SolarSystem_MARS
    JUPITER = _pyLikelihood.SolarSystem_JUPITER
    SATURN = _pyLikelihood.SolarSystem_SATURN
    URANUS = _pyLikelihood.SolarSystem_URANUS
    NEPTUNE = _pyLikelihood.SolarSystem_NEPTUNE
    PLUTO = _pyLikelihood.SolarSystem_PLUTO
    MOON = _pyLikelihood.SolarSystem_MOON
    SUN = _pyLikelihood.SolarSystem_SUN

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

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

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

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

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

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

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 _pyLikelihood.SkyDirVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        this = _pyLikelihood.new_SkyDirPair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _pyLikelihood.SkyDirPair_first_set
    __swig_getmethods__["first"] = _pyLikelihood.SkyDirPair_first_get
    if _newclass:
        first = _swig_property(_pyLikelihood.SkyDirPair_first_get, _pyLikelihood.SkyDirPair_first_set)
    __swig_setmethods__["second"] = _pyLikelihood.SkyDirPair_second_set
    __swig_getmethods__["second"] = _pyLikelihood.SkyDirPair_second_get
    if _newclass:
        second = _swig_property(_pyLikelihood.SkyDirPair_second_get, _pyLikelihood.SkyDirPair_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__ = _pyLikelihood.delete_SkyDirPair
    __del__ = lambda self: None
SkyDirPair_swigregister = _pyLikelihood.SkyDirPair_swigregister
SkyDirPair_swigregister(SkyDirPair)

class CutBase(_object):
    """Proxy of C++ dataSubselector::CutBase class."""

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

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

    def accept(self, *args):
        """
        accept(CutBase self, tip::ConstTableRecord & row) -> bool
        accept(CutBase self, std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > const & params) -> bool
        """
        return _pyLikelihood.CutBase_accept(self, *args)


    def clone(self):
        """clone(CutBase self) -> CutBase"""
        return _pyLikelihood.CutBase_clone(self)


    def __eq__(self, rhs):
        """__eq__(CutBase self, CutBase rhs) -> bool"""
        return _pyLikelihood.CutBase___eq__(self, rhs)


    def type(self):
        """type(CutBase self) -> std::string const &"""
        return _pyLikelihood.CutBase_type(self)


    def writeCut(self, stream, keynum):
        """writeCut(CutBase self, std::ostream & stream, unsigned int keynum)"""
        return _pyLikelihood.CutBase_writeCut(self, stream, keynum)


    def writeDssKeywords(self, header, keynum):
        """writeDssKeywords(CutBase self, tip::Header & header, unsigned int keynum)"""
        return _pyLikelihood.CutBase_writeDssKeywords(self, header, keynum)


    def supercedes(self, arg2):
        """supercedes(CutBase self, CutBase arg2) -> bool"""
        return _pyLikelihood.CutBase_supercedes(self, arg2)


    def filterString(self):
        """filterString(CutBase self) -> std::string"""
        return _pyLikelihood.CutBase_filterString(self)

CutBase_swigregister = _pyLikelihood.CutBase_swigregister
CutBase_swigregister(CutBase)

class BitMaskCut(CutBase):
    """Proxy of C++ dataSubselector::BitMaskCut class."""

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

    def __init__(self, *args):
        """
        __init__(dataSubselector::BitMaskCut self, std::string const & colname, unsigned int mask, std::string const & pass_ver) -> BitMaskCut
        __init__(dataSubselector::BitMaskCut self, std::string const & colname, unsigned int mask) -> BitMaskCut
        """
        this = _pyLikelihood.new_BitMaskCut(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_BitMaskCut
    __del__ = lambda self: None

    def accept(self, *args):
        """
        accept(BitMaskCut self, tip::ConstTableRecord & row) -> bool
        accept(BitMaskCut self, std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > const & params) -> bool
        """
        return _pyLikelihood.BitMaskCut_accept(self, *args)


    def clone(self):
        """clone(BitMaskCut self) -> CutBase"""
        return _pyLikelihood.BitMaskCut_clone(self)


    def supercedes(self, cut):
        """supercedes(BitMaskCut self, CutBase cut) -> bool"""
        return _pyLikelihood.BitMaskCut_supercedes(self, cut)


    def filterString(self):
        """filterString(BitMaskCut self) -> std::string"""
        return _pyLikelihood.BitMaskCut_filterString(self)


    def colname(self):
        """colname(BitMaskCut self) -> std::string const &"""
        return _pyLikelihood.BitMaskCut_colname(self)


    def mask(self):
        """mask(BitMaskCut self) -> unsigned int"""
        return _pyLikelihood.BitMaskCut_mask(self)


    def pass_ver(self):
        """pass_ver(BitMaskCut self) -> std::string const &"""
        return _pyLikelihood.BitMaskCut_pass_ver(self)


    def dstype(self):
        """dstype(BitMaskCut self) -> std::string"""
        return _pyLikelihood.BitMaskCut_dstype(self)


    def post_P7(pass_ver):
        """post_P7(std::string const & pass_ver) -> bool"""
        return _pyLikelihood.BitMaskCut_post_P7(pass_ver)

    post_P7 = staticmethod(post_P7)

    def setValidityMasks(evclassFile, evtypeFile):
        """setValidityMasks(std::string const & evclassFile, std::string const & evtypeFile)"""
        return _pyLikelihood.BitMaskCut_setValidityMasks(evclassFile, evtypeFile)

    setValidityMasks = staticmethod(setValidityMasks)

    def evclassValidityMasks():
        """evclassValidityMasks() -> void const *"""
        return _pyLikelihood.BitMaskCut_evclassValidityMasks()

    evclassValidityMasks = staticmethod(evclassValidityMasks)

    def evtypeValidityMasks():
        """evtypeValidityMasks() -> void const *"""
        return _pyLikelihood.BitMaskCut_evtypeValidityMasks()

    evtypeValidityMasks = staticmethod(evtypeValidityMasks)
BitMaskCut_swigregister = _pyLikelihood.BitMaskCut_swigregister
BitMaskCut_swigregister(BitMaskCut)

def BitMaskCut_post_P7(pass_ver):
    """BitMaskCut_post_P7(std::string const & pass_ver) -> bool"""
    return _pyLikelihood.BitMaskCut_post_P7(pass_ver)

def BitMaskCut_setValidityMasks(evclassFile, evtypeFile):
    """BitMaskCut_setValidityMasks(std::string const & evclassFile, std::string const & evtypeFile)"""
    return _pyLikelihood.BitMaskCut_setValidityMasks(evclassFile, evtypeFile)

def BitMaskCut_evclassValidityMasks():
    """BitMaskCut_evclassValidityMasks() -> void const *"""
    return _pyLikelihood.BitMaskCut_evclassValidityMasks()

def BitMaskCut_evtypeValidityMasks():
    """BitMaskCut_evtypeValidityMasks() -> void const *"""
    return _pyLikelihood.BitMaskCut_evtypeValidityMasks()

class BitMaskCutVector(_object):
    """Proxy of C++ std::vector<(p.dataSubselector::BitMaskCut)> class."""

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

    def iterator(self):
        """iterator(BitMaskCutVector self) -> SwigPyIterator"""
        return _pyLikelihood.BitMaskCutVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(BitMaskCutVector self) -> bool"""
        return _pyLikelihood.BitMaskCutVector___nonzero__(self)


    def __bool__(self):
        """__bool__(BitMaskCutVector self) -> bool"""
        return _pyLikelihood.BitMaskCutVector___bool__(self)


    def __len__(self):
        """__len__(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::size_type"""
        return _pyLikelihood.BitMaskCutVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::difference_type i, std::vector< dataSubselector::BitMaskCut * >::difference_type j) -> BitMaskCutVector"""
        return _pyLikelihood.BitMaskCutVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::difference_type i, std::vector< dataSubselector::BitMaskCut * >::difference_type j)
        __setslice__(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::difference_type i, std::vector< dataSubselector::BitMaskCut * >::difference_type j, BitMaskCutVector v)
        """
        return _pyLikelihood.BitMaskCutVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::difference_type i, std::vector< dataSubselector::BitMaskCut * >::difference_type j)"""
        return _pyLikelihood.BitMaskCutVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::difference_type i)
        __delitem__(BitMaskCutVector self, PySliceObject * slice)
        """
        return _pyLikelihood.BitMaskCutVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(BitMaskCutVector self, PySliceObject * slice) -> BitMaskCutVector
        __getitem__(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::difference_type i) -> BitMaskCut
        """
        return _pyLikelihood.BitMaskCutVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(BitMaskCutVector self, PySliceObject * slice, BitMaskCutVector v)
        __setitem__(BitMaskCutVector self, PySliceObject * slice)
        __setitem__(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::difference_type i, BitMaskCut x)
        """
        return _pyLikelihood.BitMaskCutVector___setitem__(self, *args)


    def pop(self):
        """pop(BitMaskCutVector self) -> BitMaskCut"""
        return _pyLikelihood.BitMaskCutVector_pop(self)


    def append(self, x):
        """append(BitMaskCutVector self, BitMaskCut x)"""
        return _pyLikelihood.BitMaskCutVector_append(self, x)


    def empty(self):
        """empty(BitMaskCutVector self) -> bool"""
        return _pyLikelihood.BitMaskCutVector_empty(self)


    def size(self):
        """size(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::size_type"""
        return _pyLikelihood.BitMaskCutVector_size(self)


    def swap(self, v):
        """swap(BitMaskCutVector self, BitMaskCutVector v)"""
        return _pyLikelihood.BitMaskCutVector_swap(self, v)


    def begin(self):
        """begin(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::iterator"""
        return _pyLikelihood.BitMaskCutVector_begin(self)


    def end(self):
        """end(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::iterator"""
        return _pyLikelihood.BitMaskCutVector_end(self)


    def rbegin(self):
        """rbegin(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::reverse_iterator"""
        return _pyLikelihood.BitMaskCutVector_rbegin(self)


    def rend(self):
        """rend(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::reverse_iterator"""
        return _pyLikelihood.BitMaskCutVector_rend(self)


    def clear(self):
        """clear(BitMaskCutVector self)"""
        return _pyLikelihood.BitMaskCutVector_clear(self)


    def get_allocator(self):
        """get_allocator(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::allocator_type"""
        return _pyLikelihood.BitMaskCutVector_get_allocator(self)


    def pop_back(self):
        """pop_back(BitMaskCutVector self)"""
        return _pyLikelihood.BitMaskCutVector_pop_back(self)


    def erase(self, *args):
        """
        erase(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::iterator pos) -> std::vector< dataSubselector::BitMaskCut * >::iterator
        erase(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::iterator first, std::vector< dataSubselector::BitMaskCut * >::iterator last) -> std::vector< dataSubselector::BitMaskCut * >::iterator
        """
        return _pyLikelihood.BitMaskCutVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.dataSubselector::BitMaskCut)> self) -> BitMaskCutVector
        __init__(std::vector<(p.dataSubselector::BitMaskCut)> self, BitMaskCutVector arg2) -> BitMaskCutVector
        __init__(std::vector<(p.dataSubselector::BitMaskCut)> self, std::vector< dataSubselector::BitMaskCut * >::size_type size) -> BitMaskCutVector
        __init__(std::vector<(p.dataSubselector::BitMaskCut)> self, std::vector< dataSubselector::BitMaskCut * >::size_type size, BitMaskCut value) -> BitMaskCutVector
        """
        this = _pyLikelihood.new_BitMaskCutVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(BitMaskCutVector self, BitMaskCut x)"""
        return _pyLikelihood.BitMaskCutVector_push_back(self, x)


    def front(self):
        """front(BitMaskCutVector self) -> BitMaskCut"""
        return _pyLikelihood.BitMaskCutVector_front(self)


    def back(self):
        """back(BitMaskCutVector self) -> BitMaskCut"""
        return _pyLikelihood.BitMaskCutVector_back(self)


    def assign(self, n, x):
        """assign(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::size_type n, BitMaskCut x)"""
        return _pyLikelihood.BitMaskCutVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::size_type new_size)
        resize(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::size_type new_size, BitMaskCut x)
        """
        return _pyLikelihood.BitMaskCutVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::iterator pos, BitMaskCut x) -> std::vector< dataSubselector::BitMaskCut * >::iterator
        insert(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::iterator pos, std::vector< dataSubselector::BitMaskCut * >::size_type n, BitMaskCut x)
        """
        return _pyLikelihood.BitMaskCutVector_insert(self, *args)


    def reserve(self, n):
        """reserve(BitMaskCutVector self, std::vector< dataSubselector::BitMaskCut * >::size_type n)"""
        return _pyLikelihood.BitMaskCutVector_reserve(self, n)


    def capacity(self):
        """capacity(BitMaskCutVector self) -> std::vector< dataSubselector::BitMaskCut * >::size_type"""
        return _pyLikelihood.BitMaskCutVector_capacity(self)

    __swig_destroy__ = _pyLikelihood.delete_BitMaskCutVector
    __del__ = lambda self: None
BitMaskCutVector_swigregister = _pyLikelihood.BitMaskCutVector_swigregister
BitMaskCutVector_swigregister(BitMaskCutVector)

class Cuts(_object):
    """Proxy of C++ dataSubselector::Cuts class."""

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

    def __init__(self, *args):
        """
        __init__(dataSubselector::Cuts self) -> Cuts
        __init__(dataSubselector::Cuts self, std::string const & eventFile, std::string const & extension, bool check_columns=True, bool skipTimeRangeCuts=False, bool skipEventClassCuts=False) -> Cuts
        __init__(dataSubselector::Cuts self, std::string const & eventFile, std::string const & extension, bool check_columns=True, bool skipTimeRangeCuts=False) -> Cuts
        __init__(dataSubselector::Cuts self, std::string const & eventFile, std::string const & extension, bool check_columns=True) -> Cuts
        __init__(dataSubselector::Cuts self, std::string const & eventFile, std::string const & extension) -> Cuts
        __init__(dataSubselector::Cuts self, StringVector eventFiles, std::string const & extension, bool check_columns=True, bool skipTimeRangeCuts=False, bool skipEventClassCuts=False) -> Cuts
        __init__(dataSubselector::Cuts self, StringVector eventFiles, std::string const & extension, bool check_columns=True, bool skipTimeRangeCuts=False) -> Cuts
        __init__(dataSubselector::Cuts self, StringVector eventFiles, std::string const & extension, bool check_columns=True) -> Cuts
        __init__(dataSubselector::Cuts self, StringVector eventFiles, std::string const & extension) -> Cuts
        __init__(dataSubselector::Cuts self, Cuts rhs) -> Cuts
        """
        this = _pyLikelihood.new_Cuts(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Cuts
    __del__ = lambda self: None

    def irfName(self):
        """irfName(Cuts self) -> std::string const &"""
        return _pyLikelihood.Cuts_irfName(self)


    def CALDB_implied_irfs(self):
        """CALDB_implied_irfs(Cuts self) -> std::string"""
        return _pyLikelihood.Cuts_CALDB_implied_irfs(self)


    def append_event_type_partition(self, irfs_name):
        """append_event_type_partition(Cuts self, std::string & irfs_name)"""
        return _pyLikelihood.Cuts_append_event_type_partition(self, irfs_name)


    def bitMaskCut(self, *args):
        """
        bitMaskCut(Cuts self, std::string const & colname) -> BitMaskCut
        bitMaskCut(Cuts self) -> BitMaskCut
        """
        return _pyLikelihood.Cuts_bitMaskCut(self, *args)


    def bitMaskCuts(self):
        """bitMaskCuts(Cuts self) -> BitMaskCutVector"""
        return _pyLikelihood.Cuts_bitMaskCuts(self)


    def pass_ver(self):
        """pass_ver(Cuts self) -> std::string const &"""
        return _pyLikelihood.Cuts_pass_ver(self)


    def post_P7(self):
        """post_P7(Cuts self) -> bool const"""
        return _pyLikelihood.Cuts_post_P7(self)


    def setBitMaskCut(self, bitMaskCut):
        """setBitMaskCut(Cuts self, BitMaskCut bitMaskCut)"""
        return _pyLikelihood.Cuts_setBitMaskCut(self, bitMaskCut)


    def extract_irf_versions(irf_name, pass_ver, irf_ver):
        """extract_irf_versions(std::string const & irf_name, std::string & pass_ver, std::string & irf_ver)"""
        return _pyLikelihood.Cuts_extract_irf_versions(irf_name, pass_ver, irf_ver)

    extract_irf_versions = staticmethod(extract_irf_versions)

    def read_bitmask_mapping(irfs):
        """read_bitmask_mapping(std::map< std::string,unsigned int,std::less< std::string >,std::allocator< std::pair< std::string const,unsigned int > > > & irfs)"""
        return _pyLikelihood.Cuts_read_bitmask_mapping(irfs)

    read_bitmask_mapping = staticmethod(read_bitmask_mapping)
Cuts_swigregister = _pyLikelihood.Cuts_swigregister
Cuts_swigregister(Cuts)

def Cuts_extract_irf_versions(irf_name, pass_ver, irf_ver):
    """Cuts_extract_irf_versions(std::string const & irf_name, std::string & pass_ver, std::string & irf_ver)"""
    return _pyLikelihood.Cuts_extract_irf_versions(irf_name, pass_ver, irf_ver)

def Cuts_read_bitmask_mapping(irfs):
    """Cuts_read_bitmask_mapping(std::map< std::string,unsigned int,std::less< std::string >,std::allocator< std::pair< std::string const,unsigned int > > > & irfs)"""
    return _pyLikelihood.Cuts_read_bitmask_mapping(irfs)

class CosineBinner(FloatVector):
    """Proxy of C++ healpix::CosineBinner class."""

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

    def __init__(self):
        """__init__(healpix::CosineBinner self) -> CosineBinner"""
        this = _pyLikelihood.new_CosineBinner()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fill(self, *args):
        """
        fill(CosineBinner self, double costheta, double value)
        fill(CosineBinner self, double costheta, double phi, double value) -> size_t
        """
        return _pyLikelihood.CosineBinner_fill(self, *args)


    def __call__(self, costheta, phi=-1):
        """
        __call__(CosineBinner self, double costheta, double phi=-1) -> float const
        __call__(CosineBinner self, double costheta) -> float const &
        """
        return _pyLikelihood.CosineBinner___call__(self, costheta, phi)


    def phi(self, i):
        """phi(CosineBinner self, std::vector< float,std::allocator< float > >::const_iterator i) -> double"""
        return _pyLikelihood.CosineBinner_phi(self, i)


    def end_costh(self):
        """end_costh(CosineBinner self) -> std::vector< float >::const_iterator"""
        return _pyLikelihood.CosineBinner_end_costh(self)


    def setBinning(cosmin=0., nbins=40, sqrt_weight=True):
        """
        setBinning(double cosmin=0., size_t nbins=40, bool sqrt_weight=True)
        setBinning(double cosmin=0., size_t nbins=40)
        setBinning(double cosmin=0.)
        setBinning()
        """
        return _pyLikelihood.CosineBinner_setBinning(cosmin, nbins, sqrt_weight)

    setBinning = staticmethod(setBinning)

    def setPhiBins(phibins=15):
        """
        setPhiBins(size_t phibins=15)
        setPhiBins()
        """
        return _pyLikelihood.CosineBinner_setPhiBins(phibins)

    setPhiBins = staticmethod(setPhiBins)

    def thetaBinning():
        """thetaBinning() -> std::string"""
        return _pyLikelihood.CosineBinner_thetaBinning()

    thetaBinning = staticmethod(thetaBinning)

    def cosmin():
        """cosmin() -> double"""
        return _pyLikelihood.CosineBinner_cosmin()

    cosmin = staticmethod(cosmin)

    def nbins():
        """nbins() -> size_t"""
        return _pyLikelihood.CosineBinner_nbins()

    nbins = staticmethod(nbins)

    def nphibins():
        """nphibins() -> size_t"""
        return _pyLikelihood.CosineBinner_nphibins()

    nphibins = staticmethod(nphibins)

    def cosine_index(costheta):
        """cosine_index(double costheta) -> size_t"""
        return _pyLikelihood.CosineBinner_cosine_index(costheta)

    cosine_index = staticmethod(cosine_index)

    def phi_index(phi):
        """phi_index(double phi) -> size_t"""
        return _pyLikelihood.CosineBinner_phi_index(phi)

    phi_index = staticmethod(phi_index)

    def folded_phi(phi):
        """folded_phi(double phi) -> double"""
        return _pyLikelihood.CosineBinner_folded_phi(phi)

    folded_phi = staticmethod(folded_phi)

    def costheta(self, *args):
        """
        costheta(CosineBinner self, std::vector< float,std::allocator< float > >::const_iterator i) -> double
        costheta(CosineBinner self, size_t i) -> double
        """
        return _pyLikelihood.CosineBinner_costheta(self, *args)


    def __getitem__(self, i):
        """__getitem__(CosineBinner self, size_t i) -> float"""
        return _pyLikelihood.CosineBinner___getitem__(self, i)

    __swig_destroy__ = _pyLikelihood.delete_CosineBinner
    __del__ = lambda self: None
CosineBinner_swigregister = _pyLikelihood.CosineBinner_swigregister
CosineBinner_swigregister(CosineBinner)

def CosineBinner_setBinning(cosmin=0., nbins=40, sqrt_weight=True):
    """
    setBinning(double cosmin=0., size_t nbins=40, bool sqrt_weight=True)
    setBinning(double cosmin=0., size_t nbins=40)
    setBinning(double cosmin=0.)
    CosineBinner_setBinning()
    """
    return _pyLikelihood.CosineBinner_setBinning(cosmin, nbins, sqrt_weight)

def CosineBinner_setPhiBins(phibins=15):
    """
    setPhiBins(size_t phibins=15)
    CosineBinner_setPhiBins()
    """
    return _pyLikelihood.CosineBinner_setPhiBins(phibins)

def CosineBinner_thetaBinning():
    """CosineBinner_thetaBinning() -> std::string"""
    return _pyLikelihood.CosineBinner_thetaBinning()

def CosineBinner_cosmin():
    """CosineBinner_cosmin() -> double"""
    return _pyLikelihood.CosineBinner_cosmin()

def CosineBinner_nbins():
    """CosineBinner_nbins() -> size_t"""
    return _pyLikelihood.CosineBinner_nbins()

def CosineBinner_nphibins():
    """CosineBinner_nphibins() -> size_t"""
    return _pyLikelihood.CosineBinner_nphibins()

def CosineBinner_cosine_index(costheta):
    """CosineBinner_cosine_index(double costheta) -> size_t"""
    return _pyLikelihood.CosineBinner_cosine_index(costheta)

def CosineBinner_phi_index(phi):
    """CosineBinner_phi_index(double phi) -> size_t"""
    return _pyLikelihood.CosineBinner_phi_index(phi)

def CosineBinner_folded_phi(phi):
    """CosineBinner_folded_phi(double phi) -> double"""
    return _pyLikelihood.CosineBinner_folded_phi(phi)

class Exposure(_object):
    """Proxy of C++ map_tools::Exposure class."""

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

    def fill(self, *args):
        """
        fill(Exposure self, SkyDir dirz, double deltat)
        fill(Exposure self, SkyDir dirz, SkyDir dirzenith, double deltat)
        """
        return _pyLikelihood.Exposure_fill(self, *args)


    def __init__(self, *args):
        """
        __init__(map_tools::Exposure self, double pixelsize=1., double cosbinsize=1, double zcut=-1.0, bool weighted=False, double zmaxcut=1) -> Exposure
        __init__(map_tools::Exposure self, double pixelsize=1., double cosbinsize=1, double zcut=-1.0, bool weighted=False) -> Exposure
        __init__(map_tools::Exposure self, double pixelsize=1., double cosbinsize=1, double zcut=-1.0) -> Exposure
        __init__(map_tools::Exposure self, double pixelsize=1., double cosbinsize=1) -> Exposure
        __init__(map_tools::Exposure self, double pixelsize=1.) -> Exposure
        __init__(map_tools::Exposure self) -> Exposure
        __init__(map_tools::Exposure self, std::string const & inputfile, std::string const & tablename) -> Exposure
        __init__(map_tools::Exposure self, std::string const & inputfile) -> Exposure
        """
        this = _pyLikelihood.new_Exposure(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def write(self, *args):
        """
        write(Exposure self, std::string const & outputfile, std::string const & tablename)
        write(Exposure self, std::string const & outputfile)
        """
        return _pyLikelihood.Exposure_write(self, *args)


    def load(self, *args):
        """
        load(Exposure self, tip::Table const * scData, DoubleVectorPair gti, bool verbose=True)
        load(Exposure self, tip::Table const * scData, DoubleVectorPair gti)
        load(Exposure self, tip::Table const * scData)
        """
        return _pyLikelihood.Exposure_load(self, *args)


    def lost(self):
        """lost(Exposure self) -> double"""
        return _pyLikelihood.Exposure_lost(self)


    def fill_zenith(self, dirz, dirx, dirzenith, deltat):
        """fill_zenith(Exposure self, SkyDir dirz, SkyDir dirx, SkyDir dirzenith, double deltat)"""
        return _pyLikelihood.Exposure_fill_zenith(self, dirz, dirx, dirzenith, deltat)


    def data(self, srcDir):
        """data(Exposure self, SkyDir srcDir) -> CosineBinner"""
        return _pyLikelihood.Exposure_data(self, srcDir)

    __swig_destroy__ = _pyLikelihood.delete_Exposure
    __del__ = lambda self: None
Exposure_swigregister = _pyLikelihood.Exposure_swigregister
Exposure_swigregister(Exposure)

class SkyImage(_object):
    """Proxy of C++ map_tools::SkyImage class."""

    __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):
        """
        __init__(map_tools::SkyImage self, hoops::IParGroup const & pars) -> SkyImage
        __init__(map_tools::SkyImage self, std::string const & filename, std::string const & extension) -> SkyImage
        __init__(map_tools::SkyImage self, std::string const & filename) -> SkyImage
        __init__(map_tools::SkyImage self, SkyDir center, std::string const & outputFile, double pixel_size=0.5, double fov=20, int layers=1, std::string const & ptype, bool galactic=False) -> SkyImage
        __init__(map_tools::SkyImage self, SkyDir center, std::string const & outputFile, double pixel_size=0.5, double fov=20, int layers=1, std::string const & ptype) -> SkyImage
        __init__(map_tools::SkyImage self, SkyDir center, std::string const & outputFile, double pixel_size=0.5, double fov=20, int layers=1) -> SkyImage
        __init__(map_tools::SkyImage self, SkyDir center, std::string const & outputFile, double pixel_size=0.5, double fov=20) -> SkyImage
        __init__(map_tools::SkyImage self, SkyDir center, std::string const & outputFile, double pixel_size=0.5) -> SkyImage
        __init__(map_tools::SkyImage self, SkyDir center, std::string const & outputFile) -> SkyImage
        """
        this = _pyLikelihood.new_SkyImage(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def addPoint(self, dir, delta=1.0, layer=0):
        """
        addPoint(SkyImage self, SkyDir dir, double delta=1.0, unsigned int layer=0) -> bool
        addPoint(SkyImage self, SkyDir dir, double delta=1.0) -> bool
        addPoint(SkyImage self, SkyDir dir) -> bool
        """
        return _pyLikelihood.SkyImage_addPoint(self, dir, delta, layer)

    __swig_destroy__ = _pyLikelihood.delete_SkyImage
    __del__ = lambda self: None

    def setLayer(self, newlayer):
        """setLayer(SkyImage self, unsigned int newlayer) -> unsigned int"""
        return _pyLikelihood.SkyImage_setLayer(self, newlayer)


    def getEnergies(self, energy):
        """getEnergies(SkyImage self, DoubleVector energy)"""
        return _pyLikelihood.SkyImage_getEnergies(self, energy)


    def fill(self, req, layer=0):
        """
        fill(SkyImage self, astro::SkyFunction const & req, unsigned int layer=0)
        fill(SkyImage self, astro::SkyFunction const & req)
        """
        return _pyLikelihood.SkyImage_fill(self, req, layer)


    def clear(self):
        """clear(SkyImage self)"""
        return _pyLikelihood.SkyImage_clear(self)


    def total(self):
        """total(SkyImage self) -> double"""
        return _pyLikelihood.SkyImage_total(self)


    def minimum(self):
        """minimum(SkyImage self) -> double"""
        return _pyLikelihood.SkyImage_minimum(self)


    def maximum(self):
        """maximum(SkyImage self) -> double"""
        return _pyLikelihood.SkyImage_maximum(self)


    def count(self):
        """count(SkyImage self) -> double"""
        return _pyLikelihood.SkyImage_count(self)


    def pixelValue(self, pos, layer=0):
        """
        pixelValue(SkyImage self, SkyDir pos, unsigned int layer=0) -> double
        pixelValue(SkyImage self, SkyDir pos) -> double
        """
        return _pyLikelihood.SkyImage_pixelValue(self, pos, layer)


    def getNeighbors(self, pos, neighbors):
        """getNeighbors(SkyImage self, SkyDir pos, DoubleVector neighbors)"""
        return _pyLikelihood.SkyImage_getNeighbors(self, pos, neighbors)


    def __call__(self, s):
        """__call__(SkyImage self, SkyDir s) -> double"""
        return _pyLikelihood.SkyImage___call__(self, s)


    def layers(self):
        """layers(SkyImage self) -> int"""
        return _pyLikelihood.SkyImage_layers(self)

SkyImage_swigregister = _pyLikelihood.SkyImage_swigregister
SkyImage_swigregister(SkyImage)

class Arg(_object):
    """Proxy of C++ optimizers::Arg class."""

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

    def __init__(self):
        """__init__(optimizers::Arg self) -> Arg"""
        this = _pyLikelihood.new_Arg()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Arg
    __del__ = lambda self: None
Arg_swigregister = _pyLikelihood.Arg_swigregister
Arg_swigregister(Arg)

class dArg(Arg):
    """Proxy of C++ optimizers::dArg class."""

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

    def __init__(self, x):
        """__init__(optimizers::dArg self, double x) -> dArg"""
        this = _pyLikelihood.new_dArg(x)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_dArg
    __del__ = lambda self: None

    def getValue(self):
        """getValue(dArg self) -> double"""
        return _pyLikelihood.dArg_getValue(self)

dArg_swigregister = _pyLikelihood.dArg_swigregister
dArg_swigregister(dArg)

class ArgVector(_object):
    """Proxy of C++ std::vector<(p.optimizers::Arg)> class."""

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

    def iterator(self):
        """iterator(ArgVector self) -> SwigPyIterator"""
        return _pyLikelihood.ArgVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(ArgVector self) -> bool"""
        return _pyLikelihood.ArgVector___nonzero__(self)


    def __bool__(self):
        """__bool__(ArgVector self) -> bool"""
        return _pyLikelihood.ArgVector___bool__(self)


    def __len__(self):
        """__len__(ArgVector self) -> std::vector< optimizers::Arg * >::size_type"""
        return _pyLikelihood.ArgVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArgVector self, std::vector< optimizers::Arg * >::difference_type i, std::vector< optimizers::Arg * >::difference_type j) -> ArgVector"""
        return _pyLikelihood.ArgVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArgVector self, std::vector< optimizers::Arg * >::difference_type i, std::vector< optimizers::Arg * >::difference_type j)
        __setslice__(ArgVector self, std::vector< optimizers::Arg * >::difference_type i, std::vector< optimizers::Arg * >::difference_type j, ArgVector v)
        """
        return _pyLikelihood.ArgVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArgVector self, std::vector< optimizers::Arg * >::difference_type i, std::vector< optimizers::Arg * >::difference_type j)"""
        return _pyLikelihood.ArgVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArgVector self, std::vector< optimizers::Arg * >::difference_type i)
        __delitem__(ArgVector self, PySliceObject * slice)
        """
        return _pyLikelihood.ArgVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArgVector self, PySliceObject * slice) -> ArgVector
        __getitem__(ArgVector self, std::vector< optimizers::Arg * >::difference_type i) -> Arg
        """
        return _pyLikelihood.ArgVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArgVector self, PySliceObject * slice, ArgVector v)
        __setitem__(ArgVector self, PySliceObject * slice)
        __setitem__(ArgVector self, std::vector< optimizers::Arg * >::difference_type i, Arg x)
        """
        return _pyLikelihood.ArgVector___setitem__(self, *args)


    def pop(self):
        """pop(ArgVector self) -> Arg"""
        return _pyLikelihood.ArgVector_pop(self)


    def append(self, x):
        """append(ArgVector self, Arg x)"""
        return _pyLikelihood.ArgVector_append(self, x)


    def empty(self):
        """empty(ArgVector self) -> bool"""
        return _pyLikelihood.ArgVector_empty(self)


    def size(self):
        """size(ArgVector self) -> std::vector< optimizers::Arg * >::size_type"""
        return _pyLikelihood.ArgVector_size(self)


    def swap(self, v):
        """swap(ArgVector self, ArgVector v)"""
        return _pyLikelihood.ArgVector_swap(self, v)


    def begin(self):
        """begin(ArgVector self) -> std::vector< optimizers::Arg * >::iterator"""
        return _pyLikelihood.ArgVector_begin(self)


    def end(self):
        """end(ArgVector self) -> std::vector< optimizers::Arg * >::iterator"""
        return _pyLikelihood.ArgVector_end(self)


    def rbegin(self):
        """rbegin(ArgVector self) -> std::vector< optimizers::Arg * >::reverse_iterator"""
        return _pyLikelihood.ArgVector_rbegin(self)


    def rend(self):
        """rend(ArgVector self) -> std::vector< optimizers::Arg * >::reverse_iterator"""
        return _pyLikelihood.ArgVector_rend(self)


    def clear(self):
        """clear(ArgVector self)"""
        return _pyLikelihood.ArgVector_clear(self)


    def get_allocator(self):
        """get_allocator(ArgVector self) -> std::vector< optimizers::Arg * >::allocator_type"""
        return _pyLikelihood.ArgVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ArgVector self)"""
        return _pyLikelihood.ArgVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ArgVector self, std::vector< optimizers::Arg * >::iterator pos) -> std::vector< optimizers::Arg * >::iterator
        erase(ArgVector self, std::vector< optimizers::Arg * >::iterator first, std::vector< optimizers::Arg * >::iterator last) -> std::vector< optimizers::Arg * >::iterator
        """
        return _pyLikelihood.ArgVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.optimizers::Arg)> self) -> ArgVector
        __init__(std::vector<(p.optimizers::Arg)> self, ArgVector arg2) -> ArgVector
        __init__(std::vector<(p.optimizers::Arg)> self, std::vector< optimizers::Arg * >::size_type size) -> ArgVector
        __init__(std::vector<(p.optimizers::Arg)> self, std::vector< optimizers::Arg * >::size_type size, Arg value) -> ArgVector
        """
        this = _pyLikelihood.new_ArgVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArgVector self, Arg x)"""
        return _pyLikelihood.ArgVector_push_back(self, x)


    def front(self):
        """front(ArgVector self) -> Arg"""
        return _pyLikelihood.ArgVector_front(self)


    def back(self):
        """back(ArgVector self) -> Arg"""
        return _pyLikelihood.ArgVector_back(self)


    def assign(self, n, x):
        """assign(ArgVector self, std::vector< optimizers::Arg * >::size_type n, Arg x)"""
        return _pyLikelihood.ArgVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArgVector self, std::vector< optimizers::Arg * >::size_type new_size)
        resize(ArgVector self, std::vector< optimizers::Arg * >::size_type new_size, Arg x)
        """
        return _pyLikelihood.ArgVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArgVector self, std::vector< optimizers::Arg * >::iterator pos, Arg x) -> std::vector< optimizers::Arg * >::iterator
        insert(ArgVector self, std::vector< optimizers::Arg * >::iterator pos, std::vector< optimizers::Arg * >::size_type n, Arg x)
        """
        return _pyLikelihood.ArgVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ArgVector self, std::vector< optimizers::Arg * >::size_type n)"""
        return _pyLikelihood.ArgVector_reserve(self, n)


    def capacity(self):
        """capacity(ArgVector self) -> std::vector< optimizers::Arg * >::size_type"""
        return _pyLikelihood.ArgVector_capacity(self)

    __swig_destroy__ = _pyLikelihood.delete_ArgVector
    __del__ = lambda self: None
ArgVector_swigregister = _pyLikelihood.ArgVector_swigregister
ArgVector_swigregister(ArgVector)

class Parameter(_object):
    """Proxy of C++ optimizers::Parameter class."""

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

    def __init__(self, *args):
        """
        __init__(optimizers::Parameter self) -> Parameter
        __init__(optimizers::Parameter self, std::string const & name, double value, double minValue, double maxValue, bool isFree=True, double error=0) -> Parameter
        __init__(optimizers::Parameter self, std::string const & name, double value, double minValue, double maxValue, bool isFree=True) -> Parameter
        __init__(optimizers::Parameter self, std::string const & name, double value, double minValue, double maxValue) -> Parameter
        __init__(optimizers::Parameter self, std::string const & name, double value, bool isFree=True) -> Parameter
        __init__(optimizers::Parameter self, std::string const & name, double value) -> Parameter
        __init__(optimizers::Parameter self, Parameter other) -> Parameter
        """
        this = _pyLikelihood.new_Parameter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Parameter
    __del__ = lambda self: None

    def setName(self, paramName):
        """setName(Parameter self, std::string const & paramName)"""
        return _pyLikelihood.Parameter_setName(self, paramName)


    def getName(self):
        """getName(Parameter self) -> std::string const &"""
        return _pyLikelihood.Parameter_getName(self)


    def setValue(self, value):
        """setValue(Parameter self, double value)"""
        return _pyLikelihood.Parameter_setValue(self, value)


    def getValue(self):
        """getValue(Parameter self) -> double"""
        return _pyLikelihood.Parameter_getValue(self)


    def setScale(self, scale):
        """setScale(Parameter self, double scale)"""
        return _pyLikelihood.Parameter_setScale(self, scale)


    def getScale(self):
        """getScale(Parameter self) -> double"""
        return _pyLikelihood.Parameter_getScale(self)


    def setTrueValue(self, trueValue):
        """setTrueValue(Parameter self, double trueValue)"""
        return _pyLikelihood.Parameter_setTrueValue(self, trueValue)


    def getTrueValue(self):
        """getTrueValue(Parameter self) -> double"""
        return _pyLikelihood.Parameter_getTrueValue(self)


    def setBounds(self, *args):
        """
        setBounds(Parameter self, double minValue, double maxValue)
        setBounds(Parameter self, DoublePair boundValues)
        """
        return _pyLikelihood.Parameter_setBounds(self, *args)


    def getBounds(self):
        """getBounds(Parameter self) -> DoublePair"""
        return _pyLikelihood.Parameter_getBounds(self)


    def setFree(self, free):
        """setFree(Parameter self, bool free)"""
        return _pyLikelihood.Parameter_setFree(self, free)


    def isFree(self):
        """isFree(Parameter self) -> bool"""
        return _pyLikelihood.Parameter_isFree(self)


    def setAlwaysFixed(self, flag):
        """setAlwaysFixed(Parameter self, bool flag)"""
        return _pyLikelihood.Parameter_setAlwaysFixed(self, flag)


    def alwaysFixed(self):
        """alwaysFixed(Parameter self) -> bool"""
        return _pyLikelihood.Parameter_alwaysFixed(self)


    def setError(self, error):
        """setError(Parameter self, double error)"""
        return _pyLikelihood.Parameter_setError(self, error)


    def error(self):
        """error(Parameter self) -> double"""
        return _pyLikelihood.Parameter_error(self)


    def setParRef(self, par):
        """setParRef(Parameter self, Parameter par)"""
        return _pyLikelihood.Parameter_setParRef(self, par)


    def setPrior(self, log_prior):
        """setPrior(Parameter self, Function log_prior)"""
        return _pyLikelihood.Parameter_setPrior(self, log_prior)


    def has_prior(self):
        """has_prior(Parameter self) -> bool"""
        return _pyLikelihood.Parameter_has_prior(self)


    def removePrior(self):
        """removePrior(Parameter self) -> Function"""
        return _pyLikelihood.Parameter_removePrior(self)


    def log_prior_value(self):
        """log_prior_value(Parameter self) -> double"""
        return _pyLikelihood.Parameter_log_prior_value(self)


    def log_prior_deriv(self):
        """log_prior_deriv(Parameter self) -> double"""
        return _pyLikelihood.Parameter_log_prior_deriv(self)


    def log_prior(self, *args):
        """
        log_prior(Parameter self) -> Function
        log_prior(Parameter self) -> Function
        """
        return _pyLikelihood.Parameter_log_prior(self, *args)


    def setEquals(self, rhs):
        """setEquals(Parameter self, Parameter rhs)"""
        return _pyLikelihood.Parameter_setEquals(self, rhs)

Parameter_swigregister = _pyLikelihood.Parameter_swigregister
Parameter_swigregister(Parameter)

class ParameterVector(_object):
    """Proxy of C++ std::vector<(optimizers::Parameter)> class."""

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

    def iterator(self):
        """iterator(ParameterVector self) -> SwigPyIterator"""
        return _pyLikelihood.ParameterVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(ParameterVector self) -> bool"""
        return _pyLikelihood.ParameterVector___nonzero__(self)


    def __bool__(self):
        """__bool__(ParameterVector self) -> bool"""
        return _pyLikelihood.ParameterVector___bool__(self)


    def __len__(self):
        """__len__(ParameterVector self) -> std::vector< optimizers::Parameter >::size_type"""
        return _pyLikelihood.ParameterVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ParameterVector self, std::vector< optimizers::Parameter >::difference_type i, std::vector< optimizers::Parameter >::difference_type j) -> ParameterVector"""
        return _pyLikelihood.ParameterVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ParameterVector self, std::vector< optimizers::Parameter >::difference_type i, std::vector< optimizers::Parameter >::difference_type j)
        __setslice__(ParameterVector self, std::vector< optimizers::Parameter >::difference_type i, std::vector< optimizers::Parameter >::difference_type j, ParameterVector v)
        """
        return _pyLikelihood.ParameterVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ParameterVector self, std::vector< optimizers::Parameter >::difference_type i, std::vector< optimizers::Parameter >::difference_type j)"""
        return _pyLikelihood.ParameterVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ParameterVector self, std::vector< optimizers::Parameter >::difference_type i)
        __delitem__(ParameterVector self, PySliceObject * slice)
        """
        return _pyLikelihood.ParameterVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ParameterVector self, PySliceObject * slice) -> ParameterVector
        __getitem__(ParameterVector self, std::vector< optimizers::Parameter >::difference_type i) -> Parameter
        """
        return _pyLikelihood.ParameterVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ParameterVector self, PySliceObject * slice, ParameterVector v)
        __setitem__(ParameterVector self, PySliceObject * slice)
        __setitem__(ParameterVector self, std::vector< optimizers::Parameter >::difference_type i, Parameter x)
        """
        return _pyLikelihood.ParameterVector___setitem__(self, *args)


    def pop(self):
        """pop(ParameterVector self) -> Parameter"""
        return _pyLikelihood.ParameterVector_pop(self)


    def append(self, x):
        """append(ParameterVector self, Parameter x)"""
        return _pyLikelihood.ParameterVector_append(self, x)


    def empty(self):
        """empty(ParameterVector self) -> bool"""
        return _pyLikelihood.ParameterVector_empty(self)


    def size(self):
        """size(ParameterVector self) -> std::vector< optimizers::Parameter >::size_type"""
        return _pyLikelihood.ParameterVector_size(self)


    def swap(self, v):
        """swap(ParameterVector self, ParameterVector v)"""
        return _pyLikelihood.ParameterVector_swap(self, v)


    def begin(self):
        """begin(ParameterVector self) -> std::vector< optimizers::Parameter >::iterator"""
        return _pyLikelihood.ParameterVector_begin(self)


    def end(self):
        """end(ParameterVector self) -> std::vector< optimizers::Parameter >::iterator"""
        return _pyLikelihood.ParameterVector_end(self)


    def rbegin(self):
        """rbegin(ParameterVector self) -> std::vector< optimizers::Parameter >::reverse_iterator"""
        return _pyLikelihood.ParameterVector_rbegin(self)


    def rend(self):
        """rend(ParameterVector self) -> std::vector< optimizers::Parameter >::reverse_iterator"""
        return _pyLikelihood.ParameterVector_rend(self)


    def clear(self):
        """clear(ParameterVector self)"""
        return _pyLikelihood.ParameterVector_clear(self)


    def get_allocator(self):
        """get_allocator(ParameterVector self) -> std::vector< optimizers::Parameter >::allocator_type"""
        return _pyLikelihood.ParameterVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ParameterVector self)"""
        return _pyLikelihood.ParameterVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ParameterVector self, std::vector< optimizers::Parameter >::iterator pos) -> std::vector< optimizers::Parameter >::iterator
        erase(ParameterVector self, std::vector< optimizers::Parameter >::iterator first, std::vector< optimizers::Parameter >::iterator last) -> std::vector< optimizers::Parameter >::iterator
        """
        return _pyLikelihood.ParameterVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(optimizers::Parameter)> self) -> ParameterVector
        __init__(std::vector<(optimizers::Parameter)> self, ParameterVector arg2) -> ParameterVector
        __init__(std::vector<(optimizers::Parameter)> self, std::vector< optimizers::Parameter >::size_type size) -> ParameterVector
        __init__(std::vector<(optimizers::Parameter)> self, std::vector< optimizers::Parameter >::size_type size, Parameter value) -> ParameterVector
        """
        this = _pyLikelihood.new_ParameterVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ParameterVector self, Parameter x)"""
        return _pyLikelihood.ParameterVector_push_back(self, x)


    def front(self):
        """front(ParameterVector self) -> Parameter"""
        return _pyLikelihood.ParameterVector_front(self)


    def back(self):
        """back(ParameterVector self) -> Parameter"""
        return _pyLikelihood.ParameterVector_back(self)


    def assign(self, n, x):
        """assign(ParameterVector self, std::vector< optimizers::Parameter >::size_type n, Parameter x)"""
        return _pyLikelihood.ParameterVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ParameterVector self, std::vector< optimizers::Parameter >::size_type new_size)
        resize(ParameterVector self, std::vector< optimizers::Parameter >::size_type new_size, Parameter x)
        """
        return _pyLikelihood.ParameterVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ParameterVector self, std::vector< optimizers::Parameter >::iterator pos, Parameter x) -> std::vector< optimizers::Parameter >::iterator
        insert(ParameterVector self, std::vector< optimizers::Parameter >::iterator pos, std::vector< optimizers::Parameter >::size_type n, Parameter x)
        """
        return _pyLikelihood.ParameterVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ParameterVector self, std::vector< optimizers::Parameter >::size_type n)"""
        return _pyLikelihood.ParameterVector_reserve(self, n)


    def capacity(self):
        """capacity(ParameterVector self) -> std::vector< optimizers::Parameter >::size_type"""
        return _pyLikelihood.ParameterVector_capacity(self)

    __swig_destroy__ = _pyLikelihood.delete_ParameterVector
    __del__ = lambda self: None
ParameterVector_swigregister = _pyLikelihood.ParameterVector_swigregister
ParameterVector_swigregister(ParameterVector)

class Function(_object):
    """Proxy of C++ optimizers::Function class."""

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

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

    def __call__(self, xarg):
        """__call__(Function self, Arg xarg) -> double"""
        return _pyLikelihood.Function___call__(self, xarg)


    def derivByParam(self, xarg, paramName):
        """derivByParam(Function self, Arg xarg, std::string const & paramName) -> double"""
        return _pyLikelihood.Function_derivByParam(self, xarg, paramName)


    def setScalingFunction(self, scalingFunction):
        """setScalingFunction(Function self, Function scalingFunction)"""
        return _pyLikelihood.Function_setScalingFunction(self, scalingFunction)


    def scalingFunction(self):
        """scalingFunction(Function self) -> Function"""
        return _pyLikelihood.Function_scalingFunction(self)


    def setName(self, functionName):
        """setName(Function self, std::string const & functionName)"""
        return _pyLikelihood.Function_setName(self, functionName)


    def getName(self):
        """getName(Function self) -> std::string const &"""
        return _pyLikelihood.Function_getName(self)


    def setParam(self, *args):
        """
        setParam(Function self, std::string const & paramName, double paramValue)
        setParam(Function self, Parameter param)
        """
        return _pyLikelihood.Function_setParam(self, *args)


    def getParamValue(self, paramName):
        """getParamValue(Function self, std::string const & paramName) -> double"""
        return _pyLikelihood.Function_getParamValue(self, paramName)


    def getParam(self, paramName):
        """getParam(Function self, std::string const & paramName) -> Parameter"""
        return _pyLikelihood.Function_getParam(self, paramName)


    def parameter(self, name):
        """parameter(Function self, std::string const & name) -> Parameter"""
        return _pyLikelihood.Function_parameter(self, name)


    def normPar(self, *args):
        """
        normPar(Function self) -> Parameter
        normPar(Function self) -> Parameter
        """
        return _pyLikelihood.Function_normPar(self, *args)


    def getNumParams(self):
        """getNumParams(Function self) -> unsigned int"""
        return _pyLikelihood.Function_getNumParams(self)


    def setParamValues(self, paramVec):
        """setParamValues(Function self, DoubleVector paramVec)"""
        return _pyLikelihood.Function_setParamValues(self, paramVec)


    def setParamValues_(self, arg2):
        """setParamValues_(Function self, std::vector< double,std::allocator< double > >::const_iterator arg2) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.Function_setParamValues_(self, arg2)


    def setParams(self, params):
        """setParams(Function self, ParameterVector params)"""
        return _pyLikelihood.Function_setParams(self, params)


    def getParamNames(self, names):
        """getParamNames(Function self, StringVector names)"""
        return _pyLikelihood.Function_getParamNames(self, names)


    def getParamValues(self, values):
        """getParamValues(Function self, DoubleVector values)"""
        return _pyLikelihood.Function_getParamValues(self, values)


    def getParams(self, params):
        """getParams(Function self, ParameterVector params)"""
        return _pyLikelihood.Function_getParams(self, params)


    def getNumFreeParams(self):
        """getNumFreeParams(Function self) -> unsigned int"""
        return _pyLikelihood.Function_getNumFreeParams(self)


    def setFreeParamValues(self, paramVec):
        """setFreeParamValues(Function self, DoubleVector paramVec)"""
        return _pyLikelihood.Function_setFreeParamValues(self, paramVec)


    def setFreeParamValues_(self, arg2):
        """setFreeParamValues_(Function self, std::vector< double,std::allocator< double > >::const_iterator arg2) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.Function_setFreeParamValues_(self, arg2)


    def getFreeParamNames(self, names):
        """getFreeParamNames(Function self, StringVector names)"""
        return _pyLikelihood.Function_getFreeParamNames(self, names)


    def getFreeParamValues(self, values):
        """getFreeParamValues(Function self, DoubleVector values)"""
        return _pyLikelihood.Function_getFreeParamValues(self, values)


    def getFreeParams(self, arg2):
        """getFreeParams(Function self, ParameterVector arg2)"""
        return _pyLikelihood.Function_getFreeParams(self, arg2)


    def getDerivs(self, x, derivs):
        """getDerivs(Function self, Arg x, DoubleVector derivs)"""
        return _pyLikelihood.Function_getDerivs(self, x, derivs)


    def getFreeDerivs(self, x, derivs):
        """getFreeDerivs(Function self, Arg x, DoubleVector derivs)"""
        return _pyLikelihood.Function_getFreeDerivs(self, x, derivs)


    def integral(self, arg2, arg3):
        """integral(Function self, Arg arg2, Arg arg3) -> double"""
        return _pyLikelihood.Function_integral(self, arg2, arg3)


    def derivative(self, arg2):
        """derivative(Function self, Arg arg2) -> double"""
        return _pyLikelihood.Function_derivative(self, arg2)


    def clone(self):
        """clone(Function self) -> Function"""
        return _pyLikelihood.Function_clone(self)


    def argType(self):
        """argType(Function self) -> std::string const &"""
        return _pyLikelihood.Function_argType(self)


    def genericName(self):
        """genericName(Function self) -> std::string const &"""
        return _pyLikelihood.Function_genericName(self)


    def rescale(self, factor):
        """rescale(Function self, double factor) -> bool"""
        return _pyLikelihood.Function_rescale(self, factor)


    def setParamAlwaysFixed(self, name):
        """setParamAlwaysFixed(Function self, std::string const & name)"""
        return _pyLikelihood.Function_setParamAlwaysFixed(self, name)

Function_swigregister = _pyLikelihood.Function_swigregister
Function_swigregister(Function)

class FuncPair(_object):
    """Proxy of C++ std::pair<(std::string,p.optimizers::Function)> class."""

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

    def __init__(self, *args):
        """
        __init__(std::pair<(std::string,p.optimizers::Function)> self) -> FuncPair
        __init__(std::pair<(std::string,p.optimizers::Function)> self, std::string __a, Function __b) -> FuncPair
        __init__(std::pair<(std::string,p.optimizers::Function)> self, FuncPair __p) -> FuncPair
        """
        this = _pyLikelihood.new_FuncPair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _pyLikelihood.FuncPair_first_set
    __swig_getmethods__["first"] = _pyLikelihood.FuncPair_first_get
    if _newclass:
        first = _swig_property(_pyLikelihood.FuncPair_first_get, _pyLikelihood.FuncPair_first_set)
    __swig_setmethods__["second"] = _pyLikelihood.FuncPair_second_set
    __swig_getmethods__["second"] = _pyLikelihood.FuncPair_second_get
    if _newclass:
        second = _swig_property(_pyLikelihood.FuncPair_second_get, _pyLikelihood.FuncPair_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__ = _pyLikelihood.delete_FuncPair
    __del__ = lambda self: None
FuncPair_swigregister = _pyLikelihood.FuncPair_swigregister
FuncPair_swigregister(FuncPair)

class FuncMap(_object):
    """Proxy of C++ std::map<(std::string,p.optimizers::Function)> class."""

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

    def iterator(self):
        """iterator(FuncMap self) -> SwigPyIterator"""
        return _pyLikelihood.FuncMap_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(FuncMap self) -> bool"""
        return _pyLikelihood.FuncMap___nonzero__(self)


    def __bool__(self):
        """__bool__(FuncMap self) -> bool"""
        return _pyLikelihood.FuncMap___bool__(self)


    def __len__(self):
        """__len__(FuncMap self) -> std::map< std::string,optimizers::Function * >::size_type"""
        return _pyLikelihood.FuncMap___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & key) -> Function"""
        return _pyLikelihood.FuncMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & key)"""
        return _pyLikelihood.FuncMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & key) -> bool"""
        return _pyLikelihood.FuncMap_has_key(self, key)


    def keys(self):
        """keys(FuncMap self) -> PyObject *"""
        return _pyLikelihood.FuncMap_keys(self)


    def values(self):
        """values(FuncMap self) -> PyObject *"""
        return _pyLikelihood.FuncMap_values(self)


    def items(self):
        """items(FuncMap self) -> PyObject *"""
        return _pyLikelihood.FuncMap_items(self)


    def __contains__(self, key):
        """__contains__(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & key) -> bool"""
        return _pyLikelihood.FuncMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(FuncMap self) -> SwigPyIterator"""
        return _pyLikelihood.FuncMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(FuncMap self) -> SwigPyIterator"""
        return _pyLikelihood.FuncMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & key)
        __setitem__(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & key, Function x)
        """
        return _pyLikelihood.FuncMap___setitem__(self, *args)


    def asdict(self):
        """asdict(FuncMap self) -> PyObject *"""
        return _pyLikelihood.FuncMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,p.optimizers::Function)> self, std::less< std::string > const & arg2) -> FuncMap
        __init__(std::map<(std::string,p.optimizers::Function)> self) -> FuncMap
        __init__(std::map<(std::string,p.optimizers::Function)> self, FuncMap arg2) -> FuncMap
        """
        this = _pyLikelihood.new_FuncMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(FuncMap self) -> bool"""
        return _pyLikelihood.FuncMap_empty(self)


    def size(self):
        """size(FuncMap self) -> std::map< std::string,optimizers::Function * >::size_type"""
        return _pyLikelihood.FuncMap_size(self)


    def swap(self, v):
        """swap(FuncMap self, FuncMap v)"""
        return _pyLikelihood.FuncMap_swap(self, v)


    def begin(self):
        """begin(FuncMap self) -> std::map< std::string,optimizers::Function * >::iterator"""
        return _pyLikelihood.FuncMap_begin(self)


    def end(self):
        """end(FuncMap self) -> std::map< std::string,optimizers::Function * >::iterator"""
        return _pyLikelihood.FuncMap_end(self)


    def rbegin(self):
        """rbegin(FuncMap self) -> std::map< std::string,optimizers::Function * >::reverse_iterator"""
        return _pyLikelihood.FuncMap_rbegin(self)


    def rend(self):
        """rend(FuncMap self) -> std::map< std::string,optimizers::Function * >::reverse_iterator"""
        return _pyLikelihood.FuncMap_rend(self)


    def clear(self):
        """clear(FuncMap self)"""
        return _pyLikelihood.FuncMap_clear(self)


    def get_allocator(self):
        """get_allocator(FuncMap self) -> std::map< std::string,optimizers::Function * >::allocator_type"""
        return _pyLikelihood.FuncMap_get_allocator(self)


    def count(self, x):
        """count(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & x) -> std::map< std::string,optimizers::Function * >::size_type"""
        return _pyLikelihood.FuncMap_count(self, x)


    def erase(self, *args):
        """
        erase(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & x) -> std::map< std::string,optimizers::Function * >::size_type
        erase(FuncMap self, std::map< std::string,optimizers::Function * >::iterator position)
        erase(FuncMap self, std::map< std::string,optimizers::Function * >::iterator first, std::map< std::string,optimizers::Function * >::iterator last)
        """
        return _pyLikelihood.FuncMap_erase(self, *args)


    def find(self, x):
        """find(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & x) -> std::map< std::string,optimizers::Function * >::iterator"""
        return _pyLikelihood.FuncMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & x) -> std::map< std::string,optimizers::Function * >::iterator"""
        return _pyLikelihood.FuncMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(FuncMap self, std::map< std::string,optimizers::Function * >::key_type const & x) -> std::map< std::string,optimizers::Function * >::iterator"""
        return _pyLikelihood.FuncMap_upper_bound(self, x)

    __swig_destroy__ = _pyLikelihood.delete_FuncMap
    __del__ = lambda self: None
FuncMap_swigregister = _pyLikelihood.FuncMap_swigregister
FuncMap_swigregister(FuncMap)

class Statistic(Function):
    """Proxy of C++ optimizers::Statistic class."""

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

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

    def value(self):
        """value(Statistic self) -> double"""
        return _pyLikelihood.Statistic_value(self)


    def getFreeDerivs(self, derivs):
        """getFreeDerivs(Statistic self, DoubleVector derivs)"""
        return _pyLikelihood.Statistic_getFreeDerivs(self, derivs)

Statistic_swigregister = _pyLikelihood.Statistic_swigregister
Statistic_swigregister(Statistic)

class FunctionTest(_object):
    """Proxy of C++ optimizers::FunctionTest class."""

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

    def __init__(self, func, name):
        """__init__(optimizers::FunctionTest self, Function func, std::string const & name) -> FunctionTest"""
        this = _pyLikelihood.new_FunctionTest(func, name)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FunctionTest
    __del__ = lambda self: None

    def parameters(self, params):
        """parameters(FunctionTest self, ParameterVector params)"""
        return _pyLikelihood.FunctionTest_parameters(self, params)


    def freeParameters(self, params):
        """freeParameters(FunctionTest self, ParameterVector params)"""
        return _pyLikelihood.FunctionTest_freeParameters(self, params)


    def funcEvaluations(self, arguments, returnValues):
        """funcEvaluations(FunctionTest self, ArgVector arguments, DoubleVector returnValues)"""
        return _pyLikelihood.FunctionTest_funcEvaluations(self, arguments, returnValues)


    def derivatives(self, arguments, eps=1e-5):
        """
        derivatives(FunctionTest self, ArgVector arguments, double eps=1e-5)
        derivatives(FunctionTest self, ArgVector arguments)
        """
        return _pyLikelihood.FunctionTest_derivatives(self, arguments, eps)

FunctionTest_swigregister = _pyLikelihood.FunctionTest_swigregister
FunctionTest_swigregister(FunctionTest)

class FunctionFactory(_object):
    """Proxy of C++ optimizers::FunctionFactory class."""

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

    def __init__(self):
        """__init__(optimizers::FunctionFactory self) -> FunctionFactory"""
        this = _pyLikelihood.new_FunctionFactory()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FunctionFactory
    __del__ = lambda self: None

    def create(self, name):
        """create(FunctionFactory self, std::string const & name) -> Function"""
        return _pyLikelihood.FunctionFactory_create(self, name)


    def addFunc(self, *args):
        """
        addFunc(FunctionFactory self, std::string const & name, Function func, bool fromClone=True)
        addFunc(FunctionFactory self, std::string const & name, Function func)
        addFunc(FunctionFactory self, Function func, bool fromClone=True)
        addFunc(FunctionFactory self, Function func)
        """
        return _pyLikelihood.FunctionFactory_addFunc(self, *args)


    def getFunctionNames(self, funcNames):
        """getFunctionNames(FunctionFactory self, StringVector funcNames)"""
        return _pyLikelihood.FunctionFactory_getFunctionNames(self, funcNames)


    def readXml(self, xmlFile):
        """readXml(FunctionFactory self, std::string const & xmlFile)"""
        return _pyLikelihood.FunctionFactory_readXml(self, xmlFile)


    def writeXml(self, outputFile):
        """writeXml(FunctionFactory self, std::string const & outputFile)"""
        return _pyLikelihood.FunctionFactory_writeXml(self, outputFile)

FunctionFactory_swigregister = _pyLikelihood.FunctionFactory_swigregister
FunctionFactory_swigregister(FunctionFactory)

RELATIVE = _pyLikelihood.RELATIVE
ABSOLUTE = _pyLikelihood.ABSOLUTE
class Optimizer(_object):
    """Proxy of C++ optimizers::Optimizer class."""

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

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

    def find_min(self, *args):
        """
        find_min(Optimizer self, int verbose, double tol, int tolType) -> int
        find_min(Optimizer self, int verbose, double tol) -> int
        """
        return _pyLikelihood.Optimizer_find_min(self, *args)


    def find_min_only(self, *args):
        """
        find_min_only(Optimizer self, int verbose, double tol, int tolType) -> int
        find_min_only(Optimizer self, int verbose, double tol) -> int
        """
        return _pyLikelihood.Optimizer_find_min_only(self, *args)


    def getUncertainty(self, useBase=False):
        """
        getUncertainty(Optimizer self, bool useBase=False) -> DoubleVector
        getUncertainty(Optimizer self) -> DoubleVector
        """
        return _pyLikelihood.Optimizer_getUncertainty(self, useBase)


    def covarianceMatrix(self):
        """covarianceMatrix(Optimizer self) -> DoubleVectorVector"""
        return _pyLikelihood.Optimizer_covarianceMatrix(self)


    def Minos(self, n, level=1., numericDeriv=False):
        """
        Minos(Optimizer self, unsigned int n, double level=1., bool numericDeriv=False) -> DoublePair
        Minos(Optimizer self, unsigned int n, double level=1.) -> DoublePair
        Minos(Optimizer self, unsigned int n) -> DoublePair
        """
        return _pyLikelihood.Optimizer_Minos(self, n, level, numericDeriv)


    def MnContour(self, par1, par2, level=1., npts=20):
        """
        MnContour(Optimizer self, unsigned int par1, unsigned int par2, double level=1., unsigned int npts=20)
        MnContour(Optimizer self, unsigned int par1, unsigned int par2, double level=1.)
        MnContour(Optimizer self, unsigned int par1, unsigned int par2)
        """
        return _pyLikelihood.Optimizer_MnContour(self, par1, par2, level, npts)


    def setStrategy(self, strat=1):
        """
        setStrategy(Optimizer self, unsigned int strat=1)
        setStrategy(Optimizer self)
        """
        return _pyLikelihood.Optimizer_setStrategy(self, strat)


    def getStrategy(self):
        """getStrategy(Optimizer self) -> unsigned int"""
        return _pyLikelihood.Optimizer_getStrategy(self)


    def minos_lower_error(self, n, level=1., tol=1e-3):
        """
        minos_lower_error(Optimizer self, unsigned int n, double level=1., double tol=1e-3) -> double
        minos_lower_error(Optimizer self, unsigned int n, double level=1.) -> double
        minos_lower_error(Optimizer self, unsigned int n) -> double
        """
        return _pyLikelihood.Optimizer_minos_lower_error(self, n, level, tol)


    def minos_upper_error(self, n, level=1., tol=1e-3):
        """
        minos_upper_error(Optimizer self, unsigned int n, double level=1., double tol=1e-3) -> double
        minos_upper_error(Optimizer self, unsigned int n, double level=1.) -> double
        minos_upper_error(Optimizer self, unsigned int n) -> double
        """
        return _pyLikelihood.Optimizer_minos_upper_error(self, n, level, tol)


    def stat(self, *args):
        """
        stat(Optimizer self) -> Statistic
        stat(Optimizer self) -> Statistic
        """
        return _pyLikelihood.Optimizer_stat(self, *args)


    def setMaxEval(self, maxEval):
        """setMaxEval(Optimizer self, int const maxEval)"""
        return _pyLikelihood.Optimizer_setMaxEval(self, maxEval)


    def getMaxEval(self):
        """getMaxEval(Optimizer self) -> int"""
        return _pyLikelihood.Optimizer_getMaxEval(self)


    def getRetCode(self):
        """getRetCode(Optimizer self) -> int"""
        return _pyLikelihood.Optimizer_getRetCode(self)


    def getNumericDerivFlag(self):
        """getNumericDerivFlag(Optimizer self) -> bool"""
        return _pyLikelihood.Optimizer_getNumericDerivFlag(self)


    def setNumericDerivFlag(self, val):
        """setNumericDerivFlag(Optimizer self, bool val)"""
        return _pyLikelihood.Optimizer_setNumericDerivFlag(self, val)


    def put(self, s):
        """put(Optimizer self, std::ostream & s) -> std::ostream &"""
        return _pyLikelihood.Optimizer_put(self, s)


    def doCmd(self, command, set_npar=False):
        """
        doCmd(Optimizer self, std::string command, bool set_npar=False) -> int
        doCmd(Optimizer self, std::string command) -> int
        """
        return _pyLikelihood.Optimizer_doCmd(self, command, set_npar)

Optimizer_swigregister = _pyLikelihood.Optimizer_swigregister
Optimizer_swigregister(Optimizer)


def __lshift__(s, t):
    """__lshift__(std::ostream & s, Optimizer t) -> std::ostream &"""
    return _pyLikelihood.__lshift__(s, t)

def drmngb_(bounds, scale, funcval, grad, iv, liv, lv, n, v, x):
    """drmngb_(double const * bounds, double * scale, double * funcval, double * grad, int * iv, int const * liv, int const * lv, int const * n, double * v, double * x)"""
    return _pyLikelihood.drmngb_(bounds, scale, funcval, grad, iv, liv, lv, n, v, x)

def drmnfb_(bounds, scale, funcval, iv, liv, lv, n, v, x):
    """drmnfb_(double const * bounds, double * scale, double * funcval, int * iv, int const * liv, int const * lv, int const * n, double * v, double * x)"""
    return _pyLikelihood.drmnfb_(bounds, scale, funcval, iv, liv, lv, n, v, x)

def divset_(kind, iv, liv, lv, v):
    """divset_(int const * kind, int * iv, int const * liv, int const * lv, double * v)"""
    return _pyLikelihood.divset_(kind, iv, liv, lv, v)

def dpptri_(uplo, n, array, info, strlen):
    """dpptri_(char const * uplo, int const * n, double * array, int * info, int strlen) -> int"""
    return _pyLikelihood.dpptri_(uplo, n, array, info, strlen)
class OptimizerFactory(_object):
    """Proxy of C++ optimizers::OptimizerFactory class."""

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

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

    def instance():
        """instance() -> OptimizerFactory"""
        return _pyLikelihood.OptimizerFactory_instance()

    instance = staticmethod(instance)

    def create(self, optimizerName, stat):
        """create(OptimizerFactory self, std::string const & optimizerName, Statistic stat) -> Optimizer"""
        return _pyLikelihood.OptimizerFactory_create(self, optimizerName, stat)

    __swig_destroy__ = _pyLikelihood.delete_OptimizerFactory
    __del__ = lambda self: None
OptimizerFactory_swigregister = _pyLikelihood.OptimizerFactory_swigregister
OptimizerFactory_swigregister(OptimizerFactory)

def OptimizerFactory_instance():
    """OptimizerFactory_instance() -> OptimizerFactory"""
    return _pyLikelihood.OptimizerFactory_instance()

class Mcmc(_object):
    """Proxy of C++ optimizers::Mcmc class."""

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

    def __init__(self, stat, verbose=True):
        """
        __init__(optimizers::Mcmc self, Function stat, bool verbose=True) -> Mcmc
        __init__(optimizers::Mcmc self, Function stat) -> Mcmc
        """
        this = _pyLikelihood.new_Mcmc(stat, verbose)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Mcmc
    __del__ = lambda self: None

    def addPriors(self, priors):
        """addPriors(Mcmc self, std::vector< optimizers::Function *,std::allocator< optimizers::Function * > > & priors)"""
        return _pyLikelihood.Mcmc_addPriors(self, priors)


    def generateSamples(self, samples, nsamp=10000, clear=False):
        """
        generateSamples(Mcmc self, DoubleVectorVector samples, unsigned long nsamp=10000, bool clear=False)
        generateSamples(Mcmc self, DoubleVectorVector samples, unsigned long nsamp=10000)
        generateSamples(Mcmc self, DoubleVectorVector samples)
        """
        return _pyLikelihood.Mcmc_generateSamples(self, samples, nsamp, clear)


    def setTransitionWidths(self, transitionWidths):
        """setTransitionWidths(Mcmc self, DoubleVector transitionWidths)"""
        return _pyLikelihood.Mcmc_setTransitionWidths(self, transitionWidths)


    def getTransitionWidths(self, transitionWidths):
        """getTransitionWidths(Mcmc self, DoubleVector transitionWidths)"""
        return _pyLikelihood.Mcmc_getTransitionWidths(self, transitionWidths)


    def writeSamples(self, filename, samples):
        """writeSamples(Mcmc self, std::string filename, DoubleVectorVector samples)"""
        return _pyLikelihood.Mcmc_writeSamples(self, filename, samples)

Mcmc_swigregister = _pyLikelihood.Mcmc_swigregister
Mcmc_swigregister(Mcmc)

class Minuit(Optimizer):
    """Proxy of C++ optimizers::Minuit class."""

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

    def __init__(self, stat):
        """__init__(optimizers::Minuit self, Statistic stat) -> Minuit"""
        this = _pyLikelihood.new_Minuit(stat)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Minuit
    __del__ = lambda self: None

    def find_min(self, *args):
        """
        find_min(Minuit self, int verbose=0, double tol=1e-3, int tolType) -> int
        find_min(Minuit self, int verbose=0, double tol=1e-3) -> int
        find_min(Minuit self, int verbose=0) -> int
        find_min(Minuit self) -> int
        """
        return _pyLikelihood.Minuit_find_min(self, *args)


    def find_min_only(self, *args):
        """
        find_min_only(Minuit self, int verbose=0, double tol=1e-3, int tolType) -> int
        find_min_only(Minuit self, int verbose=0, double tol=1e-3) -> int
        find_min_only(Minuit self, int verbose=0) -> int
        find_min_only(Minuit self) -> int
        """
        return _pyLikelihood.Minuit_find_min_only(self, *args)


    def getQuality(self):
        """getQuality(Minuit self) -> int"""
        return _pyLikelihood.Minuit_getQuality(self)


    def getDistance(self):
        """getDistance(Minuit self) -> double"""
        return _pyLikelihood.Minuit_getDistance(self)


    def getUncertainty(self, useBase=False):
        """
        getUncertainty(Minuit self, bool useBase=False) -> DoubleVector
        getUncertainty(Minuit self) -> DoubleVector
        """
        return _pyLikelihood.Minuit_getUncertainty(self, useBase)


    def covarianceMatrix(self):
        """covarianceMatrix(Minuit self) -> DoubleVectorVector"""
        return _pyLikelihood.Minuit_covarianceMatrix(self)


    def Minos(self, n, level=1., numericDeriv=False):
        """
        Minos(Minuit self, unsigned int n, double level=1., bool numericDeriv=False) -> DoublePair
        Minos(Minuit self, unsigned int n, double level=1.) -> DoublePair
        Minos(Minuit self, unsigned int n) -> DoublePair
        """
        return _pyLikelihood.Minuit_Minos(self, n, level, numericDeriv)


    def MnContour(self, par1, par2, level=1., npts=20):
        """
        MnContour(Minuit self, unsigned int par1, unsigned int par2, double level=1., unsigned int npts=20)
        MnContour(Minuit self, unsigned int par1, unsigned int par2, double level=1.)
        MnContour(Minuit self, unsigned int par1, unsigned int par2)
        """
        return _pyLikelihood.Minuit_MnContour(self, par1, par2, level, npts)


    def put(self, s):
        """put(Minuit self, std::ostream & s) -> std::ostream &"""
        return _pyLikelihood.Minuit_put(self, s)

    MINUIT_NOTCALC = _pyLikelihood.Minuit_MINUIT_NOTCALC
    MINUIT_DIAG = _pyLikelihood.Minuit_MINUIT_DIAG
    MINUIT_FORCEDPOS = _pyLikelihood.Minuit_MINUIT_FORCEDPOS
    MINUIT_NORMAL = _pyLikelihood.Minuit_MINUIT_NORMAL

    def setStrategy(self, strat=1):
        """
        setStrategy(Minuit self, unsigned int strat=1)
        setStrategy(Minuit self)
        """
        return _pyLikelihood.Minuit_setStrategy(self, strat)


    def getStrategy(self):
        """getStrategy(Minuit self) -> unsigned int"""
        return _pyLikelihood.Minuit_getStrategy(self)


    def doCmd(self, command, set_npar=False):
        """
        doCmd(Minuit self, std::string command, bool set_npar=False) -> int
        doCmd(Minuit self, std::string command) -> int
        """
        return _pyLikelihood.Minuit_doCmd(self, command, set_npar)


    def cast(opt):
        """cast(Optimizer opt) -> Minuit"""
        return _pyLikelihood.Minuit_cast(opt)

    cast = staticmethod(cast)
Minuit_swigregister = _pyLikelihood.Minuit_swigregister
Minuit_swigregister(Minuit)

def Minuit_cast(opt):
    """Minuit_cast(Optimizer opt) -> Minuit"""
    return _pyLikelihood.Minuit_cast(opt)


def fcn(npar, grad, fcnval, xval, iflag, futil):
    """fcn(integer * npar, double * grad, double * fcnval, double * xval, integer * iflag, void * futil)"""
    return _pyLikelihood.fcn(npar, grad, fcnval, xval, iflag, futil)
class myFCN(_object):
    """Proxy of C++ optimizers::myFCN class."""

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

    def __init__(self, arg2):
        """__init__(optimizers::myFCN self, Statistic arg2) -> myFCN"""
        this = _pyLikelihood.new_myFCN(arg2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_myFCN
    __del__ = lambda self: None

    def Up(self):
        """Up(myFCN self) -> double"""
        return _pyLikelihood.myFCN_Up(self)


    def __call__(self, arg2):
        """__call__(myFCN self, DoubleVector arg2) -> double"""
        return _pyLikelihood.myFCN___call__(self, arg2)


    def Gradient(self, arg2):
        """Gradient(myFCN self, DoubleVector arg2) -> DoubleVector"""
        return _pyLikelihood.myFCN_Gradient(self, arg2)


    def CheckGradient(self):
        """CheckGradient(myFCN self) -> bool"""
        return _pyLikelihood.myFCN_CheckGradient(self)


    def SetErrorDef(self, level):
        """SetErrorDef(myFCN self, double level)"""
        return _pyLikelihood.myFCN_SetErrorDef(self, level)

myFCN_swigregister = _pyLikelihood.myFCN_swigregister
myFCN_swigregister(myFCN)

class NewMinuit(Optimizer):
    """Proxy of C++ optimizers::NewMinuit class."""

    __swig_setmethods__ = {}
    for _s in [Optimizer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NewMinuit, name, value)
    __swig_getmethods__ = {}
    for _s in [Optimizer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NewMinuit, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pyLikelihood.delete_NewMinuit
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(optimizers::NewMinuit self, Statistic arg2) -> NewMinuit
        __init__(optimizers::NewMinuit self, NewMinuit x) -> NewMinuit
        """
        this = _pyLikelihood.new_NewMinuit(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def find_min(self, *args):
        """
        find_min(NewMinuit self, int verbose=0, double tole=1e-5, int tolType) -> int
        find_min(NewMinuit self, int verbose=0, double tole=1e-5) -> int
        find_min(NewMinuit self, int verbose=0) -> int
        find_min(NewMinuit self) -> int
        """
        return _pyLikelihood.NewMinuit_find_min(self, *args)


    def find_min_only(self, *args):
        """
        find_min_only(NewMinuit self, int verbose=0, double tole=1e-5, int tolType) -> int
        find_min_only(NewMinuit self, int verbose=0, double tole=1e-5) -> int
        find_min_only(NewMinuit self, int verbose=0) -> int
        find_min_only(NewMinuit self) -> int
        """
        return _pyLikelihood.NewMinuit_find_min_only(self, *args)


    def setStrategy(self, strat=1):
        """
        setStrategy(NewMinuit self, unsigned int strat=1)
        setStrategy(NewMinuit self)
        """
        return _pyLikelihood.NewMinuit_setStrategy(self, strat)


    def getStrategy(self):
        """getStrategy(NewMinuit self) -> unsigned int"""
        return _pyLikelihood.NewMinuit_getStrategy(self)


    def getDistance(self):
        """getDistance(NewMinuit self) -> double"""
        return _pyLikelihood.NewMinuit_getDistance(self)


    def getUncertainty(self, useBase=False):
        """
        getUncertainty(NewMinuit self, bool useBase=False) -> DoubleVector
        getUncertainty(NewMinuit self) -> DoubleVector
        """
        return _pyLikelihood.NewMinuit_getUncertainty(self, useBase)


    def covarianceMatrix(self):
        """covarianceMatrix(NewMinuit self) -> DoubleVectorVector"""
        return _pyLikelihood.NewMinuit_covarianceMatrix(self)


    def put(self, s):
        """put(NewMinuit self, std::ostream & s) -> std::ostream &"""
        return _pyLikelihood.NewMinuit_put(self, s)


    def Minos(self, n, level=1., numericDeriv=False):
        """
        Minos(NewMinuit self, unsigned int n, double level=1., bool numericDeriv=False) -> DoublePair
        Minos(NewMinuit self, unsigned int n, double level=1.) -> DoublePair
        Minos(NewMinuit self, unsigned int n) -> DoublePair
        """
        return _pyLikelihood.NewMinuit_Minos(self, n, level, numericDeriv)


    def minos_lower_error(self, n, level=1., tol=1e-3):
        """
        minos_lower_error(NewMinuit self, unsigned int n, double level=1., double tol=1e-3) -> double
        minos_lower_error(NewMinuit self, unsigned int n, double level=1.) -> double
        minos_lower_error(NewMinuit self, unsigned int n) -> double
        """
        return _pyLikelihood.NewMinuit_minos_lower_error(self, n, level, tol)


    def minos_upper_error(self, n, level=1., tol=1e-3):
        """
        minos_upper_error(NewMinuit self, unsigned int n, double level=1., double tol=1e-3) -> double
        minos_upper_error(NewMinuit self, unsigned int n, double level=1.) -> double
        minos_upper_error(NewMinuit self, unsigned int n) -> double
        """
        return _pyLikelihood.NewMinuit_minos_upper_error(self, n, level, tol)


    def MnContour(self, par1, par2, level=1., npts=20):
        """
        MnContour(NewMinuit self, unsigned int par1, unsigned int par2, double level=1., unsigned int npts=20)
        MnContour(NewMinuit self, unsigned int par1, unsigned int par2, double level=1.)
        MnContour(NewMinuit self, unsigned int par1, unsigned int par2)
        """
        return _pyLikelihood.NewMinuit_MnContour(self, par1, par2, level, npts)

NewMinuit_swigregister = _pyLikelihood.NewMinuit_swigregister
NewMinuit_swigregister(NewMinuit)

class FitsImage(_object):
    """Proxy of C++ st_facilities::FitsImage class."""

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

    def __init__(self, *args):
        """
        __init__(st_facilities::FitsImage self) -> FitsImage
        __init__(st_facilities::FitsImage self, std::string const & fitsfile, std::string const & extension) -> FitsImage
        __init__(st_facilities::FitsImage self, std::string const & fitsfile) -> FitsImage
        __init__(st_facilities::FitsImage self, FitsImage arg2) -> FitsImage
        """
        this = _pyLikelihood.new_FitsImage(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FitsImage
    __del__ = lambda self: None

    def getAxisDims(self, axisDims):
        """getAxisDims(FitsImage self, std::vector< int,std::allocator< int > > & axisDims)"""
        return _pyLikelihood.FitsImage_getAxisDims(self, axisDims)


    def getAxisNames(self, axisNames):
        """getAxisNames(FitsImage self, StringVector axisNames)"""
        return _pyLikelihood.FitsImage_getAxisNames(self, axisNames)


    def getCelestialArrays(self, lonArray, latArray):
        """getCelestialArrays(FitsImage self, DoubleVector lonArray, DoubleVector latArray)"""
        return _pyLikelihood.FitsImage_getCelestialArrays(self, lonArray, latArray)


    def getImageData(self, imageData):
        """getImageData(FitsImage self, DoubleVector imageData)"""
        return _pyLikelihood.FitsImage_getImageData(self, imageData)


    def getSolidAngles(self, solidAngles):
        """getSolidAngles(FitsImage self, DoubleVector solidAngles)"""
        return _pyLikelihood.FitsImage_getSolidAngles(self, solidAngles)


    def imageData(self):
        """imageData(FitsImage self) -> FloatVector"""
        return _pyLikelihood.FitsImage_imageData(self)


    def skyProjCreate(*args):
        """
        skyProjCreate(std::string const & fitsFile, std::string const & extension) -> SkyProj
        skyProjCreate(std::string const & fitsFile) -> SkyProj
        """
        return _pyLikelihood.FitsImage_skyProjCreate(*args)

    skyProjCreate = staticmethod(skyProjCreate)

    def solidAngle(A, B, C, D):
        """solidAngle(SkyDir A, SkyDir B, SkyDir C, SkyDir D) -> double"""
        return _pyLikelihood.FitsImage_solidAngle(A, B, C, D)

    solidAngle = staticmethod(solidAngle)
FitsImage_swigregister = _pyLikelihood.FitsImage_swigregister
FitsImage_swigregister(FitsImage)

def FitsImage_skyProjCreate(*args):
    """
    skyProjCreate(std::string const & fitsFile, std::string const & extension) -> SkyProj
    FitsImage_skyProjCreate(std::string const & fitsFile) -> SkyProj
    """
    return _pyLikelihood.FitsImage_skyProjCreate(*args)

def FitsImage_solidAngle(A, B, C, D):
    """FitsImage_solidAngle(SkyDir A, SkyDir B, SkyDir C, SkyDir D) -> double"""
    return _pyLikelihood.FitsImage_solidAngle(A, B, C, D)

class Util(_object):
    """Proxy of C++ st_facilities::Util class."""

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

    def fileExists(filename):
        """fileExists(std::string const & filename) -> bool"""
        return _pyLikelihood.Util_fileExists(filename)

    fileExists = staticmethod(fileExists)

    def file_ok(filename):
        """file_ok(std::string filename)"""
        return _pyLikelihood.Util_file_ok(filename)

    file_ok = staticmethod(file_ok)

    def readLines(*args):
        """
        readLines(std::string inputFile, StringVector lines, std::string const & skip, bool cleanLines=False)
        readLines(std::string inputFile, StringVector lines, std::string const & skip)
        readLines(std::string inputFile, StringVector lines)
        """
        return _pyLikelihood.Util_readLines(*args)

    readLines = staticmethod(readLines)

    def cleanLine(line):
        """cleanLine(std::string & line)"""
        return _pyLikelihood.Util_cleanLine(line)

    cleanLine = staticmethod(cleanLine)

    def isFitsFile(infile):
        """isFitsFile(std::string const & infile) -> bool"""
        return _pyLikelihood.Util_isFitsFile(infile)

    isFitsFile = staticmethod(isFitsFile)

    def resolve_fits_files(filename, files):
        """resolve_fits_files(std::string filename, StringVector files)"""
        return _pyLikelihood.Util_resolve_fits_files(filename, files)

    resolve_fits_files = staticmethod(resolve_fits_files)

    def isXmlFile(filename):
        """isXmlFile(std::string filename) -> bool"""
        return _pyLikelihood.Util_isXmlFile(filename)

    isXmlFile = staticmethod(isXmlFile)

    def interpolate(x, y, xx):
        """interpolate(DoubleVector x, DoubleVector y, double xx) -> double"""
        return _pyLikelihood.Util_interpolate(x, y, xx)

    interpolate = staticmethod(interpolate)

    def bilinear(*args):
        """
        bilinear(DoubleVector xx, double x, DoubleVector yy, double y, DoubleVector z) -> double
        bilinear(DoubleVector xx, double x, DoubleVector yy, double y, DoubleVectorVector z) -> double
        """
        return _pyLikelihood.Util_bilinear(*args)

    bilinear = staticmethod(bilinear)

    def expectedException(eObj, targetMessage):
        """expectedException(std::exception const & eObj, std::string const & targetMessage) -> bool"""
        return _pyLikelihood.Util_expectedException(eObj, targetMessage)

    expectedException = staticmethod(expectedException)

    def writeDateKeywords(*args):
        """
        writeDateKeywords(tip::Extension * table, double start_time, double stop_time, bool extension=True, JulianDate mission_start)
        writeDateKeywords(tip::Extension * table, double start_time, double stop_time, bool extension=True)
        writeDateKeywords(tip::Extension * table, double start_time, double stop_time)
        """
        return _pyLikelihood.Util_writeDateKeywords(*args)

    writeDateKeywords = staticmethod(writeDateKeywords)

    def resolveFitsFiles(infile):
        """resolveFitsFiles(std::string const & infile) -> StringVector"""
        return _pyLikelihood.Util_resolveFitsFiles(infile)

    resolveFitsFiles = staticmethod(resolveFitsFiles)

    def skyDir2pixel(proj, dir):
        """skyDir2pixel(SkyProj proj, SkyDir dir) -> DoublePair"""
        return _pyLikelihood.Util_skyDir2pixel(proj, dir)

    skyDir2pixel = staticmethod(skyDir2pixel)

    def pixel2SkyDir(proj, i, j):
        """pixel2SkyDir(SkyProj proj, double i, double j) -> SkyDir"""
        return _pyLikelihood.Util_pixel2SkyDir(proj, i, j)

    pixel2SkyDir = staticmethod(pixel2SkyDir)

    def setRandomSeed(seed):
        """setRandomSeed(long seed)"""
        return _pyLikelihood.Util_setRandomSeed(seed)

    setRandomSeed = staticmethod(setRandomSeed)

    def shoot():
        """shoot() -> double"""
        return _pyLikelihood.Util_shoot()

    shoot = staticmethod(shoot)

    def __init__(self):
        """__init__(st_facilities::Util self) -> Util"""
        this = _pyLikelihood.new_Util()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Util
    __del__ = lambda self: None
Util_swigregister = _pyLikelihood.Util_swigregister
Util_swigregister(Util)

def Util_fileExists(filename):
    """Util_fileExists(std::string const & filename) -> bool"""
    return _pyLikelihood.Util_fileExists(filename)

def Util_file_ok(filename):
    """Util_file_ok(std::string filename)"""
    return _pyLikelihood.Util_file_ok(filename)

def Util_readLines(*args):
    """
    readLines(std::string inputFile, StringVector lines, std::string const & skip, bool cleanLines=False)
    readLines(std::string inputFile, StringVector lines, std::string const & skip)
    Util_readLines(std::string inputFile, StringVector lines)
    """
    return _pyLikelihood.Util_readLines(*args)

def Util_cleanLine(line):
    """Util_cleanLine(std::string & line)"""
    return _pyLikelihood.Util_cleanLine(line)

def Util_isFitsFile(infile):
    """Util_isFitsFile(std::string const & infile) -> bool"""
    return _pyLikelihood.Util_isFitsFile(infile)

def Util_resolve_fits_files(filename, files):
    """Util_resolve_fits_files(std::string filename, StringVector files)"""
    return _pyLikelihood.Util_resolve_fits_files(filename, files)

def Util_isXmlFile(filename):
    """Util_isXmlFile(std::string filename) -> bool"""
    return _pyLikelihood.Util_isXmlFile(filename)

def Util_interpolate(x, y, xx):
    """Util_interpolate(DoubleVector x, DoubleVector y, double xx) -> double"""
    return _pyLikelihood.Util_interpolate(x, y, xx)

def Util_bilinear(*args):
    """
    bilinear(DoubleVector xx, double x, DoubleVector yy, double y, DoubleVector z) -> double
    Util_bilinear(DoubleVector xx, double x, DoubleVector yy, double y, DoubleVectorVector z) -> double
    """
    return _pyLikelihood.Util_bilinear(*args)

def Util_expectedException(eObj, targetMessage):
    """Util_expectedException(std::exception const & eObj, std::string const & targetMessage) -> bool"""
    return _pyLikelihood.Util_expectedException(eObj, targetMessage)

def Util_writeDateKeywords(*args):
    """
    writeDateKeywords(tip::Extension * table, double start_time, double stop_time, bool extension=True, JulianDate mission_start)
    writeDateKeywords(tip::Extension * table, double start_time, double stop_time, bool extension=True)
    Util_writeDateKeywords(tip::Extension * table, double start_time, double stop_time)
    """
    return _pyLikelihood.Util_writeDateKeywords(*args)

def Util_resolveFitsFiles(infile):
    """Util_resolveFitsFiles(std::string const & infile) -> StringVector"""
    return _pyLikelihood.Util_resolveFitsFiles(infile)

def Util_skyDir2pixel(proj, dir):
    """Util_skyDir2pixel(SkyProj proj, SkyDir dir) -> DoublePair"""
    return _pyLikelihood.Util_skyDir2pixel(proj, dir)

def Util_pixel2SkyDir(proj, i, j):
    """Util_pixel2SkyDir(SkyProj proj, double i, double j) -> SkyDir"""
    return _pyLikelihood.Util_pixel2SkyDir(proj, i, j)

def Util_setRandomSeed(seed):
    """Util_setRandomSeed(long seed)"""
    return _pyLikelihood.Util_setRandomSeed(seed)

def Util_shoot():
    """Util_shoot() -> double"""
    return _pyLikelihood.Util_shoot()

class IEfficiencyFactor(_object):
    """Proxy of C++ irfInterface::IEfficiencyFactor class."""

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

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

    def __call__(self, energy, met):
        """__call__(IEfficiencyFactor self, double energy, double met) -> double"""
        return _pyLikelihood.IEfficiencyFactor___call__(self, energy, met)


    def value(self, *args):
        """
        value(IEfficiencyFactor self, double energy, double livetimefrac, bool front, double met=0) -> double
        value(IEfficiencyFactor self, double energy, double livetimefrac, bool front) -> double
        value(IEfficiencyFactor self, double energy, double livetimefrac, double met=0) -> double
        value(IEfficiencyFactor self, double energy, double livetimefrac) -> double
        """
        return _pyLikelihood.IEfficiencyFactor_value(self, *args)


    def getLivetimeFactors(self, energy, factor1, factor2, met=0):
        """
        getLivetimeFactors(IEfficiencyFactor self, double energy, double & factor1, double & factor2, double met=0)
        getLivetimeFactors(IEfficiencyFactor self, double energy, double & factor1, double & factor2)
        """
        return _pyLikelihood.IEfficiencyFactor_getLivetimeFactors(self, energy, factor1, factor2, met)


    def clone(self):
        """clone(IEfficiencyFactor self) -> IEfficiencyFactor"""
        return _pyLikelihood.IEfficiencyFactor_clone(self)


    def readFt2File(self, ft2file):
        """readFt2File(IEfficiencyFactor self, std::string ft2file)"""
        return _pyLikelihood.IEfficiencyFactor_readFt2File(self, ft2file)


    def clearFt2Data(self):
        """clearFt2Data(IEfficiencyFactor self)"""
        return _pyLikelihood.IEfficiencyFactor_clearFt2Data(self)

IEfficiencyFactor_swigregister = _pyLikelihood.IEfficiencyFactor_swigregister
IEfficiencyFactor_swigregister(IEfficiencyFactor)

class AppHelpers(_object):
    """Proxy of C++ Likelihood::AppHelpers class."""

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

    def __init__(self):
        """__init__(Likelihood::AppHelpers self) -> AppHelpers"""
        this = _pyLikelihood.new_AppHelpers()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def funcFactory(self):
        """funcFactory(AppHelpers self) -> FunctionFactory"""
        return _pyLikelihood.AppHelpers_funcFactory(self)


    def checkOutputFile(clobber, filename):
        """checkOutputFile(bool clobber, std::string const & filename)"""
        return _pyLikelihood.AppHelpers_checkOutputFile(clobber, filename)

    checkOutputFile = staticmethod(checkOutputFile)

    def checkCuts(*args):
        """
        checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False, bool gtiWarningOnly=True)
        checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False)
        checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False)
        checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
        checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2)
        checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False, bool gtiWarningOnly=True)
        checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False)
        checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False)
        checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
        checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2)
        """
        return _pyLikelihood.AppHelpers_checkCuts(*args)

    checkCuts = staticmethod(checkCuts)

    def checkTimeCuts(*args):
        """
        checkTimeCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool gtiWarningOnly=True)
        checkTimeCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
        checkTimeCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2)
        checkTimeCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool gtiWarningOnly=True)
        checkTimeCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
        checkTimeCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2)
        """
        return _pyLikelihood.AppHelpers_checkTimeCuts(*args)

    checkTimeCuts = staticmethod(checkTimeCuts)

    def checkExpMapCuts(*args):
        """
        checkExpMapCuts(StringVector evfiles, std::string const & expMap, std::string const & evfileExt, std::string const & expMapExt)
        checkExpMapCuts(StringVector evfiles, std::string const & expMap, std::string const & evfileExt)
        checkExpMapCuts(StringVector evfiles, std::string const & expMap)
        """
        return _pyLikelihood.AppHelpers_checkExpMapCuts(*args)

    checkExpMapCuts = staticmethod(checkExpMapCuts)

    def responseFuncs(file, respBase):
        """responseFuncs(std::string const & file, std::string const & respBase) -> std::string"""
        return _pyLikelihood.AppHelpers_responseFuncs(file, respBase)

    responseFuncs = staticmethod(responseFuncs)

    def getSelectedEvtTypes(evfile, extname, selectedEvtTypes, evtype_bit_mask=3):
        """
        getSelectedEvtTypes(std::string const & evfile, std::string const & extname, std::vector< unsigned int,std::allocator< unsigned int > > & selectedEvtTypes, unsigned int evtype_bit_mask=3)
        getSelectedEvtTypes(std::string const & evfile, std::string const & extname, std::vector< unsigned int,std::allocator< unsigned int > > & selectedEvtTypes)
        """
        return _pyLikelihood.AppHelpers_getSelectedEvtTypes(evfile, extname, selectedEvtTypes, evtype_bit_mask)

    getSelectedEvtTypes = staticmethod(getSelectedEvtTypes)

    def addFunctionPrototypes(funcFactory):
        """addFunctionPrototypes(FunctionFactory funcFactory)"""
        return _pyLikelihood.AppHelpers_addFunctionPrototypes(funcFactory)

    addFunctionPrototypes = staticmethod(addFunctionPrototypes)

    def checkExposureMap(cmapfile, emapfile):
        """checkExposureMap(std::string const & cmapfile, std::string const & emapfile)"""
        return _pyLikelihood.AppHelpers_checkExposureMap(cmapfile, emapfile)

    checkExposureMap = staticmethod(checkExposureMap)

    def checkExposureMap_wcs(cmap, emap):
        """checkExposureMap_wcs(CountsMap cmap, BinnedExposureBase emap)"""
        return _pyLikelihood.AppHelpers_checkExposureMap_wcs(cmap, emap)

    checkExposureMap_wcs = staticmethod(checkExposureMap_wcs)

    def checkExposureMap_healpix(cmap, emap):
        """checkExposureMap_healpix(CountsMapHealpix cmap, BinnedExposureBase emap)"""
        return _pyLikelihood.AppHelpers_checkExposureMap_healpix(cmap, emap)

    checkExposureMap_healpix = staticmethod(checkExposureMap_healpix)

    def checkProjectionMethod(filename, hpx_ext):
        """checkProjectionMethod(std::string const & filename, std::string const & hpx_ext) -> astro::ProjBase::Method"""
        return _pyLikelihood.AppHelpers_checkProjectionMethod(filename, hpx_ext)

    checkProjectionMethod = staticmethod(checkProjectionMethod)

    def readCountsMap(filename):
        """readCountsMap(std::string const & filename) -> CountsMapBase"""
        return _pyLikelihood.AppHelpers_readCountsMap(filename)

    readCountsMap = staticmethod(readCountsMap)

    def readBinnedExposure(filename):
        """readBinnedExposure(std::string const & filename) -> BinnedExposureBase"""
        return _pyLikelihood.AppHelpers_readBinnedExposure(filename)

    readBinnedExposure = staticmethod(readBinnedExposure)
    __swig_destroy__ = _pyLikelihood.delete_AppHelpers
    __del__ = lambda self: None
AppHelpers_swigregister = _pyLikelihood.AppHelpers_swigregister
AppHelpers_swigregister(AppHelpers)

def AppHelpers_checkOutputFile(clobber, filename):
    """AppHelpers_checkOutputFile(bool clobber, std::string const & filename)"""
    return _pyLikelihood.AppHelpers_checkOutputFile(clobber, filename)

def AppHelpers_checkCuts(*args):
    """
    checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False, bool gtiWarningOnly=True)
    checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False)
    checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False)
    checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
    checkCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2)
    checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False, bool gtiWarningOnly=True)
    checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False, bool skipEventClassCuts=False)
    checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool relyOnStreams=False)
    checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
    AppHelpers_checkCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2)
    """
    return _pyLikelihood.AppHelpers_checkCuts(*args)

def AppHelpers_checkTimeCuts(*args):
    """
    checkTimeCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool gtiWarningOnly=True)
    checkTimeCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
    checkTimeCuts(std::string const & file1, std::string const & ext1, std::string const & file2, std::string const & ext2)
    checkTimeCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True, bool gtiWarningOnly=True)
    checkTimeCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2, bool compareGtis=True)
    AppHelpers_checkTimeCuts(StringVector files1, std::string const & ext1, std::string const & file2, std::string const & ext2)
    """
    return _pyLikelihood.AppHelpers_checkTimeCuts(*args)

def AppHelpers_checkExpMapCuts(*args):
    """
    checkExpMapCuts(StringVector evfiles, std::string const & expMap, std::string const & evfileExt, std::string const & expMapExt)
    checkExpMapCuts(StringVector evfiles, std::string const & expMap, std::string const & evfileExt)
    AppHelpers_checkExpMapCuts(StringVector evfiles, std::string const & expMap)
    """
    return _pyLikelihood.AppHelpers_checkExpMapCuts(*args)

def AppHelpers_responseFuncs(file, respBase):
    """AppHelpers_responseFuncs(std::string const & file, std::string const & respBase) -> std::string"""
    return _pyLikelihood.AppHelpers_responseFuncs(file, respBase)

def AppHelpers_getSelectedEvtTypes(evfile, extname, selectedEvtTypes, evtype_bit_mask=3):
    """
    getSelectedEvtTypes(std::string const & evfile, std::string const & extname, std::vector< unsigned int,std::allocator< unsigned int > > & selectedEvtTypes, unsigned int evtype_bit_mask=3)
    AppHelpers_getSelectedEvtTypes(std::string const & evfile, std::string const & extname, std::vector< unsigned int,std::allocator< unsigned int > > & selectedEvtTypes)
    """
    return _pyLikelihood.AppHelpers_getSelectedEvtTypes(evfile, extname, selectedEvtTypes, evtype_bit_mask)

def AppHelpers_addFunctionPrototypes(funcFactory):
    """AppHelpers_addFunctionPrototypes(FunctionFactory funcFactory)"""
    return _pyLikelihood.AppHelpers_addFunctionPrototypes(funcFactory)

def AppHelpers_checkExposureMap(cmapfile, emapfile):
    """AppHelpers_checkExposureMap(std::string const & cmapfile, std::string const & emapfile)"""
    return _pyLikelihood.AppHelpers_checkExposureMap(cmapfile, emapfile)

def AppHelpers_checkExposureMap_wcs(cmap, emap):
    """AppHelpers_checkExposureMap_wcs(CountsMap cmap, BinnedExposureBase emap)"""
    return _pyLikelihood.AppHelpers_checkExposureMap_wcs(cmap, emap)

def AppHelpers_checkExposureMap_healpix(cmap, emap):
    """AppHelpers_checkExposureMap_healpix(CountsMapHealpix cmap, BinnedExposureBase emap)"""
    return _pyLikelihood.AppHelpers_checkExposureMap_healpix(cmap, emap)

def AppHelpers_checkProjectionMethod(filename, hpx_ext):
    """AppHelpers_checkProjectionMethod(std::string const & filename, std::string const & hpx_ext) -> astro::ProjBase::Method"""
    return _pyLikelihood.AppHelpers_checkProjectionMethod(filename, hpx_ext)

def AppHelpers_readCountsMap(filename):
    """AppHelpers_readCountsMap(std::string const & filename) -> CountsMapBase"""
    return _pyLikelihood.AppHelpers_readCountsMap(filename)

def AppHelpers_readBinnedExposure(filename):
    """AppHelpers_readBinnedExposure(std::string const & filename) -> BinnedExposureBase"""
    return _pyLikelihood.AppHelpers_readBinnedExposure(filename)

class PsfIntegConfig(_object):
    """Proxy of C++ Likelihood::PsfIntegConfig class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PsfIntegConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PsfIntegConfig, name)
    __repr__ = _swig_repr
    adaptive = _pyLikelihood.PsfIntegConfig_adaptive
    annular = _pyLikelihood.PsfIntegConfig_annular
    pixel_center = _pyLikelihood.PsfIntegConfig_pixel_center

    def __init__(self, *args):
        """
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True, bool use_single_psf=False) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True, bool performConvolution=True) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, bool applyPsfCorrections=True) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self) -> PsfIntegConfig
        __init__(Likelihood::PsfIntegConfig self, PsfIntegConfig other) -> PsfIntegConfig
        """
        this = _pyLikelihood.new_PsfIntegConfig(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_PsfIntegConfig
    __del__ = lambda self: None

    def set_applyPsfCorrections(self, val):
        """set_applyPsfCorrections(PsfIntegConfig self, bool val)"""
        return _pyLikelihood.PsfIntegConfig_set_applyPsfCorrections(self, val)


    def applyPsfCorrections(self):
        """applyPsfCorrections(PsfIntegConfig self) -> bool"""
        return _pyLikelihood.PsfIntegConfig_applyPsfCorrections(self)


    def set_performConvolution(self, val):
        """set_performConvolution(PsfIntegConfig self, bool val)"""
        return _pyLikelihood.PsfIntegConfig_set_performConvolution(self, val)


    def performConvolution(self):
        """performConvolution(PsfIntegConfig self) -> bool"""
        return _pyLikelihood.PsfIntegConfig_performConvolution(self)


    def set_resample(self, val):
        """set_resample(PsfIntegConfig self, bool val)"""
        return _pyLikelihood.PsfIntegConfig_set_resample(self, val)


    def resample(self):
        """resample(PsfIntegConfig self) -> bool"""
        return _pyLikelihood.PsfIntegConfig_resample(self)


    def set_resamp_factor(self, val):
        """set_resamp_factor(PsfIntegConfig self, double val)"""
        return _pyLikelihood.PsfIntegConfig_set_resamp_factor(self, val)


    def resamp_factor(self):
        """resamp_factor(PsfIntegConfig self) -> double"""
        return _pyLikelihood.PsfIntegConfig_resamp_factor(self)


    def minbinsz(self, *args):
        """
        minbinsz(PsfIntegConfig self, double val)
        minbinsz(PsfIntegConfig self) -> double
        """
        return _pyLikelihood.PsfIntegConfig_minbinsz(self, *args)


    def set_integ_type(self, val):
        """set_integ_type(PsfIntegConfig self, Likelihood::PsfIntegConfig::PSFIntegType val)"""
        return _pyLikelihood.PsfIntegConfig_set_integ_type(self, val)


    def integ_type(self):
        """integ_type(PsfIntegConfig self) -> Likelihood::PsfIntegConfig::PSFIntegType"""
        return _pyLikelihood.PsfIntegConfig_integ_type(self)


    def set_psfEstimatorFtol(self, val):
        """set_psfEstimatorFtol(PsfIntegConfig self, double val)"""
        return _pyLikelihood.PsfIntegConfig_set_psfEstimatorFtol(self, val)


    def psfEstimatorFtol(self):
        """psfEstimatorFtol(PsfIntegConfig self) -> double"""
        return _pyLikelihood.PsfIntegConfig_psfEstimatorFtol(self)


    def set_psfEstimatorPeakTh(self, val):
        """set_psfEstimatorPeakTh(PsfIntegConfig self, double val)"""
        return _pyLikelihood.PsfIntegConfig_set_psfEstimatorPeakTh(self, val)


    def psfEstimatorPeakTh(self):
        """psfEstimatorPeakTh(PsfIntegConfig self) -> double"""
        return _pyLikelihood.PsfIntegConfig_psfEstimatorPeakTh(self)


    def set_verbose(self, val):
        """set_verbose(PsfIntegConfig self, bool val)"""
        return _pyLikelihood.PsfIntegConfig_set_verbose(self, val)


    def verbose(self):
        """verbose(PsfIntegConfig self) -> bool"""
        return _pyLikelihood.PsfIntegConfig_verbose(self)


    def set_use_single_psf(self, val):
        """set_use_single_psf(PsfIntegConfig self, bool val)"""
        return _pyLikelihood.PsfIntegConfig_set_use_single_psf(self, val)


    def use_single_psf(self):
        """use_single_psf(PsfIntegConfig self) -> bool"""
        return _pyLikelihood.PsfIntegConfig_use_single_psf(self)

PsfIntegConfig_swigregister = _pyLikelihood.PsfIntegConfig_swigregister
PsfIntegConfig_swigregister(PsfIntegConfig)

class BinnedLikeConfig(_object):
    """Proxy of C++ Likelihood::BinnedLikeConfig class."""

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

    def get_envars(integ_type, estimatorFtol, estimatorPeakTh, edisp_val, use_linear_quadrature, save_all_srcmaps, use_single_psf):
        """get_envars(Likelihood::PsfIntegConfig::PSFIntegType & integ_type, double & estimatorFtol, double & estimatorPeakTh, int & edisp_val, bool & use_linear_quadrature, bool & save_all_srcmaps, bool & use_single_psf)"""
        return _pyLikelihood.BinnedLikeConfig_get_envars(integ_type, estimatorFtol, estimatorPeakTh, edisp_val, use_linear_quadrature, save_all_srcmaps, use_single_psf)

    get_envars = staticmethod(get_envars)

    def __init__(self, *args):
        """
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True, int edisp_val=-1, bool use_single_fixed_map=True, bool use_linear_quadrature=False, bool save_all_srcmaps=False, bool use_single_psf=False, bool load_existing_srcmaps=True) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True, int edisp_val=-1, bool use_single_fixed_map=True, bool use_linear_quadrature=False, bool save_all_srcmaps=False, bool use_single_psf=False) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True, int edisp_val=-1, bool use_single_fixed_map=True, bool use_linear_quadrature=False, bool save_all_srcmaps=False) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True, int edisp_val=-1, bool use_single_fixed_map=True, bool use_linear_quadrature=False) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True, int edisp_val=-1, bool use_single_fixed_map=True) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True, int edisp_val=-1) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6, bool verbose=True) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3, double psfEstimatorPeakTh=1e-6) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type, double psfEstimatorFtol=1e-3) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, Likelihood::PsfIntegConfig::PSFIntegType integ_type) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True, bool applyPsfCorrections=True) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, bool computePointSources=True) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self) -> BinnedLikeConfig
        __init__(Likelihood::BinnedLikeConfig self, BinnedLikeConfig other) -> BinnedLikeConfig
        """
        this = _pyLikelihood.new_BinnedLikeConfig(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def psf_integ_config(self, *args):
        """
        psf_integ_config(BinnedLikeConfig self) -> PsfIntegConfig
        psf_integ_config(BinnedLikeConfig self) -> PsfIntegConfig
        """
        return _pyLikelihood.BinnedLikeConfig_psf_integ_config(self, *args)


    def set_computePointSources(self, val):
        """set_computePointSources(BinnedLikeConfig self, bool val)"""
        return _pyLikelihood.BinnedLikeConfig_set_computePointSources(self, val)


    def set_edisp_val(self, val):
        """set_edisp_val(BinnedLikeConfig self, int val)"""
        return _pyLikelihood.BinnedLikeConfig_set_edisp_val(self, val)


    def set_use_single_fixed_map(self, val):
        """set_use_single_fixed_map(BinnedLikeConfig self, bool val)"""
        return _pyLikelihood.BinnedLikeConfig_set_use_single_fixed_map(self, val)


    def set_use_linear_quadrature(self, val):
        """set_use_linear_quadrature(BinnedLikeConfig self, bool val)"""
        return _pyLikelihood.BinnedLikeConfig_set_use_linear_quadrature(self, val)


    def set_save_all_srcmaps(self, val):
        """set_save_all_srcmaps(BinnedLikeConfig self, bool val)"""
        return _pyLikelihood.BinnedLikeConfig_set_save_all_srcmaps(self, val)


    def set_load_existing_srcmaps(self, val):
        """set_load_existing_srcmaps(BinnedLikeConfig self, bool val)"""
        return _pyLikelihood.BinnedLikeConfig_set_load_existing_srcmaps(self, val)


    def computePointSources(self):
        """computePointSources(BinnedLikeConfig self) -> bool"""
        return _pyLikelihood.BinnedLikeConfig_computePointSources(self)


    def edisp_val(self):
        """edisp_val(BinnedLikeConfig self) -> int"""
        return _pyLikelihood.BinnedLikeConfig_edisp_val(self)


    def use_single_fixed_map(self):
        """use_single_fixed_map(BinnedLikeConfig self) -> bool"""
        return _pyLikelihood.BinnedLikeConfig_use_single_fixed_map(self)


    def use_linear_quadrature(self):
        """use_linear_quadrature(BinnedLikeConfig self) -> bool"""
        return _pyLikelihood.BinnedLikeConfig_use_linear_quadrature(self)


    def save_all_srcmaps(self):
        """save_all_srcmaps(BinnedLikeConfig self) -> bool"""
        return _pyLikelihood.BinnedLikeConfig_save_all_srcmaps(self)


    def load_existing_srcmaps(self):
        """load_existing_srcmaps(BinnedLikeConfig self) -> bool"""
        return _pyLikelihood.BinnedLikeConfig_load_existing_srcmaps(self)

    __swig_destroy__ = _pyLikelihood.delete_BinnedLikeConfig
    __del__ = lambda self: None
BinnedLikeConfig_swigregister = _pyLikelihood.BinnedLikeConfig_swigregister
BinnedLikeConfig_swigregister(BinnedLikeConfig)

def BinnedLikeConfig_get_envars(integ_type, estimatorFtol, estimatorPeakTh, edisp_val, use_linear_quadrature, save_all_srcmaps, use_single_psf):
    """BinnedLikeConfig_get_envars(Likelihood::PsfIntegConfig::PSFIntegType & integ_type, double & estimatorFtol, double & estimatorPeakTh, int & edisp_val, bool & use_linear_quadrature, bool & save_all_srcmaps, bool & use_single_psf)"""
    return _pyLikelihood.BinnedLikeConfig_get_envars(integ_type, estimatorFtol, estimatorPeakTh, edisp_val, use_linear_quadrature, save_all_srcmaps, use_single_psf)

class BrokenPowerLaw2(Function):
    """Proxy of C++ Likelihood::BrokenPowerLaw2 class."""

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

    def __init__(self, Integral=1., Index1=-2., Index2=-3., BreakValue=1000., LowerLimit=20., UpperLimit=2e5):
        """
        __init__(Likelihood::BrokenPowerLaw2 self, double Integral=1., double Index1=-2., double Index2=-3., double BreakValue=1000., double LowerLimit=20., double UpperLimit=2e5) -> BrokenPowerLaw2
        __init__(Likelihood::BrokenPowerLaw2 self, double Integral=1., double Index1=-2., double Index2=-3., double BreakValue=1000., double LowerLimit=20.) -> BrokenPowerLaw2
        __init__(Likelihood::BrokenPowerLaw2 self, double Integral=1., double Index1=-2., double Index2=-3., double BreakValue=1000.) -> BrokenPowerLaw2
        __init__(Likelihood::BrokenPowerLaw2 self, double Integral=1., double Index1=-2., double Index2=-3.) -> BrokenPowerLaw2
        __init__(Likelihood::BrokenPowerLaw2 self, double Integral=1., double Index1=-2.) -> BrokenPowerLaw2
        __init__(Likelihood::BrokenPowerLaw2 self, double Integral=1.) -> BrokenPowerLaw2
        __init__(Likelihood::BrokenPowerLaw2 self) -> BrokenPowerLaw2
        """
        this = _pyLikelihood.new_BrokenPowerLaw2(Integral, Index1, Index2, BreakValue, LowerLimit, UpperLimit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def integral(self, xmin, xmax):
        """integral(BrokenPowerLaw2 self, Arg xmin, Arg xmax) -> double"""
        return _pyLikelihood.BrokenPowerLaw2_integral(self, xmin, xmax)


    def clone(self):
        """clone(BrokenPowerLaw2 self) -> Function *"""
        return _pyLikelihood.BrokenPowerLaw2_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_BrokenPowerLaw2
    __del__ = lambda self: None
BrokenPowerLaw2_swigregister = _pyLikelihood.BrokenPowerLaw2_swigregister
BrokenPowerLaw2_swigregister(BrokenPowerLaw2)

class BrokenPowerLaw3(Function):
    """Proxy of C++ Likelihood::BrokenPowerLaw3 class."""

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

    def __init__(self, Integral1=1., Index1=-2., Integral2=1., Index2=-3., LowerLimit1=100., UpperLimit1=1e4, LowerLimit2=2e4, UpperLimit2=1e5):
        """
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1., double Index1=-2., double Integral2=1., double Index2=-3., double LowerLimit1=100., double UpperLimit1=1e4, double LowerLimit2=2e4, double UpperLimit2=1e5) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1., double Index1=-2., double Integral2=1., double Index2=-3., double LowerLimit1=100., double UpperLimit1=1e4, double LowerLimit2=2e4) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1., double Index1=-2., double Integral2=1., double Index2=-3., double LowerLimit1=100., double UpperLimit1=1e4) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1., double Index1=-2., double Integral2=1., double Index2=-3., double LowerLimit1=100.) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1., double Index1=-2., double Integral2=1., double Index2=-3.) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1., double Index1=-2., double Integral2=1.) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1., double Index1=-2.) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self, double Integral1=1.) -> BrokenPowerLaw3
        __init__(Likelihood::BrokenPowerLaw3 self) -> BrokenPowerLaw3
        """
        this = _pyLikelihood.new_BrokenPowerLaw3(Integral1, Index1, Integral2, Index2, LowerLimit1, UpperLimit1, LowerLimit2, UpperLimit2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def integral(self, xmin, xmax):
        """integral(BrokenPowerLaw3 self, Arg xmin, Arg xmax) -> double"""
        return _pyLikelihood.BrokenPowerLaw3_integral(self, xmin, xmax)


    def clone(self):
        """clone(BrokenPowerLaw3 self) -> Function *"""
        return _pyLikelihood.BrokenPowerLaw3_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_BrokenPowerLaw3
    __del__ = lambda self: None
BrokenPowerLaw3_swigregister = _pyLikelihood.BrokenPowerLaw3_swigregister
BrokenPowerLaw3_swigregister(BrokenPowerLaw3)

class BrokenPowerLawExpCutoff(Function):
    """Proxy of C++ Likelihood::BrokenPowerLawExpCutoff class."""

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

    def __init__(self, Prefactor=10, Index1=-2.1, Index2=-2.1, BreakValue=1000., Eabs=10., P1=150.):
        """
        __init__(Likelihood::BrokenPowerLawExpCutoff self, double Prefactor=10, double Index1=-2.1, double Index2=-2.1, double BreakValue=1000., double Eabs=10., double P1=150.) -> BrokenPowerLawExpCutoff
        __init__(Likelihood::BrokenPowerLawExpCutoff self, double Prefactor=10, double Index1=-2.1, double Index2=-2.1, double BreakValue=1000., double Eabs=10.) -> BrokenPowerLawExpCutoff
        __init__(Likelihood::BrokenPowerLawExpCutoff self, double Prefactor=10, double Index1=-2.1, double Index2=-2.1, double BreakValue=1000.) -> BrokenPowerLawExpCutoff
        __init__(Likelihood::BrokenPowerLawExpCutoff self, double Prefactor=10, double Index1=-2.1, double Index2=-2.1) -> BrokenPowerLawExpCutoff
        __init__(Likelihood::BrokenPowerLawExpCutoff self, double Prefactor=10, double Index1=-2.1) -> BrokenPowerLawExpCutoff
        __init__(Likelihood::BrokenPowerLawExpCutoff self, double Prefactor=10) -> BrokenPowerLawExpCutoff
        __init__(Likelihood::BrokenPowerLawExpCutoff self) -> BrokenPowerLawExpCutoff
        """
        this = _pyLikelihood.new_BrokenPowerLawExpCutoff(Prefactor, Index1, Index2, BreakValue, Eabs, P1)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(BrokenPowerLawExpCutoff self) -> Function"""
        return _pyLikelihood.BrokenPowerLawExpCutoff_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_BrokenPowerLawExpCutoff
    __del__ = lambda self: None
BrokenPowerLawExpCutoff_swigregister = _pyLikelihood.BrokenPowerLawExpCutoff_swigregister
BrokenPowerLawExpCutoff_swigregister(BrokenPowerLawExpCutoff)

class Convolve(_object):
    """Proxy of C++ Likelihood::Convolve class."""

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

    def convolve(*args):
        """
        convolve(DoubleVector signal, DoubleVector psf) -> DoubleVector
        convolve(FloatVector signal, FloatVector psf) -> FloatVector
        """
        return _pyLikelihood.Convolve_convolve(*args)

    convolve = staticmethod(convolve)

    def convolve2d(*args):
        """
        convolve2d(DoubleVectorVector signal, DoubleVectorVector psf) -> DoubleVectorVector
        convolve2d(FloatVectorVector signal, FloatVectorVector psf) -> FloatVectorVector
        """
        return _pyLikelihood.Convolve_convolve2d(*args)

    convolve2d = staticmethod(convolve2d)

    def __init__(self):
        """__init__(Likelihood::Convolve self) -> Convolve"""
        this = _pyLikelihood.new_Convolve()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Convolve
    __del__ = lambda self: None
Convolve_swigregister = _pyLikelihood.Convolve_swigregister
Convolve_swigregister(Convolve)

def Convolve_convolve(*args):
    """
    convolve(DoubleVector signal, DoubleVector psf) -> DoubleVector
    Convolve_convolve(FloatVector signal, FloatVector psf) -> FloatVector
    """
    return _pyLikelihood.Convolve_convolve(*args)

def Convolve_convolve2d(*args):
    """
    convolve2d(DoubleVectorVector signal, DoubleVectorVector psf) -> DoubleVectorVector
    Convolve_convolve2d(FloatVectorVector signal, FloatVectorVector psf) -> FloatVectorVector
    """
    return _pyLikelihood.Convolve_convolve2d(*args)

class DiffRespIntegrand(_object):
    """Proxy of C++ Likelihood::DiffRespIntegrand class."""

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

    def do2DIntegration(event, respFuncs, src, eqRot, mumin=-1.0, mumax=1.0, phimin=0, phimax=2, muerr=0.01, phierr=0.1):
        """
        do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0, double phimax=2, double muerr=0.01, double phierr=0.1) -> double
        do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0, double phimax=2, double muerr=0.01) -> double
        do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0, double phimax=2) -> double
        do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0) -> double
        do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0) -> double
        do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0) -> double
        do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot) -> double
        """
        return _pyLikelihood.DiffRespIntegrand_do2DIntegration(event, respFuncs, src, eqRot, mumin, mumax, phimin, phimax, muerr, phierr)

    do2DIntegration = staticmethod(do2DIntegration)

    def __init__(self, event, respFuncs, src, eqRot, phimin=0, phimax=2, err=0.1):
        """
        __init__(Likelihood::DiffRespIntegrand self, Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double phimin=0, double phimax=2, double err=0.1) -> DiffRespIntegrand
        __init__(Likelihood::DiffRespIntegrand self, Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double phimin=0, double phimax=2) -> DiffRespIntegrand
        __init__(Likelihood::DiffRespIntegrand self, Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double phimin=0) -> DiffRespIntegrand
        __init__(Likelihood::DiffRespIntegrand self, Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot) -> DiffRespIntegrand
        """
        this = _pyLikelihood.new_DiffRespIntegrand(event, respFuncs, src, eqRot, phimin, phimax, err)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, mu):
        """__call__(DiffRespIntegrand self, double mu) -> double"""
        return _pyLikelihood.DiffRespIntegrand___call__(self, mu)


    def getSrcDir(mu, phi, eqRot, srcDir):
        """getSrcDir(double mu, double phi, EquinoxRotation eqRot, SkyDir srcDir)"""
        return _pyLikelihood.DiffRespIntegrand_getSrcDir(mu, phi, eqRot, srcDir)

    getSrcDir = staticmethod(getSrcDir)

    def phiValue(mu, srcDir, eqRot):
        """phiValue(double mu, SkyDir srcDir, EquinoxRotation eqRot) -> double"""
        return _pyLikelihood.DiffRespIntegrand_phiValue(mu, srcDir, eqRot)

    phiValue = staticmethod(phiValue)

    def srcDir(mu, phi, eqRot):
        """srcDir(double mu, double phi, EquinoxRotation eqRot) -> SkyDir"""
        return _pyLikelihood.DiffRespIntegrand_srcDir(mu, phi, eqRot)

    srcDir = staticmethod(srcDir)
    __swig_destroy__ = _pyLikelihood.delete_DiffRespIntegrand
    __del__ = lambda self: None
DiffRespIntegrand_swigregister = _pyLikelihood.DiffRespIntegrand_swigregister
DiffRespIntegrand_swigregister(DiffRespIntegrand)

def DiffRespIntegrand_do2DIntegration(event, respFuncs, src, eqRot, mumin=-1.0, mumax=1.0, phimin=0, phimax=2, muerr=0.01, phierr=0.1):
    """
    do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0, double phimax=2, double muerr=0.01, double phierr=0.1) -> double
    do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0, double phimax=2, double muerr=0.01) -> double
    do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0, double phimax=2) -> double
    do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0, double phimin=0) -> double
    do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0, double mumax=1.0) -> double
    do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot, double mumin=-1.0) -> double
    DiffRespIntegrand_do2DIntegration(Event event, ResponseFunctions respFuncs, DiffuseSource src, EquinoxRotation eqRot) -> double
    """
    return _pyLikelihood.DiffRespIntegrand_do2DIntegration(event, respFuncs, src, eqRot, mumin, mumax, phimin, phimax, muerr, phierr)

def DiffRespIntegrand_getSrcDir(mu, phi, eqRot, srcDir):
    """DiffRespIntegrand_getSrcDir(double mu, double phi, EquinoxRotation eqRot, SkyDir srcDir)"""
    return _pyLikelihood.DiffRespIntegrand_getSrcDir(mu, phi, eqRot, srcDir)

def DiffRespIntegrand_phiValue(mu, srcDir, eqRot):
    """DiffRespIntegrand_phiValue(double mu, SkyDir srcDir, EquinoxRotation eqRot) -> double"""
    return _pyLikelihood.DiffRespIntegrand_phiValue(mu, srcDir, eqRot)

def DiffRespIntegrand_srcDir(mu, phi, eqRot):
    """DiffRespIntegrand_srcDir(double mu, double phi, EquinoxRotation eqRot) -> SkyDir"""
    return _pyLikelihood.DiffRespIntegrand_srcDir(mu, phi, eqRot)

class Drm(_object):
    """Proxy of C++ Likelihood::Drm class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::Drm self, double ra, double dec, Observation observation, DoubleVector ebounds, size_t npts=30) -> Drm
        __init__(Likelihood::Drm self, double ra, double dec, Observation observation, DoubleVector ebounds) -> Drm
        __init__(Likelihood::Drm self, double ra, double dec, DoubleVector ebounds, DoubleVectorVector values) -> Drm
        """
        this = _pyLikelihood.new_Drm(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def convolve(self, true_counts, meas_counts):
        """convolve(Drm self, DoubleVector true_counts, DoubleVector meas_counts)"""
        return _pyLikelihood.Drm_convolve(self, true_counts, meas_counts)


    def row(self, k):
        """row(Drm self, size_t k) -> DoubleVector"""
        return _pyLikelihood.Drm_row(self, k)


    def col(self, k):
        """col(Drm self, size_t k) -> DoubleVector"""
        return _pyLikelihood.Drm_col(self, k)


    def observation(self):
        """observation(Drm self) -> Observation"""
        return _pyLikelihood.Drm_observation(self)


    def matrix_element(self, etrue, emeas_min, emeas_max):
        """matrix_element(Drm self, double etrue, double emeas_min, double emeas_max) -> double"""
        return _pyLikelihood.Drm_matrix_element(self, etrue, emeas_min, emeas_max)


    def extrapolate_lo(self, *args):
        """
        extrapolate_lo(Drm self, std::deque< double > const & counts) -> double
        extrapolate_lo(Drm self, double const & c0, double const & c1) -> double
        """
        return _pyLikelihood.Drm_extrapolate_lo(self, *args)


    def extrapolate_hi(self, *args):
        """
        extrapolate_hi(Drm self, std::deque< double > const & counts) -> double
        extrapolate_hi(Drm self, double const & c0, double const & c1) -> double
        """
        return _pyLikelihood.Drm_extrapolate_hi(self, *args)


    def ebounds(self):
        """ebounds(Drm self) -> std::deque< double > const &"""
        return _pyLikelihood.Drm_ebounds(self)


    def refDir(self):
        """refDir(Drm self) -> SkyDir"""
        return _pyLikelihood.Drm_refDir(self)

    __swig_destroy__ = _pyLikelihood.delete_Drm
    __del__ = lambda self: None
Drm_swigregister = _pyLikelihood.Drm_swigregister
Drm_swigregister(Drm)

class Drm_Cache(_object):
    """Proxy of C++ Likelihood::Drm_Cache class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::Drm_Cache self, Drm drm, SourceMap sourceMap, DoubleVector energies, int edisp_val) -> Drm_Cache
        __init__(Likelihood::Drm_Cache self, Drm_Cache other) -> Drm_Cache
        """
        this = _pyLikelihood.new_Drm_Cache(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(Drm_Cache self) -> Drm_Cache"""
        return _pyLikelihood.Drm_Cache_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_Drm_Cache
    __del__ = lambda self: None

    def update(self, drm, sourceMap, energies, edisp_flag):
        """update(Drm_Cache self, Drm drm, SourceMap sourceMap, DoubleVector energies, int edisp_flag)"""
        return _pyLikelihood.Drm_Cache_update(self, drm, sourceMap, energies, edisp_flag)


    def get_correction(self, k, kref):
        """get_correction(Drm_Cache self, size_t k, int & kref) -> double"""
        return _pyLikelihood.Drm_Cache_get_correction(self, k, kref)


    def true_counts(self):
        """true_counts(Drm_Cache self) -> DoubleVector"""
        return _pyLikelihood.Drm_Cache_true_counts(self)


    def meas_counts(self):
        """meas_counts(Drm_Cache self) -> DoubleVector"""
        return _pyLikelihood.Drm_Cache_meas_counts(self)


    def xi(self):
        """xi(Drm_Cache self) -> DoubleVector"""
        return _pyLikelihood.Drm_Cache_xi(self)


    def true_counts_wt(self):
        """true_counts_wt(Drm_Cache self) -> DoubleVector"""
        return _pyLikelihood.Drm_Cache_true_counts_wt(self)


    def meas_counts_wt(self):
        """meas_counts_wt(Drm_Cache self) -> DoubleVector"""
        return _pyLikelihood.Drm_Cache_meas_counts_wt(self)


    def kref(self):
        """kref(Drm_Cache self) -> std::vector< int,std::allocator< int > > const"""
        return _pyLikelihood.Drm_Cache_kref(self)


    def edisp_val(self):
        """edisp_val(Drm_Cache self) -> int"""
        return _pyLikelihood.Drm_Cache_edisp_val(self)


    def memory_size(self):
        """memory_size(Drm_Cache self) -> size_t"""
        return _pyLikelihood.Drm_Cache_memory_size(self)

Drm_Cache_swigregister = _pyLikelihood.Drm_Cache_swigregister
Drm_Cache_swigregister(Drm_Cache)

class DMFitFunction(Function):
    """Proxy of C++ Likelihood::DMFitFunction class."""

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

    def __init__(self, norm=1., sigmav=1., mass=100., bratio=1., channel0=1, channel1=1):
        """
        __init__(Likelihood::DMFitFunction self, double norm=1., double sigmav=1., double mass=100., double bratio=1., int channel0=1, int channel1=1) -> DMFitFunction
        __init__(Likelihood::DMFitFunction self, double norm=1., double sigmav=1., double mass=100., double bratio=1., int channel0=1) -> DMFitFunction
        __init__(Likelihood::DMFitFunction self, double norm=1., double sigmav=1., double mass=100., double bratio=1.) -> DMFitFunction
        __init__(Likelihood::DMFitFunction self, double norm=1., double sigmav=1., double mass=100.) -> DMFitFunction
        __init__(Likelihood::DMFitFunction self, double norm=1., double sigmav=1.) -> DMFitFunction
        __init__(Likelihood::DMFitFunction self, double norm=1.) -> DMFitFunction
        __init__(Likelihood::DMFitFunction self) -> DMFitFunction
        """
        this = _pyLikelihood.new_DMFitFunction(norm, sigmav, mass, bratio, channel0, channel1)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(DMFitFunction self) -> Function *"""
        return _pyLikelihood.DMFitFunction_clone(self)


    def readFunction(self, filename):
        """readFunction(DMFitFunction self, std::string const & filename)"""
        return _pyLikelihood.DMFitFunction_readFunction(self, filename)


    def filename(self):
        """filename(DMFitFunction self) -> std::string const &"""
        return _pyLikelihood.DMFitFunction_filename(self)

    __swig_destroy__ = _pyLikelihood.delete_DMFitFunction
    __del__ = lambda self: None
DMFitFunction_swigregister = _pyLikelihood.DMFitFunction_swigregister
DMFitFunction_swigregister(DMFitFunction)

class Exception(_object):
    """Proxy of C++ Likelihood::Exception class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::Exception self) -> Exception
        __init__(Likelihood::Exception self, std::string errorString, int code=0) -> Exception
        __init__(Likelihood::Exception self, std::string errorString) -> Exception
        """
        this = _pyLikelihood.new_Exception(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Exception
    __del__ = lambda self: None

    def what(self):
        """what(Exception self) -> char const *"""
        return _pyLikelihood.Exception_what(self)


    def code(self):
        """code(Exception self) -> int"""
        return _pyLikelihood.Exception_code(self)

Exception_swigregister = _pyLikelihood.Exception_swigregister
Exception_swigregister(Exception)

class EquinoxRotation(_object):
    """Proxy of C++ Likelihood::EquinoxRotation class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::EquinoxRotation self) -> EquinoxRotation
        __init__(Likelihood::EquinoxRotation self, double alpha0, double delta0) -> EquinoxRotation
        """
        this = _pyLikelihood.new_EquinoxRotation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_EquinoxRotation
    __del__ = lambda self: None

    def do_rotation(self, inDir, outDir, toMapCoords=False):
        """
        do_rotation(EquinoxRotation self, SkyDir inDir, SkyDir outDir, bool toMapCoords=False)
        do_rotation(EquinoxRotation self, SkyDir inDir, SkyDir outDir)
        """
        return _pyLikelihood.EquinoxRotation_do_rotation(self, inDir, outDir, toMapCoords)


    def clone(self):
        """clone(EquinoxRotation self) -> EquinoxRotation"""
        return _pyLikelihood.EquinoxRotation_clone(self)


    def fromMapCoords(self, inDir):
        """fromMapCoords(EquinoxRotation self, SkyDir inDir) -> SkyDir"""
        return _pyLikelihood.EquinoxRotation_fromMapCoords(self, inDir)


    def toMapCoords(self, inDir):
        """toMapCoords(EquinoxRotation self, SkyDir inDir) -> SkyDir"""
        return _pyLikelihood.EquinoxRotation_toMapCoords(self, inDir)

EquinoxRotation_swigregister = _pyLikelihood.EquinoxRotation_swigregister
EquinoxRotation_swigregister(EquinoxRotation)

class ExpCutoff(Function):
    """Proxy of C++ Likelihood::ExpCutoff class."""

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

    def __init__(self, Prefactor=10., Index=-2.1, Scale=100., Ebreak=10., P1=150., P2=0, P3=0):
        """
        __init__(Likelihood::ExpCutoff self, double Prefactor=10., double Index=-2.1, double Scale=100., double Ebreak=10., double P1=150., double P2=0, double P3=0) -> ExpCutoff
        __init__(Likelihood::ExpCutoff self, double Prefactor=10., double Index=-2.1, double Scale=100., double Ebreak=10., double P1=150., double P2=0) -> ExpCutoff
        __init__(Likelihood::ExpCutoff self, double Prefactor=10., double Index=-2.1, double Scale=100., double Ebreak=10., double P1=150.) -> ExpCutoff
        __init__(Likelihood::ExpCutoff self, double Prefactor=10., double Index=-2.1, double Scale=100., double Ebreak=10.) -> ExpCutoff
        __init__(Likelihood::ExpCutoff self, double Prefactor=10., double Index=-2.1, double Scale=100.) -> ExpCutoff
        __init__(Likelihood::ExpCutoff self, double Prefactor=10., double Index=-2.1) -> ExpCutoff
        __init__(Likelihood::ExpCutoff self, double Prefactor=10.) -> ExpCutoff
        __init__(Likelihood::ExpCutoff self) -> ExpCutoff
        """
        this = _pyLikelihood.new_ExpCutoff(Prefactor, Index, Scale, Ebreak, P1, P2, P3)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(ExpCutoff self) -> Function"""
        return _pyLikelihood.ExpCutoff_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_ExpCutoff
    __del__ = lambda self: None
ExpCutoff_swigregister = _pyLikelihood.ExpCutoff_swigregister
ExpCutoff_swigregister(ExpCutoff)

class ExposureCube(_object):
    """Proxy of C++ Likelihood::ExposureCube class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::ExposureCube self) -> ExposureCube
        __init__(Likelihood::ExposureCube self, ExposureCube other) -> ExposureCube
        """
        this = _pyLikelihood.new_ExposureCube(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_ExposureCube
    __del__ = lambda self: None

    def readExposureCube(self, filename):
        """readExposureCube(ExposureCube self, std::string filename)"""
        return _pyLikelihood.ExposureCube_readExposureCube(self, filename)


    def livetime(self, dir, costheta, phi=-1):
        """
        livetime(ExposureCube self, SkyDir dir, double costheta, double phi=-1) -> double
        livetime(ExposureCube self, SkyDir dir, double costheta) -> double
        """
        return _pyLikelihood.ExposureCube_livetime(self, dir, costheta, phi)


    def get_cosine_binner(self, dir):
        """get_cosine_binner(ExposureCube self, SkyDir dir) -> CosineBinner"""
        return _pyLikelihood.ExposureCube_get_cosine_binner(self, dir)


    def setEfficiencyFactor(self, eff):
        """setEfficiencyFactor(ExposureCube self, IEfficiencyFactor eff)"""
        return _pyLikelihood.ExposureCube_setEfficiencyFactor(self, eff)


    def tstart(self):
        """tstart(ExposureCube self) -> double"""
        return _pyLikelihood.ExposureCube_tstart(self)


    def tstop(self):
        """tstop(ExposureCube self) -> double"""
        return _pyLikelihood.ExposureCube_tstop(self)


    def haveFile(self):
        """haveFile(ExposureCube self) -> bool"""
        return _pyLikelihood.ExposureCube_haveFile(self)


    def fileName(self):
        """fileName(ExposureCube self) -> std::string const &"""
        return _pyLikelihood.ExposureCube_fileName(self)


    def hasPhiDependence(self):
        """hasPhiDependence(ExposureCube self) -> bool"""
        return _pyLikelihood.ExposureCube_hasPhiDependence(self)

ExposureCube_swigregister = _pyLikelihood.ExposureCube_swigregister
ExposureCube_swigregister(ExposureCube)

class ExposureMap(_object):
    """Proxy of C++ Likelihood::ExposureMap class."""

    __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):
        """__init__(Likelihood::ExposureMap self) -> ExposureMap"""
        this = _pyLikelihood.new_ExposureMap()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_ExposureMap
    __del__ = lambda self: None

    def readExposureFile(self, exposureFile):
        """readExposureFile(ExposureMap self, std::string exposureFile)"""
        return _pyLikelihood.ExposureMap_readExposureFile(self, exposureFile)


    def integrateSpatialDist(self, energies, spatialDist, exposure):
        """integrateSpatialDist(ExposureMap self, DoubleVector energies, Function spatialDist, DoubleVector exposure)"""
        return _pyLikelihood.ExposureMap_integrateSpatialDist(self, energies, spatialDist, exposure)


    def getRA(self, ra):
        """getRA(ExposureMap self, DoubleVector ra)"""
        return _pyLikelihood.ExposureMap_getRA(self, ra)


    def getDec(self, dec):
        """getDec(ExposureMap self, DoubleVector dec)"""
        return _pyLikelihood.ExposureMap_getDec(self, dec)


    def getEnergies(self, energies):
        """getEnergies(ExposureMap self, DoubleVector energies)"""
        return _pyLikelihood.ExposureMap_getEnergies(self, energies)


    def haveMap(self):
        """haveMap(ExposureMap self) -> bool"""
        return _pyLikelihood.ExposureMap_haveMap(self)


    def computeMap(self, filename, observation, sr_radius=30, nlong=60, nlat=60, nenergies=10, compute_submap=False, nlongmin=0, nlongmax=0, nlatmin=0, nlatmax=0):
        """
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60, int nlat=60, int nenergies=10, bool compute_submap=False, int nlongmin=0, int nlongmax=0, int nlatmin=0, int nlatmax=0)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60, int nlat=60, int nenergies=10, bool compute_submap=False, int nlongmin=0, int nlongmax=0, int nlatmin=0)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60, int nlat=60, int nenergies=10, bool compute_submap=False, int nlongmin=0, int nlongmax=0)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60, int nlat=60, int nenergies=10, bool compute_submap=False, int nlongmin=0)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60, int nlat=60, int nenergies=10, bool compute_submap=False)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60, int nlat=60, int nenergies=10)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60, int nlat=60)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30, int nlong=60)
        computeMap(ExposureMap self, std::string filename, Observation observation, double sr_radius=30)
        computeMap(ExposureMap self, std::string filename, Observation observation)
        """
        return _pyLikelihood.ExposureMap_computeMap(self, filename, observation, sr_radius, nlong, nlat, nenergies, compute_submap, nlongmin, nlongmax, nlatmin, nlatmax)


    def readEnergyExtension(filename, energies):
        """readEnergyExtension(std::string const & filename, DoubleVector energies)"""
        return _pyLikelihood.ExposureMap_readEnergyExtension(filename, energies)

    readEnergyExtension = staticmethod(readEnergyExtension)

    def __call__(self, *args):
        """
        __call__(ExposureMap self, SkyDir dir, double energy) -> double
        __call__(ExposureMap self, SkyDir dir, int k) -> double
        """
        return _pyLikelihood.ExposureMap___call__(self, *args)


    def withinMapRadius(self, dir):
        """withinMapRadius(ExposureMap self, SkyDir dir) -> bool"""
        return _pyLikelihood.ExposureMap_withinMapRadius(self, dir)

ExposureMap_swigregister = _pyLikelihood.ExposureMap_swigregister
ExposureMap_swigregister(ExposureMap)

def ExposureMap_readEnergyExtension(filename, energies):
    """ExposureMap_readEnergyExtension(std::string const & filename, DoubleVector energies)"""
    return _pyLikelihood.ExposureMap_readEnergyExtension(filename, energies)

class FileFunction(Function):
    """Proxy of C++ Likelihood::FileFunction class."""

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

    def __init__(self, Normalization=1):
        """
        __init__(Likelihood::FileFunction self, double Normalization=1) -> FileFunction
        __init__(Likelihood::FileFunction self) -> FileFunction
        """
        this = _pyLikelihood.new_FileFunction(Normalization)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(FileFunction self) -> Function *"""
        return _pyLikelihood.FileFunction_clone(self)


    def readFunction(self, filename):
        """readFunction(FileFunction self, std::string const & filename)"""
        return _pyLikelihood.FileFunction_readFunction(self, filename)


    def filename(self):
        """filename(FileFunction self) -> std::string const &"""
        return _pyLikelihood.FileFunction_filename(self)


    def setSpectrum(self, energy, dnde):
        """setSpectrum(FileFunction self, DoubleVector energy, DoubleVector dnde)"""
        return _pyLikelihood.FileFunction_setSpectrum(self, energy, dnde)


    def log_energy(self):
        """log_energy(FileFunction self) -> DoubleVector"""
        return _pyLikelihood.FileFunction_log_energy(self)


    def log_dnde(self):
        """log_dnde(FileFunction self) -> DoubleVector"""
        return _pyLikelihood.FileFunction_log_dnde(self)


    def cast(func):
        """cast(Function func) -> FileFunction"""
        return _pyLikelihood.FileFunction_cast(func)

    cast = staticmethod(cast)
    __swig_destroy__ = _pyLikelihood.delete_FileFunction
    __del__ = lambda self: None
FileFunction_swigregister = _pyLikelihood.FileFunction_swigregister
FileFunction_swigregister(FileFunction)

def FileFunction_cast(func):
    """FileFunction_cast(Function func) -> FileFunction"""
    return _pyLikelihood.FileFunction_cast(func)

class TestSourceModelCache(_object):
    """Proxy of C++ Likelihood::TestSourceModelCache class."""

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

    def __init__(self, logLike, source):
        """__init__(Likelihood::TestSourceModelCache self, BinnedLikelihood logLike, PointSource source) -> TestSourceModelCache"""
        this = _pyLikelihood.new_TestSourceModelCache(logLike, source)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_TestSourceModelCache
    __del__ = lambda self: None

    def translateMap(self, newRef, out_model):
        """translateMap(TestSourceModelCache self, SkyDir newRef, FloatVector out_model) -> int"""
        return _pyLikelihood.TestSourceModelCache_translateMap(self, newRef, out_model)


    def writeTestSourceToFitsImage(self, fits_file, ext_name):
        """writeTestSourceToFitsImage(TestSourceModelCache self, std::string const & fits_file, std::string const & ext_name)"""
        return _pyLikelihood.TestSourceModelCache_writeTestSourceToFitsImage(self, fits_file, ext_name)

TestSourceModelCache_swigregister = _pyLikelihood.TestSourceModelCache_swigregister
TestSourceModelCache_swigregister(TestSourceModelCache)

class FitScanMVPrior(_object):
    """Proxy of C++ Likelihood::FitScanMVPrior class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::FitScanMVPrior self, CLHEP::HepVector const & centralVals, CLHEP::HepSymMatrix const & covariance, BoolVector constrainPars, bool includeTestSource) -> FitScanMVPrior
        __init__(Likelihood::FitScanMVPrior self, CLHEP::HepVector const & centralVals, CLHEP::HepVector const & uncertainties, BoolVector hasPrior, BoolVector constrainPars, bool includeTestSource) -> FitScanMVPrior
        """
        this = _pyLikelihood.new_FitScanMVPrior(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FitScanMVPrior
    __del__ = lambda self: None

    def update(self, *args):
        """
        update(FitScanMVPrior self, CLHEP::HepVector const & centralVals, CLHEP::HepSymMatrix const & covariance, BoolVector constrainPars, bool includeTestSource)
        update(FitScanMVPrior self, CLHEP::HepVector const & centralVals, CLHEP::HepVector const & uncertainties, BoolVector parHasPrior, BoolVector constrainPars, bool includeTestSource)
        """
        return _pyLikelihood.FitScanMVPrior_update(self, *args)


    def logLikelihood(self, params, logLike):
        """logLikelihood(FitScanMVPrior self, CLHEP::HepVector const & params, double & logLike)"""
        return _pyLikelihood.FitScanMVPrior_logLikelihood(self, params, logLike)


    def gradient(self, params, grad):
        """gradient(FitScanMVPrior self, CLHEP::HepVector const & params, CLHEP::HepVector & grad)"""
        return _pyLikelihood.FitScanMVPrior_gradient(self, params, grad)


    def hessian(self):
        """hessian(FitScanMVPrior self) -> CLHEP::HepSymMatrix const &"""
        return _pyLikelihood.FitScanMVPrior_hessian(self)


    def centralVals(self):
        """centralVals(FitScanMVPrior self) -> CLHEP::HepVector const &"""
        return _pyLikelihood.FitScanMVPrior_centralVals(self)


    def covariance(self):
        """covariance(FitScanMVPrior self) -> CLHEP::HepSymMatrix const &"""
        return _pyLikelihood.FitScanMVPrior_covariance(self)


    def constrainPars(self):
        """constrainPars(FitScanMVPrior self) -> BoolVector"""
        return _pyLikelihood.FitScanMVPrior_constrainPars(self)


    def includeTestSource(self):
        """includeTestSource(FitScanMVPrior self) -> bool"""
        return _pyLikelihood.FitScanMVPrior_includeTestSource(self)


    def get_uncertainties(self, uncertainties):
        """get_uncertainties(FitScanMVPrior self, CLHEP::HepVector & uncertainties)"""
        return _pyLikelihood.FitScanMVPrior_get_uncertainties(self, uncertainties)

FitScanMVPrior_swigregister = _pyLikelihood.FitScanMVPrior_swigregister
FitScanMVPrior_swigregister(FitScanMVPrior)

class FitScanModelWrapper(_object):
    """Proxy of C++ Likelihood::FitScanModelWrapper class."""

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

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

    def data(self):
        """data(FitScanModelWrapper self) -> FloatVector"""
        return _pyLikelihood.FitScanModelWrapper_data(self)


    def isSummed(self):
        """isSummed(FitScanModelWrapper self) -> bool"""
        return _pyLikelihood.FitScanModelWrapper_isSummed(self)


    def extractModelFromSource(self, *args):
        """
        extractModelFromSource(FitScanModelWrapper self, std::string const & srcName, FloatVector model, bool rescaleToNormOne=False)
        extractModelFromSource(FitScanModelWrapper self, std::string const & srcName, FloatVector model)
        extractModelFromSource(FitScanModelWrapper self, Source aSrc, FloatVector model, bool rescaleToNormOne=False)
        extractModelFromSource(FitScanModelWrapper self, Source aSrc, FloatVector model)
        """
        return _pyLikelihood.FitScanModelWrapper_extractModelFromSource(self, *args)


    def extractModels(self, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights=None, useUnitRefVals=False):
        """
        extractModels(FitScanModelWrapper self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None, bool useUnitRefVals=False)
        extractModels(FitScanModelWrapper self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None)
        extractModels(FitScanModelWrapper self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars)
        """
        return _pyLikelihood.FitScanModelWrapper_extractModels(self, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights, useUnitRefVals)


    def extractPriors(self, freeSrcNames, centralVals, uncertainties, parHasPrior):
        """extractPriors(FitScanModelWrapper self, StringVector freeSrcNames, CLHEP::HepVector & centralVals, CLHEP::HepVector & uncertainties, BoolVector parHasPrior) -> bool"""
        return _pyLikelihood.FitScanModelWrapper_extractPriors(self, freeSrcNames, centralVals, uncertainties, parHasPrior)


    def fixed_changed(self, srcNames, currentFreeSources):
        """fixed_changed(FitScanModelWrapper self, StringVector srcNames, BoolVector currentFreeSources) -> bool"""
        return _pyLikelihood.FitScanModelWrapper_fixed_changed(self, srcNames, currentFreeSources)


    def value(self):
        """value(FitScanModelWrapper self) -> double"""
        return _pyLikelihood.FitScanModelWrapper_value(self)


    def addSource(self, aSrc):
        """addSource(FitScanModelWrapper self, Source aSrc)"""
        return _pyLikelihood.FitScanModelWrapper_addSource(self, aSrc)


    def syncParams(self):
        """syncParams(FitScanModelWrapper self)"""
        return _pyLikelihood.FitScanModelWrapper_syncParams(self)


    def removeSource(self, sourceName):
        """removeSource(FitScanModelWrapper self, std::string const & sourceName)"""
        return _pyLikelihood.FitScanModelWrapper_removeSource(self, sourceName)


    def writeFits_EnergyBins(self, fitsFile):
        """writeFits_EnergyBins(FitScanModelWrapper self, std::string const & fitsFile) -> int"""
        return _pyLikelihood.FitScanModelWrapper_writeFits_EnergyBins(self, fitsFile)


    def writeFits_GTIs(self, fitsFile):
        """writeFits_GTIs(FitScanModelWrapper self, std::string const & fitsFile) -> int"""
        return _pyLikelihood.FitScanModelWrapper_writeFits_GTIs(self, fitsFile)


    def getMasterComponent(self, *args):
        """
        getMasterComponent(FitScanModelWrapper self) -> BinnedLikelihood
        getMasterComponent(FitScanModelWrapper self) -> BinnedLikelihood
        """
        return _pyLikelihood.FitScanModelWrapper_getMasterComponent(self, *args)


    def numComponents(self):
        """numComponents(FitScanModelWrapper self) -> size_t const"""
        return _pyLikelihood.FitScanModelWrapper_numComponents(self)


    def getComponent(self, idx):
        """getComponent(FitScanModelWrapper self, size_t idx) -> BinnedLikelihood"""
        return _pyLikelihood.FitScanModelWrapper_getComponent(self, idx)


    def energies(self):
        """energies(FitScanModelWrapper self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_energies(self)


    def shiftTestSource(self, modelCaches, newDir, targetModel):
        """shiftTestSource(FitScanModelWrapper self, std::vector< Likelihood::TestSourceModelCache *,std::allocator< Likelihood::TestSourceModelCache * > > const & modelCaches, SkyDir newDir, FloatVector targetModel) -> int"""
        return _pyLikelihood.FitScanModelWrapper_shiftTestSource(self, modelCaches, newDir, targetModel)


    def set_klims(self, kmin, kmax):
        """set_klims(FitScanModelWrapper self, size_t kmin, size_t kmax)"""
        return _pyLikelihood.FitScanModelWrapper_set_klims(self, kmin, kmax)


    def cacheFluxValues(self, aSrc):
        """cacheFluxValues(FitScanModelWrapper self, Source aSrc)"""
        return _pyLikelihood.FitScanModelWrapper_cacheFluxValues(self, aSrc)


    def nPix(self):
        """nPix(FitScanModelWrapper self) -> size_t"""
        return _pyLikelihood.FitScanModelWrapper_nPix(self)


    def nEBins(self):
        """nEBins(FitScanModelWrapper self) -> size_t"""
        return _pyLikelihood.FitScanModelWrapper_nEBins(self)


    def size(self):
        """size(FitScanModelWrapper self) -> size_t"""
        return _pyLikelihood.FitScanModelWrapper_size(self)


    def ref_energies(self):
        """ref_energies(FitScanModelWrapper self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_ref_energies(self)


    def ref_dndes(self):
        """ref_dndes(FitScanModelWrapper self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_ref_dndes(self)


    def ref_fluxes(self):
        """ref_fluxes(FitScanModelWrapper self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_ref_fluxes(self)


    def ref_energy_fluxes(self):
        """ref_energy_fluxes(FitScanModelWrapper self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_ref_energy_fluxes(self)


    def nPreds(self):
        """nPreds(FitScanModelWrapper self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_nPreds(self)

FitScanModelWrapper_swigregister = _pyLikelihood.FitScanModelWrapper_swigregister
FitScanModelWrapper_swigregister(FitScanModelWrapper)

class FitScanModelWrapper_Binned(FitScanModelWrapper):
    """Proxy of C++ Likelihood::FitScanModelWrapper_Binned class."""

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

    def __init__(self, binnedLike):
        """__init__(Likelihood::FitScanModelWrapper_Binned self, BinnedLikelihood binnedLike) -> FitScanModelWrapper_Binned"""
        this = _pyLikelihood.new_FitScanModelWrapper_Binned(binnedLike)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FitScanModelWrapper_Binned
    __del__ = lambda self: None

    def binnedLike(self):
        """binnedLike(FitScanModelWrapper_Binned self) -> BinnedLikelihood"""
        return _pyLikelihood.FitScanModelWrapper_Binned_binnedLike(self)


    def data(self):
        """data(FitScanModelWrapper_Binned self) -> FloatVector"""
        return _pyLikelihood.FitScanModelWrapper_Binned_data(self)


    def isSummed(self):
        """isSummed(FitScanModelWrapper_Binned self) -> bool"""
        return _pyLikelihood.FitScanModelWrapper_Binned_isSummed(self)


    def extractModelFromSource(self, aSrc, model, rescaleToNormOne=False):
        """
        extractModelFromSource(FitScanModelWrapper_Binned self, Source aSrc, FloatVector model, bool rescaleToNormOne=False)
        extractModelFromSource(FitScanModelWrapper_Binned self, Source aSrc, FloatVector model)
        """
        return _pyLikelihood.FitScanModelWrapper_Binned_extractModelFromSource(self, aSrc, model, rescaleToNormOne)


    def extractModels(self, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights=None, useUnitRefVals=False):
        """
        extractModels(FitScanModelWrapper_Binned self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None, bool useUnitRefVals=False)
        extractModels(FitScanModelWrapper_Binned self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None)
        extractModels(FitScanModelWrapper_Binned self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars)
        """
        return _pyLikelihood.FitScanModelWrapper_Binned_extractModels(self, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights, useUnitRefVals)


    def value(self):
        """value(FitScanModelWrapper_Binned self) -> double"""
        return _pyLikelihood.FitScanModelWrapper_Binned_value(self)


    def addSource(self, aSrc):
        """addSource(FitScanModelWrapper_Binned self, Source aSrc)"""
        return _pyLikelihood.FitScanModelWrapper_Binned_addSource(self, aSrc)


    def syncParams(self):
        """syncParams(FitScanModelWrapper_Binned self)"""
        return _pyLikelihood.FitScanModelWrapper_Binned_syncParams(self)


    def removeSource(self, sourceName):
        """removeSource(FitScanModelWrapper_Binned self, std::string const & sourceName)"""
        return _pyLikelihood.FitScanModelWrapper_Binned_removeSource(self, sourceName)


    def writeFits_GTIs(self, fitsFile):
        """writeFits_GTIs(FitScanModelWrapper_Binned self, std::string const & fitsFile) -> int"""
        return _pyLikelihood.FitScanModelWrapper_Binned_writeFits_GTIs(self, fitsFile)


    def getMasterComponent(self, *args):
        """
        getMasterComponent(FitScanModelWrapper_Binned self) -> BinnedLikelihood
        getMasterComponent(FitScanModelWrapper_Binned self) -> BinnedLikelihood
        """
        return _pyLikelihood.FitScanModelWrapper_Binned_getMasterComponent(self, *args)


    def numComponents(self):
        """numComponents(FitScanModelWrapper_Binned self) -> size_t const"""
        return _pyLikelihood.FitScanModelWrapper_Binned_numComponents(self)


    def getComponent(self, idx):
        """getComponent(FitScanModelWrapper_Binned self, size_t idx) -> BinnedLikelihood"""
        return _pyLikelihood.FitScanModelWrapper_Binned_getComponent(self, idx)


    def energies(self):
        """energies(FitScanModelWrapper_Binned self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_Binned_energies(self)


    def shiftTestSource(self, modelCaches, newDir, targetModel):
        """shiftTestSource(FitScanModelWrapper_Binned self, std::vector< Likelihood::TestSourceModelCache *,std::allocator< Likelihood::TestSourceModelCache * > > const & modelCaches, SkyDir newDir, FloatVector targetModel) -> int"""
        return _pyLikelihood.FitScanModelWrapper_Binned_shiftTestSource(self, modelCaches, newDir, targetModel)


    def set_klims(self, kmin, kmax):
        """set_klims(FitScanModelWrapper_Binned self, size_t kmin, size_t kmax)"""
        return _pyLikelihood.FitScanModelWrapper_Binned_set_klims(self, kmin, kmax)

FitScanModelWrapper_Binned_swigregister = _pyLikelihood.FitScanModelWrapper_Binned_swigregister
FitScanModelWrapper_Binned_swigregister(FitScanModelWrapper_Binned)

class FitScanModelWrapper_Summed(FitScanModelWrapper):
    """Proxy of C++ Likelihood::FitScanModelWrapper_Summed class."""

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

    def findMinAndMatches(energyBins, localIdx, matches, tol=1e-5):
        """
        findMinAndMatches(std::vector< std::vector< double,std::allocator< double > > const *,std::allocator< std::vector< double,std::allocator< double > > const * > > const & energyBins, SizetVector localIdx, std::vector< int,std::allocator< int > > & matches, float tol=1e-5) -> double
        findMinAndMatches(std::vector< std::vector< double,std::allocator< double > > const *,std::allocator< std::vector< double,std::allocator< double > > const * > > const & energyBins, SizetVector localIdx, std::vector< int,std::allocator< int > > & matches) -> double
        """
        return _pyLikelihood.FitScanModelWrapper_Summed_findMinAndMatches(energyBins, localIdx, matches, tol)

    findMinAndMatches = staticmethod(findMinAndMatches)

    def mergeVectors(toMerge, npixelsByComp, energyBinLocal, mergedData):
        """mergeVectors(std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & toMerge, SizetVector npixelsByComp, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & energyBinLocal, FloatVector mergedData)"""
        return _pyLikelihood.FitScanModelWrapper_Summed_mergeVectors(toMerge, npixelsByComp, energyBinLocal, mergedData)

    mergeVectors = staticmethod(mergeVectors)

    def __init__(self, summedLike):
        """__init__(Likelihood::FitScanModelWrapper_Summed self, SummedLikelihood summedLike) -> FitScanModelWrapper_Summed"""
        this = _pyLikelihood.new_FitScanModelWrapper_Summed(summedLike)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FitScanModelWrapper_Summed
    __del__ = lambda self: None

    def summedLike(self):
        """summedLike(FitScanModelWrapper_Summed self) -> SummedLikelihood"""
        return _pyLikelihood.FitScanModelWrapper_Summed_summedLike(self)


    def data(self):
        """data(FitScanModelWrapper_Summed self) -> FloatVector"""
        return _pyLikelihood.FitScanModelWrapper_Summed_data(self)


    def isSummed(self):
        """isSummed(FitScanModelWrapper_Summed self) -> bool"""
        return _pyLikelihood.FitScanModelWrapper_Summed_isSummed(self)


    def extractModelFromSource(self, aSrc, model, rescaleToNormOne=False):
        """
        extractModelFromSource(FitScanModelWrapper_Summed self, Source aSrc, FloatVector model, bool rescaleToNormOne=False)
        extractModelFromSource(FitScanModelWrapper_Summed self, Source aSrc, FloatVector model)
        """
        return _pyLikelihood.FitScanModelWrapper_Summed_extractModelFromSource(self, aSrc, model, rescaleToNormOne)


    def extractModels(self, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights=None, useUnitRefVals=False):
        """
        extractModels(FitScanModelWrapper_Summed self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None, bool useUnitRefVals=False)
        extractModels(FitScanModelWrapper_Summed self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None)
        extractModels(FitScanModelWrapper_Summed self, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars)
        """
        return _pyLikelihood.FitScanModelWrapper_Summed_extractModels(self, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights, useUnitRefVals)


    def value(self):
        """value(FitScanModelWrapper_Summed self) -> double"""
        return _pyLikelihood.FitScanModelWrapper_Summed_value(self)


    def addSource(self, aSrc):
        """addSource(FitScanModelWrapper_Summed self, Source aSrc)"""
        return _pyLikelihood.FitScanModelWrapper_Summed_addSource(self, aSrc)


    def syncParams(self):
        """syncParams(FitScanModelWrapper_Summed self)"""
        return _pyLikelihood.FitScanModelWrapper_Summed_syncParams(self)


    def removeSource(self, sourceName):
        """removeSource(FitScanModelWrapper_Summed self, std::string const & sourceName)"""
        return _pyLikelihood.FitScanModelWrapper_Summed_removeSource(self, sourceName)


    def writeFits_GTIs(self, fitsFile):
        """writeFits_GTIs(FitScanModelWrapper_Summed self, std::string const & fitsFile) -> int"""
        return _pyLikelihood.FitScanModelWrapper_Summed_writeFits_GTIs(self, fitsFile)


    def getMasterComponent(self, *args):
        """
        getMasterComponent(FitScanModelWrapper_Summed self) -> BinnedLikelihood
        getMasterComponent(FitScanModelWrapper_Summed self) -> BinnedLikelihood
        """
        return _pyLikelihood.FitScanModelWrapper_Summed_getMasterComponent(self, *args)


    def numComponents(self):
        """numComponents(FitScanModelWrapper_Summed self) -> size_t const"""
        return _pyLikelihood.FitScanModelWrapper_Summed_numComponents(self)


    def getComponent(self, idx):
        """getComponent(FitScanModelWrapper_Summed self, size_t idx) -> BinnedLikelihood"""
        return _pyLikelihood.FitScanModelWrapper_Summed_getComponent(self, idx)


    def energies(self):
        """energies(FitScanModelWrapper_Summed self) -> DoubleVector"""
        return _pyLikelihood.FitScanModelWrapper_Summed_energies(self)


    def shiftTestSource(self, modelCaches, newDir, targetModel):
        """shiftTestSource(FitScanModelWrapper_Summed self, std::vector< Likelihood::TestSourceModelCache *,std::allocator< Likelihood::TestSourceModelCache * > > const & modelCaches, SkyDir newDir, FloatVector targetModel) -> int"""
        return _pyLikelihood.FitScanModelWrapper_Summed_shiftTestSource(self, modelCaches, newDir, targetModel)


    def set_klims(self, kmin, kmax):
        """set_klims(FitScanModelWrapper_Summed self, size_t kmin, size_t kmax)"""
        return _pyLikelihood.FitScanModelWrapper_Summed_set_klims(self, kmin, kmax)

FitScanModelWrapper_Summed_swigregister = _pyLikelihood.FitScanModelWrapper_Summed_swigregister
FitScanModelWrapper_Summed_swigregister(FitScanModelWrapper_Summed)

def FitScanModelWrapper_Summed_findMinAndMatches(energyBins, localIdx, matches, tol=1e-5):
    """
    findMinAndMatches(std::vector< std::vector< double,std::allocator< double > > const *,std::allocator< std::vector< double,std::allocator< double > > const * > > const & energyBins, SizetVector localIdx, std::vector< int,std::allocator< int > > & matches, float tol=1e-5) -> double
    FitScanModelWrapper_Summed_findMinAndMatches(std::vector< std::vector< double,std::allocator< double > > const *,std::allocator< std::vector< double,std::allocator< double > > const * > > const & energyBins, SizetVector localIdx, std::vector< int,std::allocator< int > > & matches) -> double
    """
    return _pyLikelihood.FitScanModelWrapper_Summed_findMinAndMatches(energyBins, localIdx, matches, tol)

def FitScanModelWrapper_Summed_mergeVectors(toMerge, npixelsByComp, energyBinLocal, mergedData):
    """FitScanModelWrapper_Summed_mergeVectors(std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & toMerge, SizetVector npixelsByComp, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & energyBinLocal, FloatVector mergedData)"""
    return _pyLikelihood.FitScanModelWrapper_Summed_mergeVectors(toMerge, npixelsByComp, energyBinLocal, mergedData)

class FitScanCache(_object):
    """Proxy of C++ Likelihood::FitScanCache class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FitScanCache, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FitScanCache, name)
    __repr__ = _swig_repr
    No_Prior = _pyLikelihood.FitScanCache_No_Prior
    Local_Prior = _pyLikelihood.FitScanCache_Local_Prior
    Global_Prior = _pyLikelihood.FitScanCache_Global_Prior
    Init_Prior = _pyLikelihood.FitScanCache_Init_Prior
    Full_Prior = _pyLikelihood.FitScanCache_Full_Prior
    No_Action = _pyLikelihood.FitScanCache_No_Action
    Remake_Prior = _pyLikelihood.FitScanCache_Remake_Prior
    Refactor = _pyLikelihood.FitScanCache_Refactor
    Update_Free = _pyLikelihood.FitScanCache_Update_Free
    Update_Fixed = _pyLikelihood.FitScanCache_Update_Fixed
    Rebuild = _pyLikelihood.FitScanCache_Rebuild

    def __init__(self, modelWrapper, testSourceName, tol, maxIter, initLambda, useReduced, useWeights=False, useUnitRefVals=False):
        """
        __init__(Likelihood::FitScanCache self, FitScanModelWrapper modelWrapper, std::string const & testSourceName, double tol, int maxIter, double initLambda, bool useReduced, bool useWeights=False, bool useUnitRefVals=False) -> FitScanCache
        __init__(Likelihood::FitScanCache self, FitScanModelWrapper modelWrapper, std::string const & testSourceName, double tol, int maxIter, double initLambda, bool useReduced, bool useWeights=False) -> FitScanCache
        __init__(Likelihood::FitScanCache self, FitScanModelWrapper modelWrapper, std::string const & testSourceName, double tol, int maxIter, double initLambda, bool useReduced) -> FitScanCache
        """
        this = _pyLikelihood.new_FitScanCache(modelWrapper, testSourceName, tol, maxIter, initLambda, useReduced, useWeights, useUnitRefVals)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FitScanCache
    __del__ = lambda self: None

    def update(self):
        """update(FitScanCache self)"""
        return _pyLikelihood.FitScanCache_update(self)


    def update_with_action(self, action, changed_latched, changed_unlatched, new_free, new_fixed):
        """update_with_action(FitScanCache self, unsigned int action, StringVector changed_latched, StringVector changed_unlatched, StringVector new_free, StringVector new_fixed)"""
        return _pyLikelihood.FitScanCache_update_with_action(self, action, changed_latched, changed_unlatched, new_free, new_fixed)


    def find_action_needed(self, changed_latched, changed_unlatched, new_free, new_fixed):
        """find_action_needed(FitScanCache self, StringVector changed_latched, StringVector changed_unlatched, StringVector new_free, StringVector new_fixed) -> unsigned int"""
        return _pyLikelihood.FitScanCache_find_action_needed(self, changed_latched, changed_unlatched, new_free, new_fixed)


    def setCache(self):
        """setCache(FitScanCache self)"""
        return _pyLikelihood.FitScanCache_setCache(self)


    def refactorModel(self, freeSources, pars_scales, include_test):
        """refactorModel(FitScanCache self, BoolVector freeSources, FloatVector pars_scales, bool include_test)"""
        return _pyLikelihood.FitScanCache_refactorModel(self, freeSources, pars_scales, include_test)


    def refactorPrior(self, freeSources):
        """refactorPrior(FitScanCache self, BoolVector freeSources)"""
        return _pyLikelihood.FitScanCache_refactorPrior(self, freeSources)


    def getParScales(self, pars_scales):
        """getParScales(FitScanCache self, FloatVector pars_scales)"""
        return _pyLikelihood.FitScanCache_getParScales(self, pars_scales)


    def setEnergyBin(self, energyBin):
        """setEnergyBin(FitScanCache self, int energyBin)"""
        return _pyLikelihood.FitScanCache_setEnergyBin(self, energyBin)


    def setEnergyBins(self, firstEnergyBin, lastEnergyBin):
        """setEnergyBins(FitScanCache self, size_t firstEnergyBin, size_t lastEnergyBin)"""
        return _pyLikelihood.FitScanCache_setEnergyBins(self, firstEnergyBin, lastEnergyBin)


    def setTestSource(self, aSrc):
        """setTestSource(FitScanCache self, Source aSrc)"""
        return _pyLikelihood.FitScanCache_setTestSource(self, aSrc)


    def shiftTestSource(self, modelCache, newDir):
        """shiftTestSource(FitScanCache self, std::vector< Likelihood::TestSourceModelCache *,std::allocator< Likelihood::TestSourceModelCache * > > const & modelCache, SkyDir newDir) -> int"""
        return _pyLikelihood.FitScanCache_shiftTestSource(self, modelCache, newDir)


    def addTestSourceToCurrent(self, initNorm):
        """addTestSourceToCurrent(FitScanCache self, double initNorm)"""
        return _pyLikelihood.FitScanCache_addTestSourceToCurrent(self, initNorm)


    def removeTestSourceFromCurrent(self):
        """removeTestSourceFromCurrent(FitScanCache self)"""
        return _pyLikelihood.FitScanCache_removeTestSourceFromCurrent(self)


    def buildPriorsFromExternal(self, *args):
        """
        buildPriorsFromExternal(FitScanCache self, CLHEP::HepVector const & centralVals, CLHEP::HepSymMatrix const & covariance, BoolVector constrainPars, bool globalPrior=False)
        buildPriorsFromExternal(FitScanCache self, CLHEP::HepVector const & centralVals, CLHEP::HepSymMatrix const & covariance, BoolVector constrainPars)
        buildPriorsFromExternal(FitScanCache self, FloatVector centralVals, FloatVector covariance, BoolVector constrainPars, bool globalPrior=False)
        buildPriorsFromExternal(FitScanCache self, FloatVector centralVals, FloatVector covariance, BoolVector constrainPars)
        """
        return _pyLikelihood.FitScanCache_buildPriorsFromExternal(self, *args)


    def buildPriorsFromCurrent(self, constrainPars, covScaleFactor, globalPrior=False):
        """
        buildPriorsFromCurrent(FitScanCache self, BoolVector constrainPars, double covScaleFactor, bool globalPrior=False)
        buildPriorsFromCurrent(FitScanCache self, BoolVector constrainPars, double covScaleFactor)
        """
        return _pyLikelihood.FitScanCache_buildPriorsFromCurrent(self, constrainPars, covScaleFactor, globalPrior)


    def fitCurrent(self, *args):
        """
        fitCurrent(FitScanCache self, Likelihood::FitScanCache::Prior_Version whichPrior, int verbose=0) -> int
        fitCurrent(FitScanCache self, Likelihood::FitScanCache::Prior_Version whichPrior) -> int
        fitCurrent(FitScanCache self) -> int
        """
        return _pyLikelihood.FitScanCache_fitCurrent(self, *args)


    def calculateLoglikeCurrent(self, *args):
        """
        calculateLoglikeCurrent(FitScanCache self, double & logLike, Likelihood::FitScanCache::Prior_Version whichPrior) -> int
        calculateLoglikeCurrent(FitScanCache self, double & logLike) -> int
        """
        return _pyLikelihood.FitScanCache_calculateLoglikeCurrent(self, *args)


    def getGradiantAndHessian(self, *args):
        """
        getGradiantAndHessian(FitScanCache self, CLHEP::HepVector const & norms, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian, Likelihood::FitScanCache::Prior_Version whichPrior, size_t firstBin=0, size_t lastBin=0, int verbose=0)
        getGradiantAndHessian(FitScanCache self, CLHEP::HepVector const & norms, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian, Likelihood::FitScanCache::Prior_Version whichPrior, size_t firstBin=0, size_t lastBin=0)
        getGradiantAndHessian(FitScanCache self, CLHEP::HepVector const & norms, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian, Likelihood::FitScanCache::Prior_Version whichPrior, size_t firstBin=0)
        getGradiantAndHessian(FitScanCache self, CLHEP::HepVector const & norms, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian, Likelihood::FitScanCache::Prior_Version whichPrior)
        getGradiantAndHessian(FitScanCache self, CLHEP::HepVector const & norms, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian)
        """
        return _pyLikelihood.FitScanCache_getGradiantAndHessian(self, *args)


    def getGradiantAndHessian_STL(self, *args):
        """
        getGradiantAndHessian_STL(FitScanCache self, FloatVector norms, FloatVector model, FloatVector gradient, FloatVector hessian, Likelihood::FitScanCache::Prior_Version whichPrior, size_t firstBin=0, size_t lastBin=0, int verbose=0)
        getGradiantAndHessian_STL(FitScanCache self, FloatVector norms, FloatVector model, FloatVector gradient, FloatVector hessian, Likelihood::FitScanCache::Prior_Version whichPrior, size_t firstBin=0, size_t lastBin=0)
        getGradiantAndHessian_STL(FitScanCache self, FloatVector norms, FloatVector model, FloatVector gradient, FloatVector hessian, Likelihood::FitScanCache::Prior_Version whichPrior, size_t firstBin=0)
        getGradiantAndHessian_STL(FitScanCache self, FloatVector norms, FloatVector model, FloatVector gradient, FloatVector hessian, Likelihood::FitScanCache::Prior_Version whichPrior)
        getGradiantAndHessian_STL(FitScanCache self, FloatVector norms, FloatVector model, FloatVector gradient, FloatVector hessian)
        """
        return _pyLikelihood.FitScanCache_getGradiantAndHessian_STL(self, *args)


    def scanNormalization(self, nnorm, normSigma, posErr, negErr, norms, logLikes):
        """scanNormalization(FitScanCache self, int nnorm, double normSigma, double posErr, double negErr, DoubleVector norms, DoubleVector logLikes) -> int"""
        return _pyLikelihood.FitScanCache_scanNormalization(self, nnorm, normSigma, posErr, negErr, norms, logLikes)


    def signalUncertainty_quad(self, deltaLogLike, posErr, negErr):
        """signalUncertainty_quad(FitScanCache self, double deltaLogLike, double & posErr, double & negErr) -> int"""
        return _pyLikelihood.FitScanCache_signalUncertainty_quad(self, deltaLogLike, posErr, negErr)


    def getTemplateIndex(self, srcName):
        """getTemplateIndex(FitScanCache self, std::string const & srcName) -> int"""
        return _pyLikelihood.FitScanCache_getTemplateIndex(self, srcName)


    def updateTemplateForSource(self, srcName):
        """updateTemplateForSource(FitScanCache self, std::string const & srcName) -> int"""
        return _pyLikelihood.FitScanCache_updateTemplateForSource(self, srcName)


    def setTolerance(self, tol):
        """setTolerance(FitScanCache self, double tol)"""
        return _pyLikelihood.FitScanCache_setTolerance(self, tol)


    def setMaxIter(self, maxIter):
        """setMaxIter(FitScanCache self, int maxIter)"""
        return _pyLikelihood.FitScanCache_setMaxIter(self, maxIter)


    def setInitLambda(self, initLambda):
        """setInitLambda(FitScanCache self, double initLambda)"""
        return _pyLikelihood.FitScanCache_setInitLambda(self, initLambda)


    def fillModelCounts(self, srcName, model):
        """fillModelCounts(FitScanCache self, std::string const & srcName, FloatVector model)"""
        return _pyLikelihood.FitScanCache_fillModelCounts(self, srcName, model)


    def fillRedModel(self, srcName, model):
        """fillRedModel(FitScanCache self, std::string const & srcName, FloatVector model)"""
        return _pyLikelihood.FitScanCache_fillRedModel(self, srcName, model)


    def fillFullModel(self, srcName, model):
        """fillFullModel(FitScanCache self, std::string const & srcName, FloatVector model)"""
        return _pyLikelihood.FitScanCache_fillFullModel(self, srcName, model)


    def testSourceName(self):
        """testSourceName(FitScanCache self) -> std::string const &"""
        return _pyLikelihood.FitScanCache_testSourceName(self)


    def npix(self):
        """npix(FitScanCache self) -> size_t"""
        return _pyLikelihood.FitScanCache_npix(self)


    def nebins(self):
        """nebins(FitScanCache self) -> size_t"""
        return _pyLikelihood.FitScanCache_nebins(self)


    def nBkgModel(self):
        """nBkgModel(FitScanCache self) -> size_t"""
        return _pyLikelihood.FitScanCache_nBkgModel(self)


    def useReduced(self):
        """useReduced(FitScanCache self) -> bool"""
        return _pyLikelihood.FitScanCache_useReduced(self)


    def useWeights(self):
        """useWeights(FitScanCache self) -> bool"""
        return _pyLikelihood.FitScanCache_useWeights(self)


    def tol(self):
        """tol(FitScanCache self) -> double"""
        return _pyLikelihood.FitScanCache_tol(self)


    def maxIter(self):
        """maxIter(FitScanCache self) -> int"""
        return _pyLikelihood.FitScanCache_maxIter(self)


    def initLambda(self):
        """initLambda(FitScanCache self) -> double"""
        return _pyLikelihood.FitScanCache_initLambda(self)


    def loglike_ref(self):
        """loglike_ref(FitScanCache self) -> double const &"""
        return _pyLikelihood.FitScanCache_loglike_ref(self)


    def nFreeCurrent(self):
        """nFreeCurrent(FitScanCache self) -> size_t"""
        return _pyLikelihood.FitScanCache_nFreeCurrent(self)


    def testSourceIndex(self):
        """testSourceIndex(FitScanCache self) -> int"""
        return _pyLikelihood.FitScanCache_testSourceIndex(self)


    def currentFree(self):
        """currentFree(FitScanCache self) -> BoolVector"""
        return _pyLikelihood.FitScanCache_currentFree(self)


    def initPars(self):
        """initPars(FitScanCache self) -> CLHEP::HepVector const &"""
        return _pyLikelihood.FitScanCache_initPars(self)


    def currentPars(self):
        """currentPars(FitScanCache self) -> CLHEP::HepVector const &"""
        return _pyLikelihood.FitScanCache_currentPars(self)


    def currentCov(self):
        """currentCov(FitScanCache self) -> CLHEP::HepSymMatrix const &"""
        return _pyLikelihood.FitScanCache_currentCov(self)


    def currentModel(self):
        """currentModel(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_currentModel(self)


    def currentLogLike(self):
        """currentLogLike(FitScanCache self) -> double"""
        return _pyLikelihood.FitScanCache_currentLogLike(self)


    def currentEDM(self):
        """currentEDM(FitScanCache self) -> double"""
        return _pyLikelihood.FitScanCache_currentEDM(self)


    def firstEnergyBin(self):
        """firstEnergyBin(FitScanCache self) -> int"""
        return _pyLikelihood.FitScanCache_firstEnergyBin(self)


    def lastEnergyBin(self):
        """lastEnergyBin(FitScanCache self) -> int"""
        return _pyLikelihood.FitScanCache_lastEnergyBin(self)


    def data(self):
        """data(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_data(self)


    def nonZeroBins(self):
        """nonZeroBins(FitScanCache self) -> std::vector< int,std::allocator< int > > const &"""
        return _pyLikelihood.FitScanCache_nonZeroBins(self)


    def nFilled(self):
        """nFilled(FitScanCache self) -> size_t"""
        return _pyLikelihood.FitScanCache_nFilled(self)


    def global_idx(self, local):
        """global_idx(FitScanCache self, size_t local) -> int"""
        return _pyLikelihood.FitScanCache_global_idx(self, local)


    def energyBinStopIdxs(self):
        """energyBinStopIdxs(FitScanCache self) -> std::vector< int,std::allocator< int > > const &"""
        return _pyLikelihood.FitScanCache_energyBinStopIdxs(self)


    def refValues(self):
        """refValues(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_refValues(self)


    def templateSourceNames(self):
        """templateSourceNames(FitScanCache self) -> StringVector"""
        return _pyLikelihood.FitScanCache_templateSourceNames(self)


    def allModels(self):
        """allModels(FitScanCache self) -> FloatVectorVector"""
        return _pyLikelihood.FitScanCache_allModels(self)


    def allFixed(self):
        """allFixed(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_allFixed(self)


    def weights(self):
        """weights(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_weights(self)


    def targetModel(self):
        """targetModel(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_targetModel(self)


    def dataRed(self):
        """dataRed(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_dataRed(self)


    def allRedModels(self):
        """allRedModels(FitScanCache self) -> FloatVectorVector"""
        return _pyLikelihood.FitScanCache_allRedModels(self)


    def allRedFixed(self):
        """allRedFixed(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_allRedFixed(self)


    def firstBin(self):
        """firstBin(FitScanCache self) -> size_t"""
        return _pyLikelihood.FitScanCache_firstBin(self)


    def lastBin(self):
        """lastBin(FitScanCache self) -> size_t"""
        return _pyLikelihood.FitScanCache_lastBin(self)


    def targetRedModel(self):
        """targetRedModel(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_targetRedModel(self)


    def weightsRed(self):
        """weightsRed(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_weightsRed(self)


    def currentModels(self):
        """currentModels(FitScanCache self) -> std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const &"""
        return _pyLikelihood.FitScanCache_currentModels(self)


    def currentFixed(self):
        """currentFixed(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_currentFixed(self)


    def currentRefValues(self):
        """currentRefValues(FitScanCache self) -> FloatVector"""
        return _pyLikelihood.FitScanCache_currentRefValues(self)


    def currentSourceIndices(self):
        """currentSourceIndices(FitScanCache self) -> std::vector< int,std::allocator< int > > const &"""
        return _pyLikelihood.FitScanCache_currentSourceIndices(self)


    def getPrior(self, *args):
        """
        getPrior(FitScanCache self, Likelihood::FitScanCache::Prior_Version whichPrior, bool include_test_source=False) -> FitScanMVPrior
        getPrior(FitScanCache self, Likelihood::FitScanCache::Prior_Version whichPrior) -> FitScanMVPrior
        getPrior(FitScanCache self) -> FitScanMVPrior
        """
        return _pyLikelihood.FitScanCache_getPrior(self, *args)


    def snapshot(self):
        """snapshot(FitScanCache self) -> Snapshot"""
        return _pyLikelihood.FitScanCache_snapshot(self)


    def sourceModel(self):
        """sourceModel(FitScanCache self) -> BinnedLikelihood"""
        return _pyLikelihood.FitScanCache_sourceModel(self)

FitScanCache_swigregister = _pyLikelihood.FitScanCache_swigregister
FitScanCache_swigregister(FitScanCache)

class FitScanner(_object):
    """Proxy of C++ Likelihood::FitScanner class."""

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

    def buildEnergyBinner(energies):
        """buildEnergyBinner(DoubleVector energies) -> evtbin::Binner *"""
        return _pyLikelihood.FitScanner_buildEnergyBinner(energies)

    buildEnergyBinner = staticmethod(buildEnergyBinner)

    def buildSkyProj(projName, dir, pixSize, nPix, galactic=False):
        """
        buildSkyProj(std::string const & projName, SkyDir dir, double pixSize, int nPix, bool galactic=False) -> SkyProj
        buildSkyProj(std::string const & projName, SkyDir dir, double pixSize, int nPix) -> SkyProj
        """
        return _pyLikelihood.FitScanner_buildSkyProj(projName, dir, pixSize, nPix, galactic)

    buildSkyProj = staticmethod(buildSkyProj)
    PRIMARY_HDU = _pyLikelihood.FitScanner_PRIMARY_HDU
    FITS_IMAGE = _pyLikelihood.FitScanner_FITS_IMAGE
    FITDATA_TABLE = _pyLikelihood.FitScanner_FITDATA_TABLE
    SCANDATA_TABLE = _pyLikelihood.FitScanner_SCANDATA_TABLE

    def __init__(self, *args):
        """
        __init__(Likelihood::FitScanner self, BinnedLikelihood binnedLike, Optimizer optimizer, SkyProj proj, int nx, int ny) -> FitScanner
        __init__(Likelihood::FitScanner self, SummedLikelihood summedLike, Optimizer optimizer, SkyProj proj, int nx, int ny) -> FitScanner
        __init__(Likelihood::FitScanner self, BinnedLikelihood binnedLike, Optimizer optimizer, HealpixProj proj, std::string const & region) -> FitScanner
        __init__(Likelihood::FitScanner self, SummedLikelihood summedLike, Optimizer optimizer, HealpixProj proj, std::string const & region) -> FitScanner
        """
        this = _pyLikelihood.new_FitScanner(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_FitScanner
    __del__ = lambda self: None

    def run_tsmap(self, *args):
        """
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3, int tolType=0, int maxIter=30, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out, double initLambda=0.0, bool useWeights=False) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3, int tolType=0, int maxIter=30, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out, double initLambda=0.0) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3, int tolType=0, int maxIter=30, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3, int tolType=0, int maxIter=30, bool remakeTestSource=False, int ST_scan_level=0) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3, int tolType=0, int maxIter=30, bool remakeTestSource=False) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3, int tolType=0, int maxIter=30) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3, int tolType=0) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0, double tol=1e-3) -> int
        run_tsmap(FitScanner self, double covScale_bb=-1.0) -> int
        run_tsmap(FitScanner self) -> int
        """
        return _pyLikelihood.FitScanner_run_tsmap(self, *args)


    def run_SED(self, *args):
        """
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out, double initLambda=0.0, bool useWeights=False) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out, double initLambda=0.0) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0) -> int
        run_SED(FitScanner self, int nNorm=10, double normSigma=5.0) -> int
        run_SED(FitScanner self, int nNorm=10) -> int
        run_SED(FitScanner self) -> int
        """
        return _pyLikelihood.FitScanner_run_SED(self, *args)


    def run_tscube(self, *args):
        """
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out, double initLambda=0.0, bool useWeights=False) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out, double initLambda=0.0) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0, std::string src_model_out) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False, int ST_scan_level=0) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0, bool remakeTestSource=False) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30, int tolType=0) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3, int maxIter=30) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0, double tol=1e-3) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0, double covScale=-1.0) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0, double covScale_bb=-1.0) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10, double normSigma=5.0) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True, int nNorm=10) -> int
        run_tscube(FitScanner self, bool doTSMap=True, bool doSED=True) -> int
        run_tscube(FitScanner self, bool doTSMap=True) -> int
        run_tscube(FitScanner self) -> int
        """
        return _pyLikelihood.FitScanner_run_tscube(self, *args)


    def writeFitsFile(self, *args):
        """
        writeFitsFile(FitScanner self, std::string const & fitsFile, std::string const & creator, std::string fits_template, bool copyGTIs=False) -> int
        writeFitsFile(FitScanner self, std::string const & fitsFile, std::string const & creator, std::string fits_template) -> int
        writeFitsFile(FitScanner self, std::string const & fitsFile, std::string const & creator) -> int
        """
        return _pyLikelihood.FitScanner_writeFitsFile(self, *args)


    def modelWrapper(self):
        """modelWrapper(FitScanner self) -> FitScanModelWrapper"""
        return _pyLikelihood.FitScanner_modelWrapper(self)


    def optimizer(self):
        """optimizer(FitScanner self) -> Optimizer"""
        return _pyLikelihood.FitScanner_optimizer(self)


    def proj(self):
        """proj(FitScanner self) -> ProjBase"""
        return _pyLikelihood.FitScanner_proj(self)


    def testSourceDir(self):
        """testSourceDir(FitScanner self) -> SkyDir"""
        return _pyLikelihood.FitScanner_testSourceDir(self)


    def testSource(self):
        """testSource(FitScanner self) -> Source"""
        return _pyLikelihood.FitScanner_testSource(self)


    def testSourceName(self):
        """testSourceName(FitScanner self) -> std::string const &"""
        return _pyLikelihood.FitScanner_testSourceName(self)


    def nPixels(self):
        """nPixels(FitScanner self) -> int"""
        return _pyLikelihood.FitScanner_nPixels(self)


    def nEBins(self):
        """nEBins(FitScanner self) -> int"""
        return _pyLikelihood.FitScanner_nEBins(self)


    def nNorms(self):
        """nNorms(FitScanner self) -> int"""
        return _pyLikelihood.FitScanner_nNorms(self)


    def setPowerlawPointTestSource(self, factory, index=2.0):
        """
        setPowerlawPointTestSource(FitScanner self, FunctionFactory factory, double index=2.0) -> int
        setPowerlawPointTestSource(FitScanner self, FunctionFactory factory) -> int
        """
        return _pyLikelihood.FitScanner_setPowerlawPointTestSource(self, factory, index)


    def setPointTestSource(self, spectrum):
        """setPointTestSource(FitScanner self, Function spectrum) -> int"""
        return _pyLikelihood.FitScanner_setPointTestSource(self, spectrum)


    def setTestSourceByName(self, sourceName, shiftToPixelCenter=True):
        """
        setTestSourceByName(FitScanner self, std::string const & sourceName, bool shiftToPixelCenter=True) -> int
        setTestSourceByName(FitScanner self, std::string const & sourceName) -> int
        """
        return _pyLikelihood.FitScanner_setTestSourceByName(self, sourceName, shiftToPixelCenter)


    def setTestSource(self, source, owned=True):
        """
        setTestSource(FitScanner self, Source source, bool owned=True) -> int
        setTestSource(FitScanner self, Source source) -> int
        """
        return _pyLikelihood.FitScanner_setTestSource(self, source, owned)


    def verbose_null(self):
        """verbose_null(FitScanner self) -> int"""
        return _pyLikelihood.FitScanner_verbose_null(self)


    def verbose_bb(self):
        """verbose_bb(FitScanner self) -> int"""
        return _pyLikelihood.FitScanner_verbose_bb(self)


    def verbose_scan(self):
        """verbose_scan(FitScanner self) -> int"""
        return _pyLikelihood.FitScanner_verbose_scan(self)


    def writeTestImages(self):
        """writeTestImages(FitScanner self) -> bool"""
        return _pyLikelihood.FitScanner_writeTestImages(self)


    def useReduced(self):
        """useReduced(FitScanner self) -> bool"""
        return _pyLikelihood.FitScanner_useReduced(self)


    def set_verbose_null(self, val):
        """set_verbose_null(FitScanner self, int val)"""
        return _pyLikelihood.FitScanner_set_verbose_null(self, val)


    def set_verbose_bb(self, val):
        """set_verbose_bb(FitScanner self, int val)"""
        return _pyLikelihood.FitScanner_set_verbose_bb(self, val)


    def set_verbose_scan(self, val):
        """set_verbose_scan(FitScanner self, int val)"""
        return _pyLikelihood.FitScanner_set_verbose_scan(self, val)


    def set_writeTestImages(self, val):
        """set_writeTestImages(FitScanner self, bool val)"""
        return _pyLikelihood.FitScanner_set_writeTestImages(self, val)


    def set_useReduced(self, val):
        """set_useReduced(FitScanner self, bool val)"""
        return _pyLikelihood.FitScanner_set_useReduced(self, val)

FitScanner_swigregister = _pyLikelihood.FitScanner_swigregister
FitScanner_swigregister(FitScanner)

def FitScanner_buildEnergyBinner(energies):
    """FitScanner_buildEnergyBinner(DoubleVector energies) -> evtbin::Binner *"""
    return _pyLikelihood.FitScanner_buildEnergyBinner(energies)

def FitScanner_buildSkyProj(projName, dir, pixSize, nPix, galactic=False):
    """
    buildSkyProj(std::string const & projName, SkyDir dir, double pixSize, int nPix, bool galactic=False) -> SkyProj
    FitScanner_buildSkyProj(std::string const & projName, SkyDir dir, double pixSize, int nPix) -> SkyProj
    """
    return _pyLikelihood.FitScanner_buildSkyProj(projName, dir, pixSize, nPix, galactic)


def pixelCounts_linearQuad(emin, emax, y1, y2):
    """pixelCounts_linearQuad(double emin, double emax, double y1, double y2) -> double"""
    return _pyLikelihood.pixelCounts_linearQuad(emin, emax, y1, y2)

def pixelCounts_loglogQuad(emin, emax, y1, y2, log_ratio):
    """pixelCounts_loglogQuad(double emin, double emax, double y1, double y2, double log_ratio) -> double"""
    return _pyLikelihood.pixelCounts_loglogQuad(emin, emax, y1, y2, log_ratio)

def svd_inverse(u, v, s, inverse):
    """svd_inverse(CLHEP::HepMatrix const & u, CLHEP::HepMatrix const & v, CLHEP::HepVector const & s, CLHEP::HepMatrix & inverse)"""
    return _pyLikelihood.svd_inverse(u, v, s, inverse)

def svd_solve(hessian, gradient, u, v, s, delta, eps=1E-16):
    """
    svd_solve(CLHEP::HepSymMatrix const & hessian, CLHEP::HepVector const & gradient, CLHEP::HepMatrix & u, CLHEP::HepMatrix & v, CLHEP::HepVector & s, CLHEP::HepVector & delta, double eps=1E-16) -> int
    svd_solve(CLHEP::HepSymMatrix const & hessian, CLHEP::HepVector const & gradient, CLHEP::HepMatrix & u, CLHEP::HepMatrix & v, CLHEP::HepVector & s, CLHEP::HepVector & delta) -> int
    """
    return _pyLikelihood.svd_solve(hessian, gradient, u, v, s, delta, eps)

def Vector_Hep_to_Gsl(hep):
    """Vector_Hep_to_Gsl(CLHEP::HepVector const & hep) -> gsl_vector *"""
    return _pyLikelihood.Vector_Hep_to_Gsl(hep)

def Matrix_Hep_to_Gsl(hep):
    """Matrix_Hep_to_Gsl(CLHEP::HepMatrix const & hep) -> gsl_matrix *"""
    return _pyLikelihood.Matrix_Hep_to_Gsl(hep)

def Vector_Gsl_to_Hep(gsl, hep):
    """Vector_Gsl_to_Hep(gsl_vector const * gsl, CLHEP::HepVector & hep)"""
    return _pyLikelihood.Vector_Gsl_to_Hep(gsl, hep)

def Matrix_Gsl_to_Hep(gsl, hep):
    """Matrix_Gsl_to_Hep(gsl_matrix const * gsl, CLHEP::HepMatrix & hep)"""
    return _pyLikelihood.Matrix_Gsl_to_Hep(gsl, hep)

def Vector_Hep_to_Stl(hep, stl):
    """Vector_Hep_to_Stl(CLHEP::HepVector const & hep, FloatVector stl)"""
    return _pyLikelihood.Vector_Hep_to_Stl(hep, stl)

def Matrix_Hep_to_Stl(hep, stl):
    """Matrix_Hep_to_Stl(CLHEP::HepSymMatrix const & hep, FloatVector stl)"""
    return _pyLikelihood.Matrix_Hep_to_Stl(hep, stl)

def Vector_Stl_to_Hep(stl, hep):
    """Vector_Stl_to_Hep(FloatVector stl, CLHEP::HepVector & hep)"""
    return _pyLikelihood.Vector_Stl_to_Hep(stl, hep)

def Matrix_Stl_to_Hep(stl, hep):
    """Matrix_Stl_to_Hep(FloatVector stl, CLHEP::HepSymMatrix & hep)"""
    return _pyLikelihood.Matrix_Stl_to_Hep(stl, hep)

def sumVector(start, stop, value):
    """sumVector(std::vector< float,std::allocator< float > >::const_iterator start, std::vector< float,std::allocator< float > >::const_iterator stop, float & value)"""
    return _pyLikelihood.sumVector(start, stop, value)

def setVectorValue(val, start, stop):
    """setVectorValue(float const & val, std::vector< float,std::allocator< float > >::iterator start, std::vector< float,std::allocator< float > >::iterator stop)"""
    return _pyLikelihood.setVectorValue(val, start, stop)

def vectorAdd(start1, stop1, start2, stop2, out_start, out_stop, fact1=1., fact2=1.):
    """
    vectorAdd(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, std::vector< float,std::allocator< float > >::iterator out_start, std::vector< float,std::allocator< float > >::iterator out_stop, float fact1=1., float fact2=1.)
    vectorAdd(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, std::vector< float,std::allocator< float > >::iterator out_start, std::vector< float,std::allocator< float > >::iterator out_stop, float fact1=1.)
    vectorAdd(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, std::vector< float,std::allocator< float > >::iterator out_start, std::vector< float,std::allocator< float > >::iterator out_stop)
    """
    return _pyLikelihood.vectorAdd(start1, stop1, start2, stop2, out_start, out_stop, fact1, fact2)

def vectorMultiply(start1, stop1, start2, stop2, out_start, out_stop):
    """vectorMultiply(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, std::vector< float,std::allocator< float > >::iterator out_start, std::vector< float,std::allocator< float > >::iterator out_stop)"""
    return _pyLikelihood.vectorMultiply(start1, stop1, start2, stop2, out_start, out_stop)

def multiplyByScalar(vstart, vstop, scalar):
    """multiplyByScalar(std::vector< float,std::allocator< float > >::iterator vstart, std::vector< float,std::allocator< float > >::iterator vstop, double scalar)"""
    return _pyLikelihood.multiplyByScalar(vstart, vstop, scalar)

def vectorSubtract(start1, stop1, start2, stop2, out_start, out_stop):
    """vectorSubtract(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, std::vector< float,std::allocator< float > >::iterator out_start, std::vector< float,std::allocator< float > >::iterator out_stop)"""
    return _pyLikelihood.vectorSubtract(start1, stop1, start2, stop2, out_start, out_stop)

def innerProduct(*args):
    """
    innerProduct(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, float & value)
    innerProduct(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, std::vector< float,std::allocator< float > >::const_iterator start3, std::vector< float,std::allocator< float > >::const_iterator stop3, std::vector< float,std::allocator< float > >::const_iterator start4, std::vector< float,std::allocator< float > >::const_iterator stop4, float & value)
    innerProduct(std::vector< float,std::allocator< float > >::const_iterator start1, std::vector< float,std::allocator< float > >::const_iterator stop1, std::vector< float,std::allocator< float > >::const_iterator start2, std::vector< float,std::allocator< float > >::const_iterator stop2, std::vector< float,std::allocator< float > >::const_iterator start3, std::vector< float,std::allocator< float > >::const_iterator stop3, float & value)
    """
    return _pyLikelihood.innerProduct(*args)

def fracDiff(data_start, data_stop, model_start, model_stop, out_start, out_stop):
    """fracDiff(std::vector< float,std::allocator< float > >::const_iterator data_start, std::vector< float,std::allocator< float > >::const_iterator data_stop, std::vector< float,std::allocator< float > >::const_iterator model_start, std::vector< float,std::allocator< float > >::const_iterator model_stop, std::vector< float,std::allocator< float > >::iterator out_start, std::vector< float,std::allocator< float > >::iterator out_stop)"""
    return _pyLikelihood.fracDiff(data_start, data_stop, model_start, model_stop, out_start, out_stop)

def data_over_model2(data_start, data_stop, model_start, model_stop, out_start, out_stop):
    """data_over_model2(std::vector< float,std::allocator< float > >::const_iterator data_start, std::vector< float,std::allocator< float > >::const_iterator data_stop, std::vector< float,std::allocator< float > >::const_iterator model_start, std::vector< float,std::allocator< float > >::const_iterator model_stop, std::vector< float,std::allocator< float > >::iterator out_start, std::vector< float,std::allocator< float > >::iterator out_stop)"""
    return _pyLikelihood.data_over_model2(data_start, data_stop, model_start, model_stop, out_start, out_stop)

def reshapeVector(invect, n_i, n_j, outvect):
    """reshapeVector(FloatVector invect, size_t n_i, size_t n_j, FloatVectorVector outvect)"""
    return _pyLikelihood.reshapeVector(invect, n_i, n_j, outvect)

def symmetricError(pos_err, neg_err):
    """symmetricError(double pos_err, double neg_err) -> double"""
    return _pyLikelihood.symmetricError(pos_err, neg_err)

def sumModel_Init(templates, fixed, total):
    """sumModel_Init(FloatVectorVector templates, FloatVector fixed, FloatVector total)"""
    return _pyLikelihood.sumModel_Init(templates, fixed, total)

def sumModel(norms, templates, fixed, total, firstBin=0, lastBin=0):
    """
    sumModel(CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FloatVector total, size_t firstBin=0, size_t lastBin=0)
    sumModel(CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FloatVector total, size_t firstBin=0)
    sumModel(CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FloatVector total)
    """
    return _pyLikelihood.sumModel(norms, templates, fixed, total, firstBin, lastBin)

def getLogLikelihood(data, norms, templates, fixed, prior, weights, model, firstBin=0, lastBin=0, verbose=0):
    """
    getLogLikelihood(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model, size_t firstBin=0, size_t lastBin=0, int verbose=0) -> double
    getLogLikelihood(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model, size_t firstBin=0, size_t lastBin=0) -> double
    getLogLikelihood(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model, size_t firstBin=0) -> double
    getLogLikelihood(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model) -> double
    """
    return _pyLikelihood.getLogLikelihood(data, norms, templates, fixed, prior, weights, model, firstBin, lastBin, verbose)

def getGradientAndHessian(data, norms, templates, fixed, prior, weights, model, gradient, hessian, firstBin=0, lastBin=0, verbose=0):
    """
    getGradientAndHessian(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian, size_t firstBin=0, size_t lastBin=0, int verbose=0)
    getGradientAndHessian(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian, size_t firstBin=0, size_t lastBin=0)
    getGradientAndHessian(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian, size_t firstBin=0)
    getGradientAndHessian(FloatVector data, CLHEP::HepVector const & norms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, FloatVector model, CLHEP::HepVector & gradient, CLHEP::HepSymMatrix & hessian)
    """
    return _pyLikelihood.getGradientAndHessian(data, norms, templates, fixed, prior, weights, model, gradient, hessian, firstBin, lastBin, verbose)

def getDeltaAndCovarAndEDM(*args):
    """
    getDeltaAndCovarAndEDM(CLHEP::HepSymMatrix const & hessian, CLHEP::HepVector const & gradient, CLHEP::HepVector const & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & delta, double & edm) -> int
    getDeltaAndCovarAndEDM(CLHEP::HepSymMatrix const & hessian, CLHEP::HepVector const & gradient, CLHEP::HepVector const & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & delta, double & edm, double arg7) -> int
    """
    return _pyLikelihood.getDeltaAndCovarAndEDM(*args)

def getDeltaAndCovarAndEDM_STL(hessian, gradient, norms, covar, delta, edm, arg7=-1.0):
    """
    getDeltaAndCovarAndEDM_STL(FloatVector hessian, FloatVector gradient, FloatVector norms, FloatVector covar, FloatVector delta, DoubleVector edm, double arg7=-1.0) -> int
    getDeltaAndCovarAndEDM_STL(FloatVector hessian, FloatVector gradient, FloatVector norms, FloatVector covar, FloatVector delta, DoubleVector edm) -> int
    """
    return _pyLikelihood.getDeltaAndCovarAndEDM_STL(hessian, gradient, norms, covar, delta, edm, arg7)

def extractNonZeroBins(dataVect, npix, nonZeroBins, dataRed, energyBinStopIdxs):
    """extractNonZeroBins(FloatVector dataVect, int npix, std::vector< int,std::allocator< int > > & nonZeroBins, FloatVector dataRed, std::vector< int,std::allocator< int > > & energyBinStopIdxs)"""
    return _pyLikelihood.extractNonZeroBins(dataVect, npix, nonZeroBins, dataRed, energyBinStopIdxs)

def sparsifyModel(nonZeroBins, model, modelRed):
    """sparsifyModel(std::vector< int,std::allocator< int > > const & nonZeroBins, FloatVector model, FloatVector modelRed)"""
    return _pyLikelihood.sparsifyModel(nonZeroBins, model, modelRed)

def sparsifyWeights(nonZeroBins, weights, model, weightsRed):
    """sparsifyWeights(std::vector< int,std::allocator< int > > const & nonZeroBins, FloatVector weights, FloatVector model, FloatVector weightsRed)"""
    return _pyLikelihood.sparsifyWeights(nonZeroBins, weights, model, weightsRed)

def logLikePoisson(*args):
    """
    logLikePoisson(std::vector< float,std::allocator< float > >::const_iterator data_start, std::vector< float,std::allocator< float > >::const_iterator data_stop, std::vector< float,std::allocator< float > >::const_iterator model_start, std::vector< float,std::allocator< float > >::const_iterator model_stop) -> double
    logLikePoisson(std::vector< float,std::allocator< float > >::const_iterator data_start, std::vector< float,std::allocator< float > >::const_iterator data_stop, std::vector< float,std::allocator< float > >::const_iterator model_start, std::vector< float,std::allocator< float > >::const_iterator model_stop, std::vector< float,std::allocator< float > >::const_iterator w_start, std::vector< float,std::allocator< float > >::const_iterator w_stop) -> double
    """
    return _pyLikelihood.logLikePoisson(*args)

def fitNorms_newton(data, initNorms, templates, fixed, prior, weights, tol, maxIter, arg9, norms, covar, gradient, model, edm, logLikeVal, firstBin=0, lastBin=0, verbose=0):
    """
    fitNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0, size_t lastBin=0, int verbose=0) -> int
    fitNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0, size_t lastBin=0) -> int
    fitNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0) -> int
    fitNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal) -> int
    """
    return _pyLikelihood.fitNorms_newton(data, initNorms, templates, fixed, prior, weights, tol, maxIter, arg9, norms, covar, gradient, model, edm, logLikeVal, firstBin, lastBin, verbose)

def fitLogNorms_newton(data, initNorms, templates, fixed, prior, weights, tol, maxIter, arg9, norms, covar, gradient, model, edm, logLikeVal, firstBin=0, lastBin=0, verbose=0):
    """
    fitLogNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0, size_t lastBin=0, int verbose=0) -> int
    fitLogNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0, size_t lastBin=0) -> int
    fitLogNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0) -> int
    fitLogNorms_newton(FloatVector data, CLHEP::HepVector const & initNorms, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > const & templates, FloatVector fixed, FitScanMVPrior prior, FloatVector weights, double tol, int maxIter, double arg9, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal) -> int
    """
    return _pyLikelihood.fitLogNorms_newton(data, initNorms, templates, fixed, prior, weights, tol, maxIter, arg9, norms, covar, gradient, model, edm, logLikeVal, firstBin, lastBin, verbose)

def extractSpectralVals(source, energies, specVals):
    """extractSpectralVals(Source source, DoubleVector energies, DoubleVector specVals)"""
    return _pyLikelihood.extractSpectralVals(source, energies, specVals)

def extractSpectralDerivs(source, energies, paramNames, derivVals):
    """extractSpectralDerivs(Source source, DoubleVector energies, StringVector paramNames, DoubleVectorVector derivVals)"""
    return _pyLikelihood.extractSpectralDerivs(source, energies, paramNames, derivVals)

def extractNPreds(source, energies, nPreds):
    """extractNPreds(Source source, DoubleVector energies, DoubleVector nPreds)"""
    return _pyLikelihood.extractNPreds(source, energies, nPreds)

def extractModelFromSource(source, logLike, model, rescaleToNormOne=False):
    """
    extractModelFromSource(Source source, BinnedLikelihood logLike, FloatVector model, bool rescaleToNormOne=False)
    extractModelFromSource(Source source, BinnedLikelihood logLike, FloatVector model)
    """
    return _pyLikelihood.extractModelFromSource(source, logLike, model, rescaleToNormOne)

def extractModelCounts(sourceMap, energies, specVals, modelCounts):
    """extractModelCounts(SourceMap sourceMap, DoubleVector energies, DoubleVector specVals, FloatVector modelCounts)"""
    return _pyLikelihood.extractModelCounts(sourceMap, energies, specVals, modelCounts)

def extractModels(logLike, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights=None, useUnitRefVals=False):
    """
    extractModels(BinnedLikelihood logLike, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None, bool useUnitRefVals=False)
    extractModels(BinnedLikelihood logLike, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars, FloatVector weights=None)
    extractModels(BinnedLikelihood logLike, std::string const & test_name, StringVector freeSrcNames, FloatVectorVector templates, FloatVector fixed, FloatVector test_source_model, FloatVector refPars)
    """
    return _pyLikelihood.extractModels(logLike, test_name, freeSrcNames, templates, fixed, test_source_model, refPars, weights, useUnitRefVals)

def extractFixedModel(logLike, test_name, fixed, latched=None):
    """
    extractFixedModel(BinnedLikelihood logLike, std::string const & test_name, FloatVector fixed, StringVector latched=None)
    extractFixedModel(BinnedLikelihood logLike, std::string const & test_name, FloatVector fixed)
    """
    return _pyLikelihood.extractFixedModel(logLike, test_name, fixed, latched)

def extractPrior(par, centralVal, uncertainty):
    """extractPrior(Parameter par, double & centralVal, double & uncertainty) -> bool"""
    return _pyLikelihood.extractPrior(par, centralVal, uncertainty)

def extractPriors(logLike, freeSrcNames, centralVals, uncertainties, parHasPrior):
    """extractPriors(BinnedLikelihood logLike, StringVector freeSrcNames, CLHEP::HepVector & centralVals, CLHEP::HepVector & uncertainties, BoolVector parHasPrior) -> bool"""
    return _pyLikelihood.extractPriors(logLike, freeSrcNames, centralVals, uncertainties, parHasPrior)

def refactorModels(templates_in, fixed_in, scales_in, freePars, test_source_model, templates_out, fixed_out, scales_out):
    """refactorModels(FloatVectorVector templates_in, FloatVector fixed_in, FloatVector scales_in, BoolVector freePars, FloatVector test_source_model, std::vector< std::vector< float,std::allocator< float > > const *,std::allocator< std::vector< float,std::allocator< float > > const * > > & templates_out, FloatVector fixed_out, FloatVector scales_out)"""
    return _pyLikelihood.refactorModels(templates_in, fixed_in, scales_in, freePars, test_source_model, templates_out, fixed_out, scales_out)

def fitModelNorms_newton(logLike, test_name, tol, maxIter, arg5, norms, covar, gradient, model, edm, logLikeVal, firstBin=0, lastBin=0):
    """
    fitModelNorms_newton(BinnedLikelihood logLike, std::string const & test_name, double tol, int maxIter, double arg5, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0, size_t lastBin=0) -> int
    fitModelNorms_newton(BinnedLikelihood logLike, std::string const & test_name, double tol, int maxIter, double arg5, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal, size_t firstBin=0) -> int
    fitModelNorms_newton(BinnedLikelihood logLike, std::string const & test_name, double tol, int maxIter, double arg5, CLHEP::HepVector & norms, CLHEP::HepSymMatrix & covar, CLHEP::HepVector & gradient, FloatVector model, double & edm, double & logLikeVal) -> int
    """
    return _pyLikelihood.fitModelNorms_newton(logLike, test_name, tol, maxIter, arg5, norms, covar, gradient, model, edm, logLikeVal, firstBin, lastBin)

def get_spectral_weights(spec, dataCache, spec_weights):
    """get_spectral_weights(DoubleVector spec, BinnedCountsCache dataCache, DoubleVectorPair spec_weights)"""
    return _pyLikelihood.get_spectral_weights(spec, dataCache, spec_weights)

def get_edisp_range(dataCache, edisp_val, k, kmin, kmax):
    """get_edisp_range(BinnedCountsCache dataCache, int edisp_val, size_t k, size_t & kmin, size_t & kmax)"""
    return _pyLikelihood.get_edisp_range(dataCache, edisp_val, k, kmin, kmax)

def get_edisp_constants(srcMap, dataCache, edisp_val, k, kmin, kmax, edisp_col):
    """get_edisp_constants(SourceMap srcMap, BinnedCountsCache dataCache, int edisp_val, size_t k, size_t & kmin, size_t & kmax, DoubleVector edisp_col)"""
    return _pyLikelihood.get_edisp_constants(srcMap, dataCache, edisp_val, k, kmin, kmax, edisp_col)

def model_counts_contribution(srcMap, spec_wts, xi, npix, kref, ipix):
    """model_counts_contribution(SourceMap srcMap, DoubleVectorPair spec_wts, double const & xi, size_t npix, size_t kref, size_t ipix) -> double"""
    return _pyLikelihood.model_counts_contribution(srcMap, spec_wts, xi, npix, kref, ipix)

def model_counts_edisp(srcMap, spec_wts, edisp_col, ipix, npix, kmin, kmax):
    """model_counts_edisp(SourceMap srcMap, DoubleVectorPair spec_wts, DoubleVector edisp_col, size_t ipix, size_t npix, size_t kmin, size_t kmax) -> double"""
    return _pyLikelihood.model_counts_edisp(srcMap, spec_wts, edisp_col, ipix, npix, kmin, kmax)

def npred_contribution(npred_vals, npred_weights, spec_wts, xi, kref, counts, counts_wt):
    """npred_contribution(DoubleVector npred_vals, DoublePair npred_weights, DoubleVectorPair spec_wts, double const & xi, size_t kref, double & counts, double & counts_wt)"""
    return _pyLikelihood.npred_contribution(npred_vals, npred_weights, spec_wts, xi, kref, counts, counts_wt)

def npred_edisp(npred_vals, npred_weights, spec_wts, edisp_col, kmin, kmax, counts, counts_wt):
    """npred_edisp(DoubleVector npred_vals, DoubleVectorPair npred_weights, DoubleVectorPair spec_wts, DoubleVector edisp_col, size_t kmin, size_t kmax, double & counts, double & counts_wt)"""
    return _pyLikelihood.npred_edisp(npred_vals, npred_weights, spec_wts, edisp_col, kmin, kmax, counts, counts_wt)

def addSourceCounts(modelCounts, srcMap, dataCache, edisp_val, subtract):
    """addSourceCounts(DoubleVector modelCounts, SourceMap srcMap, BinnedCountsCache dataCache, int edisp_val, bool subtract)"""
    return _pyLikelihood.addSourceCounts(modelCounts, srcMap, dataCache, edisp_val, subtract)

def addFixedNpreds(fixed_counts_spec, fixed_counts_spec_wt, fixed_counts_spec_edisp, fixed_counts_spec_edisp_wt, srcMap, dataCache, edisp_val, subtract):
    """addFixedNpreds(DoubleVector fixed_counts_spec, DoubleVector fixed_counts_spec_wt, DoubleVector fixed_counts_spec_edisp, DoubleVector fixed_counts_spec_edisp_wt, SourceMap srcMap, BinnedCountsCache dataCache, int edisp_val, bool subtract)"""
    return _pyLikelihood.addFixedNpreds(fixed_counts_spec, fixed_counts_spec_wt, fixed_counts_spec_edisp, fixed_counts_spec_edisp_wt, srcMap, dataCache, edisp_val, subtract)

def updateModelMap(modelMap, srcMap, dataCache, use_mask, edisp_val):
    """updateModelMap(FloatVector modelMap, SourceMap srcMap, BinnedCountsCache dataCache, bool use_mask, int edisp_val)"""
    return _pyLikelihood.updateModelMap(modelMap, srcMap, dataCache, use_mask, edisp_val)

def printVector(name, vect):
    """printVector(std::string const & name, CLHEP::HepVector const & vect)"""
    return _pyLikelihood.printVector(name, vect)

def printMatrix(*args):
    """
    printMatrix(std::string const & name, CLHEP::HepSymMatrix const & mat)
    printMatrix(std::string const & name, CLHEP::HepMatrix const & mat)
    """
    return _pyLikelihood.printMatrix(*args)
class GaussianError(Function):
    """Proxy of C++ Likelihood::GaussianError class."""

    __swig_setmethods__ = {}
    for _s in [Function]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GaussianError, name, value)
    __swig_getmethods__ = {}
    for _s in [Function]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GaussianError, name)
    __repr__ = _swig_repr
    Norm = _pyLikelihood.GaussianError_Norm
    Mean = _pyLikelihood.GaussianError_Mean
    Sigma = _pyLikelihood.GaussianError_Sigma
    Offset = _pyLikelihood.GaussianError_Offset

    def __init__(self, norm=1, mean=0, sigma=1, offset=0):
        """
        __init__(Likelihood::GaussianError self, double norm=1, double mean=0, double sigma=1, double offset=0) -> GaussianError
        __init__(Likelihood::GaussianError self, double norm=1, double mean=0, double sigma=1) -> GaussianError
        __init__(Likelihood::GaussianError self, double norm=1, double mean=0) -> GaussianError
        __init__(Likelihood::GaussianError self, double norm=1) -> GaussianError
        __init__(Likelihood::GaussianError self) -> GaussianError
        """
        this = _pyLikelihood.new_GaussianError(norm, mean, sigma, offset)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def derivative(self, x):
        """derivative(GaussianError self, Arg x) -> double"""
        return _pyLikelihood.GaussianError_derivative(self, x)


    def clone(self):
        """clone(GaussianError self) -> Function *"""
        return _pyLikelihood.GaussianError_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_GaussianError
    __del__ = lambda self: None
GaussianError_swigregister = _pyLikelihood.GaussianError_swigregister
GaussianError_swigregister(GaussianError)

class LogGaussian(Function):
    """Proxy of C++ Likelihood::LogGaussian class."""

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

    def __init__(self, norm=1, mean=0, sigma=1):
        """
        __init__(Likelihood::LogGaussian self, double norm=1, double mean=0, double sigma=1) -> LogGaussian
        __init__(Likelihood::LogGaussian self, double norm=1, double mean=0) -> LogGaussian
        __init__(Likelihood::LogGaussian self, double norm=1) -> LogGaussian
        __init__(Likelihood::LogGaussian self) -> LogGaussian
        """
        this = _pyLikelihood.new_LogGaussian(norm, mean, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def derivative(self, x):
        """derivative(LogGaussian self, Arg x) -> double"""
        return _pyLikelihood.LogGaussian_derivative(self, x)


    def clone(self):
        """clone(LogGaussian self) -> Function *"""
        return _pyLikelihood.LogGaussian_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_LogGaussian
    __del__ = lambda self: None
LogGaussian_swigregister = _pyLikelihood.LogGaussian_swigregister
LogGaussian_swigregister(LogGaussian)

class LogNormalLog(_object):
    """Proxy of C++ Likelihood::LogNormalLog class."""

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

    def __init__(self, prefactor=1, log10_mean=3, log10_sigma=2):
        """
        __init__(Likelihood::LogNormalLog self, double prefactor=1, double log10_mean=3, double log10_sigma=2) -> LogNormalLog
        __init__(Likelihood::LogNormalLog self, double prefactor=1, double log10_mean=3) -> LogNormalLog
        __init__(Likelihood::LogNormalLog self, double prefactor=1) -> LogNormalLog
        __init__(Likelihood::LogNormalLog self) -> LogNormalLog
        """
        this = _pyLikelihood.new_LogNormalLog(prefactor, log10_mean, log10_sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(LogNormalLog self) -> Function *"""
        return _pyLikelihood.LogNormalLog_clone(self)


    def derivative(self, xarg):
        """derivative(LogNormalLog self, Arg xarg) -> double"""
        return _pyLikelihood.LogNormalLog_derivative(self, xarg)

    __swig_destroy__ = _pyLikelihood.delete_LogNormalLog
    __del__ = lambda self: None
LogNormalLog_swigregister = _pyLikelihood.LogNormalLog_swigregister
LogNormalLog_swigregister(LogNormalLog)

class LogParabola(Function):
    """Proxy of C++ Likelihood::LogParabola class."""

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

    def __init__(self, norm=1., alpha=1., beta=2., Eb=100.):
        """
        __init__(Likelihood::LogParabola self, double norm=1., double alpha=1., double beta=2., double Eb=100.) -> LogParabola
        __init__(Likelihood::LogParabola self, double norm=1., double alpha=1., double beta=2.) -> LogParabola
        __init__(Likelihood::LogParabola self, double norm=1., double alpha=1.) -> LogParabola
        __init__(Likelihood::LogParabola self, double norm=1.) -> LogParabola
        __init__(Likelihood::LogParabola self) -> LogParabola
        """
        this = _pyLikelihood.new_LogParabola(norm, alpha, beta, Eb)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(LogParabola self) -> Function *"""
        return _pyLikelihood.LogParabola_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_LogParabola
    __del__ = lambda self: None
LogParabola_swigregister = _pyLikelihood.LogParabola_swigregister
LogParabola_swigregister(LogParabola)

class ModelMap(_object):
    """Proxy of C++ Likelihood::ModelMap class."""

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

    def __init__(self, logLike, model_map=None):
        """
        __init__(Likelihood::ModelMap self, BinnedLikelihood logLike, FloatVector model_map=None) -> ModelMap
        __init__(Likelihood::ModelMap self, BinnedLikelihood logLike) -> ModelMap
        """
        this = _pyLikelihood.new_ModelMap(logLike, model_map)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def writeOutputMap(self, *args):
        """
        writeOutputMap(ModelMap self, std::string const & outfile, std::string outtype)
        writeOutputMap(ModelMap self, std::string const & outfile)
        """
        return _pyLikelihood.ModelMap_writeOutputMap(self, *args)

    __swig_destroy__ = _pyLikelihood.delete_ModelMap
    __del__ = lambda self: None
ModelMap_swigregister = _pyLikelihood.ModelMap_swigregister
ModelMap_swigregister(ModelMap)

class MultipleBrokenPowerLaw(Function):
    """Proxy of C++ Likelihood::MultipleBrokenPowerLaw class."""

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

    def __init__(self):
        """__init__(Likelihood::MultipleBrokenPowerLaw self) -> MultipleBrokenPowerLaw"""
        this = _pyLikelihood.new_MultipleBrokenPowerLaw()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(MultipleBrokenPowerLaw self) -> Function *"""
        return _pyLikelihood.MultipleBrokenPowerLaw_clone(self)


    def addParams(self, norm, photonIndexes, breakEnergies):
        """addParams(MultipleBrokenPowerLaw self, double norm, DoubleVector photonIndexes, DoubleVector breakEnergies)"""
        return _pyLikelihood.MultipleBrokenPowerLaw_addParams(self, norm, photonIndexes, breakEnergies)

    __swig_destroy__ = _pyLikelihood.delete_MultipleBrokenPowerLaw
    __del__ = lambda self: None
MultipleBrokenPowerLaw_swigregister = _pyLikelihood.MultipleBrokenPowerLaw_swigregister
MultipleBrokenPowerLaw_swigregister(MultipleBrokenPowerLaw)

class ProjMap(_object):
    """Proxy of C++ Likelihood::ProjMap class."""

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

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

    def cast_wcs(self):
        """cast_wcs(ProjMap self) -> WcsMap2"""
        return _pyLikelihood.ProjMap_cast_wcs(self)


    def cast_healpix(self):
        """cast_healpix(ProjMap self) -> HealpixProjMap"""
        return _pyLikelihood.ProjMap_cast_healpix(self)


    def __call__(self, *args):
        """
        __call__(ProjMap self, SkyDir dir, double energy=-1) -> double
        __call__(ProjMap self, SkyDir dir) -> double
        __call__(ProjMap self, SkyDir dir, int k) -> double
        """
        return _pyLikelihood.ProjMap___call__(self, *args)


    def convolveAll(self, psf, exposure=None, performConvolution=True):
        """
        convolveAll(ProjMap self, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True) -> ProjMap
        convolveAll(ProjMap self, MeanPsf psf, BinnedExposureBase exposure=None) -> ProjMap
        convolveAll(ProjMap self, MeanPsf psf) -> ProjMap
        """
        return _pyLikelihood.ProjMap_convolveAll(self, psf, exposure, performConvolution)


    def convolve(self, energy, psf, exposure=None, performConvolution=True, k=0):
        """
        convolve(ProjMap self, double energy, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True, int k=0) -> ProjMap
        convolve(ProjMap self, double energy, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True) -> ProjMap
        convolve(ProjMap self, double energy, MeanPsf psf, BinnedExposureBase exposure=None) -> ProjMap
        convolve(ProjMap self, double energy, MeanPsf psf) -> ProjMap
        """
        return _pyLikelihood.ProjMap_convolve(self, energy, psf, exposure, performConvolution, k)


    def makeCountsMap(self, counts_map):
        """makeCountsMap(ProjMap self, CountsMapBase counts_map) -> CountsMapBase"""
        return _pyLikelihood.ProjMap_makeCountsMap(self, counts_map)


    def solidAngle(self, ilon, ilat):
        """solidAngle(ProjMap self, double ilon, double ilat) -> double"""
        return _pyLikelihood.ProjMap_solidAngle(self, ilon, ilat)


    def pixelValue(self, ilon, ilat, k=0):
        """
        pixelValue(ProjMap self, double ilon, double ilat, int k=0) -> double
        pixelValue(ProjMap self, double ilon, double ilat) -> double
        """
        return _pyLikelihood.ProjMap_pixelValue(self, ilon, ilat, k)


    def skyDir(self, ilon, ilat):
        """skyDir(ProjMap self, double ilon, double ilat) -> SkyDir"""
        return _pyLikelihood.ProjMap_skyDir(self, ilon, ilat)


    def withinMapRadius(self, dir):
        """withinMapRadius(ProjMap self, SkyDir dir) -> bool"""
        return _pyLikelihood.ProjMap_withinMapRadius(self, dir)


    def nenergies(self):
        """nenergies(ProjMap self) -> int"""
        return _pyLikelihood.ProjMap_nenergies(self)


    def energies(self):
        """energies(ProjMap self) -> DoubleVector"""
        return _pyLikelihood.ProjMap_energies(self)


    def minMaxDistPixels(self, dir):
        """minMaxDistPixels(ProjMap self, SkyDir dir) -> SkyDirPair"""
        return _pyLikelihood.ProjMap_minMaxDistPixels(self, dir)


    def insideMap(self, dir):
        """insideMap(ProjMap self, SkyDir dir) -> bool"""
        return _pyLikelihood.ProjMap_insideMap(self, dir)


    def pixelSize(self):
        """pixelSize(ProjMap self) -> double"""
        return _pyLikelihood.ProjMap_pixelSize(self)


    def mapRadius(self):
        """mapRadius(ProjMap self) -> double"""
        return _pyLikelihood.ProjMap_mapRadius(self)


    def mapIntegral(self, *args):
        """
        mapIntegral(ProjMap self) -> double
        mapIntegral(ProjMap self, double energy) -> double
        """
        return _pyLikelihood.ProjMap_mapIntegral(self, *args)


    def rebin(self, factor, average=True):
        """
        rebin(ProjMap self, unsigned int factor, bool average=True) -> ProjMap
        rebin(ProjMap self, unsigned int factor) -> ProjMap
        """
        return _pyLikelihood.ProjMap_rebin(self, factor, average)


    def setExtrapolation(self, enforceEnergyRange):
        """setExtrapolation(ProjMap self, bool enforceEnergyRange)"""
        return _pyLikelihood.ProjMap_setExtrapolation(self, enforceEnergyRange)


    def setInterpolation(self, interpolate):
        """setInterpolation(ProjMap self, bool interpolate)"""
        return _pyLikelihood.ProjMap_setInterpolation(self, interpolate)


    def enforceEnergyRange(self):
        """enforceEnergyRange(ProjMap self) -> bool"""
        return _pyLikelihood.ProjMap_enforceEnergyRange(self)


    def extrapolated(self):
        """extrapolated(ProjMap self) -> unsigned long"""
        return _pyLikelihood.ProjMap_extrapolated(self)


    def getProj(self):
        """getProj(ProjMap self) -> ProjBase"""
        return _pyLikelihood.ProjMap_getProj(self)


    def interpolatePowerLaw(x, x1, x2, y1, y2):
        """interpolatePowerLaw(double x, double x1, double x2, double y1, double y2) -> double"""
        return _pyLikelihood.ProjMap_interpolatePowerLaw(x, x1, x2, y1, y2)

    interpolatePowerLaw = staticmethod(interpolatePowerLaw)

    def getRefDir(self):
        """getRefDir(ProjMap self) -> SkyDir"""
        return _pyLikelihood.ProjMap_getRefDir(self)

ProjMap_swigregister = _pyLikelihood.ProjMap_swigregister
ProjMap_swigregister(ProjMap)

def ProjMap_interpolatePowerLaw(x, x1, x2, y1, y2):
    """ProjMap_interpolatePowerLaw(double x, double x1, double x2, double y1, double y2) -> double"""
    return _pyLikelihood.ProjMap_interpolatePowerLaw(x, x1, x2, y1, y2)

class PiecewisePowerLaw(Function):
    """Proxy of C++ Likelihood::PiecewisePowerLaw class."""

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

    def __init__(self):
        """__init__(Likelihood::PiecewisePowerLaw self) -> PiecewisePowerLaw"""
        this = _pyLikelihood.new_PiecewisePowerLaw()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def integral(self, xmin, xmax):
        """integral(PiecewisePowerLaw self, Arg xmin, Arg xmax) -> double"""
        return _pyLikelihood.PiecewisePowerLaw_integral(self, xmin, xmax)


    def clone(self):
        """clone(PiecewisePowerLaw self) -> Function *"""
        return _pyLikelihood.PiecewisePowerLaw_clone(self)


    def addParams(self, indexL, indexH, dNdEs, energies):
        """addParams(PiecewisePowerLaw self, double indexL, double indexH, DoubleVector dNdEs, DoubleVector energies)"""
        return _pyLikelihood.PiecewisePowerLaw_addParams(self, indexL, indexH, dNdEs, energies)


    def cast(func):
        """cast(Function func) -> PiecewisePowerLaw"""
        return _pyLikelihood.PiecewisePowerLaw_cast(func)

    cast = staticmethod(cast)
    __swig_destroy__ = _pyLikelihood.delete_PiecewisePowerLaw
    __del__ = lambda self: None
PiecewisePowerLaw_swigregister = _pyLikelihood.PiecewisePowerLaw_swigregister
PiecewisePowerLaw_swigregister(PiecewisePowerLaw)

def PiecewisePowerLaw_cast(func):
    """PiecewisePowerLaw_cast(Function func) -> PiecewisePowerLaw"""
    return _pyLikelihood.PiecewisePowerLaw_cast(func)

class PowerLawSuperExpCutoff(Function):
    """Proxy of C++ Likelihood::PowerLawSuperExpCutoff class."""

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

    def __init__(self, Prefactor=10., Index1=-2.1, Scale=1000., Cutoff=10000., Index2=2.):
        """
        __init__(Likelihood::PowerLawSuperExpCutoff self, double Prefactor=10., double Index1=-2.1, double Scale=1000., double Cutoff=10000., double Index2=2.) -> PowerLawSuperExpCutoff
        __init__(Likelihood::PowerLawSuperExpCutoff self, double Prefactor=10., double Index1=-2.1, double Scale=1000., double Cutoff=10000.) -> PowerLawSuperExpCutoff
        __init__(Likelihood::PowerLawSuperExpCutoff self, double Prefactor=10., double Index1=-2.1, double Scale=1000.) -> PowerLawSuperExpCutoff
        __init__(Likelihood::PowerLawSuperExpCutoff self, double Prefactor=10., double Index1=-2.1) -> PowerLawSuperExpCutoff
        __init__(Likelihood::PowerLawSuperExpCutoff self, double Prefactor=10.) -> PowerLawSuperExpCutoff
        __init__(Likelihood::PowerLawSuperExpCutoff self) -> PowerLawSuperExpCutoff
        """
        this = _pyLikelihood.new_PowerLawSuperExpCutoff(Prefactor, Index1, Scale, Cutoff, Index2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(PowerLawSuperExpCutoff self) -> Function"""
        return _pyLikelihood.PowerLawSuperExpCutoff_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_PowerLawSuperExpCutoff
    __del__ = lambda self: None
PowerLawSuperExpCutoff_swigregister = _pyLikelihood.PowerLawSuperExpCutoff_swigregister
PowerLawSuperExpCutoff_swigregister(PowerLawSuperExpCutoff)

class PowerLaw2(Function):
    """Proxy of C++ Likelihood::PowerLaw2 class."""

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

    def __init__(self, Integral=1., Index=-2., LowerLimit=100., UpperLimit=2e5):
        """
        __init__(Likelihood::PowerLaw2 self, double Integral=1., double Index=-2., double LowerLimit=100., double UpperLimit=2e5) -> PowerLaw2
        __init__(Likelihood::PowerLaw2 self, double Integral=1., double Index=-2., double LowerLimit=100.) -> PowerLaw2
        __init__(Likelihood::PowerLaw2 self, double Integral=1., double Index=-2.) -> PowerLaw2
        __init__(Likelihood::PowerLaw2 self, double Integral=1.) -> PowerLaw2
        __init__(Likelihood::PowerLaw2 self) -> PowerLaw2
        """
        this = _pyLikelihood.new_PowerLaw2(Integral, Index, LowerLimit, UpperLimit)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def integral(self, xmin, xmax):
        """integral(PowerLaw2 self, Arg xmin, Arg xmax) -> double"""
        return _pyLikelihood.PowerLaw2_integral(self, xmin, xmax)


    def clone(self):
        """clone(PowerLaw2 self) -> Function *"""
        return _pyLikelihood.PowerLaw2_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_PowerLaw2
    __del__ = lambda self: None
PowerLaw2_swigregister = _pyLikelihood.PowerLaw2_swigregister
PowerLaw2_swigregister(PowerLaw2)

class ResponseFunctions(_object):
    """Proxy of C++ Likelihood::ResponseFunctions class."""

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

    def __init__(self):
        """__init__(Likelihood::ResponseFunctions self) -> ResponseFunctions"""
        this = _pyLikelihood.new_ResponseFunctions()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_ResponseFunctions
    __del__ = lambda self: None

    def totalResponse(self, *args):
        """
        totalResponse(ResponseFunctions self, double energy, double appEnergy, SkyDir zAxis, SkyDir xAxis, SkyDir srcDir, SkyDir appDir, int type, double time) -> double
        totalResponse(ResponseFunctions self, double inclination, double phi, double energy, double appEnergy, double separation, int evtType, double time) -> double
        """
        return _pyLikelihood.ResponseFunctions_totalResponse(self, *args)


    def setRespPtrs(self, respPtrs):
        """setRespPtrs(ResponseFunctions self, std::map< unsigned int,irfInterface::Irfs *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,irfInterface::Irfs * > > > & respPtrs)"""
        return _pyLikelihood.ResponseFunctions_setRespPtrs(self, respPtrs)


    def addRespPtr(self, key, respPtr):
        """addRespPtr(ResponseFunctions self, unsigned int key, irfInterface::Irfs * respPtr)"""
        return _pyLikelihood.ResponseFunctions_addRespPtr(self, key, respPtr)


    def deleteRespPtr(self, key):
        """deleteRespPtr(ResponseFunctions self, unsigned int key)"""
        return _pyLikelihood.ResponseFunctions_deleteRespPtr(self, key)


    def respPtr(self, eventType):
        """respPtr(ResponseFunctions self, unsigned int eventType) -> irfInterface::Irfs *"""
        return _pyLikelihood.ResponseFunctions_respPtr(self, eventType)


    def begin(self):
        """begin(ResponseFunctions self) -> std::map< unsigned int,irfInterface::Irfs *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,irfInterface::Irfs * > > >::const_iterator"""
        return _pyLikelihood.ResponseFunctions_begin(self)


    def end(self):
        """end(ResponseFunctions self) -> std::map< unsigned int,irfInterface::Irfs *,std::less< unsigned int >,std::allocator< std::pair< unsigned int const,irfInterface::Irfs * > > >::const_iterator"""
        return _pyLikelihood.ResponseFunctions_end(self)


    def efficiencyFactor(self):
        """efficiencyFactor(ResponseFunctions self) -> IEfficiencyFactor"""
        return _pyLikelihood.ResponseFunctions_efficiencyFactor(self)


    def useEdisp(self):
        """useEdisp(ResponseFunctions self) -> bool const &"""
        return _pyLikelihood.ResponseFunctions_useEdisp(self)


    def setEdispFlag(self, useEdisp):
        """setEdispFlag(ResponseFunctions self, bool useEdisp)"""
        return _pyLikelihood.ResponseFunctions_setEdispFlag(self, useEdisp)


    def respName(self):
        """respName(ResponseFunctions self) -> std::string const &"""
        return _pyLikelihood.ResponseFunctions_respName(self)


    def setRespName(self, respName):
        """setRespName(ResponseFunctions self, std::string const & respName)"""
        return _pyLikelihood.ResponseFunctions_setRespName(self, respName)


    def load(self, *args):
        """
        load(ResponseFunctions self, std::string const & respFuncs, std::string const & respBase, std::vector< unsigned int,std::allocator< unsigned int > > const & evtTypes)
        load(ResponseFunctions self, std::string const & respFuncs, std::string const & respBase)
        load(ResponseFunctions self, std::string const & respFuncs)
        """
        return _pyLikelihood.ResponseFunctions_load(self, *args)


    def psf(self, type):
        """psf(ResponseFunctions self, int type) -> irfInterface::IPsf &"""
        return _pyLikelihood.ResponseFunctions_psf(self, type)


    def edisp(self, *args):
        """
        edisp(ResponseFunctions self, int type) -> irfInterface::IEdisp
        edisp(ResponseFunctions self, double emeas, double etrue, SkyDir srcDir, SkyDir zAxis, SkyDir xAxis, int type, double time) -> double
        edisp(ResponseFunctions self, double emeas, double etrue, double theta, double phi, int type, double time) -> double
        """
        return _pyLikelihood.ResponseFunctions_edisp(self, *args)


    def aeff(self, *args):
        """
        aeff(ResponseFunctions self, int type) -> irfInterface::IAeff
        aeff(ResponseFunctions self, double etrue, SkyDir srcDir, SkyDir zAxis, SkyDir xAxis, int type, double time) -> double
        aeff(ResponseFunctions self, double etrue, double theta, double phi, int type, double time) -> double
        """
        return _pyLikelihood.ResponseFunctions_aeff(self, *args)


    def load_with_event_types(self, respFuncs, respBase, filename, extname):
        """load_with_event_types(ResponseFunctions self, std::string const & respFuncs, std::string const & respBase, std::string const & filename, std::string const & extname)"""
        return _pyLikelihood.ResponseFunctions_load_with_event_types(self, respFuncs, respBase, filename, extname)

ResponseFunctions_swigregister = _pyLikelihood.ResponseFunctions_swigregister
ResponseFunctions_swigregister(ResponseFunctions)

class RoiCuts(_object):
    """Proxy of C++ Likelihood::RoiCuts class."""

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

    def __init__(self):
        """__init__(Likelihood::RoiCuts self) -> RoiCuts"""
        this = _pyLikelihood.new_RoiCuts()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_RoiCuts
    __del__ = lambda self: None

    def getTimeCuts(self, timeCuts):
        """getTimeCuts(RoiCuts self, DoubleVectorPair timeCuts)"""
        return _pyLikelihood.RoiCuts_getTimeCuts(self, timeCuts)


    def getGtis(self, gtis):
        """getGtis(RoiCuts self, DoubleVectorPair gtis)"""
        return _pyLikelihood.RoiCuts_getGtis(self, gtis)


    def getEnergyCuts(self):
        """getEnergyCuts(RoiCuts self) -> DoublePair"""
        return _pyLikelihood.RoiCuts_getEnergyCuts(self)


    def roiCone(self):
        """roiCone(RoiCuts self) -> DoubleVector"""
        return _pyLikelihood.RoiCuts_roiCone(self)


    def getRaDec(self, ra, dec):
        """getRaDec(RoiCuts self, double & ra, double & dec)"""
        return _pyLikelihood.RoiCuts_getRaDec(self, ra, dec)


    def getMuZenMax(self):
        """getMuZenMax(RoiCuts self) -> double"""
        return _pyLikelihood.RoiCuts_getMuZenMax(self)


    def setCuts(self, ra=193.98, dec=-5.82, roi_radius=20., emin=30., emax=3.1623e5, tmin=0., tmax=1e12, muZenMax=-1., reset_tlims=False):
        """
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82, double roi_radius=20., double emin=30., double emax=3.1623e5, double tmin=0., double tmax=1e12, double muZenMax=-1., bool reset_tlims=False)
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82, double roi_radius=20., double emin=30., double emax=3.1623e5, double tmin=0., double tmax=1e12, double muZenMax=-1.)
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82, double roi_radius=20., double emin=30., double emax=3.1623e5, double tmin=0., double tmax=1e12)
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82, double roi_radius=20., double emin=30., double emax=3.1623e5, double tmin=0.)
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82, double roi_radius=20., double emin=30., double emax=3.1623e5)
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82, double roi_radius=20., double emin=30.)
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82, double roi_radius=20.)
        setCuts(RoiCuts self, double ra=193.98, double dec=-5.82)
        setCuts(RoiCuts self, double ra=193.98)
        setCuts(RoiCuts self)
        """
        return _pyLikelihood.RoiCuts_setCuts(self, ra, dec, roi_radius, emin, emax, tmin, tmax, muZenMax, reset_tlims)


    def readCuts(self, *args):
        """
        readCuts(RoiCuts self, std::string const & eventFile, std::string const & ext, bool strict=True)
        readCuts(RoiCuts self, std::string const & eventFile, std::string const & ext)
        readCuts(RoiCuts self, std::string const & eventFile)
        readCuts(RoiCuts self, StringVector eventFiles, std::string const & ext, bool strict=True)
        readCuts(RoiCuts self, StringVector eventFiles, std::string const & ext)
        readCuts(RoiCuts self, StringVector eventFiles)
        """
        return _pyLikelihood.RoiCuts_readCuts(self, *args)


    def accept(self, arg2):
        """accept(RoiCuts self, Event arg2) -> bool"""
        return _pyLikelihood.RoiCuts_accept(self, arg2)


    def writeDssKeywords(self, header):
        """writeDssKeywords(RoiCuts self, tip::Header & header)"""
        return _pyLikelihood.RoiCuts_writeDssKeywords(self, header)


    def writeDssTimeKeywords(self, header):
        """writeDssTimeKeywords(RoiCuts self, tip::Header & header)"""
        return _pyLikelihood.RoiCuts_writeDssTimeKeywords(self, header)


    def writeGtiExtension(self, filename):
        """writeGtiExtension(RoiCuts self, std::string const & filename)"""
        return _pyLikelihood.RoiCuts_writeGtiExtension(self, filename)


    def energies(self):
        """energies(RoiCuts self) -> DoubleVector"""
        return _pyLikelihood.RoiCuts_energies(self)


    def minTime(self):
        """minTime(RoiCuts self) -> double"""
        return _pyLikelihood.RoiCuts_minTime(self)


    def maxTime(self):
        """maxTime(RoiCuts self) -> double"""
        return _pyLikelihood.RoiCuts_maxTime(self)


    def setIrfsVersion(self, irfsName):
        """setIrfsVersion(RoiCuts self, std::string const & irfsName)"""
        return _pyLikelihood.RoiCuts_setIrfsVersion(self, irfsName)


    def setBitMaskCut(self, candidateCut):
        """setBitMaskCut(RoiCuts self, BitMaskCut candidateCut)"""
        return _pyLikelihood.RoiCuts_setBitMaskCut(self, candidateCut)

RoiCuts_swigregister = _pyLikelihood.RoiCuts_swigregister
RoiCuts_swigregister(RoiCuts)

class ScaleFactor(Function):
    """Proxy of C++ Likelihood::ScaleFactor class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::ScaleFactor self) -> ScaleFactor
        __init__(Likelihood::ScaleFactor self, Function spectrum, double scale_factor=1, bool use_complement=False) -> ScaleFactor
        __init__(Likelihood::ScaleFactor self, Function spectrum, double scale_factor=1) -> ScaleFactor
        __init__(Likelihood::ScaleFactor self, Function spectrum) -> ScaleFactor
        __init__(Likelihood::ScaleFactor self, ScaleFactor other) -> ScaleFactor
        """
        this = _pyLikelihood.new_ScaleFactor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_ScaleFactor
    __del__ = lambda self: None

    def clone(self):
        """clone(ScaleFactor self) -> Function *"""
        return _pyLikelihood.ScaleFactor_clone(self)


    def setParam(self, param):
        """setParam(ScaleFactor self, Parameter param)"""
        return _pyLikelihood.ScaleFactor_setParam(self, param)


    def set_complement_flag(self, use_complement):
        """set_complement_flag(ScaleFactor self, bool use_complement)"""
        return _pyLikelihood.ScaleFactor_set_complement_flag(self, use_complement)


    def use_complement(self):
        """use_complement(ScaleFactor self) -> bool"""
        return _pyLikelihood.ScaleFactor_use_complement(self)


    def spectrum(self, *args):
        """
        spectrum(ScaleFactor self) -> Function
        spectrum(ScaleFactor self) -> Function
        """
        return _pyLikelihood.ScaleFactor_spectrum(self, *args)

ScaleFactor_swigregister = _pyLikelihood.ScaleFactor_swigregister
ScaleFactor_swigregister(ScaleFactor)


def freezeSourceParams(source):
    """freezeSourceParams(Source source)"""
    return _pyLikelihood.freezeSourceParams(source)

def freezeAllParams(srcModel):
    """freezeAllParams(SourceModel srcModel)"""
    return _pyLikelihood.freezeAllParams(srcModel)

def freeNormalizations(srcModel, freeSources, free=True):
    """
    freeNormalizations(SourceModel srcModel, std::list< std::string > const & freeSources, bool free=True)
    freeNormalizations(SourceModel srcModel, std::list< std::string > const & freeSources)
    """
    return _pyLikelihood.freeNormalizations(srcModel, freeSources, free)

def constrainSourceNorms_valuesAndCovs(srcModel, srcNameList, vals, covs):
    """constrainSourceNorms_valuesAndCovs(SourceModel srcModel, std::list< std::string > const & srcNameList, DoubleVector vals, DoubleVectorVector covs)"""
    return _pyLikelihood.constrainSourceNorms_valuesAndCovs(srcModel, srcNameList, vals, covs)

def constrainSourceNorms_current(srcModel, srcNameList, covScale):
    """constrainSourceNorms_current(SourceModel srcModel, std::list< std::string > const & srcNameList, double const & covScale)"""
    return _pyLikelihood.constrainSourceNorms_current(srcModel, srcNameList, covScale)

def scan_norm_binned(modelWrapper, signal_name, optimizer, tol, tolType, kmin, kmax, nnorms, norms, norm_mle, logLike_mle, logLikes):
    """scan_norm_binned(FitScanModelWrapper modelWrapper, std::string const & signal_name, Optimizer optimizer, double tol, int tolType, size_t kmin, size_t kmax, size_t nnorms, DoubleVector norms, double & norm_mle, double & logLike_mle, DoubleVector logLikes)"""
    return _pyLikelihood.scan_norm_binned(modelWrapper, signal_name, optimizer, tol, tolType, kmin, kmax, nnorms, norms, norm_mle, logLike_mle, logLikes)

def sed_binned(modelWrapper, signal_name, optimizer, tol, tolType, nnorms, norms, norm_mles, logLike_mles, logLikes):
    """sed_binned(FitScanModelWrapper modelWrapper, std::string const & signal_name, Optimizer optimizer, double tol, int tolType, size_t nnorms, DoubleVectorVector norms, DoubleVector norm_mles, DoubleVector logLike_mles, DoubleVectorVector logLikes)"""
    return _pyLikelihood.sed_binned(modelWrapper, signal_name, optimizer, tol, tolType, nnorms, norms, norm_mles, logLike_mles, logLikes)
class ScData(_object):
    """Proxy of C++ Likelihood::ScData class."""

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

    def __init__(self):
        """__init__(Likelihood::ScData self) -> ScData"""
        this = _pyLikelihood.new_ScData()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_ScData
    __del__ = lambda self: None

    def readData(self, *args):
        """
        readData(ScData self, std::string file, double tstart, double tstop, bool clear=False, std::string const & sctable)
        readData(ScData self, std::string file, double tstart, double tstop, bool clear=False)
        readData(ScData self, std::string file, double tstart, double tstop)
        readData(ScData self, StringVector scFiles, double tstart, double tstop, std::string const & sctable)
        readData(ScData self, StringVector scFiles, double tstart, double tstop)
        """
        return _pyLikelihood.ScData_readData(self, *args)


    def livetimefrac(self, time):
        """livetimefrac(ScData self, double time) -> double"""
        return _pyLikelihood.ScData_livetimefrac(self, time)


    def numIntervals(self):
        """numIntervals(ScData self) -> size_t"""
        return _pyLikelihood.ScData_numIntervals(self)


    def start(self, i):
        """start(ScData self, size_t i) -> double"""
        return _pyLikelihood.ScData_start(self, i)


    def stop(self, i):
        """stop(ScData self, size_t i) -> double"""
        return _pyLikelihood.ScData_stop(self, i)


    def livetime(self, i):
        """livetime(ScData self, size_t i) -> double"""
        return _pyLikelihood.ScData_livetime(self, i)


    def xAxis(self, *args):
        """
        xAxis(ScData self, double time) -> SkyDir
        xAxis(ScData self, size_t i) -> SkyDir
        """
        return _pyLikelihood.ScData_xAxis(self, *args)


    def zAxis(self, *args):
        """
        zAxis(ScData self, double time) -> SkyDir
        zAxis(ScData self, size_t i) -> SkyDir
        """
        return _pyLikelihood.ScData_zAxis(self, *args)


    def time_index(self, time):
        """time_index(ScData self, double time) -> size_t"""
        return _pyLikelihood.ScData_time_index(self, time)


    def clear_arrays(self, realloc=True):
        """
        clear_arrays(ScData self, bool realloc=True)
        clear_arrays(ScData self)
        """
        return _pyLikelihood.ScData_clear_arrays(self, realloc)

ScData_swigregister = _pyLikelihood.ScData_swigregister
ScData_swigregister(ScData)

class SkyDirArg(Arg):
    """Proxy of C++ Likelihood::SkyDirArg class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::SkyDirArg self, SkyDir dir, double energy=100.) -> SkyDirArg
        __init__(Likelihood::SkyDirArg self, SkyDir dir) -> SkyDirArg
        __init__(Likelihood::SkyDirArg self, double ra, double dec, double energy=100.) -> SkyDirArg
        __init__(Likelihood::SkyDirArg self, double ra, double dec) -> SkyDirArg
        """
        this = _pyLikelihood.new_SkyDirArg(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_SkyDirArg
    __del__ = lambda self: None

    def fetchValue(self, dir):
        """fetchValue(SkyDirArg self, SkyDir dir)"""
        return _pyLikelihood.SkyDirArg_fetchValue(self, dir)


    def __call__(self):
        """__call__(SkyDirArg self) -> SkyDir"""
        return _pyLikelihood.SkyDirArg___call__(self)


    def energy(self):
        """energy(SkyDirArg self) -> double"""
        return _pyLikelihood.SkyDirArg_energy(self)

SkyDirArg_swigregister = _pyLikelihood.SkyDirArg_swigregister
SkyDirArg_swigregister(SkyDirArg)

class SkyDirFunction(Function):
    """Proxy of C++ Likelihood::SkyDirFunction class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::SkyDirFunction self, double ra=0, double dec=0) -> SkyDirFunction
        __init__(Likelihood::SkyDirFunction self, double ra=0) -> SkyDirFunction
        __init__(Likelihood::SkyDirFunction self) -> SkyDirFunction
        __init__(Likelihood::SkyDirFunction self, SkyDir dir) -> SkyDirFunction
        """
        this = _pyLikelihood.new_SkyDirFunction(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getDir(self):
        """getDir(SkyDirFunction self) -> SkyDir"""
        return _pyLikelihood.SkyDirFunction_getDir(self)


    def setParam(self, paramName, paramValue):
        """setParam(SkyDirFunction self, std::string const & paramName, double paramValue)"""
        return _pyLikelihood.SkyDirFunction_setParam(self, paramName, paramValue)


    def clone(self):
        """clone(SkyDirFunction self) -> Function *"""
        return _pyLikelihood.SkyDirFunction_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_SkyDirFunction
    __del__ = lambda self: None
SkyDirFunction_swigregister = _pyLikelihood.SkyDirFunction_swigregister
SkyDirFunction_swigregister(SkyDirFunction)

class Snapshot_Status(_object):
    """Proxy of C++ Likelihood::Snapshot_Status class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Snapshot_Status, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Snapshot_Status, name)
    __repr__ = _swig_repr
    Unchanged = _pyLikelihood.Snapshot_Status_Unchanged
    Norm_Offset = _pyLikelihood.Snapshot_Status_Norm_Offset
    Spec_Offset = _pyLikelihood.Snapshot_Status_Spec_Offset
    Spatial_Offset = _pyLikelihood.Snapshot_Status_Spatial_Offset
    Spec_Model_Offset = _pyLikelihood.Snapshot_Status_Spec_Model_Offset
    Spatial_Model_Offset = _pyLikelihood.Snapshot_Status_Spatial_Model_Offset
    Ancillary_Offset = _pyLikelihood.Snapshot_Status_Ancillary_Offset
    Fixed_Source_Added_Offset = _pyLikelihood.Snapshot_Status_Fixed_Source_Added_Offset
    Free_Source_Added_Offset = _pyLikelihood.Snapshot_Status_Free_Source_Added_Offset
    Fixed_Source_Removed_Offset = _pyLikelihood.Snapshot_Status_Fixed_Source_Removed_Offset
    Free_Source_Removed_Offset = _pyLikelihood.Snapshot_Status_Free_Source_Removed_Offset
    Source_Freed_Offset = _pyLikelihood.Snapshot_Status_Source_Freed_Offset
    Source_Fixed_Offset = _pyLikelihood.Snapshot_Status_Source_Fixed_Offset
    Value_Changed = _pyLikelihood.Snapshot_Status_Value_Changed
    Status_Changed = _pyLikelihood.Snapshot_Status_Status_Changed
    Prior_Changed = _pyLikelihood.Snapshot_Status_Prior_Changed
    Fixed_Changed = _pyLikelihood.Snapshot_Status_Fixed_Changed
    Free_Changed = _pyLikelihood.Snapshot_Status_Free_Changed
    Par_Changed_Mask = _pyLikelihood.Snapshot_Status_Par_Changed_Mask
    Model_Type_Changed = _pyLikelihood.Snapshot_Status_Model_Type_Changed
    Free_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Free_Model_Type_Changed
    Fixed_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Fixed_Model_Type_Changed
    Norm_Value_Changed = _pyLikelihood.Snapshot_Status_Norm_Value_Changed
    Norm_Status_Changed = _pyLikelihood.Snapshot_Status_Norm_Status_Changed
    Norm_Prior_Changed = _pyLikelihood.Snapshot_Status_Norm_Prior_Changed
    Norm_Fixed_Changed = _pyLikelihood.Snapshot_Status_Norm_Fixed_Changed
    Norm_Free_Changed = _pyLikelihood.Snapshot_Status_Norm_Free_Changed
    Spec_Value_Changed = _pyLikelihood.Snapshot_Status_Spec_Value_Changed
    Spec_Status_Changed = _pyLikelihood.Snapshot_Status_Spec_Status_Changed
    Spec_Prior_Changed = _pyLikelihood.Snapshot_Status_Spec_Prior_Changed
    Spec_Fixed_Changed = _pyLikelihood.Snapshot_Status_Spec_Fixed_Changed
    Spec_Free_Changed = _pyLikelihood.Snapshot_Status_Spec_Free_Changed
    Spatial_Value_Changed = _pyLikelihood.Snapshot_Status_Spatial_Value_Changed
    Spatial_Status_Changed = _pyLikelihood.Snapshot_Status_Spatial_Status_Changed
    Spatial_Prior_Changed = _pyLikelihood.Snapshot_Status_Spatial_Prior_Changed
    Spatial_Fixed_Changed = _pyLikelihood.Snapshot_Status_Spatial_Fixed_Changed
    Spatial_Free_Changed = _pyLikelihood.Snapshot_Status_Spatial_Free_Changed
    Spec_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Spec_Model_Type_Changed
    Free_Spec_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Free_Spec_Model_Type_Changed
    Fixed_Spec_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Fixed_Spec_Model_Type_Changed
    Spatial_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Spatial_Model_Type_Changed
    Free_Spatial_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Free_Spatial_Model_Type_Changed
    Fixed_Spatial_Model_Type_Changed = _pyLikelihood.Snapshot_Status_Fixed_Spatial_Model_Type_Changed
    Ancillary_Changed = _pyLikelihood.Snapshot_Status_Ancillary_Changed
    Free_Ancillary_Changed = _pyLikelihood.Snapshot_Status_Free_Ancillary_Changed
    Fixed_Ancillary_Changed = _pyLikelihood.Snapshot_Status_Fixed_Ancillary_Changed
    Fixed_Source_Added = _pyLikelihood.Snapshot_Status_Fixed_Source_Added
    Free_Source_Added = _pyLikelihood.Snapshot_Status_Free_Source_Added
    Fixed_Source_Removed = _pyLikelihood.Snapshot_Status_Fixed_Source_Removed
    Free_Source_Removed = _pyLikelihood.Snapshot_Status_Free_Source_Removed
    Source_Freed = _pyLikelihood.Snapshot_Status_Source_Freed
    Source_Fixed = _pyLikelihood.Snapshot_Status_Source_Fixed
    Fixed_Source_Changed = _pyLikelihood.Snapshot_Status_Fixed_Source_Changed
    Free_Source_Changed = _pyLikelihood.Snapshot_Status_Free_Source_Changed
    Souce_Added_Mask = _pyLikelihood.Snapshot_Status_Souce_Added_Mask
    Souce_Removed_Mask = _pyLikelihood.Snapshot_Status_Souce_Removed_Mask
    Model_Free_Mask = _pyLikelihood.Snapshot_Status_Model_Free_Mask
    Model_Fixed_Mask = _pyLikelihood.Snapshot_Status_Model_Fixed_Mask
    Norm_Mask = _pyLikelihood.Snapshot_Status_Norm_Mask
    Spec_Mask = _pyLikelihood.Snapshot_Status_Spec_Mask
    Spatial_Mask = _pyLikelihood.Snapshot_Status_Spatial_Mask
    Par_Changed = _pyLikelihood.Snapshot_Status_Par_Changed
    Free_Par_Changed = _pyLikelihood.Snapshot_Status_Free_Par_Changed
    Fixed_Par_Changed = _pyLikelihood.Snapshot_Status_Fixed_Par_Changed
    Model_Type_Mask = _pyLikelihood.Snapshot_Status_Model_Type_Mask
    Free_Model_Type_Mask = _pyLikelihood.Snapshot_Status_Free_Model_Type_Mask
    Fixed_Model_Type_Mask = _pyLikelihood.Snapshot_Status_Fixed_Model_Type_Mask
    Model_Changed_Mask = _pyLikelihood.Snapshot_Status_Model_Changed_Mask
    Free_Changed_Mask = _pyLikelihood.Snapshot_Status_Free_Changed_Mask
    Fixed_Changed_Mask = _pyLikelihood.Snapshot_Status_Fixed_Changed_Mask
    __swig_setmethods__["Flags"] = _pyLikelihood.Snapshot_Status_Flags_set
    __swig_getmethods__["Flags"] = _pyLikelihood.Snapshot_Status_Flags_get
    if _newclass:
        Flags = _swig_property(_pyLikelihood.Snapshot_Status_Flags_get, _pyLikelihood.Snapshot_Status_Flags_set)

    def __init__(self, *args):
        """
        __init__(Likelihood::Snapshot_Status self, unsigned int val) -> Snapshot_Status
        __init__(Likelihood::Snapshot_Status self) -> Snapshot_Status
        """
        this = _pyLikelihood.new_Snapshot_Status(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Snapshot_Status
    __del__ = lambda self: None

    def unchanged(self):
        """unchanged(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_unchanged(self)


    def changed(self):
        """changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_changed(self)


    def norm_changed(self):
        """norm_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_norm_changed(self)


    def norm_value_changed(self):
        """norm_value_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_norm_value_changed(self)


    def norm_status_changed(self):
        """norm_status_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_norm_status_changed(self)


    def norm_prior_changed(self):
        """norm_prior_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_norm_prior_changed(self)


    def norm_fixed_changed(self):
        """norm_fixed_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_norm_fixed_changed(self)


    def norm_free_changed(self):
        """norm_free_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_norm_free_changed(self)


    def spec_changed(self):
        """spec_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spec_changed(self)


    def spec_free_changed(self):
        """spec_free_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spec_free_changed(self)


    def spec_fixed_changed(self):
        """spec_fixed_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spec_fixed_changed(self)


    def spatial_changed(self):
        """spatial_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spatial_changed(self)


    def spatial_free_changed(self):
        """spatial_free_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spatial_free_changed(self)


    def spatial_fixed_changed(self):
        """spatial_fixed_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spatial_fixed_changed(self)


    def spec_model_type_changed(self):
        """spec_model_type_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spec_model_type_changed(self)


    def spatial_model_type_changed(self):
        """spatial_model_type_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_spatial_model_type_changed(self)


    def model_type_changed(self):
        """model_type_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_model_type_changed(self)


    def ancillary_changed(self):
        """ancillary_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_ancillary_changed(self)


    def model_free_changed(self):
        """model_free_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_model_free_changed(self)


    def model_fixed_changed(self):
        """model_fixed_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_model_fixed_changed(self)


    def model_changed(self):
        """model_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_model_changed(self)


    def free_source_changed(self):
        """free_source_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_free_source_changed(self)


    def free_source_added(self):
        """free_source_added(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_free_source_added(self)


    def free_source_removed(self):
        """free_source_removed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_free_source_removed(self)


    def fixed_source_changed(self):
        """fixed_source_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_fixed_source_changed(self)


    def fixed_source_added(self):
        """fixed_source_added(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_fixed_source_added(self)


    def fixed_source_removed(self):
        """fixed_source_removed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_fixed_source_removed(self)


    def fixed_changed(self):
        """fixed_changed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_fixed_changed(self)


    def source_freed(self):
        """source_freed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_source_freed(self)


    def source_fixed(self):
        """source_fixed(Snapshot_Status self) -> bool"""
        return _pyLikelihood.Snapshot_Status_source_fixed(self)


    def __call__(self):
        """__call__(Snapshot_Status self) -> unsigned int"""
        return _pyLikelihood.Snapshot_Status___call__(self)


    def __or__(self, *args):
        """
        __or__(Snapshot_Status self, Snapshot_Status other) -> Snapshot_Status
        __or__(Snapshot_Status self, unsigned int val) -> Snapshot_Status
        """
        return _pyLikelihood.Snapshot_Status___or__(self, *args)


    def __and__(self, *args):
        """
        __and__(Snapshot_Status self, Snapshot_Status other) -> Snapshot_Status
        __and__(Snapshot_Status self, unsigned int val) -> Snapshot_Status
        """
        return _pyLikelihood.Snapshot_Status___and__(self, *args)


    def __ior__(self, *args):
        """
        __ior__(Snapshot_Status self, Snapshot_Status other) -> Snapshot_Status
        __ior__(Snapshot_Status self, unsigned int val) -> Snapshot_Status
        """
        return _pyLikelihood.Snapshot_Status___ior__(self, *args)


    def __iand__(self, *args):
        """
        __iand__(Snapshot_Status self, Snapshot_Status other) -> Snapshot_Status
        __iand__(Snapshot_Status self, unsigned int val) -> Snapshot_Status
        """
        return _pyLikelihood.Snapshot_Status___iand__(self, *args)

Snapshot_Status_swigregister = _pyLikelihood.Snapshot_Status_swigregister
Snapshot_Status_swigregister(Snapshot_Status)

class Snapshot_Source(_object):
    """Proxy of C++ Likelihood::Snapshot_Source class."""

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

    def delete_map(theMap):
        """delete_map(Likelihood::ParameterMap & theMap)"""
        return _pyLikelihood.Snapshot_Source_delete_map(theMap)

    delete_map = staticmethod(delete_map)

    def deep_copy_param_map(theMap, delete_old=False):
        """
        deep_copy_param_map(Likelihood::ParameterMap & theMap, bool delete_old=False)
        deep_copy_param_map(Likelihood::ParameterMap & theMap)
        """
        return _pyLikelihood.Snapshot_Source_deep_copy_param_map(theMap, delete_old)

    deep_copy_param_map = staticmethod(deep_copy_param_map)

    def compare_priors(p1, p2):
        """compare_priors(Parameter p1, Parameter p2) -> bool"""
        return _pyLikelihood.Snapshot_Source_compare_priors(p1, p2)

    compare_priors = staticmethod(compare_priors)

    def parameter_status(p1, p2):
        """parameter_status(Parameter p1, Parameter p2) -> unsigned int"""
        return _pyLikelihood.Snapshot_Source_parameter_status(p1, p2)

    parameter_status = staticmethod(parameter_status)

    def extract_norm(src, theParam, clone=False):
        """
        extract_norm(Source src, optimizers::Parameter *& theParam, bool clone=False)
        extract_norm(Source src, optimizers::Parameter *& theParam)
        """
        return _pyLikelihood.Snapshot_Source_extract_norm(src, theParam, clone)

    extract_norm = staticmethod(extract_norm)

    def extract_spectral(src, model_name, theMap, clone=False):
        """
        extract_spectral(Source src, std::string & model_name, Likelihood::ParameterMap & theMap, bool clone=False)
        extract_spectral(Source src, std::string & model_name, Likelihood::ParameterMap & theMap)
        """
        return _pyLikelihood.Snapshot_Source_extract_spectral(src, model_name, theMap, clone)

    extract_spectral = staticmethod(extract_spectral)

    def extract_spatial(src, model_name, theMap, clone=False):
        """
        extract_spatial(Source src, std::string & model_name, Likelihood::ParameterMap & theMap, bool clone=False)
        extract_spatial(Source src, std::string & model_name, Likelihood::ParameterMap & theMap)
        """
        return _pyLikelihood.Snapshot_Source_extract_spatial(src, model_name, theMap, clone)

    extract_spatial = staticmethod(extract_spatial)

    def extract_ancillary(src, theMap):
        """extract_ancillary(Source src, Likelihood::StringMap & theMap)"""
        return _pyLikelihood.Snapshot_Source_extract_ancillary(src, theMap)

    extract_ancillary = staticmethod(extract_ancillary)

    def compare_norm(par1, par2, fixed):
        """compare_norm(Parameter par1, Parameter par2, bool fixed) -> Snapshot_Status"""
        return _pyLikelihood.Snapshot_Source_compare_norm(par1, par2, fixed)

    compare_norm = staticmethod(compare_norm)

    def compare_spectral(name1, name2, map1, map2, fixed):
        """compare_spectral(std::string const & name1, std::string const & name2, Likelihood::ParameterMap const & map1, Likelihood::ParameterMap const & map2, bool fixed) -> Snapshot_Status"""
        return _pyLikelihood.Snapshot_Source_compare_spectral(name1, name2, map1, map2, fixed)

    compare_spectral = staticmethod(compare_spectral)

    def compare_spatial(name1, name2, map1, map2, fixed):
        """compare_spatial(std::string const & name1, std::string const & name2, Likelihood::ParameterMap const & map1, Likelihood::ParameterMap const & map2, bool fixed) -> Snapshot_Status"""
        return _pyLikelihood.Snapshot_Source_compare_spatial(name1, name2, map1, map2, fixed)

    compare_spatial = staticmethod(compare_spatial)

    def compare_ancillary(map1, map2, fixed):
        """compare_ancillary(Likelihood::StringMap const & map1, Likelihood::StringMap const & map2, bool fixed) -> Snapshot_Status"""
        return _pyLikelihood.Snapshot_Source_compare_ancillary(map1, map2, fixed)

    compare_ancillary = staticmethod(compare_ancillary)

    def print_param(par, indent):
        """print_param(Parameter par, std::string const & indent)"""
        return _pyLikelihood.Snapshot_Source_print_param(par, indent)

    print_param = staticmethod(print_param)

    def print_param_map(parMap, indent):
        """print_param_map(Likelihood::ParameterMap const & parMap, std::string const & indent)"""
        return _pyLikelihood.Snapshot_Source_print_param_map(parMap, indent)

    print_param_map = staticmethod(print_param_map)

    def print_string_map(strMap, indent):
        """print_string_map(Likelihood::StringMap const & strMap, std::string const & indent)"""
        return _pyLikelihood.Snapshot_Source_print_string_map(strMap, indent)

    print_string_map = staticmethod(print_string_map)

    def __init__(self, *args):
        """
        __init__(Likelihood::Snapshot_Source self) -> Snapshot_Source
        __init__(Likelihood::Snapshot_Source self, Source src, bool owned=False) -> Snapshot_Source
        __init__(Likelihood::Snapshot_Source self, Source src) -> Snapshot_Source
        """
        this = _pyLikelihood.new_Snapshot_Source(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Snapshot_Source
    __del__ = lambda self: None

    def latch_source(self, src, owned=False):
        """
        latch_source(Snapshot_Source self, Source src, bool owned=False)
        latch_source(Snapshot_Source self, Source src)
        """
        return _pyLikelihood.Snapshot_Source_latch_source(self, src, owned)


    def deep_copy(self):
        """deep_copy(Snapshot_Source self)"""
        return _pyLikelihood.Snapshot_Source_deep_copy(self)


    def compare(self, other):
        """compare(Snapshot_Source self, Source other) -> Snapshot_Status"""
        return _pyLikelihood.Snapshot_Source_compare(self, other)


    def _print(self):
        """_print(Snapshot_Source self)"""
        return _pyLikelihood.Snapshot_Source__print(self)


    def fixed(self):
        """fixed(Snapshot_Source self) -> bool"""
        return _pyLikelihood.Snapshot_Source_fixed(self)

Snapshot_Source_swigregister = _pyLikelihood.Snapshot_Source_swigregister
Snapshot_Source_swigregister(Snapshot_Source)

def Snapshot_Source_delete_map(theMap):
    """Snapshot_Source_delete_map(Likelihood::ParameterMap & theMap)"""
    return _pyLikelihood.Snapshot_Source_delete_map(theMap)

def Snapshot_Source_deep_copy_param_map(theMap, delete_old=False):
    """
    deep_copy_param_map(Likelihood::ParameterMap & theMap, bool delete_old=False)
    Snapshot_Source_deep_copy_param_map(Likelihood::ParameterMap & theMap)
    """
    return _pyLikelihood.Snapshot_Source_deep_copy_param_map(theMap, delete_old)

def Snapshot_Source_compare_priors(p1, p2):
    """Snapshot_Source_compare_priors(Parameter p1, Parameter p2) -> bool"""
    return _pyLikelihood.Snapshot_Source_compare_priors(p1, p2)

def Snapshot_Source_parameter_status(p1, p2):
    """Snapshot_Source_parameter_status(Parameter p1, Parameter p2) -> unsigned int"""
    return _pyLikelihood.Snapshot_Source_parameter_status(p1, p2)

def Snapshot_Source_extract_norm(src, theParam, clone=False):
    """
    extract_norm(Source src, optimizers::Parameter *& theParam, bool clone=False)
    Snapshot_Source_extract_norm(Source src, optimizers::Parameter *& theParam)
    """
    return _pyLikelihood.Snapshot_Source_extract_norm(src, theParam, clone)

def Snapshot_Source_extract_spectral(src, model_name, theMap, clone=False):
    """
    extract_spectral(Source src, std::string & model_name, Likelihood::ParameterMap & theMap, bool clone=False)
    Snapshot_Source_extract_spectral(Source src, std::string & model_name, Likelihood::ParameterMap & theMap)
    """
    return _pyLikelihood.Snapshot_Source_extract_spectral(src, model_name, theMap, clone)

def Snapshot_Source_extract_spatial(src, model_name, theMap, clone=False):
    """
    extract_spatial(Source src, std::string & model_name, Likelihood::ParameterMap & theMap, bool clone=False)
    Snapshot_Source_extract_spatial(Source src, std::string & model_name, Likelihood::ParameterMap & theMap)
    """
    return _pyLikelihood.Snapshot_Source_extract_spatial(src, model_name, theMap, clone)

def Snapshot_Source_extract_ancillary(src, theMap):
    """Snapshot_Source_extract_ancillary(Source src, Likelihood::StringMap & theMap)"""
    return _pyLikelihood.Snapshot_Source_extract_ancillary(src, theMap)

def Snapshot_Source_compare_norm(par1, par2, fixed):
    """Snapshot_Source_compare_norm(Parameter par1, Parameter par2, bool fixed) -> Snapshot_Status"""
    return _pyLikelihood.Snapshot_Source_compare_norm(par1, par2, fixed)

def Snapshot_Source_compare_spectral(name1, name2, map1, map2, fixed):
    """Snapshot_Source_compare_spectral(std::string const & name1, std::string const & name2, Likelihood::ParameterMap const & map1, Likelihood::ParameterMap const & map2, bool fixed) -> Snapshot_Status"""
    return _pyLikelihood.Snapshot_Source_compare_spectral(name1, name2, map1, map2, fixed)

def Snapshot_Source_compare_spatial(name1, name2, map1, map2, fixed):
    """Snapshot_Source_compare_spatial(std::string const & name1, std::string const & name2, Likelihood::ParameterMap const & map1, Likelihood::ParameterMap const & map2, bool fixed) -> Snapshot_Status"""
    return _pyLikelihood.Snapshot_Source_compare_spatial(name1, name2, map1, map2, fixed)

def Snapshot_Source_compare_ancillary(map1, map2, fixed):
    """Snapshot_Source_compare_ancillary(Likelihood::StringMap const & map1, Likelihood::StringMap const & map2, bool fixed) -> Snapshot_Status"""
    return _pyLikelihood.Snapshot_Source_compare_ancillary(map1, map2, fixed)

def Snapshot_Source_print_param(par, indent):
    """Snapshot_Source_print_param(Parameter par, std::string const & indent)"""
    return _pyLikelihood.Snapshot_Source_print_param(par, indent)

def Snapshot_Source_print_param_map(parMap, indent):
    """Snapshot_Source_print_param_map(Likelihood::ParameterMap const & parMap, std::string const & indent)"""
    return _pyLikelihood.Snapshot_Source_print_param_map(parMap, indent)

def Snapshot_Source_print_string_map(strMap, indent):
    """Snapshot_Source_print_string_map(Likelihood::StringMap const & strMap, std::string const & indent)"""
    return _pyLikelihood.Snapshot_Source_print_string_map(strMap, indent)

class Snapshot(_object):
    """Proxy of C++ Likelihood::Snapshot class."""

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

    def source_free(src):
        """source_free(Source src) -> bool"""
        return _pyLikelihood.Snapshot_source_free(src)

    source_free = staticmethod(source_free)

    def __init__(self, model, owned=False):
        """
        __init__(Likelihood::Snapshot self, SourceModel model, bool owned=False) -> Snapshot
        __init__(Likelihood::Snapshot self, SourceModel model) -> Snapshot
        """
        this = _pyLikelihood.new_Snapshot(model, owned)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Snapshot
    __del__ = lambda self: None

    def latch_model(self, model, owned=False):
        """
        latch_model(Snapshot self, SourceModel model, bool owned=False)
        latch_model(Snapshot self, SourceModel model)
        """
        return _pyLikelihood.Snapshot_latch_model(self, model, owned)


    def _print(self):
        """_print(Snapshot self)"""
        return _pyLikelihood.Snapshot__print(self)


    def print_source(self, srcName):
        """print_source(Snapshot self, std::string const & srcName)"""
        return _pyLikelihood.Snapshot_print_source(self, srcName)


    def compare_source(self, srcName, src):
        """compare_source(Snapshot self, std::string const & srcName, Source src) -> Snapshot_Status"""
        return _pyLikelihood.Snapshot_compare_source(self, srcName, src)


    def compare_model(self, model, changed_sources):
        """compare_model(Snapshot self, SourceModel model, StringVector changed_sources) -> Snapshot_Status"""
        return _pyLikelihood.Snapshot_compare_model(self, model, changed_sources)


    def compare_latched(self, model, latched_sources, latched_status, changed_latched, unlatched_status, changed_unlatched, new_free, new_fixed):
        """compare_latched(Snapshot self, SourceModel model, StringVector latched_sources, Snapshot_Status latched_status, StringVector changed_latched, Snapshot_Status unlatched_status, StringVector changed_unlatched, StringVector new_free, StringVector new_fixed)"""
        return _pyLikelihood.Snapshot_compare_latched(self, model, latched_sources, latched_status, changed_latched, unlatched_status, changed_unlatched, new_free, new_fixed)

Snapshot_swigregister = _pyLikelihood.Snapshot_swigregister
Snapshot_swigregister(Snapshot)

def Snapshot_source_free(src):
    """Snapshot_source_free(Source src) -> bool"""
    return _pyLikelihood.Snapshot_source_free(src)

class SparseIntVector(_object):
    """Proxy of C++ Likelihood::SparseVector<(int)> class."""

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

    def key_compare_lower(a, b):
        """key_compare_lower(std::pair< size_t,int > const & a, size_t b) -> bool"""
        return _pyLikelihood.SparseIntVector_key_compare_lower(a, b)

    key_compare_lower = staticmethod(key_compare_lower)

    def key_compare_upper(a, b):
        """key_compare_upper(size_t a, std::pair< size_t,int > const & b) -> bool"""
        return _pyLikelihood.SparseIntVector_key_compare_upper(a, b)

    key_compare_upper = staticmethod(key_compare_upper)

    def __init__(self, *args):
        """
        __init__(Likelihood::SparseVector<(int)> self, int null=0) -> SparseIntVector
        __init__(Likelihood::SparseVector<(int)> self) -> SparseIntVector
        __init__(Likelihood::SparseVector<(int)> self, Likelihood::SparseVector< int >::size_type n, int null=0) -> SparseIntVector
        __init__(Likelihood::SparseVector<(int)> self, Likelihood::SparseVector< int >::size_type n) -> SparseIntVector
        __init__(Likelihood::SparseVector<(int)> self, std::vector< int,std::allocator< int > > const & vect, int null=0) -> SparseIntVector
        __init__(Likelihood::SparseVector<(int)> self, std::vector< int,std::allocator< int > > const & vect) -> SparseIntVector
        __init__(Likelihood::SparseVector<(int)> self, SparseIntVector other) -> SparseIntVector
        """
        this = _pyLikelihood.new_SparseIntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def begin(self, *args):
        """
        begin(SparseIntVector self) -> Likelihood::SparseVector< int >::iterator
        begin(SparseIntVector self) -> Likelihood::SparseVector< int >::const_iterator
        """
        return _pyLikelihood.SparseIntVector_begin(self, *args)


    def end(self, *args):
        """
        end(SparseIntVector self) -> Likelihood::SparseVector< int >::iterator
        end(SparseIntVector self) -> Likelihood::SparseVector< int >::const_iterator
        """
        return _pyLikelihood.SparseIntVector_end(self, *args)


    def rbegin(self, *args):
        """
        rbegin(SparseIntVector self) -> Likelihood::SparseVector< int >::reverse_iterator
        rbegin(SparseIntVector self) -> Likelihood::SparseVector< int >::const_reverse_iterator
        """
        return _pyLikelihood.SparseIntVector_rbegin(self, *args)


    def rend(self, *args):
        """
        rend(SparseIntVector self) -> Likelihood::SparseVector< int >::reverse_iterator
        rend(SparseIntVector self) -> Likelihood::SparseVector< int >::const_reverse_iterator
        """
        return _pyLikelihood.SparseIntVector_rend(self, *args)


    def size(self):
        """size(SparseIntVector self) -> Likelihood::SparseVector< int >::size_type"""
        return _pyLikelihood.SparseIntVector_size(self)


    def max_size(self):
        """max_size(SparseIntVector self) -> Likelihood::SparseVector< int >::size_type"""
        return _pyLikelihood.SparseIntVector_max_size(self)


    def capacity(self):
        """capacity(SparseIntVector self) -> Likelihood::SparseVector< int >::size_type"""
        return _pyLikelihood.SparseIntVector_capacity(self)


    def empty(self):
        """empty(SparseIntVector self) -> bool"""
        return _pyLikelihood.SparseIntVector_empty(self)


    def front(self, *args):
        """
        front(SparseIntVector self) -> Likelihood::SparseVector< int >::container_reference_type
        front(SparseIntVector self) -> Likelihood::SparseVector< int >::container_const_reference_type
        """
        return _pyLikelihood.SparseIntVector_front(self, *args)


    def back(self, *args):
        """
        back(SparseIntVector self) -> Likelihood::SparseVector< int >::container_reference_type
        back(SparseIntVector self) -> Likelihood::SparseVector< int >::container_const_reference_type
        """
        return _pyLikelihood.SparseIntVector_back(self, *args)


    def clear(self):
        """clear(SparseIntVector self)"""
        return _pyLikelihood.SparseIntVector_clear(self)


    def clear_data(self):
        """clear_data(SparseIntVector self)"""
        return _pyLikelihood.SparseIntVector_clear_data(self)


    def find(self, *args):
        """
        find(SparseIntVector self, Likelihood::SparseVector< int >::size_type k) -> Likelihood::SparseVector< int >::iterator
        find(SparseIntVector self, Likelihood::SparseVector< int >::size_type k) -> Likelihood::SparseVector< int >::const_iterator
        """
        return _pyLikelihood.SparseIntVector_find(self, *args)


    def lower_bound(self, *args):
        """
        lower_bound(SparseIntVector self, Likelihood::SparseVector< int >::size_type k) -> Likelihood::SparseVector< int >::iterator
        lower_bound(SparseIntVector self, Likelihood::SparseVector< int >::size_type k) -> Likelihood::SparseVector< int >::const_iterator
        """
        return _pyLikelihood.SparseIntVector_lower_bound(self, *args)


    def upper_bound(self, *args):
        """
        upper_bound(SparseIntVector self, Likelihood::SparseVector< int >::size_type k) -> Likelihood::SparseVector< int >::iterator
        upper_bound(SparseIntVector self, Likelihood::SparseVector< int >::size_type k) -> Likelihood::SparseVector< int >::const_iterator
        """
        return _pyLikelihood.SparseIntVector_upper_bound(self, *args)


    def nth_element(self, n):
        """nth_element(SparseIntVector self, Likelihood::SparseVector< int >::size_type n) -> Likelihood::SparseVector< int >::const_reference"""
        return _pyLikelihood.SparseIntVector_nth_element(self, n)


    def nth_index(self, n):
        """nth_index(SparseIntVector self, Likelihood::SparseVector< int >::size_type n) -> int"""
        return _pyLikelihood.SparseIntVector_nth_index(self, n)


    def push_back(self, val):
        """push_back(SparseIntVector self, int const & val)"""
        return _pyLikelihood.SparseIntVector_push_back(self, val)


    def swap(self, other):
        """swap(SparseIntVector self, SparseIntVector other)"""
        return _pyLikelihood.SparseIntVector_swap(self, other)


    def resize(self, n):
        """resize(SparseIntVector self, Likelihood::SparseVector< int >::size_type n)"""
        return _pyLikelihood.SparseIntVector_resize(self, n)


    def null(self):
        """null(SparseIntVector self) -> Likelihood::SparseVector< int >::const_reference"""
        return _pyLikelihood.SparseIntVector_null(self)


    def test_value(self, val):
        """test_value(SparseIntVector self, int const & val) -> bool"""
        return _pyLikelihood.SparseIntVector_test_value(self, val)


    def set_to_null(self):
        """set_to_null(SparseIntVector self)"""
        return _pyLikelihood.SparseIntVector_set_to_null(self)


    def free_memory(self):
        """free_memory(SparseIntVector self)"""
        return _pyLikelihood.SparseIntVector_free_memory(self)


    def non_null(self):
        """non_null(SparseIntVector self) -> std::vector< std::pair< size_t,int >,std::allocator< std::pair< size_t,int > > > const &"""
        return _pyLikelihood.SparseIntVector_non_null(self)


    def n_filled(self):
        """n_filled(SparseIntVector self) -> size_t"""
        return _pyLikelihood.SparseIntVector_n_filled(self)


    def fill_from_vect(self, vect):
        """fill_from_vect(SparseIntVector self, std::vector< int,std::allocator< int > > const & vect)"""
        return _pyLikelihood.SparseIntVector_fill_from_vect(self, vect)


    def fill_from_map(self, map):
        """fill_from_map(SparseIntVector self, std::map< size_t,int,std::less< size_t >,std::allocator< std::pair< size_t const,int > > > const & map)"""
        return _pyLikelihood.SparseIntVector_fill_from_map(self, map)


    def fill_from_key_and_value(self, keys, values):
        """fill_from_key_and_value(SparseIntVector self, SizetVector keys, std::vector< int,std::allocator< int > > const & values)"""
        return _pyLikelihood.SparseIntVector_fill_from_key_and_value(self, keys, values)


    def fill_vect(self, *args):
        """
        fill_vect(SparseIntVector self, std::vector< int,std::allocator< int > > & vect)
        fill_vect(SparseIntVector self, std::vector< int,std::allocator< int > > & vect, size_t first, size_t last)
        """
        return _pyLikelihood.SparseIntVector_fill_vect(self, *args)


    def fill_map(self, *args):
        """
        fill_map(SparseIntVector self, std::map< size_t,int,std::less< size_t >,std::allocator< std::pair< size_t const,int > > > & vect)
        fill_map(SparseIntVector self, std::map< size_t,int,std::less< size_t >,std::allocator< std::pair< size_t const,int > > > & vect, size_t first, size_t last)
        """
        return _pyLikelihood.SparseIntVector_fill_map(self, *args)


    def fill_key_and_value(self, *args):
        """
        fill_key_and_value(SparseIntVector self, SizetVector keys, std::vector< int,std::allocator< int > > & values)
        fill_key_and_value(SparseIntVector self, SizetVector keys, std::vector< int,std::allocator< int > > & values, size_t first, size_t last)
        """
        return _pyLikelihood.SparseIntVector_fill_key_and_value(self, *args)


    def add_to_vect(self, vect):
        """add_to_vect(SparseIntVector self, std::vector< int,std::allocator< int > > & vect)"""
        return _pyLikelihood.SparseIntVector_add_to_vect(self, vect)


    def subtract_from_vect(self, vect):
        """subtract_from_vect(SparseIntVector self, std::vector< int,std::allocator< int > > & vect)"""
        return _pyLikelihood.SparseIntVector_subtract_from_vect(self, vect)

    __swig_destroy__ = _pyLikelihood.delete_SparseIntVector
    __del__ = lambda self: None
SparseIntVector_swigregister = _pyLikelihood.SparseIntVector_swigregister
SparseIntVector_swigregister(SparseIntVector)

def SparseIntVector_key_compare_lower(a, b):
    """SparseIntVector_key_compare_lower(std::pair< size_t,int > const & a, size_t b) -> bool"""
    return _pyLikelihood.SparseIntVector_key_compare_lower(a, b)

def SparseIntVector_key_compare_upper(a, b):
    """SparseIntVector_key_compare_upper(size_t a, std::pair< size_t,int > const & b) -> bool"""
    return _pyLikelihood.SparseIntVector_key_compare_upper(a, b)

class SparseFloatVector(_object):
    """Proxy of C++ Likelihood::SparseVector<(float)> class."""

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

    def key_compare_lower(a, b):
        """key_compare_lower(std::pair< size_t,float > const & a, size_t b) -> bool"""
        return _pyLikelihood.SparseFloatVector_key_compare_lower(a, b)

    key_compare_lower = staticmethod(key_compare_lower)

    def key_compare_upper(a, b):
        """key_compare_upper(size_t a, std::pair< size_t,float > const & b) -> bool"""
        return _pyLikelihood.SparseFloatVector_key_compare_upper(a, b)

    key_compare_upper = staticmethod(key_compare_upper)

    def __init__(self, *args):
        """
        __init__(Likelihood::SparseVector<(float)> self, float null=0) -> SparseFloatVector
        __init__(Likelihood::SparseVector<(float)> self) -> SparseFloatVector
        __init__(Likelihood::SparseVector<(float)> self, Likelihood::SparseVector< float >::size_type n, float null=0) -> SparseFloatVector
        __init__(Likelihood::SparseVector<(float)> self, Likelihood::SparseVector< float >::size_type n) -> SparseFloatVector
        __init__(Likelihood::SparseVector<(float)> self, FloatVector vect, float null=0) -> SparseFloatVector
        __init__(Likelihood::SparseVector<(float)> self, FloatVector vect) -> SparseFloatVector
        __init__(Likelihood::SparseVector<(float)> self, SparseFloatVector other) -> SparseFloatVector
        """
        this = _pyLikelihood.new_SparseFloatVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def begin(self, *args):
        """
        begin(SparseFloatVector self) -> Likelihood::SparseVector< float >::iterator
        begin(SparseFloatVector self) -> Likelihood::SparseVector< float >::const_iterator
        """
        return _pyLikelihood.SparseFloatVector_begin(self, *args)


    def end(self, *args):
        """
        end(SparseFloatVector self) -> Likelihood::SparseVector< float >::iterator
        end(SparseFloatVector self) -> Likelihood::SparseVector< float >::const_iterator
        """
        return _pyLikelihood.SparseFloatVector_end(self, *args)


    def rbegin(self, *args):
        """
        rbegin(SparseFloatVector self) -> Likelihood::SparseVector< float >::reverse_iterator
        rbegin(SparseFloatVector self) -> Likelihood::SparseVector< float >::const_reverse_iterator
        """
        return _pyLikelihood.SparseFloatVector_rbegin(self, *args)


    def rend(self, *args):
        """
        rend(SparseFloatVector self) -> Likelihood::SparseVector< float >::reverse_iterator
        rend(SparseFloatVector self) -> Likelihood::SparseVector< float >::const_reverse_iterator
        """
        return _pyLikelihood.SparseFloatVector_rend(self, *args)


    def size(self):
        """size(SparseFloatVector self) -> Likelihood::SparseVector< float >::size_type"""
        return _pyLikelihood.SparseFloatVector_size(self)


    def max_size(self):
        """max_size(SparseFloatVector self) -> Likelihood::SparseVector< float >::size_type"""
        return _pyLikelihood.SparseFloatVector_max_size(self)


    def capacity(self):
        """capacity(SparseFloatVector self) -> Likelihood::SparseVector< float >::size_type"""
        return _pyLikelihood.SparseFloatVector_capacity(self)


    def empty(self):
        """empty(SparseFloatVector self) -> bool"""
        return _pyLikelihood.SparseFloatVector_empty(self)


    def front(self, *args):
        """
        front(SparseFloatVector self) -> Likelihood::SparseVector< float >::container_reference_type
        front(SparseFloatVector self) -> Likelihood::SparseVector< float >::container_const_reference_type
        """
        return _pyLikelihood.SparseFloatVector_front(self, *args)


    def back(self, *args):
        """
        back(SparseFloatVector self) -> Likelihood::SparseVector< float >::container_reference_type
        back(SparseFloatVector self) -> Likelihood::SparseVector< float >::container_const_reference_type
        """
        return _pyLikelihood.SparseFloatVector_back(self, *args)


    def clear(self):
        """clear(SparseFloatVector self)"""
        return _pyLikelihood.SparseFloatVector_clear(self)


    def clear_data(self):
        """clear_data(SparseFloatVector self)"""
        return _pyLikelihood.SparseFloatVector_clear_data(self)


    def find(self, *args):
        """
        find(SparseFloatVector self, Likelihood::SparseVector< float >::size_type k) -> Likelihood::SparseVector< float >::iterator
        find(SparseFloatVector self, Likelihood::SparseVector< float >::size_type k) -> Likelihood::SparseVector< float >::const_iterator
        """
        return _pyLikelihood.SparseFloatVector_find(self, *args)


    def lower_bound(self, *args):
        """
        lower_bound(SparseFloatVector self, Likelihood::SparseVector< float >::size_type k) -> Likelihood::SparseVector< float >::iterator
        lower_bound(SparseFloatVector self, Likelihood::SparseVector< float >::size_type k) -> Likelihood::SparseVector< float >::const_iterator
        """
        return _pyLikelihood.SparseFloatVector_lower_bound(self, *args)


    def upper_bound(self, *args):
        """
        upper_bound(SparseFloatVector self, Likelihood::SparseVector< float >::size_type k) -> Likelihood::SparseVector< float >::iterator
        upper_bound(SparseFloatVector self, Likelihood::SparseVector< float >::size_type k) -> Likelihood::SparseVector< float >::const_iterator
        """
        return _pyLikelihood.SparseFloatVector_upper_bound(self, *args)


    def nth_element(self, n):
        """nth_element(SparseFloatVector self, Likelihood::SparseVector< float >::size_type n) -> Likelihood::SparseVector< float >::const_reference"""
        return _pyLikelihood.SparseFloatVector_nth_element(self, n)


    def nth_index(self, n):
        """nth_index(SparseFloatVector self, Likelihood::SparseVector< float >::size_type n) -> int"""
        return _pyLikelihood.SparseFloatVector_nth_index(self, n)


    def push_back(self, val):
        """push_back(SparseFloatVector self, float const & val)"""
        return _pyLikelihood.SparseFloatVector_push_back(self, val)


    def swap(self, other):
        """swap(SparseFloatVector self, SparseFloatVector other)"""
        return _pyLikelihood.SparseFloatVector_swap(self, other)


    def resize(self, n):
        """resize(SparseFloatVector self, Likelihood::SparseVector< float >::size_type n)"""
        return _pyLikelihood.SparseFloatVector_resize(self, n)


    def null(self):
        """null(SparseFloatVector self) -> Likelihood::SparseVector< float >::const_reference"""
        return _pyLikelihood.SparseFloatVector_null(self)


    def test_value(self, val):
        """test_value(SparseFloatVector self, float const & val) -> bool"""
        return _pyLikelihood.SparseFloatVector_test_value(self, val)


    def set_to_null(self):
        """set_to_null(SparseFloatVector self)"""
        return _pyLikelihood.SparseFloatVector_set_to_null(self)


    def free_memory(self):
        """free_memory(SparseFloatVector self)"""
        return _pyLikelihood.SparseFloatVector_free_memory(self)


    def non_null(self):
        """non_null(SparseFloatVector self) -> std::vector< std::pair< size_t,float >,std::allocator< std::pair< size_t,float > > > const &"""
        return _pyLikelihood.SparseFloatVector_non_null(self)


    def n_filled(self):
        """n_filled(SparseFloatVector self) -> size_t"""
        return _pyLikelihood.SparseFloatVector_n_filled(self)


    def fill_from_vect(self, vect):
        """fill_from_vect(SparseFloatVector self, FloatVector vect)"""
        return _pyLikelihood.SparseFloatVector_fill_from_vect(self, vect)


    def fill_from_map(self, map):
        """fill_from_map(SparseFloatVector self, std::map< size_t,float,std::less< size_t >,std::allocator< std::pair< size_t const,float > > > const & map)"""
        return _pyLikelihood.SparseFloatVector_fill_from_map(self, map)


    def fill_from_key_and_value(self, keys, values):
        """fill_from_key_and_value(SparseFloatVector self, SizetVector keys, FloatVector values)"""
        return _pyLikelihood.SparseFloatVector_fill_from_key_and_value(self, keys, values)


    def fill_vect(self, *args):
        """
        fill_vect(SparseFloatVector self, FloatVector vect)
        fill_vect(SparseFloatVector self, FloatVector vect, size_t first, size_t last)
        """
        return _pyLikelihood.SparseFloatVector_fill_vect(self, *args)


    def fill_map(self, *args):
        """
        fill_map(SparseFloatVector self, std::map< size_t,float,std::less< size_t >,std::allocator< std::pair< size_t const,float > > > & vect)
        fill_map(SparseFloatVector self, std::map< size_t,float,std::less< size_t >,std::allocator< std::pair< size_t const,float > > > & vect, size_t first, size_t last)
        """
        return _pyLikelihood.SparseFloatVector_fill_map(self, *args)


    def fill_key_and_value(self, *args):
        """
        fill_key_and_value(SparseFloatVector self, SizetVector keys, FloatVector values)
        fill_key_and_value(SparseFloatVector self, SizetVector keys, FloatVector values, size_t first, size_t last)
        """
        return _pyLikelihood.SparseFloatVector_fill_key_and_value(self, *args)


    def add_to_vect(self, vect):
        """add_to_vect(SparseFloatVector self, FloatVector vect)"""
        return _pyLikelihood.SparseFloatVector_add_to_vect(self, vect)


    def subtract_from_vect(self, vect):
        """subtract_from_vect(SparseFloatVector self, FloatVector vect)"""
        return _pyLikelihood.SparseFloatVector_subtract_from_vect(self, vect)

    __swig_destroy__ = _pyLikelihood.delete_SparseFloatVector
    __del__ = lambda self: None
SparseFloatVector_swigregister = _pyLikelihood.SparseFloatVector_swigregister
SparseFloatVector_swigregister(SparseFloatVector)

def SparseFloatVector_key_compare_lower(a, b):
    """SparseFloatVector_key_compare_lower(std::pair< size_t,float > const & a, size_t b) -> bool"""
    return _pyLikelihood.SparseFloatVector_key_compare_lower(a, b)

def SparseFloatVector_key_compare_upper(a, b):
    """SparseFloatVector_key_compare_upper(size_t a, std::pair< size_t,float > const & b) -> bool"""
    return _pyLikelihood.SparseFloatVector_key_compare_upper(a, b)

class SparseDoubleVector(_object):
    """Proxy of C++ Likelihood::SparseVector<(double)> class."""

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

    def key_compare_lower(a, b):
        """key_compare_lower(std::pair< size_t,double > const & a, size_t b) -> bool"""
        return _pyLikelihood.SparseDoubleVector_key_compare_lower(a, b)

    key_compare_lower = staticmethod(key_compare_lower)

    def key_compare_upper(a, b):
        """key_compare_upper(size_t a, std::pair< size_t,double > const & b) -> bool"""
        return _pyLikelihood.SparseDoubleVector_key_compare_upper(a, b)

    key_compare_upper = staticmethod(key_compare_upper)

    def __init__(self, *args):
        """
        __init__(Likelihood::SparseVector<(double)> self, double null=0) -> SparseDoubleVector
        __init__(Likelihood::SparseVector<(double)> self) -> SparseDoubleVector
        __init__(Likelihood::SparseVector<(double)> self, Likelihood::SparseVector< double >::size_type n, double null=0) -> SparseDoubleVector
        __init__(Likelihood::SparseVector<(double)> self, Likelihood::SparseVector< double >::size_type n) -> SparseDoubleVector
        __init__(Likelihood::SparseVector<(double)> self, DoubleVector vect, double null=0) -> SparseDoubleVector
        __init__(Likelihood::SparseVector<(double)> self, DoubleVector vect) -> SparseDoubleVector
        __init__(Likelihood::SparseVector<(double)> self, SparseDoubleVector other) -> SparseDoubleVector
        """
        this = _pyLikelihood.new_SparseDoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def begin(self, *args):
        """
        begin(SparseDoubleVector self) -> Likelihood::SparseVector< double >::iterator
        begin(SparseDoubleVector self) -> Likelihood::SparseVector< double >::const_iterator
        """
        return _pyLikelihood.SparseDoubleVector_begin(self, *args)


    def end(self, *args):
        """
        end(SparseDoubleVector self) -> Likelihood::SparseVector< double >::iterator
        end(SparseDoubleVector self) -> Likelihood::SparseVector< double >::const_iterator
        """
        return _pyLikelihood.SparseDoubleVector_end(self, *args)


    def rbegin(self, *args):
        """
        rbegin(SparseDoubleVector self) -> Likelihood::SparseVector< double >::reverse_iterator
        rbegin(SparseDoubleVector self) -> Likelihood::SparseVector< double >::const_reverse_iterator
        """
        return _pyLikelihood.SparseDoubleVector_rbegin(self, *args)


    def rend(self, *args):
        """
        rend(SparseDoubleVector self) -> Likelihood::SparseVector< double >::reverse_iterator
        rend(SparseDoubleVector self) -> Likelihood::SparseVector< double >::const_reverse_iterator
        """
        return _pyLikelihood.SparseDoubleVector_rend(self, *args)


    def size(self):
        """size(SparseDoubleVector self) -> Likelihood::SparseVector< double >::size_type"""
        return _pyLikelihood.SparseDoubleVector_size(self)


    def max_size(self):
        """max_size(SparseDoubleVector self) -> Likelihood::SparseVector< double >::size_type"""
        return _pyLikelihood.SparseDoubleVector_max_size(self)


    def capacity(self):
        """capacity(SparseDoubleVector self) -> Likelihood::SparseVector< double >::size_type"""
        return _pyLikelihood.SparseDoubleVector_capacity(self)


    def empty(self):
        """empty(SparseDoubleVector self) -> bool"""
        return _pyLikelihood.SparseDoubleVector_empty(self)


    def front(self, *args):
        """
        front(SparseDoubleVector self) -> Likelihood::SparseVector< double >::container_reference_type
        front(SparseDoubleVector self) -> Likelihood::SparseVector< double >::container_const_reference_type
        """
        return _pyLikelihood.SparseDoubleVector_front(self, *args)


    def back(self, *args):
        """
        back(SparseDoubleVector self) -> Likelihood::SparseVector< double >::container_reference_type
        back(SparseDoubleVector self) -> Likelihood::SparseVector< double >::container_const_reference_type
        """
        return _pyLikelihood.SparseDoubleVector_back(self, *args)


    def clear(self):
        """clear(SparseDoubleVector self)"""
        return _pyLikelihood.SparseDoubleVector_clear(self)


    def clear_data(self):
        """clear_data(SparseDoubleVector self)"""
        return _pyLikelihood.SparseDoubleVector_clear_data(self)


    def find(self, *args):
        """
        find(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type k) -> Likelihood::SparseVector< double >::iterator
        find(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type k) -> Likelihood::SparseVector< double >::const_iterator
        """
        return _pyLikelihood.SparseDoubleVector_find(self, *args)


    def lower_bound(self, *args):
        """
        lower_bound(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type k) -> Likelihood::SparseVector< double >::iterator
        lower_bound(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type k) -> Likelihood::SparseVector< double >::const_iterator
        """
        return _pyLikelihood.SparseDoubleVector_lower_bound(self, *args)


    def upper_bound(self, *args):
        """
        upper_bound(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type k) -> Likelihood::SparseVector< double >::iterator
        upper_bound(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type k) -> Likelihood::SparseVector< double >::const_iterator
        """
        return _pyLikelihood.SparseDoubleVector_upper_bound(self, *args)


    def nth_element(self, n):
        """nth_element(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type n) -> Likelihood::SparseVector< double >::const_reference"""
        return _pyLikelihood.SparseDoubleVector_nth_element(self, n)


    def nth_index(self, n):
        """nth_index(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type n) -> int"""
        return _pyLikelihood.SparseDoubleVector_nth_index(self, n)


    def push_back(self, val):
        """push_back(SparseDoubleVector self, double const & val)"""
        return _pyLikelihood.SparseDoubleVector_push_back(self, val)


    def swap(self, other):
        """swap(SparseDoubleVector self, SparseDoubleVector other)"""
        return _pyLikelihood.SparseDoubleVector_swap(self, other)


    def resize(self, n):
        """resize(SparseDoubleVector self, Likelihood::SparseVector< double >::size_type n)"""
        return _pyLikelihood.SparseDoubleVector_resize(self, n)


    def null(self):
        """null(SparseDoubleVector self) -> Likelihood::SparseVector< double >::const_reference"""
        return _pyLikelihood.SparseDoubleVector_null(self)


    def test_value(self, val):
        """test_value(SparseDoubleVector self, double const & val) -> bool"""
        return _pyLikelihood.SparseDoubleVector_test_value(self, val)


    def set_to_null(self):
        """set_to_null(SparseDoubleVector self)"""
        return _pyLikelihood.SparseDoubleVector_set_to_null(self)


    def free_memory(self):
        """free_memory(SparseDoubleVector self)"""
        return _pyLikelihood.SparseDoubleVector_free_memory(self)


    def non_null(self):
        """non_null(SparseDoubleVector self) -> std::vector< std::pair< size_t,double >,std::allocator< std::pair< size_t,double > > > const &"""
        return _pyLikelihood.SparseDoubleVector_non_null(self)


    def n_filled(self):
        """n_filled(SparseDoubleVector self) -> size_t"""
        return _pyLikelihood.SparseDoubleVector_n_filled(self)


    def fill_from_vect(self, vect):
        """fill_from_vect(SparseDoubleVector self, DoubleVector vect)"""
        return _pyLikelihood.SparseDoubleVector_fill_from_vect(self, vect)


    def fill_from_map(self, map):
        """fill_from_map(SparseDoubleVector self, std::map< size_t,double,std::less< size_t >,std::allocator< std::pair< size_t const,double > > > const & map)"""
        return _pyLikelihood.SparseDoubleVector_fill_from_map(self, map)


    def fill_from_key_and_value(self, keys, values):
        """fill_from_key_and_value(SparseDoubleVector self, SizetVector keys, DoubleVector values)"""
        return _pyLikelihood.SparseDoubleVector_fill_from_key_and_value(self, keys, values)


    def fill_vect(self, *args):
        """
        fill_vect(SparseDoubleVector self, DoubleVector vect)
        fill_vect(SparseDoubleVector self, DoubleVector vect, size_t first, size_t last)
        """
        return _pyLikelihood.SparseDoubleVector_fill_vect(self, *args)


    def fill_map(self, *args):
        """
        fill_map(SparseDoubleVector self, std::map< size_t,double,std::less< size_t >,std::allocator< std::pair< size_t const,double > > > & vect)
        fill_map(SparseDoubleVector self, std::map< size_t,double,std::less< size_t >,std::allocator< std::pair< size_t const,double > > > & vect, size_t first, size_t last)
        """
        return _pyLikelihood.SparseDoubleVector_fill_map(self, *args)


    def fill_key_and_value(self, *args):
        """
        fill_key_and_value(SparseDoubleVector self, SizetVector keys, DoubleVector values)
        fill_key_and_value(SparseDoubleVector self, SizetVector keys, DoubleVector values, size_t first, size_t last)
        """
        return _pyLikelihood.SparseDoubleVector_fill_key_and_value(self, *args)


    def add_to_vect(self, vect):
        """add_to_vect(SparseDoubleVector self, DoubleVector vect)"""
        return _pyLikelihood.SparseDoubleVector_add_to_vect(self, vect)


    def subtract_from_vect(self, vect):
        """subtract_from_vect(SparseDoubleVector self, DoubleVector vect)"""
        return _pyLikelihood.SparseDoubleVector_subtract_from_vect(self, vect)

    __swig_destroy__ = _pyLikelihood.delete_SparseDoubleVector
    __del__ = lambda self: None
SparseDoubleVector_swigregister = _pyLikelihood.SparseDoubleVector_swigregister
SparseDoubleVector_swigregister(SparseDoubleVector)

def SparseDoubleVector_key_compare_lower(a, b):
    """SparseDoubleVector_key_compare_lower(std::pair< size_t,double > const & a, size_t b) -> bool"""
    return _pyLikelihood.SparseDoubleVector_key_compare_lower(a, b)

def SparseDoubleVector_key_compare_upper(a, b):
    """SparseDoubleVector_key_compare_upper(size_t a, std::pair< size_t,double > const & b) -> bool"""
    return _pyLikelihood.SparseDoubleVector_key_compare_upper(a, b)

class TrapQuad(_object):
    """Proxy of C++ Likelihood::TrapQuad class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::TrapQuad self, DoubleVector x, DoubleVector y, bool useLog=False) -> TrapQuad
        __init__(Likelihood::TrapQuad self, DoubleVector x, DoubleVector y) -> TrapQuad
        __init__(Likelihood::TrapQuad self, Function func, bool useLog=False) -> TrapQuad
        __init__(Likelihood::TrapQuad self, Function func) -> TrapQuad
        """
        this = _pyLikelihood.new_TrapQuad(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_TrapQuad
    __del__ = lambda self: None

    def integral(self, *args):
        """
        integral(TrapQuad self) -> double
        integral(TrapQuad self, double xmin, double xmax, int npts=100) -> double
        integral(TrapQuad self, double xmin, double xmax) -> double
        integral(TrapQuad self, DoubleVector xvals) -> double
        """
        return _pyLikelihood.TrapQuad_integral(self, *args)

TrapQuad_swigregister = _pyLikelihood.TrapQuad_swigregister
TrapQuad_swigregister(TrapQuad)

class TiedParameter(Parameter):
    """Proxy of C++ Likelihood::TiedParameter class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::TiedParameter self) -> TiedParameter
        __init__(Likelihood::TiedParameter self, TiedParameter other) -> TiedParameter
        """
        this = _pyLikelihood.new_TiedParameter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_TiedParameter
    __del__ = lambda self: None

    def addParam(self, like, i):
        """addParam(TiedParameter self, LogLike like, size_t i)"""
        return _pyLikelihood.TiedParameter_addParam(self, like, i)


    def removeParam(self, like, i):
        """removeParam(TiedParameter self, LogLike like, size_t i)"""
        return _pyLikelihood.TiedParameter_removeParam(self, like, i)


    def has_member(self, like, i):
        """has_member(TiedParameter self, LogLike like, size_t i) -> bool"""
        return _pyLikelihood.TiedParameter_has_member(self, like, i)


    def setName(self, name):
        """setName(TiedParameter self, std::string const name)"""
        return _pyLikelihood.TiedParameter_setName(self, name)


    def setValue(self, value):
        """setValue(TiedParameter self, double value)"""
        return _pyLikelihood.TiedParameter_setValue(self, value)


    def setScale(self, scale):
        """setScale(TiedParameter self, double scale)"""
        return _pyLikelihood.TiedParameter_setScale(self, scale)


    def setTrueValue(self, trueValue):
        """setTrueValue(TiedParameter self, double trueValue)"""
        return _pyLikelihood.TiedParameter_setTrueValue(self, trueValue)


    def setBounds(self, minValue, maxValue):
        """setBounds(TiedParameter self, double minValue, double maxValue)"""
        return _pyLikelihood.TiedParameter_setBounds(self, minValue, maxValue)


    def setFree(self, free):
        """setFree(TiedParameter self, bool free)"""
        return _pyLikelihood.TiedParameter_setFree(self, free)


    def setAlwaysFixed(self, flag):
        """setAlwaysFixed(TiedParameter self, bool flag)"""
        return _pyLikelihood.TiedParameter_setAlwaysFixed(self, flag)


    def setError(self, error):
        """setError(TiedParameter self, double error)"""
        return _pyLikelihood.TiedParameter_setError(self, error)


    def pars(self):
        """pars(TiedParameter self) -> ParVector_t"""
        return _pyLikelihood.TiedParameter_pars(self)


    def containsIndex(self, like, par_index):
        """containsIndex(TiedParameter self, LogLike like, size_t par_index) -> bool"""
        return _pyLikelihood.TiedParameter_containsIndex(self, like, par_index)

TiedParameter_swigregister = _pyLikelihood.TiedParameter_swigregister
TiedParameter_swigregister(TiedParameter)

class WcsMapLibrary(_object):
    """Proxy of C++ Likelihood::WcsMapLibrary class."""

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

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

    def wcsmap(self, filename, extname):
        """wcsmap(WcsMapLibrary self, std::string const & filename, std::string const & extname) -> ProjMap"""
        return _pyLikelihood.WcsMapLibrary_wcsmap(self, filename, extname)


    def delete_map(self, filename, extname):
        """delete_map(WcsMapLibrary self, std::string const & filename, std::string const & extname)"""
        return _pyLikelihood.WcsMapLibrary_delete_map(self, filename, extname)


    def has_map(self, filename, extname):
        """has_map(WcsMapLibrary self, std::string const & filename, std::string const & extname) -> bool"""
        return _pyLikelihood.WcsMapLibrary_has_map(self, filename, extname)


    def add_observer(self, observer):
        """add_observer(WcsMapLibrary self, MapBase observer)"""
        return _pyLikelihood.WcsMapLibrary_add_observer(self, observer)


    def remove_observer(self, observer):
        """remove_observer(WcsMapLibrary self, MapBase observer)"""
        return _pyLikelihood.WcsMapLibrary_remove_observer(self, observer)


    def notify(self):
        """notify(WcsMapLibrary self)"""
        return _pyLikelihood.WcsMapLibrary_notify(self)


    def instance():
        """instance() -> WcsMapLibrary"""
        return _pyLikelihood.WcsMapLibrary_instance()

    instance = staticmethod(instance)

    def delete_instance():
        """delete_instance()"""
        return _pyLikelihood.WcsMapLibrary_delete_instance()

    delete_instance = staticmethod(delete_instance)
WcsMapLibrary_swigregister = _pyLikelihood.WcsMapLibrary_swigregister
WcsMapLibrary_swigregister(WcsMapLibrary)

def WcsMapLibrary_instance():
    """WcsMapLibrary_instance() -> WcsMapLibrary"""
    return _pyLikelihood.WcsMapLibrary_instance()

def WcsMapLibrary_delete_instance():
    """WcsMapLibrary_delete_instance()"""
    return _pyLikelihood.WcsMapLibrary_delete_instance()

class WeightMap(_object):
    """Proxy of C++ Likelihood::WeightMap class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::WeightMap self, ProjMap weight_map, CountsMapBase dataMap, Observation observation, bool verbose=True) -> WeightMap
        __init__(Likelihood::WeightMap self, ProjMap weight_map, CountsMapBase dataMap, Observation observation) -> WeightMap
        __init__(Likelihood::WeightMap self, std::string const & sourceMapsFile, CountsMapBase dataMap, Observation observation) -> WeightMap
        """
        this = _pyLikelihood.new_WeightMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_WeightMap
    __del__ = lambda self: None

    def model(self):
        """model(WeightMap self) -> FloatVector"""
        return _pyLikelihood.WeightMap_model(self)


    def setImage(self, model):
        """setImage(WeightMap self, FloatVector model)"""
        return _pyLikelihood.WeightMap_setImage(self, model)

WeightMap_swigregister = _pyLikelihood.WeightMap_swigregister
WeightMap_swigregister(WeightMap)

class BinnedExposureBase(_object):
    """Proxy of C++ Likelihood::BinnedExposureBase class."""

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

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

    def fracDiff(target, result):
        """fracDiff(double target, double result) -> double"""
        return _pyLikelihood.BinnedExposureBase_fracDiff(target, result)

    fracDiff = staticmethod(fracDiff)

    def findNearest(xx, x, tol=1e-5):
        """
        findNearest(DoubleVector xx, double x, double tol=1e-5) -> std::vector< double,std::allocator< double > >::const_iterator
        findNearest(DoubleVector xx, double x) -> std::vector< double,std::allocator< double > >::const_iterator
        """
        return _pyLikelihood.BinnedExposureBase_findNearest(xx, x, tol)

    findNearest = staticmethod(findNearest)
    __swig_destroy__ = _pyLikelihood.delete_BinnedExposureBase
    __del__ = lambda self: None

    def __call__(self, energy, ra, dec):
        """__call__(BinnedExposureBase self, double energy, double ra, double dec) -> double"""
        return _pyLikelihood.BinnedExposureBase___call__(self, energy, ra, dec)


    def writeOutput(self, filename):
        """writeOutput(BinnedExposureBase self, std::string const & filename)"""
        return _pyLikelihood.BinnedExposureBase_writeOutput(self, filename)


    def energies(self):
        """energies(BinnedExposureBase self) -> DoubleVector"""
        return _pyLikelihood.BinnedExposureBase_energies(self)


    def get_exposures_for_dir(self, dir, energies, exposures):
        """get_exposures_for_dir(BinnedExposureBase self, SkyDir dir, DoubleVector energies, DoubleVector exposures)"""
        return _pyLikelihood.BinnedExposureBase_get_exposures_for_dir(self, dir, energies, exposures)


    def setBoundaryFlag(self, enforce_boundaries):
        """setBoundaryFlag(BinnedExposureBase self, bool enforce_boundaries)"""
        return _pyLikelihood.BinnedExposureBase_setBoundaryFlag(self, enforce_boundaries)


    def allSky(self):
        """allSky(BinnedExposureBase self) -> bool"""
        return _pyLikelihood.BinnedExposureBase_allSky(self)

BinnedExposureBase_swigregister = _pyLikelihood.BinnedExposureBase_swigregister
BinnedExposureBase_swigregister(BinnedExposureBase)

def BinnedExposureBase_fracDiff(target, result):
    """BinnedExposureBase_fracDiff(double target, double result) -> double"""
    return _pyLikelihood.BinnedExposureBase_fracDiff(target, result)

def BinnedExposureBase_findNearest(xx, x, tol=1e-5):
    """
    findNearest(DoubleVector xx, double x, double tol=1e-5) -> std::vector< double,std::allocator< double > >::const_iterator
    BinnedExposureBase_findNearest(DoubleVector xx, double x) -> std::vector< double,std::allocator< double > >::const_iterator
    """
    return _pyLikelihood.BinnedExposureBase_findNearest(xx, x, tol)

class Event(_object):
    """Proxy of C++ Likelihood::Event class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::Event self) -> Event
        __init__(Likelihood::Event self, double ra, double dec, double energy, double time, SkyDir scZAxis, SkyDir scXAxis, double muZenith, bool useEdisp, std::string const & respName, int type=2, double efficiency=1) -> Event
        __init__(Likelihood::Event self, double ra, double dec, double energy, double time, SkyDir scZAxis, SkyDir scXAxis, double muZenith, bool useEdisp, std::string const & respName, int type=2) -> Event
        __init__(Likelihood::Event self, double ra, double dec, double energy, double time, SkyDir scZAxis, SkyDir scXAxis, double muZenith, bool useEdisp, std::string const & respName) -> Event
        """
        this = _pyLikelihood.new_Event(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Event
    __del__ = lambda self: None

    def getDir(self):
        """getDir(Event self) -> SkyDir"""
        return _pyLikelihood.Event_getDir(self)


    def getScDir(self):
        """getScDir(Event self) -> SkyDir"""
        return _pyLikelihood.Event_getScDir(self)


    def zAxis(self):
        """zAxis(Event self) -> SkyDir"""
        return _pyLikelihood.Event_zAxis(self)


    def xAxis(self):
        """xAxis(Event self) -> SkyDir"""
        return _pyLikelihood.Event_xAxis(self)


    def getEnergy(self):
        """getEnergy(Event self) -> double"""
        return _pyLikelihood.Event_getEnergy(self)


    def getArrTime(self):
        """getArrTime(Event self) -> double"""
        return _pyLikelihood.Event_getArrTime(self)


    def getMuZenith(self):
        """getMuZenith(Event self) -> double"""
        return _pyLikelihood.Event_getMuZenith(self)


    def getType(self):
        """getType(Event self) -> int"""
        return _pyLikelihood.Event_getType(self)


    def set_classLevel(self, classLevel):
        """set_classLevel(Event self, int classLevel)"""
        return _pyLikelihood.Event_set_classLevel(self, classLevel)


    def classLevel(self):
        """classLevel(Event self) -> int"""
        return _pyLikelihood.Event_classLevel(self)


    def getSeparation(self, dir):
        """getSeparation(Event self, SkyDir dir) -> double"""
        return _pyLikelihood.Event_getSeparation(self, dir)


    def computeResponseGQ(self, srcs, respFuncs, useDummyValue=False):
        """
        computeResponseGQ(Event self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs, ResponseFunctions respFuncs, bool useDummyValue=False)
        computeResponseGQ(Event self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs, ResponseFunctions respFuncs)
        """
        return _pyLikelihood.Event_computeResponseGQ(self, srcs, respFuncs, useDummyValue)


    def computeResponse(self, *args):
        """
        computeResponse(Event self, DiffuseSource src, ResponseFunctions respFuncs, double sr_radius=30., double sr_radius2=80.)
        computeResponse(Event self, DiffuseSource src, ResponseFunctions respFuncs, double sr_radius=30.)
        computeResponse(Event self, DiffuseSource src, ResponseFunctions respFuncs)
        computeResponse(Event self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs, ResponseFunctions respFuncs, double sr_radius=30., double sr_radius2=80)
        computeResponse(Event self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs, ResponseFunctions respFuncs, double sr_radius=30.)
        computeResponse(Event self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs, ResponseFunctions respFuncs)
        """
        return _pyLikelihood.Event_computeResponse(self, *args)


    def getNewDiffuseSrcs(self, srcList, srcs):
        """getNewDiffuseSrcs(Event self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > const & srcList, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs)"""
        return _pyLikelihood.Event_getNewDiffuseSrcs(self, srcList, srcs)


    def writeDiffuseResponses(self, filename):
        """writeDiffuseResponses(Event self, std::string const & filename)"""
        return _pyLikelihood.Event_writeDiffuseResponses(self, filename)


    def setDiffuseResponse(self, *args):
        """
        setDiffuseResponse(Event self, std::string const & componentName, double value)
        setDiffuseResponse(Event self, std::string const & srcName, DoubleVector gaussianParams)
        """
        return _pyLikelihood.Event_setDiffuseResponse(self, *args)


    def toLower(name):
        """toLower(std::string & name)"""
        return _pyLikelihood.Event_toLower(name)

    toLower = staticmethod(toLower)

    def trueEnergies(self):
        """trueEnergies(Event self) -> DoubleVector"""
        return _pyLikelihood.Event_trueEnergies(self)


    def diffuseResponse(self, *args):
        """
        diffuseResponse(Event self, double energy, std::string const & srcName) -> double
        diffuseResponse(Event self, std::string const & srcName) -> DoubleVector
        """
        return _pyLikelihood.Event_diffuseResponse(self, *args)


    def computeGaussianParams(self, srcName, norm, mean, sigma):
        """computeGaussianParams(Event self, std::string const & srcName, double & norm, double & mean, double & sigma)"""
        return _pyLikelihood.Event_computeGaussianParams(self, srcName, norm, mean, sigma)


    def diffuseSrcName(self, srcName):
        """diffuseSrcName(Event self, std::string const & srcName) -> std::string const &"""
        return _pyLikelihood.Event_diffuseSrcName(self, srcName)


    def updateModelSum(self, src, cResp=None):
        """
        updateModelSum(Event self, Source src, Likelihood::Event::CachedResponse * cResp=None)
        updateModelSum(Event self, Source src)
        """
        return _pyLikelihood.Event_updateModelSum(self, src, cResp)


    def resetModelSum(self):
        """resetModelSum(Event self)"""
        return _pyLikelihood.Event_resetModelSum(self)


    def modelSum(self):
        """modelSum(Event self) -> double"""
        return _pyLikelihood.Event_modelSum(self)


    def deleteSource(self, srcName):
        """deleteSource(Event self, std::string const & srcName)"""
        return _pyLikelihood.Event_deleteSource(self, srcName)


    def efficiency(self):
        """efficiency(Event self) -> double"""
        return _pyLikelihood.Event_efficiency(self)


    def ra_dec(self):
        """ra_dec(Event self) -> DoublePair"""
        return _pyLikelihood.Event_ra_dec(self)


    def sc_dir(self):
        """sc_dir(Event self) -> DoublePair"""
        return _pyLikelihood.Event_sc_dir(self)

Event_swigregister = _pyLikelihood.Event_swigregister
Event_swigregister(Event)

def Event_toLower(name):
    """Event_toLower(std::string & name)"""
    return _pyLikelihood.Event_toLower(name)

Unknown = _pyLikelihood.Unknown
WCS = _pyLikelihood.WCS
WCS_Sparse = _pyLikelihood.WCS_Sparse
HPX_AllSky = _pyLikelihood.HPX_AllSky
HPX_Sparse = _pyLikelihood.HPX_Sparse
HPX_Partial = _pyLikelihood.HPX_Partial

def makeTemplateFilepath(basename, filepath):
    """makeTemplateFilepath(std::string const & basename, std::string & filepath)"""
    return _pyLikelihood.makeTemplateFilepath(basename, filepath)

def fileHasExtension(filename, extension):
    """fileHasExtension(std::string const & filename, std::string const & extension) -> bool"""
    return _pyLikelihood.fileHasExtension(filename, extension)

def read_ebounds_to_vector(filename, energies):
    """read_ebounds_to_vector(std::string const & filename, DoubleVector energies)"""
    return _pyLikelihood.read_ebounds_to_vector(filename, energies)

def read_fits_image_to_float_vector(filename, extension, vect):
    """read_fits_image_to_float_vector(std::string const & filename, std::string const & extension, FloatVector vect) -> int"""
    return _pyLikelihood.read_fits_image_to_float_vector(filename, extension, vect)

def read_healpix_table_to_float_vector(filename, extension, vect):
    """read_healpix_table_to_float_vector(std::string const & filename, std::string const & extension, FloatVector vect) -> int"""
    return _pyLikelihood.read_healpix_table_to_float_vector(filename, extension, vect)

def read_healpix_table_to_sparse_vector(filename, extension, npix, vect):
    """read_healpix_table_to_sparse_vector(std::string const & filename, std::string const & extension, size_t npix, SparseFloatVector vect) -> int"""
    return _pyLikelihood.read_healpix_table_to_sparse_vector(filename, extension, npix, vect)

def get_src_map_type(filename, extension):
    """get_src_map_type(std::string const & filename, std::string const & extension) -> Likelihood::FileUtils::SrcMapType"""
    return _pyLikelihood.get_src_map_type(filename, extension)

def replace_energies(filename, extension, energies):
    """replace_energies(std::string const & filename, std::string const & extension, DoubleVector energies) -> tip::Extension *"""
    return _pyLikelihood.replace_energies(filename, extension, energies)

def replace_image_from_hist_wcs(image, hist):
    """replace_image_from_hist_wcs(tip::Image & image, Likelihood::HistND & hist)"""
    return _pyLikelihood.replace_image_from_hist_wcs(image, hist)

def replace_image_from_hist_hpx(table, colString, hist, hpx_binner):
    """replace_image_from_hist_hpx(tip::Table & table, std::string const & colString, Likelihood::HistND & hist, evtbin::HealpixBinner & hpx_binner)"""
    return _pyLikelihood.replace_image_from_hist_hpx(table, colString, hist, hpx_binner)

def replace_image_from_float_vector(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    replace_image_from_float_vector(std::string const & filename, std::string const & extension, CountsMapBase dataMap, FloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    replace_image_from_float_vector(std::string const & filename, std::string const & extension, CountsMapBase dataMap, FloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    replace_image_from_float_vector(std::string const & filename, std::string const & extension, CountsMapBase dataMap, FloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.replace_image_from_float_vector(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def replace_image_from_float_vector_wcs(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    replace_image_from_float_vector_wcs(std::string const & filename, std::string const & extension, CountsMap dataMap, FloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    replace_image_from_float_vector_wcs(std::string const & filename, std::string const & extension, CountsMap dataMap, FloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    replace_image_from_float_vector_wcs(std::string const & filename, std::string const & extension, CountsMap dataMap, FloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.replace_image_from_float_vector_wcs(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def replace_image_from_float_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    replace_image_from_float_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, FloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    replace_image_from_float_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, FloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    replace_image_from_float_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, FloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.replace_image_from_float_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def replace_image_from_sparse_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    replace_image_from_sparse_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, SparseFloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    replace_image_from_sparse_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, SparseFloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    replace_image_from_sparse_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, SparseFloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.replace_image_from_sparse_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def append_image_from_float_vector(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    append_image_from_float_vector(std::string const & filename, std::string const & extension, CountsMapBase dataMap, FloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    append_image_from_float_vector(std::string const & filename, std::string const & extension, CountsMapBase dataMap, FloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    append_image_from_float_vector(std::string const & filename, std::string const & extension, CountsMapBase dataMap, FloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.append_image_from_float_vector(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def append_image_from_float_vector_wcs(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    append_image_from_float_vector_wcs(std::string const & filename, std::string const & extension, CountsMap dataMap, FloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    append_image_from_float_vector_wcs(std::string const & filename, std::string const & extension, CountsMap dataMap, FloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    append_image_from_float_vector_wcs(std::string const & filename, std::string const & extension, CountsMap dataMap, FloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.append_image_from_float_vector_wcs(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def append_image_from_float_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    append_image_from_float_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, FloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    append_image_from_float_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, FloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    append_image_from_float_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, FloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.append_image_from_float_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def append_image_from_sparse_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin=0, kmax=-1):
    """
    append_image_from_sparse_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, SparseFloatVector imageData, bool is_src_map, int kmin=0, int kmax=-1) -> tip::Extension
    append_image_from_sparse_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, SparseFloatVector imageData, bool is_src_map, int kmin=0) -> tip::Extension
    append_image_from_sparse_vector_healpix(std::string const & filename, std::string const & extension, CountsMapHealpix dataMap, SparseFloatVector imageData, bool is_src_map) -> tip::Extension *
    """
    return _pyLikelihood.append_image_from_sparse_vector_healpix(filename, extension, dataMap, imageData, is_src_map, kmin, kmax)

def append_table_only(file_name, table_name):
    """append_table_only(std::string const & file_name, std::string const & table_name)"""
    return _pyLikelihood.append_table_only(file_name, table_name)

def write_model_parameters_to_table(file_name, table_name, sources):
    """write_model_parameters_to_table(std::string const & file_name, std::string const & table_name, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & sources) -> tip::Extension *"""
    return _pyLikelihood.write_model_parameters_to_table(file_name, table_name, sources)

def write_source_parameters_to_table(source, irec, src_name_col, func_name_col, par_name_col, par_value_col, par_scale_col, par_error_col, par_free_col):
    """write_source_parameters_to_table(Source source, size_t & irec, tip::IColumn & src_name_col, tip::IColumn & func_name_col, tip::IColumn & par_name_col, tip::IColumn & par_value_col, tip::IColumn & par_scale_col, tip::IColumn & par_error_col, tip::IColumn & par_free_col)"""
    return _pyLikelihood.write_source_parameters_to_table(source, irec, src_name_col, func_name_col, par_name_col, par_value_col, par_scale_col, par_error_col, par_free_col)

def write_function_parameters_to_table(srcName, func, irec, src_name_col, func_name_col, par_name_col, par_value_col, par_scale_col, par_error_col, par_free_col):
    """write_function_parameters_to_table(std::string const & srcName, Function func, size_t & irec, tip::IColumn & src_name_col, tip::IColumn & func_name_col, tip::IColumn & par_name_col, tip::IColumn & par_value_col, tip::IColumn & par_scale_col, tip::IColumn & par_error_col, tip::IColumn & par_free_col)"""
    return _pyLikelihood.write_function_parameters_to_table(srcName, func, irec, src_name_col, func_name_col, par_name_col, par_value_col, par_scale_col, par_error_col, par_free_col)

def write_parameter_to_table(srcName, funcName, param, irec, src_name_col, func_name_col, par_name_col, par_value_col, par_scale_col, par_error_col, par_free_col):
    """write_parameter_to_table(std::string const & srcName, std::string const & funcName, Parameter param, size_t irec, tip::IColumn & src_name_col, tip::IColumn & func_name_col, tip::IColumn & par_name_col, tip::IColumn & par_value_col, tip::IColumn & par_scale_col, tip::IColumn & par_error_col, tip::IColumn & par_free_col)"""
    return _pyLikelihood.write_parameter_to_table(srcName, funcName, param, irec, src_name_col, func_name_col, par_name_col, par_value_col, par_scale_col, par_error_col, par_free_col)

def append_column(table, colName, colFormat):
    """append_column(tip::Table & table, std::string const & colName, std::string const & colFormat) -> tip::IColumn &"""
    return _pyLikelihood.append_column(table, colName, colFormat)

def get_column(table, colName):
    """get_column(tip::Table const & table, std::string const & colName) -> tip::IColumn const &"""
    return _pyLikelihood.get_column(table, colName)

def read_parameters_from_table(file_name, table_name, srcModel):
    """read_parameters_from_table(std::string const & file_name, std::string const & table_name, SourceModel srcModel)"""
    return _pyLikelihood.read_parameters_from_table(file_name, table_name, srcModel)

def write_drm_to_table(file_name, table_name, drm):
    """write_drm_to_table(std::string const & file_name, std::string const & table_name, Drm drm) -> tip::Extension *"""
    return _pyLikelihood.write_drm_to_table(file_name, table_name, drm)

def read_drm_from_table(file_name, table_name):
    """read_drm_from_table(std::string const & file_name, std::string const & table_name) -> Drm"""
    return _pyLikelihood.read_drm_from_table(file_name, table_name)
class HealpixProjMap(ProjMap):
    """Proxy of C++ Likelihood::HealpixProjMap class."""

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

    def foldVector(vector_in, hp_proj, npix, nebins, image_out):
        """foldVector(FloatVector vector_in, HealpixProj hp_proj, int npix, int nebins, std::vector< Healpix_Map< float >,std::allocator< Healpix_Map< float > > > & image_out)"""
        return _pyLikelihood.HealpixProjMap_foldVector(vector_in, hp_proj, npix, nebins, image_out)

    foldVector = staticmethod(foldVector)

    def convertToDifferential(image_out, energy_bin_widths, npix, solid_angle):
        """convertToDifferential(std::vector< Healpix_Map< float >,std::allocator< Healpix_Map< float > > > & image_out, DoubleVector energy_bin_widths, int npix, double const & solid_angle)"""
        return _pyLikelihood.HealpixProjMap_convertToDifferential(image_out, energy_bin_widths, npix, solid_angle)

    convertToDifferential = staticmethod(convertToDifferential)

    def convertToIntegral(image_out, image_in, energy_bin_widths, npix, solid_angle):
        """convertToIntegral(FloatVector image_out, std::vector< Healpix_Map< float >,std::allocator< Healpix_Map< float > > > const & image_in, DoubleVector energy_bin_widths, int npix, double const & solid_angle)"""
        return _pyLikelihood.HealpixProjMap_convertToIntegral(image_out, image_in, energy_bin_widths, npix, solid_angle)

    convertToIntegral = staticmethod(convertToIntegral)

    def __init__(self, *args):
        """
        __init__(Likelihood::HealpixProjMap self, std::string const & filename, std::string const & extension, bool interpolate=True, bool enforceEnergyRange=False) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, std::string const & filename, std::string const & extension, bool interpolate=True) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, std::string const & filename, std::string const & extension) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme, double energy=100., bool use_lb=False, double radius=180, double ra=0, double dec=0., bool interpolate=False, bool enforceEnergyRange=False) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme, double energy=100., bool use_lb=False, double radius=180, double ra=0, double dec=0., bool interpolate=False) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme, double energy=100., bool use_lb=False, double radius=180, double ra=0, double dec=0.) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme, double energy=100., bool use_lb=False, double radius=180, double ra=0) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme, double energy=100., bool use_lb=False, double radius=180) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme, double energy=100., bool use_lb=False) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme, double energy=100.) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int order, Healpix_Ordering_Scheme scheme) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5, double energy=100., bool use_lb=False, double radius=180, double ra=0, double dec=0., bool interpolate=False, bool enforceEnergyRange=False) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5, double energy=100., bool use_lb=False, double radius=180, double ra=0, double dec=0., bool interpolate=False) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5, double energy=100., bool use_lb=False, double radius=180, double ra=0, double dec=0.) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5, double energy=100., bool use_lb=False, double radius=180, double ra=0) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5, double energy=100., bool use_lb=False, double radius=180) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5, double energy=100., bool use_lb=False) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5, double energy=100.) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, DiffuseSource diffuseSource, int nside, Healpix_Ordering_Scheme scheme, nside_dummy const arg5) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, CountsMapHealpix theMap, Likelihood::CountsMapBase::ConversionType cType) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, HealpixProjMap arg2, bool copy_image=True) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, HealpixProjMap arg2) -> HealpixProjMap
        __init__(Likelihood::HealpixProjMap self, HealpixProjMap arg2, double const & energy, Healpix_Map< float > const & image) -> HealpixProjMap
        """
        this = _pyLikelihood.new_HealpixProjMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_HealpixProjMap
    __del__ = lambda self: None

    def cast_healpix(self):
        """cast_healpix(HealpixProjMap self) -> HealpixProjMap"""
        return _pyLikelihood.HealpixProjMap_cast_healpix(self)


    def __call__(self, *args):
        """
        __call__(HealpixProjMap self, SkyDir dir, double energy=-1) -> double
        __call__(HealpixProjMap self, SkyDir dir) -> double
        __call__(HealpixProjMap self, SkyDir dir, int k) -> double
        """
        return _pyLikelihood.HealpixProjMap___call__(self, *args)


    def convolveAll(self, psf, exposure=None, performConvolution=True):
        """
        convolveAll(HealpixProjMap self, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True) -> ProjMap
        convolveAll(HealpixProjMap self, MeanPsf psf, BinnedExposureBase exposure=None) -> ProjMap
        convolveAll(HealpixProjMap self, MeanPsf psf) -> ProjMap
        """
        return _pyLikelihood.HealpixProjMap_convolveAll(self, psf, exposure, performConvolution)


    def convolve(self, energy, psf, exposure=None, performConvolution=True, k=0):
        """
        convolve(HealpixProjMap self, double energy, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True, int k=0) -> ProjMap
        convolve(HealpixProjMap self, double energy, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True) -> ProjMap
        convolve(HealpixProjMap self, double energy, MeanPsf psf, BinnedExposureBase exposure=None) -> ProjMap
        convolve(HealpixProjMap self, double energy, MeanPsf psf) -> ProjMap
        """
        return _pyLikelihood.HealpixProjMap_convolve(self, energy, psf, exposure, performConvolution, k)


    def makeCountsMap(self, counts_map):
        """makeCountsMap(HealpixProjMap self, CountsMapBase counts_map) -> CountsMapBase"""
        return _pyLikelihood.HealpixProjMap_makeCountsMap(self, counts_map)


    def solidAngle(self, ilon, ilat):
        """solidAngle(HealpixProjMap self, double ilon, double ilat) -> double"""
        return _pyLikelihood.HealpixProjMap_solidAngle(self, ilon, ilat)


    def solidAngleHealpix(self):
        """solidAngleHealpix(HealpixProjMap self) -> double"""
        return _pyLikelihood.HealpixProjMap_solidAngleHealpix(self)


    def image(self):
        """image(HealpixProjMap self) -> std::vector< Healpix_Map< float >,std::allocator< Healpix_Map< float > > > const &"""
        return _pyLikelihood.HealpixProjMap_image(self)


    def pixelValue(self, ilon, ilat, k=0):
        """
        pixelValue(HealpixProjMap self, double ilon, double ilat, int k=0) -> double
        pixelValue(HealpixProjMap self, double ilon, double ilat) -> double
        """
        return _pyLikelihood.HealpixProjMap_pixelValue(self, ilon, ilat, k)


    def minMaxDistPixels(self, dir):
        """minMaxDistPixels(HealpixProjMap self, SkyDir dir) -> SkyDirPair"""
        return _pyLikelihood.HealpixProjMap_minMaxDistPixels(self, dir)


    def insideMap(self, dir):
        """insideMap(HealpixProjMap self, SkyDir dir) -> bool"""
        return _pyLikelihood.HealpixProjMap_insideMap(self, dir)


    def pixelSize(self):
        """pixelSize(HealpixProjMap self) -> double"""
        return _pyLikelihood.HealpixProjMap_pixelSize(self)


    def rebin(self, factor, average=True):
        """
        rebin(HealpixProjMap self, unsigned int factor, bool average=True) -> ProjMap
        rebin(HealpixProjMap self, unsigned int factor) -> ProjMap
        """
        return _pyLikelihood.HealpixProjMap_rebin(self, factor, average)


    def globalToLocal(self, glo):
        """globalToLocal(HealpixProjMap self, int glo) -> int"""
        return _pyLikelihood.HealpixProjMap_globalToLocal(self, glo)


    def localToGlobal(self, loc):
        """localToGlobal(HealpixProjMap self, int loc) -> int"""
        return _pyLikelihood.HealpixProjMap_localToGlobal(self, loc)


    def nPixels(self):
        """nPixels(HealpixProjMap self) -> int"""
        return _pyLikelihood.HealpixProjMap_nPixels(self)

HealpixProjMap_swigregister = _pyLikelihood.HealpixProjMap_swigregister
HealpixProjMap_swigregister(HealpixProjMap)

def HealpixProjMap_foldVector(vector_in, hp_proj, npix, nebins, image_out):
    """HealpixProjMap_foldVector(FloatVector vector_in, HealpixProj hp_proj, int npix, int nebins, std::vector< Healpix_Map< float >,std::allocator< Healpix_Map< float > > > & image_out)"""
    return _pyLikelihood.HealpixProjMap_foldVector(vector_in, hp_proj, npix, nebins, image_out)

def HealpixProjMap_convertToDifferential(image_out, energy_bin_widths, npix, solid_angle):
    """HealpixProjMap_convertToDifferential(std::vector< Healpix_Map< float >,std::allocator< Healpix_Map< float > > > & image_out, DoubleVector energy_bin_widths, int npix, double const & solid_angle)"""
    return _pyLikelihood.HealpixProjMap_convertToDifferential(image_out, energy_bin_widths, npix, solid_angle)

def HealpixProjMap_convertToIntegral(image_out, image_in, energy_bin_widths, npix, solid_angle):
    """HealpixProjMap_convertToIntegral(FloatVector image_out, std::vector< Healpix_Map< float >,std::allocator< Healpix_Map< float > > > const & image_in, DoubleVector energy_bin_widths, int npix, double const & solid_angle)"""
    return _pyLikelihood.HealpixProjMap_convertToIntegral(image_out, image_in, energy_bin_widths, npix, solid_angle)

class MapBase(_object):
    """Proxy of C++ Likelihood::MapBase class."""

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

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

    def mapIntegral(self, energy):
        """mapIntegral(MapBase self, double energy) -> double"""
        return _pyLikelihood.MapBase_mapIntegral(self, energy)


    def readFitsFile(self, *args):
        """
        readFitsFile(MapBase self, std::string const & fitsFile, std::string const & extension, bool loadMap=True)
        readFitsFile(MapBase self, std::string const & fitsFile, std::string const & extension)
        readFitsFile(MapBase self, std::string const & fitsFile)
        readFitsFile(MapBase self)
        """
        return _pyLikelihood.MapBase_readFitsFile(self, *args)


    def insideMap(self, dir):
        """insideMap(MapBase self, SkyDir dir) -> bool"""
        return _pyLikelihood.MapBase_insideMap(self, dir)


    def getDiffRespLimits(self, dir, mumin, mumax, phimin, phimax):
        """getDiffRespLimits(MapBase self, SkyDir dir, double & mumin, double & mumax, double & phimin, double & phimax)"""
        return _pyLikelihood.MapBase_getDiffRespLimits(self, dir, mumin, mumax, phimin, phimax)


    def getDiffRespLimits_wcs(self, dir, wcsmap, mumin, mumax, phimin, phimax):
        """getDiffRespLimits_wcs(MapBase self, SkyDir dir, WcsMap2 wcsmap, double & mumin, double & mumax, double & phimin, double & phimax)"""
        return _pyLikelihood.MapBase_getDiffRespLimits_wcs(self, dir, wcsmap, mumin, mumax, phimin, phimax)


    def getDiffRespLimits_healpix(self, dir, healmap, mumin, mumax, phimin, phimax):
        """getDiffRespLimits_healpix(MapBase self, SkyDir dir, HealpixProjMap healmap, double & mumin, double & mumax, double & phimin, double & phimax)"""
        return _pyLikelihood.MapBase_getDiffRespLimits_healpix(self, dir, healmap, mumin, mumax, phimin, phimax)


    def fitsFile(self):
        """fitsFile(MapBase self) -> std::string const &"""
        return _pyLikelihood.MapBase_fitsFile(self)


    def projmap(self, *args):
        """
        projmap(MapBase self) -> ProjMap
        projmap(MapBase self) -> ProjMap
        """
        return _pyLikelihood.MapBase_projmap(self, *args)


    def getRefDir(self):
        """getRefDir(MapBase self) -> SkyDir"""
        return _pyLikelihood.MapBase_getRefDir(self)


    def deleteMap(self):
        """deleteMap(MapBase self)"""
        return _pyLikelihood.MapBase_deleteMap(self)


    def update(self):
        """update(MapBase self)"""
        return _pyLikelihood.MapBase_update(self)


    def rebin(self, factor, average=True):
        """
        rebin(MapBase self, unsigned int factor, bool average=True)
        rebin(MapBase self, unsigned int factor)
        """
        return _pyLikelihood.MapBase_rebin(self, factor, average)


    def integrateSpatialDist(self, energies, expmap, exposure):
        """integrateSpatialDist(MapBase self, DoubleVector energies, ExposureMap expmap, DoubleVector exposure)"""
        return _pyLikelihood.MapBase_integrateSpatialDist(self, energies, expmap, exposure)

MapBase_swigregister = _pyLikelihood.MapBase_swigregister
MapBase_swigregister(MapBase)

class MapBaseException(_object):
    """Proxy of C++ Likelihood::MapBaseException class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::MapBaseException self) -> MapBaseException
        __init__(Likelihood::MapBaseException self, std::string errorString) -> MapBaseException
        """
        this = _pyLikelihood.new_MapBaseException(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_MapBaseException
    __del__ = lambda self: None

    def what(self):
        """what(MapBaseException self) -> char const *"""
        return _pyLikelihood.MapBaseException_what(self)

MapBaseException_swigregister = _pyLikelihood.MapBaseException_swigregister
MapBaseException_swigregister(MapBaseException)

class Pixel(_object):
    """Proxy of C++ Likelihood::Pixel class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::Pixel self, double ra=0, double dec=0, double solidAngle=0, ProjBase proj=None) -> Pixel
        __init__(Likelihood::Pixel self, double ra=0, double dec=0, double solidAngle=0) -> Pixel
        __init__(Likelihood::Pixel self, double ra=0, double dec=0) -> Pixel
        __init__(Likelihood::Pixel self, double ra=0) -> Pixel
        __init__(Likelihood::Pixel self) -> Pixel
        __init__(Likelihood::Pixel self, SkyDir dir, double solidAngle, ProjBase proj=None) -> Pixel
        __init__(Likelihood::Pixel self, SkyDir dir, double solidAngle) -> Pixel
        """
        this = _pyLikelihood.new_Pixel(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def modelCounts(self, emin, emax, srcModel):
        """modelCounts(Pixel self, double emin, double emax, SourceModel srcModel) -> double"""
        return _pyLikelihood.Pixel_modelCounts(self, emin, emax, srcModel)


    def getFreeDerivs(self, emin, emax, srcModel, derivs):
        """getFreeDerivs(Pixel self, double emin, double emax, SourceModel srcModel, DoubleVector derivs)"""
        return _pyLikelihood.Pixel_getFreeDerivs(self, emin, emax, srcModel, derivs)


    def dir(self):
        """dir(Pixel self) -> SkyDir"""
        return _pyLikelihood.Pixel_dir(self)


    def solidAngle(self):
        """solidAngle(Pixel self) -> double"""
        return _pyLikelihood.Pixel_solidAngle(self)


    def proj(self):
        """proj(Pixel self) -> ProjBase"""
        return _pyLikelihood.Pixel_proj(self)

    __swig_destroy__ = _pyLikelihood.delete_Pixel
    __del__ = lambda self: None
Pixel_swigregister = _pyLikelihood.Pixel_swigregister
Pixel_swigregister(Pixel)

class PixelVector(_object):
    """Proxy of C++ std::vector<(Likelihood::Pixel)> class."""

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

    def iterator(self):
        """iterator(PixelVector self) -> SwigPyIterator"""
        return _pyLikelihood.PixelVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(PixelVector self) -> bool"""
        return _pyLikelihood.PixelVector___nonzero__(self)


    def __bool__(self):
        """__bool__(PixelVector self) -> bool"""
        return _pyLikelihood.PixelVector___bool__(self)


    def __len__(self):
        """__len__(PixelVector self) -> std::vector< Likelihood::Pixel >::size_type"""
        return _pyLikelihood.PixelVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(PixelVector self, std::vector< Likelihood::Pixel >::difference_type i, std::vector< Likelihood::Pixel >::difference_type j) -> PixelVector"""
        return _pyLikelihood.PixelVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(PixelVector self, std::vector< Likelihood::Pixel >::difference_type i, std::vector< Likelihood::Pixel >::difference_type j)
        __setslice__(PixelVector self, std::vector< Likelihood::Pixel >::difference_type i, std::vector< Likelihood::Pixel >::difference_type j, PixelVector v)
        """
        return _pyLikelihood.PixelVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(PixelVector self, std::vector< Likelihood::Pixel >::difference_type i, std::vector< Likelihood::Pixel >::difference_type j)"""
        return _pyLikelihood.PixelVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(PixelVector self, std::vector< Likelihood::Pixel >::difference_type i)
        __delitem__(PixelVector self, PySliceObject * slice)
        """
        return _pyLikelihood.PixelVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(PixelVector self, PySliceObject * slice) -> PixelVector
        __getitem__(PixelVector self, std::vector< Likelihood::Pixel >::difference_type i) -> Pixel
        """
        return _pyLikelihood.PixelVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(PixelVector self, PySliceObject * slice, PixelVector v)
        __setitem__(PixelVector self, PySliceObject * slice)
        __setitem__(PixelVector self, std::vector< Likelihood::Pixel >::difference_type i, Pixel x)
        """
        return _pyLikelihood.PixelVector___setitem__(self, *args)


    def pop(self):
        """pop(PixelVector self) -> Pixel"""
        return _pyLikelihood.PixelVector_pop(self)


    def append(self, x):
        """append(PixelVector self, Pixel x)"""
        return _pyLikelihood.PixelVector_append(self, x)


    def empty(self):
        """empty(PixelVector self) -> bool"""
        return _pyLikelihood.PixelVector_empty(self)


    def size(self):
        """size(PixelVector self) -> std::vector< Likelihood::Pixel >::size_type"""
        return _pyLikelihood.PixelVector_size(self)


    def swap(self, v):
        """swap(PixelVector self, PixelVector v)"""
        return _pyLikelihood.PixelVector_swap(self, v)


    def begin(self):
        """begin(PixelVector self) -> std::vector< Likelihood::Pixel >::iterator"""
        return _pyLikelihood.PixelVector_begin(self)


    def end(self):
        """end(PixelVector self) -> std::vector< Likelihood::Pixel >::iterator"""
        return _pyLikelihood.PixelVector_end(self)


    def rbegin(self):
        """rbegin(PixelVector self) -> std::vector< Likelihood::Pixel >::reverse_iterator"""
        return _pyLikelihood.PixelVector_rbegin(self)


    def rend(self):
        """rend(PixelVector self) -> std::vector< Likelihood::Pixel >::reverse_iterator"""
        return _pyLikelihood.PixelVector_rend(self)


    def clear(self):
        """clear(PixelVector self)"""
        return _pyLikelihood.PixelVector_clear(self)


    def get_allocator(self):
        """get_allocator(PixelVector self) -> std::vector< Likelihood::Pixel >::allocator_type"""
        return _pyLikelihood.PixelVector_get_allocator(self)


    def pop_back(self):
        """pop_back(PixelVector self)"""
        return _pyLikelihood.PixelVector_pop_back(self)


    def erase(self, *args):
        """
        erase(PixelVector self, std::vector< Likelihood::Pixel >::iterator pos) -> std::vector< Likelihood::Pixel >::iterator
        erase(PixelVector self, std::vector< Likelihood::Pixel >::iterator first, std::vector< Likelihood::Pixel >::iterator last) -> std::vector< Likelihood::Pixel >::iterator
        """
        return _pyLikelihood.PixelVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(Likelihood::Pixel)> self) -> PixelVector
        __init__(std::vector<(Likelihood::Pixel)> self, PixelVector arg2) -> PixelVector
        __init__(std::vector<(Likelihood::Pixel)> self, std::vector< Likelihood::Pixel >::size_type size) -> PixelVector
        __init__(std::vector<(Likelihood::Pixel)> self, std::vector< Likelihood::Pixel >::size_type size, Pixel value) -> PixelVector
        """
        this = _pyLikelihood.new_PixelVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(PixelVector self, Pixel x)"""
        return _pyLikelihood.PixelVector_push_back(self, x)


    def front(self):
        """front(PixelVector self) -> Pixel"""
        return _pyLikelihood.PixelVector_front(self)


    def back(self):
        """back(PixelVector self) -> Pixel"""
        return _pyLikelihood.PixelVector_back(self)


    def assign(self, n, x):
        """assign(PixelVector self, std::vector< Likelihood::Pixel >::size_type n, Pixel x)"""
        return _pyLikelihood.PixelVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(PixelVector self, std::vector< Likelihood::Pixel >::size_type new_size)
        resize(PixelVector self, std::vector< Likelihood::Pixel >::size_type new_size, Pixel x)
        """
        return _pyLikelihood.PixelVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(PixelVector self, std::vector< Likelihood::Pixel >::iterator pos, Pixel x) -> std::vector< Likelihood::Pixel >::iterator
        insert(PixelVector self, std::vector< Likelihood::Pixel >::iterator pos, std::vector< Likelihood::Pixel >::size_type n, Pixel x)
        """
        return _pyLikelihood.PixelVector_insert(self, *args)


    def reserve(self, n):
        """reserve(PixelVector self, std::vector< Likelihood::Pixel >::size_type n)"""
        return _pyLikelihood.PixelVector_reserve(self, n)


    def capacity(self):
        """capacity(PixelVector self) -> std::vector< Likelihood::Pixel >::size_type"""
        return _pyLikelihood.PixelVector_capacity(self)

    __swig_destroy__ = _pyLikelihood.delete_PixelVector
    __del__ = lambda self: None
PixelVector_swigregister = _pyLikelihood.PixelVector_swigregister
PixelVector_swigregister(PixelVector)

class SourceMap(_object):
    """Proxy of C++ Likelihood::SourceMap class."""

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

    def fill_sparse_model(vect, sparse):
        """fill_sparse_model(FloatVector vect, SparseFloatVector sparse)"""
        return _pyLikelihood.SourceMap_fill_sparse_model(vect, sparse)

    fill_sparse_model = staticmethod(fill_sparse_model)

    def fill_full_model(sparse, vect):
        """fill_full_model(SparseFloatVector sparse, FloatVector vect)"""
        return _pyLikelihood.SourceMap_fill_full_model(sparse, vect)

    fill_full_model = staticmethod(fill_full_model)

    def __init__(self, *args):
        """
        __init__(Likelihood::SourceMap self, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config, Drm drm=None, WeightMap weights=None, bool save_model=False) -> SourceMap
        __init__(Likelihood::SourceMap self, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config, Drm drm=None, WeightMap weights=None) -> SourceMap
        __init__(Likelihood::SourceMap self, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config, Drm drm=None) -> SourceMap
        __init__(Likelihood::SourceMap self, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config) -> SourceMap
        __init__(Likelihood::SourceMap self, std::string const & sourceMapsFile, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config, WeightMap weights=None, Drm drm=None, bool save_model=False) -> SourceMap
        __init__(Likelihood::SourceMap self, std::string const & sourceMapsFile, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config, WeightMap weights=None, Drm drm=None) -> SourceMap
        __init__(Likelihood::SourceMap self, std::string const & sourceMapsFile, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config, WeightMap weights=None) -> SourceMap
        __init__(Likelihood::SourceMap self, std::string const & sourceMapsFile, Source src, BinnedCountsCache dataCache, Observation observation, BinnedLikeConfig config) -> SourceMap
        __init__(Likelihood::SourceMap self, SourceMap other) -> SourceMap
        """
        this = _pyLikelihood.new_SourceMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_SourceMap
    __del__ = lambda self: None

    def src(self):
        """src(SourceMap self) -> Source"""
        return _pyLikelihood.SourceMap_src(self)


    def name(self):
        """name(SourceMap self) -> std::string const &"""
        return _pyLikelihood.SourceMap_name(self)


    def srcType(self):
        """srcType(SourceMap self) -> std::string const &"""
        return _pyLikelihood.SourceMap_srcType(self)


    def config(self):
        """config(SourceMap self) -> BinnedLikeConfig"""
        return _pyLikelihood.SourceMap_config(self)


    def drm(self):
        """drm(SourceMap self) -> Drm"""
        return _pyLikelihood.SourceMap_drm(self)


    def weights(self):
        """weights(SourceMap self) -> WeightMap"""
        return _pyLikelihood.SourceMap_weights(self)


    def mapType(self):
        """mapType(SourceMap self) -> Likelihood::FileUtils::SrcMapType"""
        return _pyLikelihood.SourceMap_mapType(self)


    def save_model(self):
        """save_model(SourceMap self) -> bool"""
        return _pyLikelihood.SourceMap_save_model(self)


    def model_is_local(self):
        """model_is_local(SourceMap self) -> bool"""
        return _pyLikelihood.SourceMap_model_is_local(self)


    def clear_model(self, force=False):
        """
        clear_model(SourceMap self, bool force=False)
        clear_model(SourceMap self)
        """
        return _pyLikelihood.SourceMap_clear_model(self, force)


    def setSource(self, src):
        """setSource(SourceMap self, Source src)"""
        return _pyLikelihood.SourceMap_setSource(self, src)


    def update_drm_cache(self, drm, force=False):
        """
        update_drm_cache(SourceMap self, Drm drm, bool force=False) -> Drm_Cache
        update_drm_cache(SourceMap self, Drm drm) -> Drm_Cache
        """
        return _pyLikelihood.SourceMap_update_drm_cache(self, drm, force)


    def setSpectralValues(self, energies, latch_params=False):
        """
        setSpectralValues(SourceMap self, DoubleVector energies, bool latch_params=False)
        setSpectralValues(SourceMap self, DoubleVector energies)
        """
        return _pyLikelihood.SourceMap_setSpectralValues(self, energies, latch_params)


    def setSpectralDerivs(self, energies, paramNames):
        """setSpectralDerivs(SourceMap self, DoubleVector energies, StringVector paramNames)"""
        return _pyLikelihood.SourceMap_setSpectralDerivs(self, energies, paramNames)


    def spectrum_changed(self):
        """spectrum_changed(SourceMap self) -> bool"""
        return _pyLikelihood.SourceMap_spectrum_changed(self)


    def edisp_type(self):
        """edisp_type(SourceMap self) -> int"""
        return _pyLikelihood.SourceMap_edisp_type(self)


    def summed_counts(self, kmin, kmax, edisp_val=0, use_weighted=False):
        """
        summed_counts(SourceMap self, size_t kmin, size_t kmax, int edisp_val=0, bool use_weighted=False) -> double
        summed_counts(SourceMap self, size_t kmin, size_t kmax, int edisp_val=0) -> double
        summed_counts(SourceMap self, size_t kmin, size_t kmax) -> double
        """
        return _pyLikelihood.SourceMap_summed_counts(self, kmin, kmax, edisp_val, use_weighted)


    def cached_model(self):
        """cached_model(SourceMap self) -> FloatVector"""
        return _pyLikelihood.SourceMap_cached_model(self)


    def cached_sparse_model(self):
        """cached_sparse_model(SourceMap self) -> SparseFloatVector"""
        return _pyLikelihood.SourceMap_cached_sparse_model(self)


    def cached_specValues(self):
        """cached_specValues(SourceMap self) -> DoubleVector"""
        return _pyLikelihood.SourceMap_cached_specValues(self)


    def cached_specWts(self):
        """cached_specWts(SourceMap self) -> DoubleVectorPair"""
        return _pyLikelihood.SourceMap_cached_specWts(self)


    def cached_specDerivs(self):
        """cached_specDerivs(SourceMap self) -> DoubleVectorVector"""
        return _pyLikelihood.SourceMap_cached_specDerivs(self)


    def cached_npreds(self):
        """cached_npreds(SourceMap self) -> DoubleVector"""
        return _pyLikelihood.SourceMap_cached_npreds(self)


    def cached_weighted_npreds(self):
        """cached_weighted_npreds(SourceMap self) -> std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > const &"""
        return _pyLikelihood.SourceMap_cached_weighted_npreds(self)


    def cached_drm_Cache(self):
        """cached_drm_Cache(SourceMap self) -> Drm_Cache"""
        return _pyLikelihood.SourceMap_cached_drm_Cache(self)


    def cached_drm(self):
        """cached_drm(SourceMap self) -> Drm"""
        return _pyLikelihood.SourceMap_cached_drm(self)


    def cached_meanPsf(self):
        """cached_meanPsf(SourceMap self) -> MeanPsf"""
        return _pyLikelihood.SourceMap_cached_meanPsf(self)


    def dataCache(self):
        """dataCache(SourceMap self) -> BinnedCountsCache"""
        return _pyLikelihood.SourceMap_dataCache(self)


    def model(self, force=False):
        """
        model(SourceMap self, bool force=False) -> FloatVector
        model(SourceMap self) -> FloatVector
        """
        return _pyLikelihood.SourceMap_model(self, force)


    def specVals(self, force=False):
        """
        specVals(SourceMap self, bool force=False) -> DoubleVector
        specVals(SourceMap self) -> DoubleVector
        """
        return _pyLikelihood.SourceMap_specVals(self, force)


    def specWts(self, force=False):
        """
        specWts(SourceMap self, bool force=False) -> DoubleVectorPair
        specWts(SourceMap self) -> DoubleVectorPair
        """
        return _pyLikelihood.SourceMap_specWts(self, force)


    def specDerivs(self, paramNames, force=False):
        """
        specDerivs(SourceMap self, StringVector paramNames, bool force=False) -> DoubleVectorVector
        specDerivs(SourceMap self, StringVector paramNames) -> DoubleVectorVector
        """
        return _pyLikelihood.SourceMap_specDerivs(self, paramNames, force)


    def npreds(self, force=False):
        """
        npreds(SourceMap self, bool force=False) -> DoubleVector
        npreds(SourceMap self) -> DoubleVector
        """
        return _pyLikelihood.SourceMap_npreds(self, force)


    def weighted_npreds(self, force=False):
        """
        weighted_npreds(SourceMap self, bool force=False) -> std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > const
        weighted_npreds(SourceMap self) -> std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > const &
        """
        return _pyLikelihood.SourceMap_weighted_npreds(self, force)


    def drm_cache(self, force=False):
        """
        drm_cache(SourceMap self, bool force=False) -> Drm_Cache
        drm_cache(SourceMap self) -> Drm_Cache
        """
        return _pyLikelihood.SourceMap_drm_cache(self, force)


    def addToVector(self, vect, includeSpec=False, kmin=0, kmax=-1):
        """
        addToVector(SourceMap self, FloatVector vect, bool includeSpec=False, int kmin=0, int kmax=-1)
        addToVector(SourceMap self, FloatVector vect, bool includeSpec=False, int kmin=0)
        addToVector(SourceMap self, FloatVector vect, bool includeSpec=False)
        addToVector(SourceMap self, FloatVector vect)
        """
        return _pyLikelihood.SourceMap_addToVector(self, vect, includeSpec, kmin, kmax)


    def subtractFromVector(self, vect, includeSpec=False, kmin=0, kmax=-1):
        """
        subtractFromVector(SourceMap self, FloatVector vect, bool includeSpec=False, int kmin=0, int kmax=-1)
        subtractFromVector(SourceMap self, FloatVector vect, bool includeSpec=False, int kmin=0)
        subtractFromVector(SourceMap self, FloatVector vect, bool includeSpec=False)
        subtractFromVector(SourceMap self, FloatVector vect)
        """
        return _pyLikelihood.SourceMap_subtractFromVector(self, vect, includeSpec, kmin, kmax)


    def setImage(self, model):
        """setImage(SourceMap self, FloatVector model)"""
        return _pyLikelihood.SourceMap_setImage(self, model)


    def setWeights(self, weights):
        """setWeights(SourceMap self, WeightMap weights)"""
        return _pyLikelihood.SourceMap_setWeights(self, weights)


    def setSaveModel(self, val):
        """setSaveModel(SourceMap self, bool val)"""
        return _pyLikelihood.SourceMap_setSaveModel(self, val)


    def setFilename(self, filename):
        """setFilename(SourceMap self, std::string const & filename)"""
        return _pyLikelihood.SourceMap_setFilename(self, filename)


    def setModelIsLocal(self, val):
        """setModelIsLocal(SourceMap self, bool val)"""
        return _pyLikelihood.SourceMap_setModelIsLocal(self, val)


    def memory_size(self):
        """memory_size(SourceMap self) -> size_t"""
        return _pyLikelihood.SourceMap_memory_size(self)


    def test_sparse(self, prefix):
        """test_sparse(SourceMap self, std::string const & prefix)"""
        return _pyLikelihood.SourceMap_test_sparse(self, prefix)

SourceMap_swigregister = _pyLikelihood.SourceMap_swigregister
SourceMap_swigregister(SourceMap)

def SourceMap_fill_sparse_model(vect, sparse):
    """SourceMap_fill_sparse_model(FloatVector vect, SparseFloatVector sparse)"""
    return _pyLikelihood.SourceMap_fill_sparse_model(vect, sparse)

def SourceMap_fill_full_model(sparse, vect):
    """SourceMap_fill_full_model(SparseFloatVector sparse, FloatVector vect)"""
    return _pyLikelihood.SourceMap_fill_full_model(sparse, vect)

class WcsMap2(ProjMap):
    """Proxy of C++ Likelihood::WcsMap2 class."""

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

    def foldVector(vector_in, naxis1, naxis2, naxis3, image_out):
        """foldVector(FloatVector vector_in, int naxis1, int naxis2, int naxis3, std::vector< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >,std::allocator< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > > > & image_out)"""
        return _pyLikelihood.WcsMap2_foldVector(vector_in, naxis1, naxis2, naxis3, image_out)

    foldVector = staticmethod(foldVector)

    def fillSolidAngles(pixels, naxis1, naxis2, image_out):
        """fillSolidAngles(PixelVector pixels, int naxis1, int naxis2, FloatVectorVector image_out)"""
        return _pyLikelihood.WcsMap2_fillSolidAngles(pixels, naxis1, naxis2, image_out)

    fillSolidAngles = staticmethod(fillSolidAngles)

    def convertToDifferential(image_out, energy_bin_widths, solid_angles):
        """convertToDifferential(std::vector< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >,std::allocator< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > > > & image_out, DoubleVector energy_bin_widths, FloatVectorVector solid_angles)"""
        return _pyLikelihood.WcsMap2_convertToDifferential(image_out, energy_bin_widths, solid_angles)

    convertToDifferential = staticmethod(convertToDifferential)

    def convertToIntegral(image_out, image_in, energy_bin_widths, solid_angles):
        """convertToIntegral(FloatVector image_out, std::vector< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >,std::allocator< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > > > const & image_in, DoubleVector energy_bin_widths, FloatVectorVector solid_angles)"""
        return _pyLikelihood.WcsMap2_convertToIntegral(image_out, image_in, energy_bin_widths, solid_angles)

    convertToIntegral = staticmethod(convertToIntegral)

    def __init__(self, *args):
        """
        __init__(Likelihood::WcsMap2 self, std::string const & filename, std::string const & extension, bool interpolate=True, bool enforceEnergyRange=False, bool computeIntegrals=True) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, std::string const & filename, std::string const & extension, bool interpolate=True, bool enforceEnergyRange=False) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, std::string const & filename, std::string const & extension, bool interpolate=True) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, std::string const & filename, std::string const & extension) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, std::string const & filename) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double pix_size, int npts, double energy=100., std::string const & proj_name, bool use_lb=False, bool interpolate=False, bool enforceEnergyRange=False, bool computeIntegrals=True) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double pix_size, int npts, double energy=100., std::string const & proj_name, bool use_lb=False, bool interpolate=False, bool enforceEnergyRange=False) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double pix_size, int npts, double energy=100., std::string const & proj_name, bool use_lb=False, bool interpolate=False) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double pix_size, int npts, double energy=100., std::string const & proj_name, bool use_lb=False) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double pix_size, int npts, double energy=100., std::string const & proj_name) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double pix_size, int npts, double energy=100.) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double pix_size, int npts) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double crpix1, double crpix2, double cdelt1, double cdelt2, int naxis1, int naxis2, double energy=100., std::string const & proj_name, bool use_lb=False, bool interpolate=False, bool enforceEnergyRange=False, bool computeIntegrals=True) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double crpix1, double crpix2, double cdelt1, double cdelt2, int naxis1, int naxis2, double energy=100., std::string const & proj_name, bool use_lb=False, bool interpolate=False, bool enforceEnergyRange=False) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double crpix1, double crpix2, double cdelt1, double cdelt2, int naxis1, int naxis2, double energy=100., std::string const & proj_name, bool use_lb=False, bool interpolate=False) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double crpix1, double crpix2, double cdelt1, double cdelt2, int naxis1, int naxis2, double energy=100., std::string const & proj_name, bool use_lb=False) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double crpix1, double crpix2, double cdelt1, double cdelt2, int naxis1, int naxis2, double energy=100., std::string const & proj_name) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double crpix1, double crpix2, double cdelt1, double cdelt2, int naxis1, int naxis2, double energy=100.) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, DiffuseSource diffuseSource, double ra, double dec, double crpix1, double crpix2, double cdelt1, double cdelt2, int naxis1, int naxis2) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, CountsMap theMap, Likelihood::CountsMapBase::ConversionType cType) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, WcsMap2 arg2, bool copy_image=True) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, WcsMap2 arg2) -> WcsMap2
        __init__(Likelihood::WcsMap2 self, WcsMap2 arg2, double const & energy, FloatVectorVector image) -> WcsMap2
        """
        this = _pyLikelihood.new_WcsMap2(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_WcsMap2
    __del__ = lambda self: None

    def cast_wcs(self):
        """cast_wcs(WcsMap2 self) -> WcsMap2"""
        return _pyLikelihood.WcsMap2_cast_wcs(self)


    def __call__(self, *args):
        """
        __call__(WcsMap2 self, SkyDir dir, double energy=-1) -> double
        __call__(WcsMap2 self, SkyDir dir) -> double
        __call__(WcsMap2 self, SkyDir dir, int k) -> double
        """
        return _pyLikelihood.WcsMap2___call__(self, *args)


    def convolveAll(self, psf, exposure=None, performConvolution=True):
        """
        convolveAll(WcsMap2 self, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True) -> ProjMap
        convolveAll(WcsMap2 self, MeanPsf psf, BinnedExposureBase exposure=None) -> ProjMap
        convolveAll(WcsMap2 self, MeanPsf psf) -> ProjMap
        """
        return _pyLikelihood.WcsMap2_convolveAll(self, psf, exposure, performConvolution)


    def convolve(self, *args):
        """
        convolve(WcsMap2 self, double energy, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True, int k=0) -> ProjMap
        convolve(WcsMap2 self, double energy, MeanPsf psf, BinnedExposureBase exposure=None, bool performConvolution=True) -> ProjMap
        convolve(WcsMap2 self, double energy, MeanPsf psf, BinnedExposureBase exposure=None) -> ProjMap
        convolve(WcsMap2 self, double energy, MeanPsf psf) -> ProjMap
        convolve(WcsMap2 self, double energy, MeanPsf psf, BinnedExposureBase exposure, SpatialFunction fn, bool performConvolution=True, int k=0) -> ProjMap
        convolve(WcsMap2 self, double energy, MeanPsf psf, BinnedExposureBase exposure, SpatialFunction fn, bool performConvolution=True) -> ProjMap
        convolve(WcsMap2 self, double energy, MeanPsf psf, BinnedExposureBase exposure, SpatialFunction fn) -> ProjMap
        """
        return _pyLikelihood.WcsMap2_convolve(self, *args)


    def makeCountsMap(self, counts_map):
        """makeCountsMap(WcsMap2 self, CountsMapBase counts_map) -> CountsMapBase"""
        return _pyLikelihood.WcsMap2_makeCountsMap(self, counts_map)


    def image(self):
        """image(WcsMap2 self) -> std::vector< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >,std::allocator< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > > > const &"""
        return _pyLikelihood.WcsMap2_image(self)


    def solidAngle(self, *args):
        """
        solidAngle(WcsMap2 self, ProjBase proj, double ilon, double ilat) -> double
        solidAngle(WcsMap2 self, double ilon, double ilat) -> double
        """
        return _pyLikelihood.WcsMap2_solidAngle(self, *args)


    def solidAngles(self):
        """solidAngles(WcsMap2 self) -> FloatVectorVector"""
        return _pyLikelihood.WcsMap2_solidAngles(self)


    def pixelValue(self, ilon, ilat, k=0):
        """
        pixelValue(WcsMap2 self, double ilon, double ilat, int k=0) -> double
        pixelValue(WcsMap2 self, double ilon, double ilat) -> double
        """
        return _pyLikelihood.WcsMap2_pixelValue(self, ilon, ilat, k)


    def nxpix(self):
        """nxpix(WcsMap2 self) -> int"""
        return _pyLikelihood.WcsMap2_nxpix(self)


    def nypix(self):
        """nypix(WcsMap2 self) -> int"""
        return _pyLikelihood.WcsMap2_nypix(self)


    def minMaxDistPixels(self, dir):
        """minMaxDistPixels(WcsMap2 self, SkyDir dir) -> SkyDirPair"""
        return _pyLikelihood.WcsMap2_minMaxDistPixels(self, dir)


    def insideMap(self, dir):
        """insideMap(WcsMap2 self, SkyDir dir) -> bool"""
        return _pyLikelihood.WcsMap2_insideMap(self, dir)


    def pixelSize(self):
        """pixelSize(WcsMap2 self) -> double"""
        return _pyLikelihood.WcsMap2_pixelSize(self)


    def getCorners(self, corners):
        """getCorners(WcsMap2 self, SkyDirVector corners)"""
        return _pyLikelihood.WcsMap2_getCorners(self, corners)


    def cdelt1(self):
        """cdelt1(WcsMap2 self) -> double"""
        return _pyLikelihood.WcsMap2_cdelt1(self)


    def cdelt2(self):
        """cdelt2(WcsMap2 self) -> double"""
        return _pyLikelihood.WcsMap2_cdelt2(self)


    def rebin(self, factor, average=True):
        """
        rebin(WcsMap2 self, unsigned int factor, bool average=True) -> ProjMap
        rebin(WcsMap2 self, unsigned int factor) -> ProjMap
        """
        return _pyLikelihood.WcsMap2_rebin(self, factor, average)


    def crval1(self):
        """crval1(WcsMap2 self) -> double"""
        return _pyLikelihood.WcsMap2_crval1(self)


    def crval2(self):
        """crval2(WcsMap2 self) -> double"""
        return _pyLikelihood.WcsMap2_crval2(self)


    def periodic(self):
        """periodic(WcsMap2 self) -> bool"""
        return _pyLikelihood.WcsMap2_periodic(self)

WcsMap2_swigregister = _pyLikelihood.WcsMap2_swigregister
WcsMap2_swigregister(WcsMap2)

def WcsMap2_foldVector(vector_in, naxis1, naxis2, naxis3, image_out):
    """WcsMap2_foldVector(FloatVector vector_in, int naxis1, int naxis2, int naxis3, std::vector< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >,std::allocator< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > > > & image_out)"""
    return _pyLikelihood.WcsMap2_foldVector(vector_in, naxis1, naxis2, naxis3, image_out)

def WcsMap2_fillSolidAngles(pixels, naxis1, naxis2, image_out):
    """WcsMap2_fillSolidAngles(PixelVector pixels, int naxis1, int naxis2, FloatVectorVector image_out)"""
    return _pyLikelihood.WcsMap2_fillSolidAngles(pixels, naxis1, naxis2, image_out)

def WcsMap2_convertToDifferential(image_out, energy_bin_widths, solid_angles):
    """WcsMap2_convertToDifferential(std::vector< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >,std::allocator< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > > > & image_out, DoubleVector energy_bin_widths, FloatVectorVector solid_angles)"""
    return _pyLikelihood.WcsMap2_convertToDifferential(image_out, energy_bin_widths, solid_angles)

def WcsMap2_convertToIntegral(image_out, image_in, energy_bin_widths, solid_angles):
    """WcsMap2_convertToIntegral(FloatVector image_out, std::vector< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >,std::allocator< std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > > > const & image_in, DoubleVector energy_bin_widths, FloatVectorVector solid_angles)"""
    return _pyLikelihood.WcsMap2_convertToIntegral(image_out, image_in, energy_bin_widths, solid_angles)

class BinnedExposure(BinnedExposureBase):
    """Proxy of C++ Likelihood::BinnedExposure class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::BinnedExposure self) -> BinnedExposure
        __init__(Likelihood::BinnedExposure self, CountsMap cmap, Observation observation, bool useEbounds=True, AppParGroup pars=None) -> BinnedExposure
        __init__(Likelihood::BinnedExposure self, CountsMap cmap, Observation observation, bool useEbounds=True) -> BinnedExposure
        __init__(Likelihood::BinnedExposure self, CountsMap cmap, Observation observation) -> BinnedExposure
        __init__(Likelihood::BinnedExposure self, DoubleVector energies, Observation observation, AppParGroup pars=None) -> BinnedExposure
        __init__(Likelihood::BinnedExposure self, DoubleVector energies, Observation observation) -> BinnedExposure
        __init__(Likelihood::BinnedExposure self, std::string const & filename) -> BinnedExposure
        """
        this = _pyLikelihood.new_BinnedExposure(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_BinnedExposure
    __del__ = lambda self: None

    def __call__(self, energy, ra, dec):
        """__call__(BinnedExposure self, double energy, double ra, double dec) -> double"""
        return _pyLikelihood.BinnedExposure___call__(self, energy, ra, dec)


    def get_exposures_for_dir(self, dir, energies, exposures):
        """get_exposures_for_dir(BinnedExposure self, SkyDir dir, DoubleVector energies, DoubleVector exposures)"""
        return _pyLikelihood.BinnedExposure_get_exposures_for_dir(self, dir, energies, exposures)


    def writeOutput(self, filename):
        """writeOutput(BinnedExposure self, std::string const & filename)"""
        return _pyLikelihood.BinnedExposure_writeOutput(self, filename)

BinnedExposure_swigregister = _pyLikelihood.BinnedExposure_swigregister
BinnedExposure_swigregister(BinnedExposure)

class BinnedHealpixExposure(BinnedExposureBase):
    """Proxy of C++ Likelihood::BinnedHealpixExposure class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::BinnedHealpixExposure self, evtbin::HealpixMap const & cmap, Observation observation, bool useEbounds=True, AppParGroup pars=None) -> BinnedHealpixExposure
        __init__(Likelihood::BinnedHealpixExposure self, evtbin::HealpixMap const & cmap, Observation observation, bool useEbounds=True) -> BinnedHealpixExposure
        __init__(Likelihood::BinnedHealpixExposure self, evtbin::HealpixMap const & cmap, Observation observation) -> BinnedHealpixExposure
        __init__(Likelihood::BinnedHealpixExposure self, DoubleVector energies, Observation observation, AppParGroup pars=None) -> BinnedHealpixExposure
        __init__(Likelihood::BinnedHealpixExposure self, DoubleVector energies, Observation observation) -> BinnedHealpixExposure
        __init__(Likelihood::BinnedHealpixExposure self, std::string const & filename) -> BinnedHealpixExposure
        """
        this = _pyLikelihood.new_BinnedHealpixExposure(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_BinnedHealpixExposure
    __del__ = lambda self: None

    def __call__(self, energy, ra, dec):
        """__call__(BinnedHealpixExposure self, double energy, double ra, double dec) -> double"""
        return _pyLikelihood.BinnedHealpixExposure___call__(self, energy, ra, dec)


    def get_exposures_for_dir(self, dir, energies, exposures):
        """get_exposures_for_dir(BinnedHealpixExposure self, SkyDir dir, DoubleVector energies, DoubleVector exposures)"""
        return _pyLikelihood.BinnedHealpixExposure_get_exposures_for_dir(self, dir, energies, exposures)


    def writeOutput(self, filename):
        """writeOutput(BinnedHealpixExposure self, std::string const & filename)"""
        return _pyLikelihood.BinnedHealpixExposure_writeOutput(self, filename)

BinnedHealpixExposure_swigregister = _pyLikelihood.BinnedHealpixExposure_swigregister
BinnedHealpixExposure_swigregister(BinnedHealpixExposure)

class EventContainer(_object):
    """Proxy of C++ Likelihood::EventContainer class."""

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

    def __init__(self, respFuncs, roiCuts, scData):
        """__init__(Likelihood::EventContainer self, ResponseFunctions respFuncs, RoiCuts roiCuts, ScData scData) -> EventContainer"""
        this = _pyLikelihood.new_EventContainer(respFuncs, roiCuts, scData)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_EventContainer
    __del__ = lambda self: None

    def getEvents(self, event_file, apply_roi_cut=True, event_type_mask=3):
        """
        getEvents(EventContainer self, std::string event_file, bool apply_roi_cut=True, unsigned int event_type_mask=3)
        getEvents(EventContainer self, std::string event_file, bool apply_roi_cut=True)
        getEvents(EventContainer self, std::string event_file)
        """
        return _pyLikelihood.EventContainer_getEvents(self, event_file, apply_roi_cut, event_type_mask)


    def computeEventResponses(self, *args):
        """
        computeEventResponses(EventContainer self, Source src, double sr_radius=30.)
        computeEventResponses(EventContainer self, Source src)
        computeEventResponses(EventContainer self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs, double sr_radius=30.)
        computeEventResponses(EventContainer self, std::vector< Likelihood::DiffuseSource *,std::allocator< Likelihood::DiffuseSource * > > & srcs)
        """
        return _pyLikelihood.EventContainer_computeEventResponses(self, *args)


    def nobs(self, ebounds, src=None):
        """
        nobs(EventContainer self, DoubleVector ebounds, Source src=None) -> DoubleVector
        nobs(EventContainer self, DoubleVector ebounds) -> DoubleVector
        """
        return _pyLikelihood.EventContainer_nobs(self, ebounds, src)


    def nEvents(self):
        """nEvents(EventContainer self) -> unsigned long"""
        return _pyLikelihood.EventContainer_nEvents(self)


    def events(self, *args):
        """
        events(EventContainer self) -> EventVector
        events(EventContainer self) -> EventVector
        """
        return _pyLikelihood.EventContainer_events(self, *args)


    def clear(self):
        """clear(EventContainer self)"""
        return _pyLikelihood.EventContainer_clear(self)

EventContainer_swigregister = _pyLikelihood.EventContainer_swigregister
EventContainer_swigregister(EventContainer)

class MapCubeFunction2(Function, MapBase):
    """Proxy of C++ Likelihood::MapCubeFunction2 class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::MapCubeFunction2 self) -> MapCubeFunction2
        __init__(Likelihood::MapCubeFunction2 self, std::string const & fitsFile) -> MapCubeFunction2
        __init__(Likelihood::MapCubeFunction2 self, MapCubeFunction2 arg2) -> MapCubeFunction2
        """
        this = _pyLikelihood.new_MapCubeFunction2(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_MapCubeFunction2
    __del__ = lambda self: None

    def value(self, arg2):
        """value(MapCubeFunction2 self, Arg arg2) -> double"""
        return _pyLikelihood.MapCubeFunction2_value(self, arg2)


    def derivByParamImp(self, dir, paramName):
        """derivByParamImp(MapCubeFunction2 self, Arg dir, std::string const & paramName) -> double"""
        return _pyLikelihood.MapCubeFunction2_derivByParamImp(self, dir, paramName)


    def clone(self):
        """clone(MapCubeFunction2 self) -> MapCubeFunction2"""
        return _pyLikelihood.MapCubeFunction2_clone(self)


    def mapIntegral(self, *args):
        """
        mapIntegral(MapCubeFunction2 self) -> double
        mapIntegral(MapCubeFunction2 self, double energy) -> double
        """
        return _pyLikelihood.MapCubeFunction2_mapIntegral(self, *args)


    def integrateSpatialDist(self, energies, expmap, exposure):
        """integrateSpatialDist(MapCubeFunction2 self, DoubleVector energies, ExposureMap expmap, DoubleVector exposure)"""
        return _pyLikelihood.MapCubeFunction2_integrateSpatialDist(self, energies, expmap, exposure)


    def integrateSpatialDist_wcs(self, energies, expmap, wcsmap, exposure):
        """integrateSpatialDist_wcs(MapCubeFunction2 self, DoubleVector energies, ExposureMap expmap, WcsMap2 wcsmap, DoubleVector exposure)"""
        return _pyLikelihood.MapCubeFunction2_integrateSpatialDist_wcs(self, energies, expmap, wcsmap, exposure)


    def integrateSpatialDist_healpix(self, energies, expmap, healmap, exposure):
        """integrateSpatialDist_healpix(MapCubeFunction2 self, DoubleVector energies, ExposureMap expmap, HealpixProjMap healmap, DoubleVector exposure)"""
        return _pyLikelihood.MapCubeFunction2_integrateSpatialDist_healpix(self, energies, expmap, healmap, exposure)

MapCubeFunction2_swigregister = _pyLikelihood.MapCubeFunction2_swigregister
MapCubeFunction2_swigregister(MapCubeFunction2)


def get_index_and_remainder(val, n, i, rem):
    """get_index_and_remainder(double val, size_t n, size_t & i, double & rem)"""
    return _pyLikelihood.get_index_and_remainder(val, n, i, rem)

def bilinear_on_grid(x, y, z):
    """bilinear_on_grid(double x, double y, DoubleVectorVector z) -> double"""
    return _pyLikelihood.bilinear_on_grid(x, y, z)

def test_bilinear(x, y, z):
    """test_bilinear(double x, double y, DoubleVectorVector z) -> double"""
    return _pyLikelihood.test_bilinear(x, y, z)

def maxRadius(pixels, dir):
    """maxRadius(PixelVector pixels, SkyDir dir) -> double"""
    return _pyLikelihood.maxRadius(pixels, dir)

def maxPsfRadius(src, dataMap):
    """maxPsfRadius(PointSource src, CountsMap dataMap) -> double"""
    return _pyLikelihood.maxPsfRadius(src, dataMap)

def neededMapSize(src, dataMap):
    """neededMapSize(DiffuseSource src, CountsMapBase dataMap) -> double"""
    return _pyLikelihood.neededMapSize(src, dataMap)

def fillHealpixFromWcsMap(*args):
    """
    fillHealpixFromWcsMap(WcsMap2 inputMap, HealpixProj proj, Healpix_Map< float > & hpm)
    fillHealpixFromWcsMap(WcsMap2 inputMap, HealpixProj proj, std::vector< int,std::allocator< int > > const & pixList, Healpix_Map< float > & hpm)
    """
    return _pyLikelihood.fillHealpixFromWcsMap(*args)

def build_psf(src, dataMap, obs):
    """build_psf(Source src, CountsMapBase dataMap, Observation obs) -> MeanPsf"""
    return _pyLikelihood.build_psf(src, dataMap, obs)

def haveMapCubeFunction(src):
    """haveMapCubeFunction(DiffuseSource src) -> bool"""
    return _pyLikelihood.haveMapCubeFunction(src)

def computeResampFactor(src, dataMap, config):
    """computeResampFactor(DiffuseSource src, CountsMapBase dataMap, PsfIntegConfig config) -> double"""
    return _pyLikelihood.computeResampFactor(src, dataMap, config)

def createOffsetMap(src, dataMap, pixelOffsets):
    """createOffsetMap(Source src, CountsMap dataMap, DoubleVectorVector pixelOffsets)"""
    return _pyLikelihood.createOffsetMap(src, dataMap, pixelOffsets)

def makeModelMap(src, dataCache, meanpsf, bexpmap, config, srcMapsFile, drm, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makeModelMap(Source src, BinnedCountsCache dataCache, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, std::string const & srcMapsFile, Drm drm, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makeModelMap(Source src, BinnedCountsCache dataCache, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, std::string const & srcMapsFile, Drm drm, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makeModelMap(Source src, BinnedCountsCache dataCache, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, std::string const & srcMapsFile, Drm drm, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makeModelMap(src, dataCache, meanpsf, bexpmap, config, srcMapsFile, drm, formatter, modelmap, mapType, kmin, kmax)

def makeDiffuseMap(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makeDiffuseMap(DiffuseSource src, CountsMapBase dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makeDiffuseMap(DiffuseSource src, CountsMapBase dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makeDiffuseMap(DiffuseSource src, CountsMapBase dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makeDiffuseMap(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin, kmax)

def makeDiffuseMap_wcs(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makeDiffuseMap_wcs(DiffuseSource src, CountsMap dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makeDiffuseMap_wcs(DiffuseSource src, CountsMap dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makeDiffuseMap_wcs(DiffuseSource src, CountsMap dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makeDiffuseMap_wcs(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin, kmax)

def makeDiffuseMap_healpix(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makeDiffuseMap_healpix(DiffuseSource src, CountsMapHealpix dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makeDiffuseMap_healpix(DiffuseSource src, CountsMapHealpix dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makeDiffuseMap_healpix(DiffuseSource src, CountsMapHealpix dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makeDiffuseMap_healpix(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin, kmax)

def makeDiffuseMap_native(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makeDiffuseMap_native(DiffuseSource src, CountsMapHealpix dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makeDiffuseMap_native(DiffuseSource src, CountsMapHealpix dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makeDiffuseMap_native(DiffuseSource src, CountsMapHealpix dataMap, MeanPsf meanpsf, BinnedExposureBase bexpmap, PsfIntegConfig config, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makeDiffuseMap_native(src, dataMap, meanpsf, bexpmap, config, formatter, modelmap, mapType, kmin, kmax)

def makePointSourceMap(src, dataMap, config, meanpsf, bexpmap, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makePointSourceMap(PointSource src, CountsMapBase dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makePointSourceMap(PointSource src, CountsMapBase dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makePointSourceMap(PointSource src, CountsMapBase dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makePointSourceMap(src, dataMap, config, meanpsf, bexpmap, formatter, modelmap, mapType, kmin, kmax)

def makePointSourceMap_wcs(pointSrc, dataMap, config, meanpsf, bexpmap, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makePointSourceMap_wcs(PointSource pointSrc, CountsMap dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makePointSourceMap_wcs(PointSource pointSrc, CountsMap dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makePointSourceMap_wcs(PointSource pointSrc, CountsMap dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makePointSourceMap_wcs(pointSrc, dataMap, config, meanpsf, bexpmap, formatter, modelmap, mapType, kmin, kmax)

def makePointSourceMap_healpix(pointSrc, dataMap, config, meanpsf, bexpmap, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makePointSourceMap_healpix(PointSource pointSrc, CountsMapHealpix dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makePointSourceMap_healpix(PointSource pointSrc, CountsMapHealpix dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makePointSourceMap_healpix(PointSource pointSrc, CountsMapHealpix dataMap, PsfIntegConfig config, MeanPsf meanpsf, BinnedExposureBase bexpmap, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makePointSourceMap_healpix(pointSrc, dataMap, config, meanpsf, bexpmap, formatter, modelmap, mapType, kmin, kmax)

def makeCompositeMap(compSrc, dataCache, srcMapsFile, drm, formatter, modelmap, mapType, kmin=0, kmax=-1):
    """
    makeCompositeMap(CompositeSource compSrc, BinnedCountsCache dataCache, std::string const & srcMapsFile, Drm drm, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1) -> int
    makeCompositeMap(CompositeSource compSrc, BinnedCountsCache dataCache, std::string const & srcMapsFile, Drm drm, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0) -> int
    makeCompositeMap(CompositeSource compSrc, BinnedCountsCache dataCache, std::string const & srcMapsFile, Drm drm, st_stream::StreamFormatter & formatter, FloatVector modelmap, Likelihood::FileUtils::SrcMapType & mapType) -> int
    """
    return _pyLikelihood.makeCompositeMap(compSrc, dataCache, srcMapsFile, drm, formatter, modelmap, mapType, kmin, kmax)

def psfValueEstimate(meanPsf, energy, srcDir, pixel, srcCoord, pixCoord, pixelOffsets, ref_pixel_size, config):
    """psfValueEstimate(MeanPsf meanPsf, double energy, SkyDir srcDir, Pixel pixel, DoublePair srcCoord, DoublePair pixCoord, DoubleVectorVector pixelOffsets, double ref_pixel_size, PsfIntegConfig config) -> double"""
    return _pyLikelihood.psfValueEstimate(meanPsf, energy, srcDir, pixel, srcCoord, pixCoord, pixelOffsets, ref_pixel_size, config)

def psfValue_pixelCenter(meanPsf, energy, srcDir, pixel):
    """psfValue_pixelCenter(MeanPsf meanPsf, double energy, SkyDir srcDir, Pixel pixel) -> double"""
    return _pyLikelihood.psfValue_pixelCenter(meanPsf, energy, srcDir, pixel)

def psfValue_annular(meanPsf, energy, srcDir, pixel):
    """psfValue_annular(MeanPsf meanPsf, double energy, SkyDir srcDir, Pixel pixel) -> double"""
    return _pyLikelihood.psfValue_annular(meanPsf, energy, srcDir, pixel)

def integrate_psf_adaptive(meanPsf, energy, srcDir, pixel, srcCoord, pixCoord, pixelOffsets, ref_pixel_size, config):
    """integrate_psf_adaptive(MeanPsf meanPsf, double energy, SkyDir srcDir, Pixel pixel, DoublePair srcCoord, DoublePair pixCoord, DoubleVectorVector pixelOffsets, double ref_pixel_size, PsfIntegConfig config) -> double"""
    return _pyLikelihood.integrate_psf_adaptive(meanPsf, energy, srcDir, pixel, srcCoord, pixCoord, pixelOffsets, ref_pixel_size, config)

def integrate_psf(meanPsf, energy, srcDir, pixel, npts=11):
    """
    integrate_psf(MeanPsf meanPsf, double energy, SkyDir srcDir, Pixel pixel, size_t npts=11) -> double
    integrate_psf(MeanPsf meanPsf, double energy, SkyDir srcDir, Pixel pixel) -> double
    """
    return _pyLikelihood.integrate_psf(meanPsf, energy, srcDir, pixel, npts)

def integrate_psf_fast(meanPsf, energy, srcDir, pixel, srcCoord, pixCoord, pixelOffsets, ref_pixel_size, npts):
    """integrate_psf_fast(MeanPsf meanPsf, double energy, SkyDir srcDir, Pixel pixel, DoublePair srcCoord, DoublePair pixCoord, DoubleVectorVector pixelOffsets, double ref_pixel_size, size_t npts) -> double"""
    return _pyLikelihood.integrate_psf_fast(meanPsf, energy, srcDir, pixel, srcCoord, pixCoord, pixelOffsets, ref_pixel_size, npts)
class SpatialMap(Function, MapBase):
    """Proxy of C++ Likelihood::SpatialMap class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::SpatialMap self) -> SpatialMap
        __init__(Likelihood::SpatialMap self, std::string const & fitsFile, std::string const & extension) -> SpatialMap
        __init__(Likelihood::SpatialMap self, std::string const & fitsFile) -> SpatialMap
        __init__(Likelihood::SpatialMap self, SpatialMap arg2) -> SpatialMap
        """
        this = _pyLikelihood.new_SpatialMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_SpatialMap
    __del__ = lambda self: None

    def value(self, *args):
        """
        value(SpatialMap self, Arg arg2) -> double
        value(SpatialMap self, SkyDir arg2) -> double
        """
        return _pyLikelihood.SpatialMap_value(self, *args)


    def derivByParamImp(self, arg2, arg3):
        """derivByParamImp(SpatialMap self, Arg arg2, std::string const & arg3) -> double"""
        return _pyLikelihood.SpatialMap_derivByParamImp(self, arg2, arg3)


    def clone(self):
        """clone(SpatialMap self) -> Function"""
        return _pyLikelihood.SpatialMap_clone(self)


    def fitsFile(self):
        """fitsFile(SpatialMap self) -> std::string const &"""
        return _pyLikelihood.SpatialMap_fitsFile(self)


    def mapIntegral(self, energy):
        """mapIntegral(SpatialMap self, double energy) -> double"""
        return _pyLikelihood.SpatialMap_mapIntegral(self, energy)


    def integrateSpatialDist(self, energies, expmap, exposure):
        """integrateSpatialDist(SpatialMap self, DoubleVector energies, ExposureMap expmap, DoubleVector exposure)"""
        return _pyLikelihood.SpatialMap_integrateSpatialDist(self, energies, expmap, exposure)


    def integrateSpatialDist_wcs(self, energies, expmap, wcsmap, exposure):
        """integrateSpatialDist_wcs(SpatialMap self, DoubleVector energies, ExposureMap expmap, WcsMap2 wcsmap, DoubleVector exposure)"""
        return _pyLikelihood.SpatialMap_integrateSpatialDist_wcs(self, energies, expmap, wcsmap, exposure)


    def integrateSpatialDist_healpix(self, energies, expmap, healmap, exposure):
        """integrateSpatialDist_healpix(SpatialMap self, DoubleVector energies, ExposureMap expmap, HealpixProjMap healmap, DoubleVector exposure)"""
        return _pyLikelihood.SpatialMap_integrateSpatialDist_healpix(self, energies, expmap, healmap, exposure)


    def cast(func):
        """cast(Function func) -> SpatialMap"""
        return _pyLikelihood.SpatialMap_cast(func)

    cast = staticmethod(cast)
SpatialMap_swigregister = _pyLikelihood.SpatialMap_swigregister
SpatialMap_swigregister(SpatialMap)

def SpatialMap_cast(func):
    """SpatialMap_cast(Function func) -> SpatialMap"""
    return _pyLikelihood.SpatialMap_cast(func)

class CountsMapBase(_object):
    """Proxy of C++ Likelihood::CountsMapBase class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Intensity = _pyLikelihood.CountsMapBase_Intensity
    Weights = _pyLikelihood.CountsMapBase_Weights

    def makeAlphaMap(epsilon2, input_map_files):
        """makeAlphaMap(float const & epsilon2, StringVector input_map_files) -> CountsMapBase"""
        return _pyLikelihood.CountsMapBase_makeAlphaMap(epsilon2, input_map_files)

    makeAlphaMap = staticmethod(makeAlphaMap)

    def makeWtsMap(epsilon2, alphaMap, beffMap):
        """makeWtsMap(float const & epsilon2, CountsMapBase alphaMap, CountsMapBase beffMap) -> CountsMapBase"""
        return _pyLikelihood.CountsMapBase_makeWtsMap(epsilon2, alphaMap, beffMap)

    makeWtsMap = staticmethod(makeWtsMap)

    def copyAndUpdateDssKeywords(infile, outfile, helper, irfs):
        """copyAndUpdateDssKeywords(std::string const & infile, std::string const & outfile, AppHelpers helper, std::string const & irfs)"""
        return _pyLikelihood.CountsMapBase_copyAndUpdateDssKeywords(infile, outfile, helper, irfs)

    copyAndUpdateDssKeywords = staticmethod(copyAndUpdateDssKeywords)

    def addBkgEffKeywords(outfile, inputmap, efact):
        """addBkgEffKeywords(std::string const & outfile, std::string const & inputmap, float const & efact)"""
        return _pyLikelihood.CountsMapBase_addBkgEffKeywords(outfile, inputmap, efact)

    addBkgEffKeywords = staticmethod(addBkgEffKeywords)

    def addAlphaMapKeywords(outfile, epsilon, inputFiles):
        """addAlphaMapKeywords(std::string const & outfile, double epsilon, StringVector inputFiles)"""
        return _pyLikelihood.CountsMapBase_addAlphaMapKeywords(outfile, epsilon, inputFiles)

    addAlphaMapKeywords = staticmethod(addAlphaMapKeywords)

    def addWtsMapKeywords(outfile, epsilon, bkgmap, alphamap):
        """addWtsMapKeywords(std::string const & outfile, double epsilon, std::string const & bkgmap, std::string const & alphamap)"""
        return _pyLikelihood.CountsMapBase_addWtsMapKeywords(outfile, epsilon, bkgmap, alphamap)

    addWtsMapKeywords = staticmethod(addWtsMapKeywords)

    def addPhasedExpMapKeywords(outfile, phased_expmap):
        """addPhasedExpMapKeywords(std::string const & outfile, std::string const & phased_expmap)"""
        return _pyLikelihood.CountsMapBase_addPhasedExpMapKeywords(outfile, phased_expmap)

    addPhasedExpMapKeywords = staticmethod(addPhasedExpMapKeywords)
    __swig_destroy__ = _pyLikelihood.delete_CountsMapBase
    __del__ = lambda self: None

    def clone(self):
        """clone(CountsMapBase self) -> CountsMapBase"""
        return _pyLikelihood.CountsMapBase_clone(self)


    def makeProjMap(self, *args):
        """
        makeProjMap(CountsMapBase self, Likelihood::CountsMapBase::ConversionType cType) -> ProjMap
        makeProjMap(CountsMapBase self) -> ProjMap
        """
        return _pyLikelihood.CountsMapBase_makeProjMap(self, *args)


    def makeBkgEffMap(self, psf, efact):
        """makeBkgEffMap(CountsMapBase self, MeanPsf psf, float const & efact) -> CountsMapBase"""
        return _pyLikelihood.CountsMapBase_makeBkgEffMap(self, psf, efact)


    def writeOutput(self, creator, out_file):
        """writeOutput(CountsMapBase self, std::string const & creator, std::string const & out_file)"""
        return _pyLikelihood.CountsMapBase_writeOutput(self, creator, out_file)


    def writeAsWeightsMap(self, creator, out_file):
        """writeAsWeightsMap(CountsMapBase self, std::string const & creator, std::string const & out_file)"""
        return _pyLikelihood.CountsMapBase_writeAsWeightsMap(self, creator, out_file)


    def writeEmptyOutput(self, creator, out_file):
        """writeEmptyOutput(CountsMapBase self, std::string const & creator, std::string const & out_file)"""
        return _pyLikelihood.CountsMapBase_writeEmptyOutput(self, creator, out_file)


    def withinBounds(self, dir, energy, border_size=0):
        """
        withinBounds(CountsMapBase self, SkyDir dir, double energy, long border_size=0) -> bool
        withinBounds(CountsMapBase self, SkyDir dir, double energy) -> bool
        """
        return _pyLikelihood.CountsMapBase_withinBounds(self, dir, energy, border_size)


    def setKeywords(self, header):
        """setKeywords(CountsMapBase self, tip::Header & header)"""
        return _pyLikelihood.CountsMapBase_setKeywords(self, header)


    def getBoundaryPixelDirs(self, pixelDirs):
        """getBoundaryPixelDirs(CountsMapBase self, SkyDirVector pixelDirs)"""
        return _pyLikelihood.CountsMapBase_getBoundaryPixelDirs(self, pixelDirs)


    def pixelSize(self):
        """pixelSize(CountsMapBase self) -> double"""
        return _pyLikelihood.CountsMapBase_pixelSize(self)


    def mapRadius(self):
        """mapRadius(CountsMapBase self) -> double"""
        return _pyLikelihood.CountsMapBase_mapRadius(self)


    def writeEnergies(self, creator, out_file, kmin=0, kmax=-1):
        """
        writeEnergies(CountsMapBase self, std::string const & creator, std::string const & out_file, int kmin=0, int kmax=-1)
        writeEnergies(CountsMapBase self, std::string const & creator, std::string const & out_file, int kmin=0)
        writeEnergies(CountsMapBase self, std::string const & creator, std::string const & out_file)
        """
        return _pyLikelihood.CountsMapBase_writeEnergies(self, creator, out_file, kmin, kmax)


    def setImage(self, *args):
        """
        setImage(CountsMapBase self, FloatVector image)
        setImage(CountsMapBase self, DoubleVector image)
        """
        return _pyLikelihood.CountsMapBase_setImage(self, *args)


    def imageDimension(self, idim):
        """imageDimension(CountsMapBase self, int idim) -> long"""
        return _pyLikelihood.CountsMapBase_imageDimension(self, idim)


    def getAxisVector(self, idim, axisVector):
        """getAxisVector(CountsMapBase self, int idim, DoubleVector axisVector)"""
        return _pyLikelihood.CountsMapBase_getAxisVector(self, idim, axisVector)


    def getEnergies(self, energies):
        """getEnergies(CountsMapBase self, DoubleVector energies)"""
        return _pyLikelihood.CountsMapBase_getEnergies(self, energies)


    def getEnergyBinGeomCenters(self, eBinCenters):
        """getEnergyBinGeomCenters(CountsMapBase self, DoubleVector eBinCenters)"""
        return _pyLikelihood.CountsMapBase_getEnergyBinGeomCenters(self, eBinCenters)


    def getEnergyBinWidths(self, eBinCenters):
        """getEnergyBinWidths(CountsMapBase self, DoubleVector eBinCenters)"""
        return _pyLikelihood.CountsMapBase_getEnergyBinWidths(self, eBinCenters)


    def projection(self):
        """projection(CountsMapBase self) -> ProjBase"""
        return _pyLikelihood.CountsMapBase_projection(self)


    def data(self):
        """data(CountsMapBase self) -> FloatVector"""
        return _pyLikelihood.CountsMapBase_data(self)


    def data_access(self):
        """data_access(CountsMapBase self) -> FloatVector"""
        return _pyLikelihood.CountsMapBase_data_access(self)


    def refDir(self):
        """refDir(CountsMapBase self) -> SkyDir"""
        return _pyLikelihood.CountsMapBase_refDir(self)


    def proj_name(self):
        """proj_name(CountsMapBase self) -> std::string const &"""
        return _pyLikelihood.CountsMapBase_proj_name(self)


    def isGalactic(self):
        """isGalactic(CountsMapBase self) -> bool"""
        return _pyLikelihood.CountsMapBase_isGalactic(self)


    def energies(self):
        """energies(CountsMapBase self) -> DoubleVector"""
        return _pyLikelihood.CountsMapBase_energies(self)


    def filename(self):
        """filename(CountsMapBase self) -> std::string const &"""
        return _pyLikelihood.CountsMapBase_filename(self)


    def tstart(self):
        """tstart(CountsMapBase self) -> double"""
        return _pyLikelihood.CountsMapBase_tstart(self)


    def tstop(self):
        """tstop(CountsMapBase self) -> double"""
        return _pyLikelihood.CountsMapBase_tstop(self)


    def pixels(self):
        """pixels(CountsMapBase self) -> PixelVector"""
        return _pyLikelihood.CountsMapBase_pixels(self)


    def num_energies(self):
        """num_energies(CountsMapBase self) -> size_t"""
        return _pyLikelihood.CountsMapBase_num_energies(self)


    def num_ebins(self):
        """num_ebins(CountsMapBase self) -> size_t"""
        return _pyLikelihood.CountsMapBase_num_ebins(self)

CountsMapBase_swigregister = _pyLikelihood.CountsMapBase_swigregister
CountsMapBase_swigregister(CountsMapBase)

def CountsMapBase_makeAlphaMap(epsilon2, input_map_files):
    """CountsMapBase_makeAlphaMap(float const & epsilon2, StringVector input_map_files) -> CountsMapBase"""
    return _pyLikelihood.CountsMapBase_makeAlphaMap(epsilon2, input_map_files)

def CountsMapBase_makeWtsMap(epsilon2, alphaMap, beffMap):
    """CountsMapBase_makeWtsMap(float const & epsilon2, CountsMapBase alphaMap, CountsMapBase beffMap) -> CountsMapBase"""
    return _pyLikelihood.CountsMapBase_makeWtsMap(epsilon2, alphaMap, beffMap)

def CountsMapBase_copyAndUpdateDssKeywords(infile, outfile, helper, irfs):
    """CountsMapBase_copyAndUpdateDssKeywords(std::string const & infile, std::string const & outfile, AppHelpers helper, std::string const & irfs)"""
    return _pyLikelihood.CountsMapBase_copyAndUpdateDssKeywords(infile, outfile, helper, irfs)

def CountsMapBase_addBkgEffKeywords(outfile, inputmap, efact):
    """CountsMapBase_addBkgEffKeywords(std::string const & outfile, std::string const & inputmap, float const & efact)"""
    return _pyLikelihood.CountsMapBase_addBkgEffKeywords(outfile, inputmap, efact)

def CountsMapBase_addAlphaMapKeywords(outfile, epsilon, inputFiles):
    """CountsMapBase_addAlphaMapKeywords(std::string const & outfile, double epsilon, StringVector inputFiles)"""
    return _pyLikelihood.CountsMapBase_addAlphaMapKeywords(outfile, epsilon, inputFiles)

def CountsMapBase_addWtsMapKeywords(outfile, epsilon, bkgmap, alphamap):
    """CountsMapBase_addWtsMapKeywords(std::string const & outfile, double epsilon, std::string const & bkgmap, std::string const & alphamap)"""
    return _pyLikelihood.CountsMapBase_addWtsMapKeywords(outfile, epsilon, bkgmap, alphamap)

def CountsMapBase_addPhasedExpMapKeywords(outfile, phased_expmap):
    """CountsMapBase_addPhasedExpMapKeywords(std::string const & outfile, std::string const & phased_expmap)"""
    return _pyLikelihood.CountsMapBase_addPhasedExpMapKeywords(outfile, phased_expmap)

class Source(_object):
    """Proxy of C++ Likelihood::Source class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Point = _pyLikelihood.Source_Point
    Diffuse = _pyLikelihood.Source_Diffuse
    Composite = _pyLikelihood.Source_Composite
    Unknown = _pyLikelihood.Source_Unknown

    def sourceTypeName(t):
        """sourceTypeName(Likelihood::Source::SourceType t) -> std::string const &"""
        return _pyLikelihood.Source_sourceTypeName(t)

    sourceTypeName = staticmethod(sourceTypeName)
    __swig_destroy__ = _pyLikelihood.delete_Source
    __del__ = lambda self: None

    def clone(self):
        """clone(Source self) -> Source"""
        return _pyLikelihood.Source_clone(self)


    def getName(self):
        """getName(Source self) -> std::string const &"""
        return _pyLikelihood.Source_getName(self)


    def getSrcFuncs(self, *args):
        """
        getSrcFuncs(Source self) -> FuncMap
        getSrcFuncs(Source self) -> FuncMap
        """
        return _pyLikelihood.Source_getSrcFuncs(self, *args)


    def srcType(self):
        """srcType(Source self) -> Likelihood::Source::SourceType"""
        return _pyLikelihood.Source_srcType(self)


    def getType(self):
        """getType(Source self) -> std::string const &"""
        return _pyLikelihood.Source_getType(self)


    def spectrum(self, *args):
        """
        spectrum(Source self) -> Function
        spectrum(Source self) -> Function
        """
        return _pyLikelihood.Source_spectrum(self, *args)


    def observation(self):
        """observation(Source self) -> Observation"""
        return _pyLikelihood.Source_observation(self)


    def use_edisp(self):
        """use_edisp(Source self) -> bool"""
        return _pyLikelihood.Source_use_edisp(self)


    def use_psf(self):
        """use_psf(Source self) -> bool"""
        return _pyLikelihood.Source_use_psf(self)


    def use_exposure(self):
        """use_exposure(Source self) -> bool"""
        return _pyLikelihood.Source_use_exposure(self)


    def exposure(self):
        """exposure(Source self) -> DoubleVector"""
        return _pyLikelihood.Source_exposure(self)


    def setSpectrum(self, *args):
        """
        setSpectrum(Source self, Function spectrum)
        setSpectrum(Source self, std::string const & functionName)
        """
        return _pyLikelihood.Source_setSpectrum(self, *args)


    def setName(self, name):
        """setName(Source self, std::string const & name)"""
        return _pyLikelihood.Source_setName(self, name)


    def setObservation(self, observation):
        """setObservation(Source self, Observation observation)"""
        return _pyLikelihood.Source_setObservation(self, observation)


    def set_edisp_flag(self, useEdisp):
        """set_edisp_flag(Source self, bool useEdisp)"""
        return _pyLikelihood.Source_set_edisp_flag(self, useEdisp)


    def set_psf_flag(self, usePSF):
        """set_psf_flag(Source self, bool usePSF)"""
        return _pyLikelihood.Source_set_psf_flag(self, usePSF)


    def set_exposure_flag(self, useExposure):
        """set_exposure_flag(Source self, bool useExposure)"""
        return _pyLikelihood.Source_set_exposure_flag(self, useExposure)


    def fluxDensity(self, *args):
        """
        fluxDensity(Source self, Event evt, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(Source self, Event evt) -> double
        fluxDensity(Source self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(Source self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time) -> double
        """
        return _pyLikelihood.Source_fluxDensity(self, *args)


    def fluxDensityDeriv(self, *args):
        """
        fluxDensityDeriv(Source self, Event evt, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(Source self, Event evt, std::string const & paramName) -> double
        fluxDensityDeriv(Source self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(Source self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName) -> double
        """
        return _pyLikelihood.Source_fluxDensityDeriv(self, *args)


    def computeExposure(self, energies, verbose=False):
        """
        computeExposure(Source self, DoubleVector energies, bool verbose=False)
        computeExposure(Source self, DoubleVector energies)
        """
        return _pyLikelihood.Source_computeExposure(self, energies, verbose)


    def pixelCounts(self, emin, emax, wtMin, wtMax):
        """pixelCounts(Source self, double emin, double emax, double wtMin, double wtMax) -> double"""
        return _pyLikelihood.Source_pixelCounts(self, emin, emax, wtMin, wtMax)


    def pixelCountsDeriv(self, emin, emax, wtMin, wtMax, paramName):
        """pixelCountsDeriv(Source self, double emin, double emax, double wtMin, double wtMax, std::string const & paramName) -> double"""
        return _pyLikelihood.Source_pixelCountsDeriv(self, emin, emax, wtMin, wtMax, paramName)


    def fixedSpectrum(self):
        """fixedSpectrum(Source self) -> bool"""
        return _pyLikelihood.Source_fixedSpectrum(self)


    def Npred(self, *args):
        """
        Npred(Source self) -> double
        Npred(Source self, double emin, double emax) -> double
        """
        return _pyLikelihood.Source_Npred(self, *args)


    def NpredDeriv(self, *args):
        """
        NpredDeriv(Source self, std::string const & paramName) -> double
        NpredDeriv(Source self, std::string const & paramName, double emin, double emax) -> double
        """
        return _pyLikelihood.Source_NpredDeriv(self, *args)


    def fluxDeriv(self, *args):
        """
        fluxDeriv(Source self, std::string const & parName) -> double
        fluxDeriv(Source self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        fluxDeriv(Source self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.Source_fluxDeriv(self, *args)


    def energyFlux(self, *args):
        """
        energyFlux(Source self) -> double
        energyFlux(Source self, double emin, double emax, size_t npts=100) -> double
        energyFlux(Source self, double emin, double emax) -> double
        """
        return _pyLikelihood.Source_energyFlux(self, *args)


    def energyFluxDeriv(self, *args):
        """
        energyFluxDeriv(Source self, std::string const & parName) -> double
        energyFluxDeriv(Source self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        energyFluxDeriv(Source self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.Source_energyFluxDeriv(self, *args)


    def angularIntegral(self, energy):
        """angularIntegral(Source self, double energy) -> double"""
        return _pyLikelihood.Source_angularIntegral(self, energy)


    def flux(self, *args):
        """
        flux(Source self) -> double
        flux(Source self, double emin, double emax, size_t npts=100) -> double
        flux(Source self, double emin, double emax) -> double
        flux(Source self) -> double
        flux(Source self, double emin, double emax, size_t npts=100) -> double
        flux(Source self, double emin, double emax) -> double
        """
        return _pyLikelihood.Source_flux(self, *args)

Source_swigregister = _pyLikelihood.Source_swigregister
Source_swigregister(Source)

def Source_sourceTypeName(t):
    """Source_sourceTypeName(Likelihood::Source::SourceType t) -> std::string const &"""
    return _pyLikelihood.Source_sourceTypeName(t)

class SrcArg(Arg):
    """Proxy of C++ Likelihood::SrcArg class."""

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

    def __init__(self, src):
        """__init__(Likelihood::SrcArg self, Source src) -> SrcArg"""
        this = _pyLikelihood.new_SrcArg(src)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_SrcArg
    __del__ = lambda self: None

    def getValue(self):
        """getValue(SrcArg self) -> Source"""
        return _pyLikelihood.SrcArg_getValue(self)

SrcArg_swigregister = _pyLikelihood.SrcArg_swigregister
SrcArg_swigregister(SrcArg)

class Observation(_object):
    """Proxy of C++ Likelihood::Observation class."""

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

    def __init__(self, respFuncs=None, scData=None, roiCuts=None, expCube=None, expMap=None, eventCont=None, bexpmap=None, phased_expmap=None):
        """
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None, ScData scData=None, RoiCuts roiCuts=None, ExposureCube expCube=None, ExposureMap expMap=None, EventContainer eventCont=None, BinnedExposureBase bexpmap=None, ProjMap phased_expmap=None) -> Observation
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None, ScData scData=None, RoiCuts roiCuts=None, ExposureCube expCube=None, ExposureMap expMap=None, EventContainer eventCont=None, BinnedExposureBase bexpmap=None) -> Observation
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None, ScData scData=None, RoiCuts roiCuts=None, ExposureCube expCube=None, ExposureMap expMap=None, EventContainer eventCont=None) -> Observation
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None, ScData scData=None, RoiCuts roiCuts=None, ExposureCube expCube=None, ExposureMap expMap=None) -> Observation
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None, ScData scData=None, RoiCuts roiCuts=None, ExposureCube expCube=None) -> Observation
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None, ScData scData=None, RoiCuts roiCuts=None) -> Observation
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None, ScData scData=None) -> Observation
        __init__(Likelihood::Observation self, ResponseFunctions respFuncs=None) -> Observation
        __init__(Likelihood::Observation self) -> Observation
        """
        this = _pyLikelihood.new_Observation(respFuncs, scData, roiCuts, expCube, expMap, eventCont, bexpmap, phased_expmap)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def respFuncs(self, *args):
        """
        respFuncs(Observation self) -> ResponseFunctions
        respFuncs(Observation self) -> ResponseFunctions
        """
        return _pyLikelihood.Observation_respFuncs(self, *args)


    def scData(self, *args):
        """
        scData(Observation self) -> ScData
        scData(Observation self) -> ScData
        """
        return _pyLikelihood.Observation_scData(self, *args)


    def roiCuts(self, *args):
        """
        roiCuts(Observation self) -> RoiCuts
        roiCuts(Observation self) -> RoiCuts
        """
        return _pyLikelihood.Observation_roiCuts(self, *args)


    def expCube(self, *args):
        """
        expCube(Observation self) -> ExposureCube
        expCube(Observation self) -> ExposureCube
        """
        return _pyLikelihood.Observation_expCube(self, *args)


    def expMap(self, *args):
        """
        expMap(Observation self) -> ExposureMap
        expMap(Observation self) -> ExposureMap
        """
        return _pyLikelihood.Observation_expMap(self, *args)


    def eventCont(self, *args):
        """
        eventCont(Observation self) -> EventContainer
        eventCont(Observation self) -> EventContainer
        """
        return _pyLikelihood.Observation_eventCont(self, *args)


    def bexpmap(self, *args):
        """
        bexpmap(Observation self) -> BinnedExposureBase
        bexpmap(Observation self) -> BinnedExposureBase
        """
        return _pyLikelihood.Observation_bexpmap(self, *args)


    def bexpmap_ptr(self, *args):
        """
        bexpmap_ptr(Observation self) -> BinnedExposureBase
        bexpmap_ptr(Observation self) -> BinnedExposureBase
        """
        return _pyLikelihood.Observation_bexpmap_ptr(self, *args)


    def phased_expmap(self, *args):
        """
        phased_expmap(Observation self) -> ProjMap
        phased_expmap(Observation self) -> ProjMap
        """
        return _pyLikelihood.Observation_phased_expmap(self, *args)


    def have_phased_expmap(self):
        """have_phased_expmap(Observation self) -> bool"""
        return _pyLikelihood.Observation_have_phased_expmap(self)


    def setMeanPsf(self, meanpsf):
        """setMeanPsf(Observation self, MeanPsf meanpsf)"""
        return _pyLikelihood.Observation_setMeanPsf(self, meanpsf)


    def meanpsf(self, *args):
        """
        meanpsf(Observation self) -> MeanPsf
        meanpsf(Observation self) -> MeanPsf
        """
        return _pyLikelihood.Observation_meanpsf(self, *args)

    __swig_destroy__ = _pyLikelihood.delete_Observation
    __del__ = lambda self: None
Observation_swigregister = _pyLikelihood.Observation_swigregister
Observation_swigregister(Observation)

class BinnedCountsCache(_object):
    """Proxy of C++ Likelihood::BinnedCountsCache class."""

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

    def __init__(self, dataMap, observation, weightMap, srcMapsFile, overwriteWeights=False):
        """
        __init__(Likelihood::BinnedCountsCache self, CountsMapBase dataMap, Observation observation, ProjMap weightMap, std::string const & srcMapsFile, bool overwriteWeights=False) -> BinnedCountsCache
        __init__(Likelihood::BinnedCountsCache self, CountsMapBase dataMap, Observation observation, ProjMap weightMap, std::string const & srcMapsFile) -> BinnedCountsCache
        """
        this = _pyLikelihood.new_BinnedCountsCache(dataMap, observation, weightMap, srcMapsFile, overwriteWeights)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_BinnedCountsCache
    __del__ = lambda self: None

    def countsMap(self):
        """countsMap(BinnedCountsCache self) -> CountsMapBase"""
        return _pyLikelihood.BinnedCountsCache_countsMap(self)


    def energies(self):
        """energies(BinnedCountsCache self) -> DoubleVector"""
        return _pyLikelihood.BinnedCountsCache_energies(self)


    def log_energy_ratios(self):
        """log_energy_ratios(BinnedCountsCache self) -> DoubleVector"""
        return _pyLikelihood.BinnedCountsCache_log_energy_ratios(self)


    def num_energies(self):
        """num_energies(BinnedCountsCache self) -> size_t"""
        return _pyLikelihood.BinnedCountsCache_num_energies(self)


    def num_ebins(self):
        """num_ebins(BinnedCountsCache self) -> size_t"""
        return _pyLikelihood.BinnedCountsCache_num_ebins(self)


    def num_pixels(self):
        """num_pixels(BinnedCountsCache self) -> size_t"""
        return _pyLikelihood.BinnedCountsCache_num_pixels(self)


    def data_map_size(self):
        """data_map_size(BinnedCountsCache self) -> size_t"""
        return _pyLikelihood.BinnedCountsCache_data_map_size(self)


    def source_map_size(self):
        """source_map_size(BinnedCountsCache self) -> size_t"""
        return _pyLikelihood.BinnedCountsCache_source_map_size(self)


    def nFilled(self):
        """nFilled(BinnedCountsCache self) -> size_t"""
        return _pyLikelihood.BinnedCountsCache_nFilled(self)


    def weightMap_orig(self):
        """weightMap_orig(BinnedCountsCache self) -> ProjMap"""
        return _pyLikelihood.BinnedCountsCache_weightMap_orig(self)


    def weightMap(self):
        """weightMap(BinnedCountsCache self) -> WeightMap"""
        return _pyLikelihood.BinnedCountsCache_weightMap(self)


    def weightedCounts(self):
        """weightedCounts(BinnedCountsCache self) -> CountsMapBase"""
        return _pyLikelihood.BinnedCountsCache_weightedCounts(self)


    def has_weights(self):
        """has_weights(BinnedCountsCache self) -> bool"""
        return _pyLikelihood.BinnedCountsCache_has_weights(self)


    def data(self, weighted=False):
        """
        data(BinnedCountsCache self, bool weighted=False) -> FloatVector
        data(BinnedCountsCache self) -> FloatVector
        """
        return _pyLikelihood.BinnedCountsCache_data(self, weighted)


    def countsSpectrum(self, weighted=False):
        """
        countsSpectrum(BinnedCountsCache self, bool weighted=False) -> DoubleVector
        countsSpectrum(BinnedCountsCache self) -> DoubleVector
        """
        return _pyLikelihood.BinnedCountsCache_countsSpectrum(self, weighted)


    def filledPixels(self):
        """filledPixels(BinnedCountsCache self) -> std::vector< unsigned int,std::allocator< unsigned int > > const &"""
        return _pyLikelihood.BinnedCountsCache_filledPixels(self)


    def firstPixels(self):
        """firstPixels(BinnedCountsCache self) -> SizetVector"""
        return _pyLikelihood.BinnedCountsCache_firstPixels(self)


    def setCountsMap(self, counts):
        """setCountsMap(BinnedCountsCache self, FloatVector counts)"""
        return _pyLikelihood.BinnedCountsCache_setCountsMap(self, counts)


    def setWeightsMap(self, wmap, observation):
        """setWeightsMap(BinnedCountsCache self, ProjMap wmap, Observation observation)"""
        return _pyLikelihood.BinnedCountsCache_setWeightsMap(self, wmap, observation)


    def saveWeightsMap(self, srcMapsFile, replace=False):
        """
        saveWeightsMap(BinnedCountsCache self, std::string const & srcMapsFile, bool replace=False) -> tip::Extension
        saveWeightsMap(BinnedCountsCache self, std::string const & srcMapsFile) -> tip::Extension *
        """
        return _pyLikelihood.BinnedCountsCache_saveWeightsMap(self, srcMapsFile, replace)


    def fillWeightedCounts(self):
        """fillWeightedCounts(BinnedCountsCache self)"""
        return _pyLikelihood.BinnedCountsCache_fillWeightedCounts(self)


    def identifyFilledPixels(self):
        """identifyFilledPixels(BinnedCountsCache self)"""
        return _pyLikelihood.BinnedCountsCache_identifyFilledPixels(self)


    def computeCountsSpectrum(self):
        """computeCountsSpectrum(BinnedCountsCache self)"""
        return _pyLikelihood.BinnedCountsCache_computeCountsSpectrum(self)


    def computeCountsSpectrum_wcs(self):
        """computeCountsSpectrum_wcs(BinnedCountsCache self)"""
        return _pyLikelihood.BinnedCountsCache_computeCountsSpectrum_wcs(self)


    def computeCountsSpectrum_healpix(self):
        """computeCountsSpectrum_healpix(BinnedCountsCache self)"""
        return _pyLikelihood.BinnedCountsCache_computeCountsSpectrum_healpix(self)

BinnedCountsCache_swigregister = _pyLikelihood.BinnedCountsCache_swigregister
BinnedCountsCache_swigregister(BinnedCountsCache)

class CountsMap(CountsMapBase):
    """Proxy of C++ Likelihood::CountsMap class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::CountsMap self, std::string const & event_file, std::string const & ev_table, std::string const & sc_file, std::string const & sc_table, double ref_ra, double ref_dec, std::string const & proj, unsigned long num_x_pix, unsigned long num_y_pix, double pix_scale, double axis_rot, bool use_lb, std::string const & ra_field, std::string const & dec_field, double emin, double emax, unsigned long nenergies) -> CountsMap
        __init__(Likelihood::CountsMap self, std::string const & event_file, std::string const & ev_table, std::string const & sc_file, std::string const & sc_table, double ref_ra, double ref_dec, std::string const & proj, unsigned long num_x_pix, unsigned long num_y_pix, double pix_scale, double axis_rot, bool use_lb, std::string const & ra_field, std::string const & dec_field, DoubleVector energies) -> CountsMap
        __init__(Likelihood::CountsMap self, std::string const & event_file, std::string const & ev_table, std::string const & sc_file, std::string const & sc_table, double ref_ra, double ref_dec, std::string const & proj, unsigned long num_x_pix, unsigned long num_y_pix, double x_pix_scale, double y_pix_scale, double axis_rot, bool use_lb, std::string const & ra_field, std::string const & dec_field, DoubleVector energies) -> CountsMap
        __init__(Likelihood::CountsMap self, std::string const & event_file, std::string const & ev_table, std::string const & sc_file, std::string const & sc_table, double ref_ra, double ref_dec, std::string const & proj, unsigned long num_x_pix, unsigned long num_y_pix, double x_pix_scale, double y_pix_scale, double axis_rot, bool use_lb, std::string const & ra_field, std::string const & dec_field, DoubleVector emins, DoubleVector emaxs) -> CountsMap
        __init__(Likelihood::CountsMap self, std::string const & countsMapFile) -> CountsMap
        __init__(Likelihood::CountsMap self, CountsMap counts_map) -> CountsMap
        __init__(Likelihood::CountsMap self, CountsMap counts_map, unsigned int firstBin, unsigned int lastBin) -> CountsMap
        __init__(Likelihood::CountsMap self, WcsMap2 projMap, CountsMap counts_map) -> CountsMap
        """
        this = _pyLikelihood.new_CountsMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_CountsMap
    __del__ = lambda self: None

    def clone(self):
        """clone(CountsMap self) -> CountsMapBase"""
        return _pyLikelihood.CountsMap_clone(self)


    def makeProjMap(self, *args):
        """
        makeProjMap(CountsMap self, Likelihood::CountsMapBase::ConversionType cType) -> ProjMap
        makeProjMap(CountsMap self) -> ProjMap
        """
        return _pyLikelihood.CountsMap_makeProjMap(self, *args)


    def makeBkgEffMap(self, psf, efact):
        """makeBkgEffMap(CountsMap self, MeanPsf psf, float const & efact) -> CountsMapBase"""
        return _pyLikelihood.CountsMap_makeBkgEffMap(self, psf, efact)


    def binInput(self, begin, end):
        """binInput(CountsMap self, tip::Table::ConstIterator begin, tip::Table::ConstIterator end)"""
        return _pyLikelihood.CountsMap_binInput(self, begin, end)


    def writeOutput(self, creator, out_file):
        """writeOutput(CountsMap self, std::string const & creator, std::string const & out_file)"""
        return _pyLikelihood.CountsMap_writeOutput(self, creator, out_file)


    def writeAsWeightsMap(self, creator, out_file):
        """writeAsWeightsMap(CountsMap self, std::string const & creator, std::string const & out_file)"""
        return _pyLikelihood.CountsMap_writeAsWeightsMap(self, creator, out_file)


    def setKeywords(self, header):
        """setKeywords(CountsMap self, tip::Header & header)"""
        return _pyLikelihood.CountsMap_setKeywords(self, header)


    def getBoundaryPixelDirs(self, pixelDirs):
        """getBoundaryPixelDirs(CountsMap self, SkyDirVector pixelDirs)"""
        return _pyLikelihood.CountsMap_getBoundaryPixelDirs(self, pixelDirs)


    def withinBounds(self, dir, energy, border_size=0):
        """
        withinBounds(CountsMap self, SkyDir dir, double energy, long border_size=0) -> bool
        withinBounds(CountsMap self, SkyDir dir, double energy) -> bool
        """
        return _pyLikelihood.CountsMap_withinBounds(self, dir, energy, border_size)


    def pixelSize(self):
        """pixelSize(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_pixelSize(self)


    def mapRadius(self):
        """mapRadius(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_mapRadius(self)


    def cdelt1(self):
        """cdelt1(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_cdelt1(self)


    def cdelt2(self):
        """cdelt2(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_cdelt2(self)


    def crpix1(self):
        """crpix1(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_crpix1(self)


    def crpix2(self):
        """crpix2(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_crpix2(self)


    def crval1(self):
        """crval1(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_crval1(self)


    def crval2(self):
        """crval2(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_crval2(self)


    def crota2(self):
        """crota2(CountsMap self) -> double"""
        return _pyLikelihood.CountsMap_crota2(self)


    def naxis1(self):
        """naxis1(CountsMap self) -> long"""
        return _pyLikelihood.CountsMap_naxis1(self)


    def naxis2(self):
        """naxis2(CountsMap self) -> long"""
        return _pyLikelihood.CountsMap_naxis2(self)


    def conformingMap(self):
        """conformingMap(CountsMap self) -> bool"""
        return _pyLikelihood.CountsMap_conformingMap(self)

CountsMap_swigregister = _pyLikelihood.CountsMap_swigregister
CountsMap_swigregister(CountsMap)

class CountsMapHealpix(CountsMapBase):
    """Proxy of C++ Likelihood::CountsMapHealpix class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::CountsMapHealpix self, std::string const & countsMapFile) -> CountsMapHealpix
        __init__(Likelihood::CountsMapHealpix self, CountsMapHealpix counts_map) -> CountsMapHealpix
        __init__(Likelihood::CountsMapHealpix self, CountsMapHealpix counts_map, unsigned int firstBin, unsigned int lastBin) -> CountsMapHealpix
        __init__(Likelihood::CountsMapHealpix self, HealpixProjMap projMap, CountsMapHealpix counts_map) -> CountsMapHealpix
        """
        this = _pyLikelihood.new_CountsMapHealpix(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_CountsMapHealpix
    __del__ = lambda self: None

    def clone(self):
        """clone(CountsMapHealpix self) -> CountsMapBase"""
        return _pyLikelihood.CountsMapHealpix_clone(self)


    def makeProjMap(self, *args):
        """
        makeProjMap(CountsMapHealpix self, Likelihood::CountsMapBase::ConversionType cType) -> ProjMap
        makeProjMap(CountsMapHealpix self) -> ProjMap
        """
        return _pyLikelihood.CountsMapHealpix_makeProjMap(self, *args)


    def makeBkgEffMap(self, psf, efact):
        """makeBkgEffMap(CountsMapHealpix self, MeanPsf psf, float const & efact) -> CountsMapBase"""
        return _pyLikelihood.CountsMapHealpix_makeBkgEffMap(self, psf, efact)


    def binInput(self, begin, end):
        """binInput(CountsMapHealpix self, tip::Table::ConstIterator begin, tip::Table::ConstIterator end)"""
        return _pyLikelihood.CountsMapHealpix_binInput(self, begin, end)


    def writeOutput(self, creator, out_file):
        """writeOutput(CountsMapHealpix self, std::string const & creator, std::string const & out_file)"""
        return _pyLikelihood.CountsMapHealpix_writeOutput(self, creator, out_file)


    def writeAsWeightsMap(self, creator, out_file):
        """writeAsWeightsMap(CountsMapHealpix self, std::string const & creator, std::string const & out_file)"""
        return _pyLikelihood.CountsMapHealpix_writeAsWeightsMap(self, creator, out_file)


    def setKeywords(self, header):
        """setKeywords(CountsMapHealpix self, tip::Header & header)"""
        return _pyLikelihood.CountsMapHealpix_setKeywords(self, header)


    def getBoundaryPixelDirs(self, pixelDirs):
        """getBoundaryPixelDirs(CountsMapHealpix self, SkyDirVector pixelDirs)"""
        return _pyLikelihood.CountsMapHealpix_getBoundaryPixelDirs(self, pixelDirs)


    def withinBounds(self, dir, energy, border_size=0):
        """
        withinBounds(CountsMapHealpix self, SkyDir dir, double energy, long border_size=0) -> bool
        withinBounds(CountsMapHealpix self, SkyDir dir, double energy) -> bool
        """
        return _pyLikelihood.CountsMapHealpix_withinBounds(self, dir, energy, border_size)


    def pixelSize(self):
        """pixelSize(CountsMapHealpix self) -> double"""
        return _pyLikelihood.CountsMapHealpix_pixelSize(self)


    def nPixels(self):
        """nPixels(CountsMapHealpix self) -> int"""
        return _pyLikelihood.CountsMapHealpix_nPixels(self)


    def solidAngle(self):
        """solidAngle(CountsMapHealpix self) -> double"""
        return _pyLikelihood.CountsMapHealpix_solidAngle(self)


    def allSky(self):
        """allSky(CountsMapHealpix self) -> bool"""
        return _pyLikelihood.CountsMapHealpix_allSky(self)


    def mapRadius(self):
        """mapRadius(CountsMapHealpix self) -> double"""
        return _pyLikelihood.CountsMapHealpix_mapRadius(self)


    def healpixProj(self):
        """healpixProj(CountsMapHealpix self) -> HealpixProj"""
        return _pyLikelihood.CountsMapHealpix_healpixProj(self)


    def pixelIndices(self):
        """pixelIndices(CountsMapHealpix self) -> std::vector< int,std::allocator< int > > const &"""
        return _pyLikelihood.CountsMapHealpix_pixelIndices(self)


    def globalToLocalIndex(self, glo):
        """globalToLocalIndex(CountsMapHealpix self, int glo) -> int"""
        return _pyLikelihood.CountsMapHealpix_globalToLocalIndex(self, glo)


    def localToGlobalIndex(self, loc):
        """localToGlobalIndex(CountsMapHealpix self, int loc) -> int"""
        return _pyLikelihood.CountsMapHealpix_localToGlobalIndex(self, loc)

CountsMapHealpix_swigregister = _pyLikelihood.CountsMapHealpix_swigregister
CountsMapHealpix_swigregister(CountsMapHealpix)

class DiffuseSource(Source):
    """Proxy of C++ Likelihood::DiffuseSource class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::DiffuseSource self, Function spatialDist, Observation observation, bool requireExposure=True, bool mapBasedIntegral=False) -> DiffuseSource
        __init__(Likelihood::DiffuseSource self, Function spatialDist, Observation observation, bool requireExposure=True) -> DiffuseSource
        __init__(Likelihood::DiffuseSource self, Function spatialDist, Observation observation) -> DiffuseSource
        __init__(Likelihood::DiffuseSource self, DiffuseSource rhs) -> DiffuseSource
        """
        this = _pyLikelihood.new_DiffuseSource(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_DiffuseSource
    __del__ = lambda self: None

    def clone(self):
        """clone(DiffuseSource self) -> Source"""
        return _pyLikelihood.DiffuseSource_clone(self)


    def spatialDist(self, *args):
        """
        spatialDist(DiffuseSource self) -> Function
        spatialDist(DiffuseSource self, SkyDir dir) -> double
        """
        return _pyLikelihood.DiffuseSource_spatialDist(self, *args)


    def mapBaseObject(self, *args):
        """
        mapBaseObject(DiffuseSource self) -> MapBase
        mapBaseObject(DiffuseSource self) -> MapBase
        """
        return _pyLikelihood.DiffuseSource_mapBaseObject(self, *args)


    def mapBasedIntegral(self):
        """mapBasedIntegral(DiffuseSource self) -> bool"""
        return _pyLikelihood.DiffuseSource_mapBasedIntegral(self)


    def mapRadius(self):
        """mapRadius(DiffuseSource self) -> double"""
        return _pyLikelihood.DiffuseSource_mapRadius(self)


    def mapRefDir(self):
        """mapRefDir(DiffuseSource self) -> SkyDir"""
        return _pyLikelihood.DiffuseSource_mapRefDir(self)


    def fluxDensity(self, *args):
        """
        fluxDensity(DiffuseSource self, Event evt, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(DiffuseSource self, Event evt) -> double
        fluxDensity(DiffuseSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(DiffuseSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time) -> double
        """
        return _pyLikelihood.DiffuseSource_fluxDensity(self, *args)


    def fluxDensityDeriv(self, *args):
        """
        fluxDensityDeriv(DiffuseSource self, Event evt, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(DiffuseSource self, Event evt, std::string const & paramName) -> double
        fluxDensityDeriv(DiffuseSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(DiffuseSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName) -> double
        """
        return _pyLikelihood.DiffuseSource_fluxDensityDeriv(self, *args)


    def computeExposure(self, energies, verbose=False):
        """
        computeExposure(DiffuseSource self, DoubleVector energies, bool verbose=False)
        computeExposure(DiffuseSource self, DoubleVector energies)
        """
        return _pyLikelihood.DiffuseSource_computeExposure(self, energies, verbose)


    def flux(self, *args):
        """
        flux(DiffuseSource self) -> double
        flux(DiffuseSource self, double emin, double emax, size_t npts=100) -> double
        flux(DiffuseSource self, double emin, double emax) -> double
        """
        return _pyLikelihood.DiffuseSource_flux(self, *args)


    def fluxDeriv(self, *args):
        """
        fluxDeriv(DiffuseSource self, std::string const & parName) -> double
        fluxDeriv(DiffuseSource self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        fluxDeriv(DiffuseSource self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.DiffuseSource_fluxDeriv(self, *args)


    def energyFlux(self, *args):
        """
        energyFlux(DiffuseSource self) -> double
        energyFlux(DiffuseSource self, double emin, double emax, size_t npts=100) -> double
        energyFlux(DiffuseSource self, double emin, double emax) -> double
        """
        return _pyLikelihood.DiffuseSource_energyFlux(self, *args)


    def energyFluxDeriv(self, *args):
        """
        energyFluxDeriv(DiffuseSource self, std::string const & parName) -> double
        energyFluxDeriv(DiffuseSource self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        energyFluxDeriv(DiffuseSource self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.DiffuseSource_energyFluxDeriv(self, *args)


    def angularIntegral(self, energy):
        """angularIntegral(DiffuseSource self, double energy) -> double"""
        return _pyLikelihood.DiffuseSource_angularIntegral(self, energy)


    def diffuseResponse(self, evt):
        """diffuseResponse(DiffuseSource self, Event evt) -> double"""
        return _pyLikelihood.DiffuseSource_diffuseResponse(self, evt)


    def cast(src):
        """cast(Source src) -> DiffuseSource"""
        return _pyLikelihood.DiffuseSource_cast(src)

    cast = staticmethod(cast)
DiffuseSource_swigregister = _pyLikelihood.DiffuseSource_swigregister
DiffuseSource_swigregister(DiffuseSource)

def DiffuseSource_cast(src):
    """DiffuseSource_cast(Source src) -> DiffuseSource"""
    return _pyLikelihood.DiffuseSource_cast(src)

class MeanPsf(_object):
    """Proxy of C++ Likelihood::MeanPsf class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::MeanPsf self, double ra, double dec, DoubleVector energies, Observation observation) -> MeanPsf
        __init__(Likelihood::MeanPsf self, SkyDir srcDir, DoubleVector energies, Observation observation) -> MeanPsf
        """
        this = _pyLikelihood.new_MeanPsf(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, energy, theta, phi=0):
        """
        __call__(MeanPsf self, double energy, double theta, double phi=0) -> double
        __call__(MeanPsf self, double energy, double theta) -> double
        """
        return _pyLikelihood.MeanPsf___call__(self, energy, theta, phi)


    def write(self, filename):
        """write(MeanPsf self, std::string const & filename)"""
        return _pyLikelihood.MeanPsf_write(self, filename)


    def energies(self):
        """energies(MeanPsf self) -> DoubleVector"""
        return _pyLikelihood.MeanPsf_energies(self)


    def peakValue(self, energy):
        """peakValue(MeanPsf self, double energy) -> double"""
        return _pyLikelihood.MeanPsf_peakValue(self, energy)


    def exposure(self, *args):
        """
        exposure(MeanPsf self) -> DoubleVector
        exposure(MeanPsf self, double energy) -> double
        """
        return _pyLikelihood.MeanPsf_exposure(self, *args)


    def integral(self, angle, energy):
        """integral(MeanPsf self, double angle, double energy) -> double"""
        return _pyLikelihood.MeanPsf_integral(self, angle, energy)


    def containmentRadius(self, energy, frac=0.68, rtol=1E-3):
        """
        containmentRadius(MeanPsf self, double energy, double frac=0.68, double rtol=1E-3) -> double
        containmentRadius(MeanPsf self, double energy, double frac=0.68) -> double
        containmentRadius(MeanPsf self, double energy) -> double
        """
        return _pyLikelihood.MeanPsf_containmentRadius(self, energy, frac, rtol)


    def derivative(self, angle, energy):
        """derivative(MeanPsf self, double angle, double energy) -> double"""
        return _pyLikelihood.MeanPsf_derivative(self, angle, energy)


    def getImage(self, *args):
        """
        getImage(MeanPsf self, double energy, double lon0, double lat0, DoubleVector lons, DoubleVector lats, DoubleVectorVector image)
        getImage(MeanPsf self, double energy, double lon0, double lat0, DoubleVectorPair dirs, DoubleVector image)
        """
        return _pyLikelihood.MeanPsf_getImage(self, *args)

    __swig_destroy__ = _pyLikelihood.delete_MeanPsf
    __del__ = lambda self: None
MeanPsf_swigregister = _pyLikelihood.MeanPsf_swigregister
MeanPsf_swigregister(MeanPsf)

class Npred(Function):
    """Proxy of C++ Likelihood::Npred class."""

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

    def __init__(self):
        """__init__(Likelihood::Npred self) -> Npred"""
        this = _pyLikelihood.new_Npred()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Npred
    __del__ = lambda self: None
Npred_swigregister = _pyLikelihood.Npred_swigregister
Npred_swigregister(Npred)

class OneSourceFunc(Statistic):
    """Proxy of C++ Likelihood::OneSourceFunc class."""

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

    def __init__(self, src, events, weights=None):
        """
        __init__(Likelihood::OneSourceFunc self, Source src, EventVector events, DoubleVector weights=None) -> OneSourceFunc
        __init__(Likelihood::OneSourceFunc self, Source src, EventVector events) -> OneSourceFunc
        """
        this = _pyLikelihood.new_OneSourceFunc(src, events, weights)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setFreeParamValues_(self, it):
        """setFreeParamValues_(OneSourceFunc self, std::vector< double,std::allocator< double > >::const_iterator it) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.OneSourceFunc_setFreeParamValues_(self, it)


    def setParamValues_(self, arg2):
        """setParamValues_(OneSourceFunc self, std::vector< double,std::allocator< double > >::const_iterator arg2) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.OneSourceFunc_setParamValues_(self, arg2)


    def clone(self):
        """clone(OneSourceFunc self) -> Statistic"""
        return _pyLikelihood.OneSourceFunc_clone(self)


    def setParams(self, arg2):
        """setParams(OneSourceFunc self, ParameterVector arg2)"""
        return _pyLikelihood.OneSourceFunc_setParams(self, arg2)


    def setEpsW(self, arg2):
        """setEpsW(OneSourceFunc self, double arg2)"""
        return _pyLikelihood.OneSourceFunc_setEpsW(self, arg2)


    def setEpsF(self, arg2):
        """setEpsF(OneSourceFunc self, double arg2)"""
        return _pyLikelihood.OneSourceFunc_setEpsF(self, arg2)


    def value(self):
        """value(OneSourceFunc self) -> double"""
        return _pyLikelihood.OneSourceFunc_value(self)


    def getFreeDerivs(self, *args):
        """
        getFreeDerivs(OneSourceFunc self, Arg x, DoubleVector derivs)
        getFreeDerivs(OneSourceFunc self, DoubleVector derivs)
        """
        return _pyLikelihood.OneSourceFunc_getFreeDerivs(self, *args)

    __swig_destroy__ = _pyLikelihood.delete_OneSourceFunc
    __del__ = lambda self: None
OneSourceFunc_swigregister = _pyLikelihood.OneSourceFunc_swigregister
OneSourceFunc_swigregister(OneSourceFunc)

class PointSource(Source):
    """Proxy of C++ Likelihood::PointSource class."""

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

    def computeExposureWithHyperCube(dir, energies, observation, exposure, verbose):
        """computeExposureWithHyperCube(SkyDir dir, DoubleVector energies, Observation observation, DoubleVector exposure, bool verbose)"""
        return _pyLikelihood.PointSource_computeExposureWithHyperCube(dir, energies, observation, exposure, verbose)

    computeExposureWithHyperCube = staticmethod(computeExposureWithHyperCube)

    def __init__(self, *args):
        """
        __init__(Likelihood::PointSource self, Observation observation=None) -> PointSource
        __init__(Likelihood::PointSource self) -> PointSource
        __init__(Likelihood::PointSource self, double ra, double dec, Observation observation, bool verbose=False) -> PointSource
        __init__(Likelihood::PointSource self, double ra, double dec, Observation observation) -> PointSource
        __init__(Likelihood::PointSource self, PointSource rhs) -> PointSource
        """
        this = _pyLikelihood.new_PointSource(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(PointSource self) -> Source"""
        return _pyLikelihood.PointSource_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_PointSource
    __del__ = lambda self: None

    def getDir(self):
        """getDir(PointSource self) -> SkyDir"""
        return _pyLikelihood.PointSource_getDir(self)


    def getSeparation(self, dir):
        """getSeparation(PointSource self, SkyDir dir) -> double"""
        return _pyLikelihood.PointSource_getSeparation(self, dir)


    def setGalDir(self, l, b, updateExposure=True, verbose=True):
        """
        setGalDir(PointSource self, double l, double b, bool updateExposure=True, bool verbose=True)
        setGalDir(PointSource self, double l, double b, bool updateExposure=True)
        setGalDir(PointSource self, double l, double b)
        """
        return _pyLikelihood.PointSource_setGalDir(self, l, b, updateExposure, verbose)


    def setDir(self, *args):
        """
        setDir(PointSource self, double ra, double dec, bool updateExposure=True, bool verbose=True)
        setDir(PointSource self, double ra, double dec, bool updateExposure=True)
        setDir(PointSource self, double ra, double dec)
        setDir(PointSource self, SkyDir dir, bool updateExposure=True, bool verbose=True)
        setDir(PointSource self, SkyDir dir, bool updateExposure=True)
        setDir(PointSource self, SkyDir dir)
        """
        return _pyLikelihood.PointSource_setDir(self, *args)


    def fluxDensity(self, *args):
        """
        fluxDensity(PointSource self, Event evt, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(PointSource self, Event evt) -> double
        fluxDensity(PointSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(PointSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time) -> double
        """
        return _pyLikelihood.PointSource_fluxDensity(self, *args)


    def fluxDensityDeriv(self, *args):
        """
        fluxDensityDeriv(PointSource self, Event evt, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(PointSource self, Event evt, std::string const & paramName) -> double
        fluxDensityDeriv(PointSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(PointSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName) -> double
        """
        return _pyLikelihood.PointSource_fluxDensityDeriv(self, *args)


    def computeExposure(self, *args):
        """
        computeExposure(PointSource self, SkyDir dir, DoubleVector energies, Observation observation, DoubleVector exposure, bool verbose)
        computeExposure(PointSource self, DoubleVector energies, bool verbose=False)
        computeExposure(PointSource self, DoubleVector energies)
        """
        return _pyLikelihood.PointSource_computeExposure(self, *args)


    def flux(self, *args):
        """
        flux(PointSource self) -> double
        flux(PointSource self, double emin, double emax, size_t npts=100) -> double
        flux(PointSource self, double emin, double emax) -> double
        """
        return _pyLikelihood.PointSource_flux(self, *args)


    def fluxDeriv(self, *args):
        """
        fluxDeriv(PointSource self, std::string const & parName) -> double
        fluxDeriv(PointSource self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        fluxDeriv(PointSource self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.PointSource_fluxDeriv(self, *args)


    def energyFlux(self, *args):
        """
        energyFlux(PointSource self) -> double
        energyFlux(PointSource self, double emin, double emax, size_t npts=100) -> double
        energyFlux(PointSource self, double emin, double emax) -> double
        """
        return _pyLikelihood.PointSource_energyFlux(self, *args)


    def energyFluxDeriv(self, *args):
        """
        energyFluxDeriv(PointSource self, std::string const & parName) -> double
        energyFluxDeriv(PointSource self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        energyFluxDeriv(PointSource self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.PointSource_energyFluxDeriv(self, *args)


    def cast(src):
        """cast(Source src) -> PointSource"""
        return _pyLikelihood.PointSource_cast(src)

    cast = staticmethod(cast)
PointSource_swigregister = _pyLikelihood.PointSource_swigregister
PointSource_swigregister(PointSource)

def PointSource_computeExposureWithHyperCube(dir, energies, observation, exposure, verbose):
    """PointSource_computeExposureWithHyperCube(SkyDir dir, DoubleVector energies, Observation observation, DoubleVector exposure, bool verbose)"""
    return _pyLikelihood.PointSource_computeExposureWithHyperCube(dir, energies, observation, exposure, verbose)

def PointSource_cast(src):
    """PointSource_cast(Source src) -> PointSource"""
    return _pyLikelihood.PointSource_cast(src)

class ResponseFunctor(_object):
    """Proxy of C++ Likelihood::ResponseFunctor class."""

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

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

    def __call__(self, energy, separation):
        """__call__(ResponseFunctor self, double energy, double separation) -> double"""
        return _pyLikelihood.ResponseFunctor___call__(self, energy, separation)

ResponseFunctor_swigregister = _pyLikelihood.ResponseFunctor_swigregister
ResponseFunctor_swigregister(ResponseFunctor)

class BinnedResponseFunctor(ResponseFunctor):
    """Proxy of C++ Likelihood::BinnedResponseFunctor class."""

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

    def __init__(self, psf):
        """__init__(Likelihood::BinnedResponseFunctor self, MeanPsf psf) -> BinnedResponseFunctor"""
        this = _pyLikelihood.new_BinnedResponseFunctor(psf)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, energy, separation):
        """__call__(BinnedResponseFunctor self, double energy, double separation) -> double"""
        return _pyLikelihood.BinnedResponseFunctor___call__(self, energy, separation)

    __swig_destroy__ = _pyLikelihood.delete_BinnedResponseFunctor
    __del__ = lambda self: None
BinnedResponseFunctor_swigregister = _pyLikelihood.BinnedResponseFunctor_swigregister
BinnedResponseFunctor_swigregister(BinnedResponseFunctor)

class UnbinnedResponseFunctor(ResponseFunctor):
    """Proxy of C++ Likelihood::UnbinnedResponseFunctor class."""

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

    def __init__(self, respFuncs, theta, phi, type):
        """__init__(Likelihood::UnbinnedResponseFunctor self, ResponseFunctions respFuncs, double theta, double phi, int type) -> UnbinnedResponseFunctor"""
        this = _pyLikelihood.new_UnbinnedResponseFunctor(respFuncs, theta, phi, type)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, energy, separation):
        """__call__(UnbinnedResponseFunctor self, double energy, double separation) -> double"""
        return _pyLikelihood.UnbinnedResponseFunctor___call__(self, energy, separation)

    __swig_destroy__ = _pyLikelihood.delete_UnbinnedResponseFunctor
    __del__ = lambda self: None
UnbinnedResponseFunctor_swigregister = _pyLikelihood.UnbinnedResponseFunctor_swigregister
UnbinnedResponseFunctor_swigregister(UnbinnedResponseFunctor)

class SpatialFunction(Function):
    """Proxy of C++ Likelihood::SpatialFunction class."""

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

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

    def value(self, arg2):
        """value(SpatialFunction self, SkyDir arg2) -> double"""
        return _pyLikelihood.SpatialFunction_value(self, arg2)


    def spatialResponse(self, *args):
        """
        spatialResponse(SpatialFunction self, SkyDir arg2, double energy, MeanPsf psf) -> double
        spatialResponse(SpatialFunction self, double delta, double energy, MeanPsf psf) -> double
        """
        return _pyLikelihood.SpatialFunction_spatialResponse(self, *args)


    def diffuseResponse(self, *args):
        """
        diffuseResponse(SpatialFunction self, Event evt, ResponseFunctions respFuncs) -> double
        diffuseResponse(SpatialFunction self, ResponseFunctor fn, double energy, double separation) -> double
        """
        return _pyLikelihood.SpatialFunction_diffuseResponse(self, *args)


    def getDiffRespLimits(self, arg2, mumin, mumax, phimin, phimax):
        """getDiffRespLimits(SpatialFunction self, SkyDir arg2, double & mumin, double & mumax, double & phimin, double & phimax) -> double"""
        return _pyLikelihood.SpatialFunction_getDiffRespLimits(self, arg2, mumin, mumax, phimin, phimax)


    def dir(self):
        """dir(SpatialFunction self) -> SkyDir"""
        return _pyLikelihood.SpatialFunction_dir(self)


    def setCenter(self, ra, dec):
        """setCenter(SpatialFunction self, double ra, double dec)"""
        return _pyLikelihood.SpatialFunction_setCenter(self, ra, dec)


    def update(self):
        """update(SpatialFunction self)"""
        return _pyLikelihood.SpatialFunction_update(self)


    def setParam(self, paramName, paramValue):
        """setParam(SpatialFunction self, std::string const & paramName, double paramValue)"""
        return _pyLikelihood.SpatialFunction_setParam(self, paramName, paramValue)


    def mapRadius(self):
        """mapRadius(SpatialFunction self) -> double"""
        return _pyLikelihood.SpatialFunction_mapRadius(self)

SpatialFunction_swigregister = _pyLikelihood.SpatialFunction_swigregister
SpatialFunction_swigregister(SpatialFunction)

class SourceFactory(_object):
    """Proxy of C++ Likelihood::SourceFactory class."""

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

    def __init__(self, observation, verbose=False):
        """
        __init__(Likelihood::SourceFactory self, Observation observation, bool verbose=False) -> SourceFactory
        __init__(Likelihood::SourceFactory self, Observation observation) -> SourceFactory
        """
        this = _pyLikelihood.new_SourceFactory(observation, verbose)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_SourceFactory
    __del__ = lambda self: None

    def create(self, name):
        """create(SourceFactory self, std::string const & name) -> Source"""
        return _pyLikelihood.SourceFactory_create(self, name)


    def releaseSource(self, name):
        """releaseSource(SourceFactory self, std::string const & name) -> Source"""
        return _pyLikelihood.SourceFactory_releaseSource(self, name)


    def addSource(self, name, src, fromClone=True):
        """
        addSource(SourceFactory self, std::string const & name, Source src, bool fromClone=True)
        addSource(SourceFactory self, std::string const & name, Source src)
        """
        return _pyLikelihood.SourceFactory_addSource(self, name, src, fromClone)


    def replaceSource(self, src, fromClone=True):
        """
        replaceSource(SourceFactory self, Source src, bool fromClone=True)
        replaceSource(SourceFactory self, Source src)
        """
        return _pyLikelihood.SourceFactory_replaceSource(self, src, fromClone)


    def readXml(self, xmlFile, arg3, requireExposure=True, addPointSources=True, loadMaps=True):
        """
        readXml(SourceFactory self, std::string const & xmlFile, FunctionFactory arg3, bool requireExposure=True, bool addPointSources=True, bool loadMaps=True)
        readXml(SourceFactory self, std::string const & xmlFile, FunctionFactory arg3, bool requireExposure=True, bool addPointSources=True)
        readXml(SourceFactory self, std::string const & xmlFile, FunctionFactory arg3, bool requireExposure=True)
        readXml(SourceFactory self, std::string const & xmlFile, FunctionFactory arg3)
        """
        return _pyLikelihood.SourceFactory_readXml(self, xmlFile, arg3, requireExposure, addPointSources, loadMaps)


    def fetchSrcNames(self, srcNames):
        """fetchSrcNames(SourceFactory self, StringVector srcNames)"""
        return _pyLikelihood.SourceFactory_fetchSrcNames(self, srcNames)


    def funcFactory():
        """funcFactory() -> FunctionFactory"""
        return _pyLikelihood.SourceFactory_funcFactory()

    funcFactory = staticmethod(funcFactory)
SourceFactory_swigregister = _pyLikelihood.SourceFactory_swigregister
SourceFactory_swigregister(SourceFactory)

def SourceFactory_funcFactory():
    """SourceFactory_funcFactory() -> FunctionFactory"""
    return _pyLikelihood.SourceFactory_funcFactory()

class SourceMapCache(_object):
    """Proxy of C++ Likelihood::SourceMapCache class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::SourceMapCache self, BinnedCountsCache dataCache, Observation observation, std::string const & srcMapsFile, BinnedLikeConfig config, Drm drm=None) -> SourceMapCache
        __init__(Likelihood::SourceMapCache self, BinnedCountsCache dataCache, Observation observation, std::string const & srcMapsFile, BinnedLikeConfig config) -> SourceMapCache
        __init__(Likelihood::SourceMapCache self, SourceMapCache other) -> SourceMapCache
        """
        this = _pyLikelihood.new_SourceMapCache(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """clone(SourceMapCache self) -> SourceMapCache"""
        return _pyLikelihood.SourceMapCache_clone(self)

    __swig_destroy__ = _pyLikelihood.delete_SourceMapCache
    __del__ = lambda self: None

    def dataCache(self):
        """dataCache(SourceMapCache self) -> BinnedCountsCache"""
        return _pyLikelihood.SourceMapCache_dataCache(self)


    def config(self):
        """config(SourceMapCache self) -> BinnedLikeConfig"""
        return _pyLikelihood.SourceMapCache_config(self)


    def srcMapsFile(self):
        """srcMapsFile(SourceMapCache self) -> std::string const &"""
        return _pyLikelihood.SourceMapCache_srcMapsFile(self)


    def n_srcs(self):
        """n_srcs(SourceMapCache self) -> size_t"""
        return _pyLikelihood.SourceMapCache_n_srcs(self)


    def setVerbose(self, verbose):
        """setVerbose(SourceMapCache self, bool verbose)"""
        return _pyLikelihood.SourceMapCache_setVerbose(self, verbose)


    def set_edisp_val(self, edisp_val):
        """set_edisp_val(SourceMapCache self, int edisp_val)"""
        return _pyLikelihood.SourceMapCache_set_edisp_val(self, edisp_val)


    def createCountsMap(self, *args):
        """
        createCountsMap(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs, CountsMapBase dataMap) -> CountsMapBase
        createCountsMap(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs) -> CountsMapBase
        """
        return _pyLikelihood.SourceMapCache_createCountsMap(self, *args)


    def NpredValue(self, *args):
        """
        NpredValue(SourceMapCache self, Source src, size_t kmin, size_t kmax, bool weighted=False) -> double
        NpredValue(SourceMapCache self, Source src, size_t kmin, size_t kmax) -> double
        NpredValue(SourceMapCache self, Source src, SourceMap srcMap, size_t kmin, size_t kmax, bool weighted=False) -> double
        NpredValue(SourceMapCache self, Source src, SourceMap srcMap, size_t kmin, size_t kmax) -> double
        """
        return _pyLikelihood.SourceMapCache_NpredValue(self, *args)


    def hasSourceMap(self, name):
        """hasSourceMap(SourceMapCache self, std::string const & name) -> bool"""
        return _pyLikelihood.SourceMapCache_hasSourceMap(self, name)


    def getSourceMap(self, src, verbose=True, config=None):
        """
        getSourceMap(SourceMapCache self, Source src, bool verbose=True, BinnedLikeConfig config=None) -> SourceMap
        getSourceMap(SourceMapCache self, Source src, bool verbose=True) -> SourceMap
        getSourceMap(SourceMapCache self, Source src) -> SourceMap
        """
        return _pyLikelihood.SourceMapCache_getSourceMap(self, src, verbose, config)


    def createSourceMap(self, src, config=None):
        """
        createSourceMap(SourceMapCache self, Source src, BinnedLikeConfig config=None) -> SourceMap
        createSourceMap(SourceMapCache self, Source src) -> SourceMap
        """
        return _pyLikelihood.SourceMapCache_createSourceMap(self, src, config)


    def eraseSourceMap(self, srcName):
        """eraseSourceMap(SourceMapCache self, std::string const & srcName)"""
        return _pyLikelihood.SourceMapCache_eraseSourceMap(self, srcName)


    def insertSourceMap(self, srcName, srcMap):
        """insertSourceMap(SourceMapCache self, std::string const & srcName, SourceMap srcMap)"""
        return _pyLikelihood.SourceMapCache_insertSourceMap(self, srcName, srcMap)


    def removeSourceMap(self, srcName):
        """removeSourceMap(SourceMapCache self, std::string const & srcName) -> SourceMap"""
        return _pyLikelihood.SourceMapCache_removeSourceMap(self, srcName)


    def loadSourceMaps(self, srcs, recreate=False, saveMaps=False):
        """
        loadSourceMaps(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs, bool recreate=False, bool saveMaps=False)
        loadSourceMaps(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs, bool recreate=False)
        loadSourceMaps(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs)
        """
        return _pyLikelihood.SourceMapCache_loadSourceMaps(self, srcs, recreate, saveMaps)


    def loadSourceMap(self, src, recreate=False, config=None):
        """
        loadSourceMap(SourceMapCache self, Source src, bool recreate=False, BinnedLikeConfig config=None)
        loadSourceMap(SourceMapCache self, Source src, bool recreate=False)
        loadSourceMap(SourceMapCache self, Source src)
        """
        return _pyLikelihood.SourceMapCache_loadSourceMap(self, src, recreate, config)


    def setSourceMapImage(self, src, image):
        """setSourceMapImage(SourceMapCache self, Source src, FloatVector image)"""
        return _pyLikelihood.SourceMapCache_setSourceMapImage(self, src, image)


    def saveSourceMaps(self, filename, srcs, replace=False):
        """
        saveSourceMaps(SourceMapCache self, std::string const & filename, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs, bool replace=False)
        saveSourceMaps(SourceMapCache self, std::string const & filename, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs)
        """
        return _pyLikelihood.SourceMapCache_saveSourceMaps(self, filename, srcs, replace)


    def saveSourceMap_partial(self, filename, source, kmin=0, kmax=-1, replace=False):
        """
        saveSourceMap_partial(SourceMapCache self, std::string const & filename, Source source, int kmin=0, int kmax=-1, bool replace=False)
        saveSourceMap_partial(SourceMapCache self, std::string const & filename, Source source, int kmin=0, int kmax=-1)
        saveSourceMap_partial(SourceMapCache self, std::string const & filename, Source source, int kmin=0)
        saveSourceMap_partial(SourceMapCache self, std::string const & filename, Source source)
        """
        return _pyLikelihood.SourceMapCache_saveSourceMap_partial(self, filename, source, kmin, kmax, replace)


    def computeModelMap(self, *args):
        """
        computeModelMap(SourceMapCache self, Source src, FloatVector modelMap, bool use_mask=True)
        computeModelMap(SourceMapCache self, Source src, FloatVector modelMap)
        computeModelMap(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs, FloatVector modelMap, bool use_mask=True)
        computeModelMap(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & srcs, FloatVector modelMap)
        """
        return _pyLikelihood.SourceMapCache_computeModelMap(self, *args)


    def updateModelMap(self, modelMap, src, srcMap, use_mask=True):
        """
        updateModelMap(SourceMapCache self, FloatVector modelMap, Source src, SourceMap srcMap, bool use_mask=True)
        updateModelMap(SourceMapCache self, FloatVector modelMap, Source src, SourceMap srcMap)
        """
        return _pyLikelihood.SourceMapCache_updateModelMap(self, modelMap, src, srcMap, use_mask)


    def updateModelMap_fromSrcMap(self, modelMap, src, srcMap, use_mask=True):
        """
        updateModelMap_fromSrcMap(SourceMapCache self, FloatVector modelMap, Source src, SourceMap srcMap, bool use_mask=True)
        updateModelMap_fromSrcMap(SourceMapCache self, FloatVector modelMap, Source src, SourceMap srcMap)
        """
        return _pyLikelihood.SourceMapCache_updateModelMap_fromSrcMap(self, modelMap, src, srcMap, use_mask)


    def getNpreds(self, src, npreds):
        """getNpreds(SourceMapCache self, Source src, DoubleVector npreds)"""
        return _pyLikelihood.SourceMapCache_getNpreds(self, src, npreds)


    def modelCountsSpectrum(self, src, weighted=False):
        """
        modelCountsSpectrum(SourceMapCache self, Source src, bool weighted=False) -> DoubleVector
        modelCountsSpectrum(SourceMapCache self, Source src) -> DoubleVector
        """
        return _pyLikelihood.SourceMapCache_modelCountsSpectrum(self, src, weighted)


    def setWeightsMap(self, wmap):
        """setWeightsMap(SourceMapCache self, ProjMap wmap)"""
        return _pyLikelihood.SourceMapCache_setWeightsMap(self, wmap)


    def fillSummedSourceMap(self, sources, model, kmin=0, kmax=-1):
        """
        fillSummedSourceMap(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & sources, FloatVector model, int kmin=0, int kmax=-1)
        fillSummedSourceMap(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & sources, FloatVector model, int kmin=0)
        fillSummedSourceMap(SourceMapCache self, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > const & sources, FloatVector model)
        """
        return _pyLikelihood.SourceMapCache_fillSummedSourceMap(self, sources, model, kmin, kmax)


    def fillSingleSourceMap(self, src, model, mapType, kmin=0, kmax=-1):
        """
        fillSingleSourceMap(SourceMapCache self, Source src, FloatVector model, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1)
        fillSingleSourceMap(SourceMapCache self, Source src, FloatVector model, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0)
        fillSingleSourceMap(SourceMapCache self, Source src, FloatVector model, Likelihood::FileUtils::SrcMapType & mapType)
        """
        return _pyLikelihood.SourceMapCache_fillSingleSourceMap(self, src, model, mapType, kmin, kmax)


    def edisp_val(self, src=None):
        """
        edisp_val(SourceMapCache self, Source src=None) -> int
        edisp_val(SourceMapCache self) -> int
        """
        return _pyLikelihood.SourceMapCache_edisp_val(self, src)


    def memory_size(self):
        """memory_size(SourceMapCache self) -> size_t"""
        return _pyLikelihood.SourceMapCache_memory_size(self)

SourceMapCache_swigregister = _pyLikelihood.SourceMapCache_swigregister
SourceMapCache_swigregister(SourceMapCache)

class SourceModel(Statistic):
    """Proxy of C++ Likelihood::SourceModel class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::SourceModel self, Observation observation, bool verbose=False) -> SourceModel
        __init__(Likelihood::SourceModel self, Observation observation) -> SourceModel
        __init__(Likelihood::SourceModel self, SourceModel rhs) -> SourceModel
        """
        this = _pyLikelihood.new_SourceModel(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_SourceModel
    __del__ = lambda self: None

    def setParam(self, param, funcName, srcName):
        """setParam(SourceModel self, Parameter param, std::string const & funcName, std::string const & srcName)"""
        return _pyLikelihood.SourceModel_setParam(self, param, funcName, srcName)


    def setParamValues_(self, arg2):
        """setParamValues_(SourceModel self, std::vector< double,std::allocator< double > >::const_iterator arg2) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.SourceModel_setParamValues_(self, arg2)


    def setFreeParamValues_(self, arg2):
        """setFreeParamValues_(SourceModel self, std::vector< double,std::allocator< double > >::const_iterator arg2) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.SourceModel_setFreeParamValues_(self, arg2)


    def getParamValue(self, paramName, funcName, srcName):
        """getParamValue(SourceModel self, std::string const & paramName, std::string const & funcName, std::string const & srcName) -> double"""
        return _pyLikelihood.SourceModel_getParamValue(self, paramName, funcName, srcName)


    def getParam(self, paramName, funcName, srcName):
        """getParam(SourceModel self, std::string const & paramName, std::string const & funcName, std::string const & srcName) -> Parameter"""
        return _pyLikelihood.SourceModel_getParam(self, paramName, funcName, srcName)


    def setParamTrueValue(self, paramName, funcName, srcName, paramValue):
        """setParamTrueValue(SourceModel self, std::string const & paramName, std::string const & funcName, std::string const & srcName, double paramValue)"""
        return _pyLikelihood.SourceModel_setParamTrueValue(self, paramName, funcName, srcName, paramValue)


    def setParams(self, params):
        """setParams(SourceModel self, ParameterVector params)"""
        return _pyLikelihood.SourceModel_setParams(self, params)


    def setFreeParams(self, params):
        """setFreeParams(SourceModel self, ParameterVector params)"""
        return _pyLikelihood.SourceModel_setFreeParams(self, params)


    def getFreeDerivs(self, x, derivs):
        """getFreeDerivs(SourceModel self, Arg x, DoubleVector derivs)"""
        return _pyLikelihood.SourceModel_getFreeDerivs(self, x, derivs)


    def addSource(self, src, fromClone=True, srcMap=None, loadMap=True):
        """
        addSource(SourceModel self, Source src, bool fromClone=True, SourceMap srcMap=None, bool loadMap=True)
        addSource(SourceModel self, Source src, bool fromClone=True, SourceMap srcMap=None)
        addSource(SourceModel self, Source src, bool fromClone=True)
        addSource(SourceModel self, Source src)
        """
        return _pyLikelihood.SourceModel_addSource(self, src, fromClone, srcMap, loadMap)


    def deleteSource(self, srcName):
        """deleteSource(SourceModel self, std::string const & srcName) -> Source"""
        return _pyLikelihood.SourceModel_deleteSource(self, srcName)


    def deleteAllSources(self):
        """deleteAllSources(SourceModel self)"""
        return _pyLikelihood.SourceModel_deleteAllSources(self)


    def getSource(self, srcName):
        """getSource(SourceModel self, std::string const & srcName) -> Source"""
        return _pyLikelihood.SourceModel_getSource(self, srcName)


    def source(self, srcName):
        """source(SourceModel self, std::string const & srcName) -> Source"""
        return _pyLikelihood.SourceModel_source(self, srcName)


    def getSources(self, srcNames, srcs):
        """getSources(SourceModel self, StringVector srcNames, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > & srcs)"""
        return _pyLikelihood.SourceModel_getSources(self, srcNames, srcs)


    def sources(self):
        """sources(SourceModel self) -> std::map< std::string,Likelihood::Source *,std::less< std::string >,std::allocator< std::pair< std::string const,Likelihood::Source * > > > const &"""
        return _pyLikelihood.SourceModel_sources(self)


    def getNumSrcs(self):
        """getNumSrcs(SourceModel self) -> unsigned int"""
        return _pyLikelihood.SourceModel_getNumSrcs(self)


    def getSrcNames(self, arg2):
        """getSrcNames(SourceModel self, StringVector arg2)"""
        return _pyLikelihood.SourceModel_getSrcNames(self, arg2)


    def hasSrcNamed(self, srcName):
        """hasSrcNamed(SourceModel self, std::string const & srcName) -> bool"""
        return _pyLikelihood.SourceModel_hasSrcNamed(self, srcName)


    def mergeSources(self, compName, srcNames, specFuncName):
        """mergeSources(SourceModel self, std::string const & compName, StringVector srcNames, std::string const & specFuncName) -> CompositeSource"""
        return _pyLikelihood.SourceModel_mergeSources(self, compName, srcNames, specFuncName)


    def splitCompositeSource(self, compName, srcNames):
        """splitCompositeSource(SourceModel self, std::string const & compName, StringVector srcNames) -> Function"""
        return _pyLikelihood.SourceModel_splitCompositeSource(self, compName, srcNames)


    def steal_source(self, other, srcName, srcMap):
        """steal_source(SourceModel self, SourceModel other, std::string const & srcName, SourceMap srcMap) -> Source"""
        return _pyLikelihood.SourceModel_steal_source(self, other, srcName, srcMap)


    def give_source(self, other, srcName, srcMap):
        """give_source(SourceModel self, SourceModel other, std::string const & srcName, SourceMap srcMap) -> Source"""
        return _pyLikelihood.SourceModel_give_source(self, other, srcName, srcMap)


    def value(self, x):
        """value(SourceModel self, Arg x) -> double"""
        return _pyLikelihood.SourceModel_value(self, x)


    def readXml(self, xmlFile, funcFactory, requireExposure=True, addPointSources=True, loadMaps=True):
        """
        readXml(SourceModel self, std::string xmlFile, FunctionFactory funcFactory, bool requireExposure=True, bool addPointSources=True, bool loadMaps=True)
        readXml(SourceModel self, std::string xmlFile, FunctionFactory funcFactory, bool requireExposure=True, bool addPointSources=True)
        readXml(SourceModel self, std::string xmlFile, FunctionFactory funcFactory, bool requireExposure=True)
        readXml(SourceModel self, std::string xmlFile, FunctionFactory funcFactory)
        """
        return _pyLikelihood.SourceModel_readXml(self, xmlFile, funcFactory, requireExposure, addPointSources, loadMaps)


    def reReadXml(self, xmlFile):
        """reReadXml(SourceModel self, std::string xmlFile)"""
        return _pyLikelihood.SourceModel_reReadXml(self, xmlFile)


    def writeXml(self, *args):
        """
        writeXml(SourceModel self, std::string xmlFile, std::string const & functionLibrary, std::string const & srcLibTitle)
        writeXml(SourceModel self, std::string xmlFile, std::string const & functionLibrary)
        writeXml(SourceModel self, std::string xmlFile)
        writeXml(SourceModel self, Likelihood::SourceModelBuilder & builder)
        """
        return _pyLikelihood.SourceModel_writeXml(self, *args)


    def write_fluxXml(self, *args):
        """
        write_fluxXml(SourceModel self, std::string xmlFile)
        write_fluxXml(SourceModel self, Likelihood::FluxBuilder & builder)
        """
        return _pyLikelihood.SourceModel_write_fluxXml(self, *args)


    def createCountsMap(self, *args):
        """
        createCountsMap(SourceModel self, CountsMapBase dataMap) -> CountsMapBase
        createCountsMap(SourceModel self) -> CountsMapBase
        """
        return _pyLikelihood.SourceModel_createCountsMap(self, *args)


    def observation(self):
        """observation(SourceModel self) -> Observation"""
        return _pyLikelihood.SourceModel_observation(self)


    def syncParams(self):
        """syncParams(SourceModel self)"""
        return _pyLikelihood.SourceModel_syncParams(self)


    def parameters(self, *args):
        """
        parameters(SourceModel self) -> ParameterVector
        parameters(SourceModel self) -> ParameterVector
        """
        return _pyLikelihood.SourceModel_parameters(self, *args)


    def set_ebounds(self, emin, emax):
        """set_ebounds(SourceModel self, double emin, double emax)"""
        return _pyLikelihood.SourceModel_set_ebounds(self, emin, emax)


    def unset_ebounds(self):
        """unset_ebounds(SourceModel self)"""
        return _pyLikelihood.SourceModel_unset_ebounds(self)

SourceModel_swigregister = _pyLikelihood.SourceModel_swigregister
SourceModel_swigregister(SourceModel)

class CompositeSource(Source):
    """Proxy of C++ Likelihood::CompositeSource class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::CompositeSource self, Observation observation=0) -> CompositeSource
        __init__(Likelihood::CompositeSource self) -> CompositeSource
        __init__(Likelihood::CompositeSource self, Observation observation, std::string const & name, std::string const & specFuncName) -> CompositeSource
        __init__(Likelihood::CompositeSource self, CompositeSource rhs) -> CompositeSource
        """
        this = _pyLikelihood.new_CompositeSource(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_CompositeSource
    __del__ = lambda self: None

    def clone(self):
        """clone(CompositeSource self) -> Source"""
        return _pyLikelihood.CompositeSource_clone(self)


    def config(self):
        """config(CompositeSource self) -> BinnedLikeConfig"""
        return _pyLikelihood.CompositeSource_config(self)


    def xmlFile(self):
        """xmlFile(CompositeSource self) -> std::string const &"""
        return _pyLikelihood.CompositeSource_xmlFile(self)


    def sourceModel(self):
        """sourceModel(CompositeSource self) -> SourceModel"""
        return _pyLikelihood.CompositeSource_sourceModel(self)


    def addSource(self, src, srcMap=None, fromClone=False):
        """
        addSource(CompositeSource self, Source src, SourceMap srcMap=None, bool fromClone=False)
        addSource(CompositeSource self, Source src, SourceMap srcMap=None)
        addSource(CompositeSource self, Source src)
        """
        return _pyLikelihood.CompositeSource_addSource(self, src, srcMap, fromClone)


    def deleteSource(self, srcName, srcMap):
        """deleteSource(CompositeSource self, std::string const & srcName, Likelihood::SourceMap *& srcMap) -> Source"""
        return _pyLikelihood.CompositeSource_deleteSource(self, srcName, srcMap)


    def deleteAllSources(self):
        """deleteAllSources(CompositeSource self)"""
        return _pyLikelihood.CompositeSource_deleteAllSources(self)


    def getSource(self, srcName):
        """getSource(CompositeSource self, std::string const & srcName) -> Source"""
        return _pyLikelihood.CompositeSource_getSource(self, srcName)


    def source(self, srcName):
        """source(CompositeSource self, std::string const & srcName) -> Source"""
        return _pyLikelihood.CompositeSource_source(self, srcName)


    def getSources(self, srcNames, srcs):
        """getSources(CompositeSource self, StringVector srcNames, std::vector< Likelihood::Source const *,std::allocator< Likelihood::Source const * > > & srcs)"""
        return _pyLikelihood.CompositeSource_getSources(self, srcNames, srcs)


    def getNumSrcs(self):
        """getNumSrcs(CompositeSource self) -> unsigned int"""
        return _pyLikelihood.CompositeSource_getNumSrcs(self)


    def getSrcNames(self, srcNames):
        """getSrcNames(CompositeSource self, StringVector srcNames)"""
        return _pyLikelihood.CompositeSource_getSrcNames(self, srcNames)


    def hasSrcNamed(self, srcName):
        """hasSrcNamed(CompositeSource self, std::string const & srcName) -> bool"""
        return _pyLikelihood.CompositeSource_hasSrcNamed(self, srcName)


    def steal_source(self, other, srcName):
        """steal_source(CompositeSource self, SourceModel other, std::string const & srcName) -> Source"""
        return _pyLikelihood.CompositeSource_steal_source(self, other, srcName)


    def give_source(self, other, srcName):
        """give_source(CompositeSource self, SourceModel other, std::string const & srcName) -> Source"""
        return _pyLikelihood.CompositeSource_give_source(self, other, srcName)


    def buildSourceMapCache(self, dataCache, srcMapsFile, drm=None):
        """
        buildSourceMapCache(CompositeSource self, BinnedCountsCache dataCache, std::string const & srcMapsFile, Drm drm=None) -> SourceMapCache
        buildSourceMapCache(CompositeSource self, BinnedCountsCache dataCache, std::string const & srcMapsFile) -> SourceMapCache
        """
        return _pyLikelihood.CompositeSource_buildSourceMapCache(self, dataCache, srcMapsFile, drm)


    def sourceMapCache(self):
        """sourceMapCache(CompositeSource self) -> SourceMapCache"""
        return _pyLikelihood.CompositeSource_sourceMapCache(self)


    def fluxDensity(self, *args):
        """
        fluxDensity(CompositeSource self, Event evt, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(CompositeSource self, Event evt) -> double
        fluxDensity(CompositeSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensity(CompositeSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time) -> double
        """
        return _pyLikelihood.CompositeSource_fluxDensity(self, *args)


    def fluxDensityDeriv(self, *args):
        """
        fluxDensityDeriv(CompositeSource self, Event evt, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(CompositeSource self, Event evt, std::string const & paramName) -> double
        fluxDensityDeriv(CompositeSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName, Likelihood::Source::CachedResponse * cResp=None) -> double
        fluxDensityDeriv(CompositeSource self, double inclination, double phi, double energy, SkyDir appDir, int evtType, double time, std::string const & paramName) -> double
        """
        return _pyLikelihood.CompositeSource_fluxDensityDeriv(self, *args)


    def computeExposure(self, energies, verbose=False):
        """
        computeExposure(CompositeSource self, DoubleVector energies, bool verbose=False)
        computeExposure(CompositeSource self, DoubleVector energies)
        """
        return _pyLikelihood.CompositeSource_computeExposure(self, energies, verbose)


    def flux(self, *args):
        """
        flux(CompositeSource self) -> double
        flux(CompositeSource self, double emin, double emax, size_t npts=100) -> double
        flux(CompositeSource self, double emin, double emax) -> double
        """
        return _pyLikelihood.CompositeSource_flux(self, *args)


    def fluxDeriv(self, *args):
        """
        fluxDeriv(CompositeSource self, std::string const & parName) -> double
        fluxDeriv(CompositeSource self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        fluxDeriv(CompositeSource self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.CompositeSource_fluxDeriv(self, *args)


    def energyFlux(self, *args):
        """
        energyFlux(CompositeSource self) -> double
        energyFlux(CompositeSource self, double emin, double emax, size_t npts=100) -> double
        energyFlux(CompositeSource self, double emin, double emax) -> double
        """
        return _pyLikelihood.CompositeSource_energyFlux(self, *args)


    def energyFluxDeriv(self, *args):
        """
        energyFluxDeriv(CompositeSource self, std::string const & parName) -> double
        energyFluxDeriv(CompositeSource self, std::string const & parName, double emin, double emax, size_t npts=100) -> double
        energyFluxDeriv(CompositeSource self, std::string const & parName, double emin, double emax) -> double
        """
        return _pyLikelihood.CompositeSource_energyFluxDeriv(self, *args)


    def fillSummedSourceMap(self, model, kmin=0, kmax=-1):
        """
        fillSummedSourceMap(CompositeSource self, FloatVector model, int kmin=0, int kmax=-1)
        fillSummedSourceMap(CompositeSource self, FloatVector model, int kmin=0)
        fillSummedSourceMap(CompositeSource self, FloatVector model)
        """
        return _pyLikelihood.CompositeSource_fillSummedSourceMap(self, model, kmin, kmax)


    def cast(src):
        """cast(Source src) -> CompositeSource"""
        return _pyLikelihood.CompositeSource_cast(src)

    cast = staticmethod(cast)
CompositeSource_swigregister = _pyLikelihood.CompositeSource_swigregister
CompositeSource_swigregister(CompositeSource)

def CompositeSource_cast(src):
    """CompositeSource_cast(Source src) -> CompositeSource"""
    return _pyLikelihood.CompositeSource_cast(src)


def fillMapWithPSF_pole(psf, energy, outMap):
    """fillMapWithPSF_pole(MeanPsf psf, double const & energy, Healpix_Map< float > & outMap)"""
    return _pyLikelihood.fillMapWithPSF_pole(psf, energy, outMap)

def fillMapWithPSF_refDir(psf, energy, refDir, use_lb, outMap):
    """fillMapWithPSF_refDir(MeanPsf psf, double const & energy, SkyDir refDir, bool use_lb, Healpix_Map< float > & outMap)"""
    return _pyLikelihood.fillMapWithPSF_refDir(psf, energy, refDir, use_lb, outMap)

def convolve(inMap, psf, outMap):
    """convolve(Healpix_Map< float > const & inMap, Healpix_Map< float > const & psf, Healpix_Map< float > & outMap)"""
    return _pyLikelihood.convolve(inMap, psf, outMap)

def psfMinPixSize(energy):
    """psfMinPixSize(double energy) -> double"""
    return _pyLikelihood.psfMinPixSize(energy)
class RadialProfile(Function):
    """Proxy of C++ Likelihood::RadialProfile class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::RadialProfile self) -> RadialProfile
        __init__(Likelihood::RadialProfile self, std::string const & template_file) -> RadialProfile
        __init__(Likelihood::RadialProfile self, RadialProfile arg2) -> RadialProfile
        """
        this = _pyLikelihood.new_RadialProfile(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_RadialProfile
    __del__ = lambda self: None

    def readTemplateFile(self, template_file):
        """readTemplateFile(RadialProfile self, std::string const & template_file)"""
        return _pyLikelihood.RadialProfile_readTemplateFile(self, template_file)


    def templateFile(self):
        """templateFile(RadialProfile self) -> std::string const &"""
        return _pyLikelihood.RadialProfile_templateFile(self)


    def setCenter(self, ra, dec):
        """setCenter(RadialProfile self, double ra, double dec)"""
        return _pyLikelihood.RadialProfile_setCenter(self, ra, dec)


    def clone(self):
        """clone(RadialProfile self) -> Function"""
        return _pyLikelihood.RadialProfile_clone(self)


    def angularIntegral(self):
        """angularIntegral(RadialProfile self) -> double"""
        return _pyLikelihood.RadialProfile_angularIntegral(self)


    def mapRadius(self):
        """mapRadius(RadialProfile self) -> double"""
        return _pyLikelihood.RadialProfile_mapRadius(self)


    def getCenter(self):
        """getCenter(RadialProfile self) -> SkyDir"""
        return _pyLikelihood.RadialProfile_getCenter(self)


    def valueAtOffset(self, offset):
        """valueAtOffset(RadialProfile self, double offset) -> double"""
        return _pyLikelihood.RadialProfile_valueAtOffset(self, offset)

RadialProfile_swigregister = _pyLikelihood.RadialProfile_swigregister
RadialProfile_swigregister(RadialProfile)

class RadialDisk(SpatialFunction):
    """Proxy of C++ Likelihood::RadialDisk class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::RadialDisk self) -> RadialDisk
        __init__(Likelihood::RadialDisk self, double ra, double dec, double radius) -> RadialDisk
        __init__(Likelihood::RadialDisk self, RadialDisk arg2) -> RadialDisk
        """
        this = _pyLikelihood.new_RadialDisk(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_RadialDisk
    __del__ = lambda self: None

    def value(self, *args):
        """
        value(RadialDisk self, SkyDir arg2) -> double
        value(RadialDisk self, double delta, double radius) -> double
        """
        return _pyLikelihood.RadialDisk_value(self, *args)


    def spatialResponse(self, *args):
        """
        spatialResponse(RadialDisk self, SkyDir arg2, double energy, MeanPsf psf) -> double
        spatialResponse(RadialDisk self, double delta, double energy, MeanPsf psf) -> double
        """
        return _pyLikelihood.RadialDisk_spatialResponse(self, *args)


    def diffuseResponse(self, fn, energy, separation):
        """diffuseResponse(RadialDisk self, ResponseFunctor fn, double energy, double separation) -> double"""
        return _pyLikelihood.RadialDisk_diffuseResponse(self, fn, energy, separation)


    def getDiffRespLimits(self, arg2, mumin, mumax, phimin, phimax):
        """getDiffRespLimits(RadialDisk self, SkyDir arg2, double & mumin, double & mumax, double & phimin, double & phimax) -> double"""
        return _pyLikelihood.RadialDisk_getDiffRespLimits(self, arg2, mumin, mumax, phimin, phimax)


    def clone(self):
        """clone(RadialDisk self) -> RadialDisk"""
        return _pyLikelihood.RadialDisk_clone(self)


    def update(self):
        """update(RadialDisk self)"""
        return _pyLikelihood.RadialDisk_update(self)


    def convolve(fn, energy, separation, sigma, tol=0.0001):
        """
        convolve(ResponseFunctor fn, double energy, double separation, double sigma, double tol=0.0001) -> double
        convolve(ResponseFunctor fn, double energy, double separation, double sigma) -> double
        """
        return _pyLikelihood.RadialDisk_convolve(fn, energy, separation, sigma, tol)

    convolve = staticmethod(convolve)

    def mapRadius(self):
        """mapRadius(RadialDisk self) -> double"""
        return _pyLikelihood.RadialDisk_mapRadius(self)

RadialDisk_swigregister = _pyLikelihood.RadialDisk_swigregister
RadialDisk_swigregister(RadialDisk)

def RadialDisk_convolve(fn, energy, separation, sigma, tol=0.0001):
    """
    convolve(ResponseFunctor fn, double energy, double separation, double sigma, double tol=0.0001) -> double
    RadialDisk_convolve(ResponseFunctor fn, double energy, double separation, double sigma) -> double
    """
    return _pyLikelihood.RadialDisk_convolve(fn, energy, separation, sigma, tol)

class RadialGaussian(SpatialFunction):
    """Proxy of C++ Likelihood::RadialGaussian class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::RadialGaussian self) -> RadialGaussian
        __init__(Likelihood::RadialGaussian self, double ra, double dec, double sigma) -> RadialGaussian
        __init__(Likelihood::RadialGaussian self, RadialGaussian arg2) -> RadialGaussian
        """
        this = _pyLikelihood.new_RadialGaussian(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_RadialGaussian
    __del__ = lambda self: None

    def value(self, *args):
        """
        value(RadialGaussian self, SkyDir arg2) -> double
        value(RadialGaussian self, double delta, double sigma) -> double
        """
        return _pyLikelihood.RadialGaussian_value(self, *args)


    def spatialResponse(self, *args):
        """
        spatialResponse(RadialGaussian self, SkyDir arg2, double energy, MeanPsf psf) -> double
        spatialResponse(RadialGaussian self, double delta, double energy, MeanPsf psf) -> double
        """
        return _pyLikelihood.RadialGaussian_spatialResponse(self, *args)


    def diffuseResponse(self, fn, energy, dtheta):
        """diffuseResponse(RadialGaussian self, ResponseFunctor fn, double energy, double dtheta) -> double"""
        return _pyLikelihood.RadialGaussian_diffuseResponse(self, fn, energy, dtheta)


    def getDiffRespLimits(self, arg2, mumin, mumax, phimin, phimax):
        """getDiffRespLimits(RadialGaussian self, SkyDir arg2, double & mumin, double & mumax, double & phimin, double & phimax) -> double"""
        return _pyLikelihood.RadialGaussian_getDiffRespLimits(self, arg2, mumin, mumax, phimin, phimax)


    def clone(self):
        """clone(RadialGaussian self) -> RadialGaussian"""
        return _pyLikelihood.RadialGaussian_clone(self)


    def update(self):
        """update(RadialGaussian self)"""
        return _pyLikelihood.RadialGaussian_update(self)


    def convolve(fn, energy, separation, sigma, tol=0.0001):
        """
        convolve(ResponseFunctor fn, double energy, double separation, double sigma, double tol=0.0001) -> double
        convolve(ResponseFunctor fn, double energy, double separation, double sigma) -> double
        """
        return _pyLikelihood.RadialGaussian_convolve(fn, energy, separation, sigma, tol)

    convolve = staticmethod(convolve)

    def mapRadius(self):
        """mapRadius(RadialGaussian self) -> double"""
        return _pyLikelihood.RadialGaussian_mapRadius(self)

RadialGaussian_swigregister = _pyLikelihood.RadialGaussian_swigregister
RadialGaussian_swigregister(RadialGaussian)

def RadialGaussian_convolve(fn, energy, separation, sigma, tol=0.0001):
    """
    convolve(ResponseFunctor fn, double energy, double separation, double sigma, double tol=0.0001) -> double
    RadialGaussian_convolve(ResponseFunctor fn, double energy, double separation, double sigma) -> double
    """
    return _pyLikelihood.RadialGaussian_convolve(fn, energy, separation, sigma, tol)

class LogLike(SourceModel):
    """Proxy of C++ Likelihood::LogLike class."""

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

    def __init__(self, observation):
        """__init__(Likelihood::LogLike self, Observation observation) -> LogLike"""
        this = _pyLikelihood.new_LogLike(observation)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_LogLike
    __del__ = lambda self: None

    def value(self, *args):
        """
        value(LogLike self, Arg dummy, bool include_priors) -> double
        value(LogLike self, Arg dummy) -> double
        value(LogLike self) -> double
        """
        return _pyLikelihood.LogLike_value(self, *args)


    def getFreeDerivs(self, *args):
        """
        getFreeDerivs(LogLike self, Arg dummy, DoubleVector derivs, bool include_priors)
        getFreeDerivs(LogLike self, Arg dummy, DoubleVector freeDerivs)
        getFreeDerivs(LogLike self, DoubleVector freeDerivs, bool include_priors)
        getFreeDerivs(LogLike self, DoubleVector freeDerivs)
        """
        return _pyLikelihood.LogLike_getFreeDerivs(self, *args)


    def addSource(self, src, fromClone=True, srcMap=None, loadMap=True):
        """
        addSource(LogLike self, Source src, bool fromClone=True, SourceMap srcMap=None, bool loadMap=True)
        addSource(LogLike self, Source src, bool fromClone=True, SourceMap srcMap=None)
        addSource(LogLike self, Source src, bool fromClone=True)
        addSource(LogLike self, Source src)
        """
        return _pyLikelihood.LogLike_addSource(self, src, fromClone, srcMap, loadMap)


    def deleteSource(self, srcName):
        """deleteSource(LogLike self, std::string const & srcName) -> Source"""
        return _pyLikelihood.LogLike_deleteSource(self, srcName)


    def getEvents(self, event_file):
        """getEvents(LogLike self, std::string event_file)"""
        return _pyLikelihood.LogLike_getEvents(self, event_file)


    def computeEventResponses(self, sr_radius=30.):
        """
        computeEventResponses(LogLike self, double sr_radius=30.)
        computeEventResponses(LogLike self)
        """
        return _pyLikelihood.LogLike_computeEventResponses(self, sr_radius)


    def syncParams(self):
        """syncParams(LogLike self)"""
        return _pyLikelihood.LogLike_syncParams(self)


    def syncSrcParams(self, srcName):
        """syncSrcParams(LogLike self, std::string const & srcName)"""
        return _pyLikelihood.LogLike_syncSrcParams(self, srcName)


    def NpredValue(self, srcName, weighted=False):
        """
        NpredValue(LogLike self, std::string const & srcName, bool weighted=False) -> double
        NpredValue(LogLike self, std::string const & srcName) -> double
        """
        return _pyLikelihood.LogLike_NpredValue(self, srcName, weighted)


    def restoreBestFit(self):
        """restoreBestFit(LogLike self)"""
        return _pyLikelihood.LogLike_restoreBestFit(self)


    def saveCurrentFit(self):
        """saveCurrentFit(LogLike self)"""
        return _pyLikelihood.LogLike_saveCurrentFit(self)


    def addPrior(self, index, log_prior):
        """addPrior(LogLike self, size_t index, Function log_prior)"""
        return _pyLikelihood.LogLike_addPrior(self, index, log_prior)


    def set_ebounds(self, emin, emax):
        """set_ebounds(LogLike self, double emin, double emax)"""
        return _pyLikelihood.LogLike_set_ebounds(self, emin, emax)


    def unset_ebounds(self):
        """unset_ebounds(LogLike self)"""
        return _pyLikelihood.LogLike_unset_ebounds(self)


    def set_ScaleFactor_complement(func, use_complement):
        """set_ScaleFactor_complement(Function func, bool use_complement)"""
        return _pyLikelihood.LogLike_set_ScaleFactor_complement(func, use_complement)

    set_ScaleFactor_complement = staticmethod(set_ScaleFactor_complement)

    def enableFPE():
        """enableFPE()"""
        return _pyLikelihood.LogLike_enableFPE()

    enableFPE = staticmethod(enableFPE)

    def initOutputStreams(self, maxChatter=2):
        """
        initOutputStreams(LogLike self, unsigned int maxChatter=2)
        initOutputStreams(LogLike self)
        """
        return _pyLikelihood.LogLike_initOutputStreams(self, maxChatter)


    def print_source_params(self):
        """print_source_params(LogLike self)"""
        return _pyLikelihood.LogLike_print_source_params(self)


    def src_param_table(self):
        """src_param_table(LogLike self)"""
        return _pyLikelihood.LogLike_src_param_table(self)


    def getNumFreeParams(self):
        """getNumFreeParams(LogLike self) -> int"""
        return _pyLikelihood.LogLike_getNumFreeParams(self)


    def getFreeParamValues(self, params):
        """getFreeParamValues(LogLike self, DoubleVector params)"""
        return _pyLikelihood.LogLike_getFreeParamValues(self, params)


    def srcNames(self):
        """srcNames(LogLike self) -> StringVector"""
        return _pyLikelihood.LogLike_srcNames(self)


    def Mcmc(self):
        """Mcmc(LogLike self) -> Mcmc"""
        return _pyLikelihood.LogLike_Mcmc(self)

LogLike_swigregister = _pyLikelihood.LogLike_swigregister
LogLike_swigregister(LogLike)

def LogLike_set_ScaleFactor_complement(func, use_complement):
    """LogLike_set_ScaleFactor_complement(Function func, bool use_complement)"""
    return _pyLikelihood.LogLike_set_ScaleFactor_complement(func, use_complement)

def LogLike_enableFPE():
    """LogLike_enableFPE()"""
    return _pyLikelihood.LogLike_enableFPE()

class ParamPair_t(_object):
    """Proxy of C++ std::pair<(p.Likelihood::LogLike,size_t)> class."""

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

    def __init__(self, *args):
        """
        __init__(std::pair<(p.Likelihood::LogLike,size_t)> self) -> ParamPair_t
        __init__(std::pair<(p.Likelihood::LogLike,size_t)> self, LogLike __a, size_t __b) -> ParamPair_t
        __init__(std::pair<(p.Likelihood::LogLike,size_t)> self, ParamPair_t __p) -> ParamPair_t
        """
        this = _pyLikelihood.new_ParamPair_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _pyLikelihood.ParamPair_t_first_set
    __swig_getmethods__["first"] = _pyLikelihood.ParamPair_t_first_get
    if _newclass:
        first = _swig_property(_pyLikelihood.ParamPair_t_first_get, _pyLikelihood.ParamPair_t_first_set)
    __swig_setmethods__["second"] = _pyLikelihood.ParamPair_t_second_set
    __swig_getmethods__["second"] = _pyLikelihood.ParamPair_t_second_get
    if _newclass:
        second = _swig_property(_pyLikelihood.ParamPair_t_second_get, _pyLikelihood.ParamPair_t_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__ = _pyLikelihood.delete_ParamPair_t
    __del__ = lambda self: None
ParamPair_t_swigregister = _pyLikelihood.ParamPair_t_swigregister
ParamPair_t_swigregister(ParamPair_t)

class ParVector_t(_object):
    """Proxy of C++ std::vector<(std::pair<(p.Likelihood::LogLike,size_t)>)> class."""

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

    def iterator(self):
        """iterator(ParVector_t self) -> SwigPyIterator"""
        return _pyLikelihood.ParVector_t_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(ParVector_t self) -> bool"""
        return _pyLikelihood.ParVector_t___nonzero__(self)


    def __bool__(self):
        """__bool__(ParVector_t self) -> bool"""
        return _pyLikelihood.ParVector_t___bool__(self)


    def __len__(self):
        """__len__(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type"""
        return _pyLikelihood.ParVector_t___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type i, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type j) -> ParVector_t"""
        return _pyLikelihood.ParVector_t___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type i, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type j)
        __setslice__(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type i, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type j, ParVector_t v)
        """
        return _pyLikelihood.ParVector_t___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type i, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type j)"""
        return _pyLikelihood.ParVector_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type i)
        __delitem__(ParVector_t self, PySliceObject * slice)
        """
        return _pyLikelihood.ParVector_t___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ParVector_t self, PySliceObject * slice) -> ParVector_t
        __getitem__(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type i) -> ParamPair_t
        """
        return _pyLikelihood.ParVector_t___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ParVector_t self, PySliceObject * slice, ParVector_t v)
        __setitem__(ParVector_t self, PySliceObject * slice)
        __setitem__(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::difference_type i, ParamPair_t x)
        """
        return _pyLikelihood.ParVector_t___setitem__(self, *args)


    def pop(self):
        """pop(ParVector_t self) -> ParamPair_t"""
        return _pyLikelihood.ParVector_t_pop(self)


    def append(self, x):
        """append(ParVector_t self, ParamPair_t x)"""
        return _pyLikelihood.ParVector_t_append(self, x)


    def empty(self):
        """empty(ParVector_t self) -> bool"""
        return _pyLikelihood.ParVector_t_empty(self)


    def size(self):
        """size(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type"""
        return _pyLikelihood.ParVector_t_size(self)


    def swap(self, v):
        """swap(ParVector_t self, ParVector_t v)"""
        return _pyLikelihood.ParVector_t_swap(self, v)


    def begin(self):
        """begin(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator"""
        return _pyLikelihood.ParVector_t_begin(self)


    def end(self):
        """end(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator"""
        return _pyLikelihood.ParVector_t_end(self)


    def rbegin(self):
        """rbegin(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::reverse_iterator"""
        return _pyLikelihood.ParVector_t_rbegin(self)


    def rend(self):
        """rend(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::reverse_iterator"""
        return _pyLikelihood.ParVector_t_rend(self)


    def clear(self):
        """clear(ParVector_t self)"""
        return _pyLikelihood.ParVector_t_clear(self)


    def get_allocator(self):
        """get_allocator(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::allocator_type"""
        return _pyLikelihood.ParVector_t_get_allocator(self)


    def pop_back(self):
        """pop_back(ParVector_t self)"""
        return _pyLikelihood.ParVector_t_pop_back(self)


    def erase(self, *args):
        """
        erase(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator pos) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator
        erase(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator first, std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator last) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator
        """
        return _pyLikelihood.ParVector_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::pair<(p.Likelihood::LogLike,size_t)>)> self) -> ParVector_t
        __init__(std::vector<(std::pair<(p.Likelihood::LogLike,size_t)>)> self, ParVector_t arg2) -> ParVector_t
        __init__(std::vector<(std::pair<(p.Likelihood::LogLike,size_t)>)> self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type size) -> ParVector_t
        __init__(std::vector<(std::pair<(p.Likelihood::LogLike,size_t)>)> self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type size, ParamPair_t value) -> ParVector_t
        """
        this = _pyLikelihood.new_ParVector_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ParVector_t self, ParamPair_t x)"""
        return _pyLikelihood.ParVector_t_push_back(self, x)


    def front(self):
        """front(ParVector_t self) -> ParamPair_t"""
        return _pyLikelihood.ParVector_t_front(self)


    def back(self):
        """back(ParVector_t self) -> ParamPair_t"""
        return _pyLikelihood.ParVector_t_back(self)


    def assign(self, n, x):
        """assign(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type n, ParamPair_t x)"""
        return _pyLikelihood.ParVector_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type new_size)
        resize(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type new_size, ParamPair_t x)
        """
        return _pyLikelihood.ParVector_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator pos, ParamPair_t x) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator
        insert(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::iterator pos, std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type n, ParamPair_t x)
        """
        return _pyLikelihood.ParVector_t_insert(self, *args)


    def reserve(self, n):
        """reserve(ParVector_t self, std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type n)"""
        return _pyLikelihood.ParVector_t_reserve(self, n)


    def capacity(self):
        """capacity(ParVector_t self) -> std::vector< std::pair< Likelihood::LogLike *,size_t > >::size_type"""
        return _pyLikelihood.ParVector_t_capacity(self)

    __swig_destroy__ = _pyLikelihood.delete_ParVector_t
    __del__ = lambda self: None
ParVector_t_swigregister = _pyLikelihood.ParVector_t_swigregister
ParVector_t_swigregister(ParVector_t)

class BinnedLikelihood(LogLike):
    """Proxy of C++ Likelihood::BinnedLikelihood class."""

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

    def __init__(self, *args):
        """
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, std::string const & srcMapsFile) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1, bool overwriteWeights=False) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2, double minbinsz=0.1) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True, double resamp_factor=2) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True, bool resample=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True, bool performConvolution=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True, bool applyPsfCorrections=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile, bool computePointSources=True) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation, std::string const & srcMapsFile) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, ProjMap weightMap, Observation observation) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, BinnedLikeConfig config, std::string const & srcMapsFile, ProjMap weightMap=None, bool overwriteWeights=False) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, BinnedLikeConfig config, std::string const & srcMapsFile, ProjMap weightMap=None) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, BinnedLikeConfig config, std::string const & srcMapsFile) -> BinnedLikelihood
        __init__(Likelihood::BinnedLikelihood self, CountsMapBase dataMap, Observation observation, BinnedLikeConfig config) -> BinnedLikelihood
        """
        this = _pyLikelihood.new_BinnedLikelihood(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_BinnedLikelihood
    __del__ = lambda self: None

    def dataCache(self):
        """dataCache(BinnedLikelihood self) -> BinnedCountsCache"""
        return _pyLikelihood.BinnedLikelihood_dataCache(self)


    def countsMap(self):
        """countsMap(BinnedLikelihood self) -> CountsMapBase"""
        return _pyLikelihood.BinnedLikelihood_countsMap(self)


    def energies(self):
        """energies(BinnedLikelihood self) -> DoubleVector"""
        return _pyLikelihood.BinnedLikelihood_energies(self)


    def config(self):
        """config(BinnedLikelihood self) -> BinnedLikeConfig"""
        return _pyLikelihood.BinnedLikelihood_config(self)


    def num_ebins(self):
        """num_ebins(BinnedLikelihood self) -> size_t"""
        return _pyLikelihood.BinnedLikelihood_num_ebins(self)


    def num_pixels(self):
        """num_pixels(BinnedLikelihood self) -> size_t"""
        return _pyLikelihood.BinnedLikelihood_num_pixels(self)


    def data_map_size(self):
        """data_map_size(BinnedLikelihood self) -> size_t"""
        return _pyLikelihood.BinnedLikelihood_data_map_size(self)


    def source_map_size(self):
        """source_map_size(BinnedLikelihood self) -> size_t"""
        return _pyLikelihood.BinnedLikelihood_source_map_size(self)


    def klims(self):
        """klims(BinnedLikelihood self) -> IntPair"""
        return _pyLikelihood.BinnedLikelihood_klims(self)


    def weightMap_orig(self):
        """weightMap_orig(BinnedLikelihood self) -> ProjMap"""
        return _pyLikelihood.BinnedLikelihood_weightMap_orig(self)


    def weightMap(self):
        """weightMap(BinnedLikelihood self) -> WeightMap"""
        return _pyLikelihood.BinnedLikelihood_weightMap(self)


    def weightedCounts(self):
        """weightedCounts(BinnedLikelihood self) -> CountsMapBase"""
        return _pyLikelihood.BinnedLikelihood_weightedCounts(self)


    def has_weights(self):
        """has_weights(BinnedLikelihood self) -> bool"""
        return _pyLikelihood.BinnedLikelihood_has_weights(self)


    def srcMapsFile(self):
        """srcMapsFile(BinnedLikelihood self) -> std::string const &"""
        return _pyLikelihood.BinnedLikelihood_srcMapsFile(self)


    def fixedSources(self):
        """fixedSources(BinnedLikelihood self) -> StringVector"""
        return _pyLikelihood.BinnedLikelihood_fixedSources(self)


    def fixedModelSpectrum(self):
        """fixedModelSpectrum(BinnedLikelihood self) -> DoubleVector"""
        return _pyLikelihood.BinnedLikelihood_fixedModelSpectrum(self)


    def fixedModelSpectrum_wt(self):
        """fixedModelSpectrum_wt(BinnedLikelihood self) -> DoubleVector"""
        return _pyLikelihood.BinnedLikelihood_fixedModelSpectrum_wt(self)


    def fixedModelSpectrum_edisp(self):
        """fixedModelSpectrum_edisp(BinnedLikelihood self) -> DoubleVector"""
        return _pyLikelihood.BinnedLikelihood_fixedModelSpectrum_edisp(self)


    def fixedModelSpectrum_edisp_wt(self):
        """fixedModelSpectrum_edisp_wt(BinnedLikelihood self) -> DoubleVector"""
        return _pyLikelihood.BinnedLikelihood_fixedModelSpectrum_edisp_wt(self)


    def fixedModelCounts(self):
        """fixedModelCounts(BinnedLikelihood self) -> DoubleVector"""
        return _pyLikelihood.BinnedLikelihood_fixedModelCounts(self)


    def updateFixedWeights(self):
        """updateFixedWeights(BinnedLikelihood self) -> bool"""
        return _pyLikelihood.BinnedLikelihood_updateFixedWeights(self)


    def setUpdateFixedWeights(self, update):
        """setUpdateFixedWeights(BinnedLikelihood self, bool update)"""
        return _pyLikelihood.BinnedLikelihood_setUpdateFixedWeights(self, update)


    def set_klims(self, kmin, kmax):
        """set_klims(BinnedLikelihood self, size_t kmin, size_t kmax)"""
        return _pyLikelihood.BinnedLikelihood_set_klims(self, kmin, kmax)


    def setVerbose(self, verbose):
        """setVerbose(BinnedLikelihood self, bool verbose)"""
        return _pyLikelihood.BinnedLikelihood_setVerbose(self, verbose)


    def set_edisp_flag(self, use_edisp):
        """set_edisp_flag(BinnedLikelihood self, bool use_edisp)"""
        return _pyLikelihood.BinnedLikelihood_set_edisp_flag(self, use_edisp)


    def set_edisp_val(self, edisp_val):
        """set_edisp_val(BinnedLikelihood self, int edisp_val)"""
        return _pyLikelihood.BinnedLikelihood_set_edisp_val(self, edisp_val)


    def set_use_single_fixed_map(self, use_sfm):
        """set_use_single_fixed_map(BinnedLikelihood self, bool use_sfm)"""
        return _pyLikelihood.BinnedLikelihood_set_use_single_fixed_map(self, use_sfm)


    def set_save_all_srcmaps(self, val):
        """set_save_all_srcmaps(BinnedLikelihood self, bool val)"""
        return _pyLikelihood.BinnedLikelihood_set_save_all_srcmaps(self, val)


    def setCountsMap(self, counts):
        """setCountsMap(BinnedLikelihood self, FloatVector counts)"""
        return _pyLikelihood.BinnedLikelihood_setCountsMap(self, counts)


    def setWeightsMap(self, wmap):
        """setWeightsMap(BinnedLikelihood self, ProjMap wmap)"""
        return _pyLikelihood.BinnedLikelihood_setWeightsMap(self, wmap)


    def value(self, *args):
        """
        value(BinnedLikelihood self, Arg dummy, bool include_priors) -> double
        value(BinnedLikelihood self, Arg dummy) -> double
        value(BinnedLikelihood self) -> double
        """
        return _pyLikelihood.BinnedLikelihood_value(self, *args)


    def getFreeDerivs(self, *args):
        """
        getFreeDerivs(BinnedLikelihood self, Arg dummy, DoubleVector derivs, bool include_priors)
        getFreeDerivs(BinnedLikelihood self, DoubleVector freeDerivs, bool include_priors)
        getFreeDerivs(BinnedLikelihood self, DoubleVector freeDerivs)
        """
        return _pyLikelihood.BinnedLikelihood_getFreeDerivs(self, *args)


    def setParamValues_(self, arg2):
        """setParamValues_(BinnedLikelihood self, std::vector< double,std::allocator< double > >::const_iterator arg2) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.BinnedLikelihood_setParamValues_(self, arg2)


    def setFreeParamValues_(self, arg2):
        """setFreeParamValues_(BinnedLikelihood self, std::vector< double,std::allocator< double > >::const_iterator arg2) -> std::vector< double,std::allocator< double > >::const_iterator"""
        return _pyLikelihood.BinnedLikelihood_setFreeParamValues_(self, arg2)


    def createCountsMap(self, *args):
        """
        createCountsMap(BinnedLikelihood self, CountsMapBase dataMap) -> CountsMapBase
        createCountsMap(BinnedLikelihood self) -> CountsMapBase
        """
        return _pyLikelihood.BinnedLikelihood_createCountsMap(self, *args)


    def readXml(self, xmlFile, funcFactory, requireExposure=True, addPointSources=True, loadMaps=True):
        """
        readXml(BinnedLikelihood self, std::string xmlFile, FunctionFactory funcFactory, bool requireExposure=True, bool addPointSources=True, bool loadMaps=True)
        readXml(BinnedLikelihood self, std::string xmlFile, FunctionFactory funcFactory, bool requireExposure=True, bool addPointSources=True)
        readXml(BinnedLikelihood self, std::string xmlFile, FunctionFactory funcFactory, bool requireExposure=True)
        readXml(BinnedLikelihood self, std::string xmlFile, FunctionFactory funcFactory)
        """
        return _pyLikelihood.BinnedLikelihood_readXml(self, xmlFile, funcFactory, requireExposure, addPointSources, loadMaps)


    def addSource(self, *args):
        """
        addSource(BinnedLikelihood self, Source src, bool fromClone=True, SourceMap srcMap=None, bool loadMap=True)
        addSource(BinnedLikelihood self, Source src, bool fromClone=True, SourceMap srcMap=None)
        addSource(BinnedLikelihood self, Source src, bool fromClone=True)
        addSource(BinnedLikelihood self, Source src)
        addSource(BinnedLikelihood self, Source src, BinnedLikeConfig config, bool fromClone=True)
        addSource(BinnedLikelihood self, Source src, BinnedLikeConfig config)
        """
        return _pyLikelihood.BinnedLikelihood_addSource(self, *args)


    def deleteSource(self, srcName):
        """deleteSource(BinnedLikelihood self, std::string const & srcName) -> Source"""
        return _pyLikelihood.BinnedLikelihood_deleteSource(self, srcName)


    def set_ebounds(self, emin, emax):
        """set_ebounds(BinnedLikelihood self, double emin, double emax)"""
        return _pyLikelihood.BinnedLikelihood_set_ebounds(self, emin, emax)


    def unset_ebounds(self):
        """unset_ebounds(BinnedLikelihood self)"""
        return _pyLikelihood.BinnedLikelihood_unset_ebounds(self)


    def syncParams(self):
        """syncParams(BinnedLikelihood self)"""
        return _pyLikelihood.BinnedLikelihood_syncParams(self)


    def syncSrcParams(self, srcName):
        """syncSrcParams(BinnedLikelihood self, std::string const & srcName)"""
        return _pyLikelihood.BinnedLikelihood_syncSrcParams(self, srcName)


    def NpredValue(self, *args):
        """
        NpredValue(BinnedLikelihood self, std::string const & srcName, bool weighted=False) -> double
        NpredValue(BinnedLikelihood self, std::string const & srcName) -> double
        NpredValue(BinnedLikelihood self, std::string const & name, SourceMap srcMap, bool weighted=False) -> double
        NpredValue(BinnedLikelihood self, std::string const & name, SourceMap srcMap) -> double
        """
        return _pyLikelihood.BinnedLikelihood_NpredValue(self, *args)


    def hasSourceMap(self, name):
        """hasSourceMap(BinnedLikelihood self, std::string const & name) -> bool"""
        return _pyLikelihood.BinnedLikelihood_hasSourceMap(self, name)


    def sourceMap(self, name):
        """sourceMap(BinnedLikelihood self, std::string const & name) -> SourceMap"""
        return _pyLikelihood.BinnedLikelihood_sourceMap(self, name)


    def getSourceMap(self, srcName, verbose=True):
        """
        getSourceMap(BinnedLikelihood self, std::string const & srcName, bool verbose=True) -> SourceMap
        getSourceMap(BinnedLikelihood self, std::string const & srcName) -> SourceMap
        """
        return _pyLikelihood.BinnedLikelihood_getSourceMap(self, srcName, verbose)


    def createSourceMap(self, srcName):
        """createSourceMap(BinnedLikelihood self, std::string const & srcName) -> SourceMap"""
        return _pyLikelihood.BinnedLikelihood_createSourceMap(self, srcName)


    def eraseSourceMap(self, srcName):
        """eraseSourceMap(BinnedLikelihood self, std::string const & srcName)"""
        return _pyLikelihood.BinnedLikelihood_eraseSourceMap(self, srcName)


    def insertSourceMap(self, srcName, srcMap):
        """insertSourceMap(BinnedLikelihood self, std::string const & srcName, SourceMap srcMap)"""
        return _pyLikelihood.BinnedLikelihood_insertSourceMap(self, srcName, srcMap)


    def removeSourceMap(self, srcName):
        """removeSourceMap(BinnedLikelihood self, std::string const & srcName) -> SourceMap"""
        return _pyLikelihood.BinnedLikelihood_removeSourceMap(self, srcName)


    def loadSourceMaps(self, *args):
        """
        loadSourceMaps(BinnedLikelihood self, bool recreate=False, bool saveMaps=False)
        loadSourceMaps(BinnedLikelihood self, bool recreate=False)
        loadSourceMaps(BinnedLikelihood self)
        loadSourceMaps(BinnedLikelihood self, StringVector srcNames, bool recreate=False, bool saveMaps=False)
        loadSourceMaps(BinnedLikelihood self, StringVector srcNames, bool recreate=False)
        loadSourceMaps(BinnedLikelihood self, StringVector srcNames)
        """
        return _pyLikelihood.BinnedLikelihood_loadSourceMaps(self, *args)


    def loadSourceMap(self, srcName, recreate=False, buildFixedWeights=True):
        """
        loadSourceMap(BinnedLikelihood self, std::string const & srcName, bool recreate=False, bool buildFixedWeights=True)
        loadSourceMap(BinnedLikelihood self, std::string const & srcName, bool recreate=False)
        loadSourceMap(BinnedLikelihood self, std::string const & srcName)
        """
        return _pyLikelihood.BinnedLikelihood_loadSourceMap(self, srcName, recreate, buildFixedWeights)


    def setSourceMapImage(self, name, image):
        """setSourceMapImage(BinnedLikelihood self, std::string const & name, FloatVector image)"""
        return _pyLikelihood.BinnedLikelihood_setSourceMapImage(self, name, image)


    def saveSourceMaps(self, *args):
        """
        saveSourceMaps(BinnedLikelihood self, std::string const & filename, bool replace=False, bool includecountsmap=True)
        saveSourceMaps(BinnedLikelihood self, std::string const & filename, bool replace=False)
        saveSourceMaps(BinnedLikelihood self, std::string const & filename)
        saveSourceMaps(BinnedLikelihood self)
        """
        return _pyLikelihood.BinnedLikelihood_saveSourceMaps(self, *args)


    def saveSourceMap_partial(self, filename, source, kmin=0, kmax=-1, replace=False):
        """
        saveSourceMap_partial(BinnedLikelihood self, std::string const & filename, Source source, int kmin=0, int kmax=-1, bool replace=False)
        saveSourceMap_partial(BinnedLikelihood self, std::string const & filename, Source source, int kmin=0, int kmax=-1)
        saveSourceMap_partial(BinnedLikelihood self, std::string const & filename, Source source, int kmin=0)
        saveSourceMap_partial(BinnedLikelihood self, std::string const & filename, Source source)
        """
        return _pyLikelihood.BinnedLikelihood_saveSourceMap_partial(self, filename, source, kmin, kmax, replace)


    def saveTotalFixedSourceMap(self, replace=False):
        """
        saveTotalFixedSourceMap(BinnedLikelihood self, bool replace=False) -> tip::Extension
        saveTotalFixedSourceMap(BinnedLikelihood self) -> tip::Extension *
        """
        return _pyLikelihood.BinnedLikelihood_saveTotalFixedSourceMap(self, replace)


    def computeModelMap_internal(self, weighted=False):
        """
        computeModelMap_internal(BinnedLikelihood self, bool weighted=False) -> double
        computeModelMap_internal(BinnedLikelihood self) -> double
        """
        return _pyLikelihood.BinnedLikelihood_computeModelMap_internal(self, weighted)


    def computeModelMap(self, *args):
        """
        computeModelMap(BinnedLikelihood self, FloatVector modelMap, bool use_mask=True)
        computeModelMap(BinnedLikelihood self, FloatVector modelMap)
        computeModelMap(BinnedLikelihood self, std::string const & srcName, FloatVector modelMap, bool use_mask=True)
        computeModelMap(BinnedLikelihood self, std::string const & srcName, FloatVector modelMap)
        computeModelMap(BinnedLikelihood self, StringVector srcNames, FloatVector modelMap, bool use_mask=True)
        computeModelMap(BinnedLikelihood self, StringVector srcNames, FloatVector modelMap)
        """
        return _pyLikelihood.BinnedLikelihood_computeModelMap(self, *args)


    def updateModelMap(self, modelMap, srcMap, use_mask=True):
        """
        updateModelMap(BinnedLikelihood self, FloatVector modelMap, SourceMap srcMap, bool use_mask=True)
        updateModelMap(BinnedLikelihood self, FloatVector modelMap, SourceMap srcMap)
        """
        return _pyLikelihood.BinnedLikelihood_updateModelMap(self, modelMap, srcMap, use_mask)


    def updateModelMap_fromSrcMap(self, modelMap, src, srcMap, use_mask=True):
        """
        updateModelMap_fromSrcMap(BinnedLikelihood self, FloatVector modelMap, Source src, SourceMap srcMap, bool use_mask=True)
        updateModelMap_fromSrcMap(BinnedLikelihood self, FloatVector modelMap, Source src, SourceMap srcMap)
        """
        return _pyLikelihood.BinnedLikelihood_updateModelMap_fromSrcMap(self, modelMap, src, srcMap, use_mask)


    def npred(self, weighted=False):
        """
        npred(BinnedLikelihood self, bool weighted=False) -> double
        npred(BinnedLikelihood self) -> double
        """
        return _pyLikelihood.BinnedLikelihood_npred(self, weighted)


    def getNpreds(self, srcName, npreds):
        """getNpreds(BinnedLikelihood self, std::string const & srcName, DoubleVector npreds)"""
        return _pyLikelihood.BinnedLikelihood_getNpreds(self, srcName, npreds)


    def modelCountsSpectrum(self, srcname, weighted=False):
        """
        modelCountsSpectrum(BinnedLikelihood self, std::string const & srcname, bool weighted=False) -> DoubleVector
        modelCountsSpectrum(BinnedLikelihood self, std::string const & srcname) -> DoubleVector
        """
        return _pyLikelihood.BinnedLikelihood_modelCountsSpectrum(self, srcname, weighted)


    def fixedModelUpdated(self):
        """fixedModelUpdated(BinnedLikelihood self) -> bool"""
        return _pyLikelihood.BinnedLikelihood_fixedModelUpdated(self)


    def fillSummedSourceMap(self, sources, model):
        """fillSummedSourceMap(BinnedLikelihood self, StringVector sources, FloatVector model)"""
        return _pyLikelihood.BinnedLikelihood_fillSummedSourceMap(self, sources, model)


    def fillSingleSourceMap(self, sourceName, model, mapType, kmin=0, kmax=-1):
        """
        fillSingleSourceMap(BinnedLikelihood self, std::string const & sourceName, FloatVector model, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0, int kmax=-1)
        fillSingleSourceMap(BinnedLikelihood self, std::string const & sourceName, FloatVector model, Likelihood::FileUtils::SrcMapType & mapType, int kmin=0)
        fillSingleSourceMap(BinnedLikelihood self, std::string const & sourceName, FloatVector model, Likelihood::FileUtils::SrcMapType & mapType)
        """
        return _pyLikelihood.BinnedLikelihood_fillSingleSourceMap(self, sourceName, model, mapType, kmin, kmax)


    def buildFixedModelWts(self, process_all=False):
        """
        buildFixedModelWts(BinnedLikelihood self, bool process_all=False)
        buildFixedModelWts(BinnedLikelihood self)
        """
        return _pyLikelihood.BinnedLikelihood_buildFixedModelWts(self, process_all)


    def addFixedSource(self, srcName):
        """addFixedSource(BinnedLikelihood self, std::string const & srcName)"""
        return _pyLikelihood.BinnedLikelihood_addFixedSource(self, srcName)


    def deleteFixedSource(self, srcName):
        """deleteFixedSource(BinnedLikelihood self, std::string const & srcName)"""
        return _pyLikelihood.BinnedLikelihood_deleteFixedSource(self, srcName)


    def countsSpectrum(self, *args):
        """
        countsSpectrum(BinnedLikelihood self, bool weighted=False) -> DoubleVector
        countsSpectrum(BinnedLikelihood self) -> DoubleVector
        countsSpectrum(BinnedLikelihood self, std::string const & srcName, bool use_klims=True) -> DoubleVector
        countsSpectrum(BinnedLikelihood self, std::string const & srcName) -> DoubleVector
        """
        return _pyLikelihood.BinnedLikelihood_countsSpectrum(self, *args)


    def edisp_val(self, *args):
        """
        edisp_val(BinnedLikelihood self, std::string const & srcname) -> int
        edisp_val(BinnedLikelihood self) -> int
        """
        return _pyLikelihood.BinnedLikelihood_edisp_val(self, *args)


    def drm(self):
        """drm(BinnedLikelihood self) -> Drm"""
        return _pyLikelihood.BinnedLikelihood_drm(self)


    def npred_explicit(like, weighted=False):
        """
        npred_explicit(BinnedLikelihood like, bool weighted=False) -> float
        npred_explicit(BinnedLikelihood like) -> float
        """
        return _pyLikelihood.BinnedLikelihood_npred_explicit(like, weighted)

    npred_explicit = staticmethod(npred_explicit)

    def npred_explicit_src(like, srcName, weighted=False):
        """
        npred_explicit_src(BinnedLikelihood like, std::string const & srcName, bool weighted=False) -> float
        npred_explicit_src(BinnedLikelihood like, std::string const & srcName) -> float
        """
        return _pyLikelihood.BinnedLikelihood_npred_explicit_src(like, srcName, weighted)

    npred_explicit_src = staticmethod(npred_explicit_src)

    def nll_explict(like, weighted=False):
        """
        nll_explict(BinnedLikelihood like, bool weighted=False) -> double
        nll_explict(BinnedLikelihood like) -> double
        """
        return _pyLikelihood.BinnedLikelihood_nll_explict(like, weighted)

    nll_explict = staticmethod(nll_explict)

    def modelCounts(self, srcName):
        """modelCounts(BinnedLikelihood self, std::string const & srcName) -> DoubleVector"""
        return _pyLikelihood.BinnedLikelihood_modelCounts(self, srcName)

BinnedLikelihood_swigregister = _pyLikelihood.BinnedLikelihood_swigregister
BinnedLikelihood_swigregister(BinnedLikelihood)

def BinnedLikelihood_npred_explicit(like, weighted=False):
    """
    npred_explicit(BinnedLikelihood like, bool weighted=False) -> float
    BinnedLikelihood_npred_explicit(BinnedLikelihood like) -> float
    """
    return _pyLikelihood.BinnedLikelihood_npred_explicit(like, weighted)

def BinnedLikelihood_npred_explicit_src(like, srcName, weighted=False):
    """
    npred_explicit_src(BinnedLikelihood like, std::string const & srcName, bool weighted=False) -> float
    BinnedLikelihood_npred_explicit_src(BinnedLikelihood like, std::string const & srcName) -> float
    """
    return _pyLikelihood.BinnedLikelihood_npred_explicit_src(like, srcName, weighted)

def BinnedLikelihood_nll_explict(like, weighted=False):
    """
    nll_explict(BinnedLikelihood like, bool weighted=False) -> double
    BinnedLikelihood_nll_explict(BinnedLikelihood like) -> double
    """
    return _pyLikelihood.BinnedLikelihood_nll_explict(like, weighted)

class Composite2(Statistic):
    """Proxy of C++ Likelihood::Composite2 class."""

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

    def __init__(self):
        """__init__(Likelihood::Composite2 self) -> Composite2"""
        this = _pyLikelihood.new_Composite2()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Composite2
    __del__ = lambda self: None

    def addComponent(self, component):
        """addComponent(Composite2 self, LogLike component)"""
        return _pyLikelihood.Composite2_addComponent(self, component)


    def tieParameters(self, pars):
        """tieParameters(Composite2 self, ParVector_t pars)"""
        return _pyLikelihood.Composite2_tieParameters(self, pars)


    def value(self):
        """value(Composite2 self) -> double"""
        return _pyLikelihood.Composite2_value(self)


    def getFreeParams(self, params):
        """getFreeParams(Composite2 self, ParameterVector params)"""
        return _pyLikelihood.Composite2_getFreeParams(self, params)


    def fetchParamValues(self, values, getFree):
        """fetchParamValues(Composite2 self, DoubleVector values, bool getFree)"""
        return _pyLikelihood.Composite2_fetchParamValues(self, values, getFree)


    def setFreeParamValues(self, values):
        """setFreeParamValues(Composite2 self, DoubleVector values)"""
        return _pyLikelihood.Composite2_setFreeParamValues(self, values)


    def getNumFreeParams(self):
        """getNumFreeParams(Composite2 self) -> unsigned int"""
        return _pyLikelihood.Composite2_getNumFreeParams(self)


    def getFreeDerivs(self, derivs):
        """getFreeDerivs(Composite2 self, DoubleVector derivs)"""
        return _pyLikelihood.Composite2_getFreeDerivs(self, derivs)


    def setErrors(self, errors):
        """setErrors(Composite2 self, DoubleVector errors)"""
        return _pyLikelihood.Composite2_setErrors(self, errors)


    def findIndex(self, like, par_index):
        """findIndex(Composite2 self, LogLike like, size_t par_index) -> int"""
        return _pyLikelihood.Composite2_findIndex(self, like, par_index)


    def syncParams(self):
        """syncParams(Composite2 self)"""
        return _pyLikelihood.Composite2_syncParams(self)


    def NpredValue(self, arg2, weighted=False):
        """
        NpredValue(Composite2 self, std::string const & arg2, bool weighted=False) -> double
        NpredValue(Composite2 self, std::string const & arg2) -> double
        """
        return _pyLikelihood.Composite2_NpredValue(self, arg2, weighted)


    def getTiedParam(self, like, i):
        """getTiedParam(Composite2 self, LogLike like, size_t i) -> TiedParameter"""
        return _pyLikelihood.Composite2_getTiedParam(self, like, i)


    def setTiedParamValue(self, like, i, value):
        """setTiedParamValue(Composite2 self, LogLike like, size_t i, double value)"""
        return _pyLikelihood.Composite2_setTiedParamValue(self, like, i, value)

Composite2_swigregister = _pyLikelihood.Composite2_swigregister
Composite2_swigregister(Composite2)

class CompositeLikelihood(Statistic):
    """Proxy of C++ Likelihood::CompositeLikelihood class."""

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

    def __init__(self):
        """__init__(Likelihood::CompositeLikelihood self) -> CompositeLikelihood"""
        this = _pyLikelihood.new_CompositeLikelihood()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_CompositeLikelihood
    __del__ = lambda self: None

    def addComponent(self, srcName, component):
        """addComponent(CompositeLikelihood self, std::string const & srcName, LogLike component)"""
        return _pyLikelihood.CompositeLikelihood_addComponent(self, srcName, component)


    def value(self):
        """value(CompositeLikelihood self) -> double"""
        return _pyLikelihood.CompositeLikelihood_value(self)


    def getFreeParams(self, params):
        """getFreeParams(CompositeLikelihood self, ParameterVector params)"""
        return _pyLikelihood.CompositeLikelihood_getFreeParams(self, params)


    def setFreeParamValues(self, values):
        """setFreeParamValues(CompositeLikelihood self, DoubleVector values)"""
        return _pyLikelihood.CompositeLikelihood_setFreeParamValues(self, values)


    def getNumFreeParams(self):
        """getNumFreeParams(CompositeLikelihood self) -> unsigned int"""
        return _pyLikelihood.CompositeLikelihood_getNumFreeParams(self)


    def getFreeDerivs(self, derivs):
        """getFreeDerivs(CompositeLikelihood self, DoubleVector derivs)"""
        return _pyLikelihood.CompositeLikelihood_getFreeDerivs(self, derivs)


    def fetchParamValues(self, values, getFree):
        """fetchParamValues(CompositeLikelihood self, DoubleVector values, bool getFree)"""
        return _pyLikelihood.CompositeLikelihood_fetchParamValues(self, values, getFree)


    def syncParams(self):
        """syncParams(CompositeLikelihood self)"""
        return _pyLikelihood.CompositeLikelihood_syncParams(self)


    def NpredValue(self, arg2, arg3):
        """NpredValue(CompositeLikelihood self, std::string const & arg2, bool arg3) -> double"""
        return _pyLikelihood.CompositeLikelihood_NpredValue(self, arg2, arg3)

CompositeLikelihood_swigregister = _pyLikelihood.CompositeLikelihood_swigregister
CompositeLikelihood_swigregister(CompositeLikelihood)

class OptEM(LogLike):
    """Proxy of C++ Likelihood::OptEM class."""

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

    def __init__(self, observation):
        """__init__(Likelihood::OptEM self, Observation observation) -> OptEM"""
        this = _pyLikelihood.new_OptEM(observation)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_OptEM
    __del__ = lambda self: None

    def findMin(self, verbose=0):
        """
        findMin(OptEM self, int const verbose=0)
        findMin(OptEM self)
        """
        return _pyLikelihood.OptEM_findMin(self, verbose)

OptEM_swigregister = _pyLikelihood.OptEM_swigregister
OptEM_swigregister(OptEM)


def chifunc(arg1):
    """chifunc(int arg1) -> double"""
    return _pyLikelihood.chifunc(arg1)
class SummedLikelihood(Statistic):
    """Proxy of C++ Likelihood::SummedLikelihood class."""

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

    def __init__(self):
        """__init__(Likelihood::SummedLikelihood self) -> SummedLikelihood"""
        this = _pyLikelihood.new_SummedLikelihood()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_SummedLikelihood
    __del__ = lambda self: None

    def addComponent(self, component):
        """addComponent(SummedLikelihood self, LogLike component)"""
        return _pyLikelihood.SummedLikelihood_addComponent(self, component)


    def numComponents(self):
        """numComponents(SummedLikelihood self) -> size_t"""
        return _pyLikelihood.SummedLikelihood_numComponents(self)


    def getComponent(self, *args):
        """
        getComponent(SummedLikelihood self, size_t comp_index) -> LogLike
        getComponent(SummedLikelihood self, size_t comp_index) -> LogLike
        """
        return _pyLikelihood.SummedLikelihood_getComponent(self, *args)


    def value(self):
        """value(SummedLikelihood self) -> double"""
        return _pyLikelihood.SummedLikelihood_value(self)


    def getFreeParams(self, params):
        """getFreeParams(SummedLikelihood self, ParameterVector params)"""
        return _pyLikelihood.SummedLikelihood_getFreeParams(self, params)


    def setFreeParamValues(self, values):
        """setFreeParamValues(SummedLikelihood self, DoubleVector values)"""
        return _pyLikelihood.SummedLikelihood_setFreeParamValues(self, values)


    def getNumFreeParams(self):
        """getNumFreeParams(SummedLikelihood self) -> unsigned int"""
        return _pyLikelihood.SummedLikelihood_getNumFreeParams(self)


    def getFreeDerivs(self, derivs):
        """getFreeDerivs(SummedLikelihood self, DoubleVector derivs)"""
        return _pyLikelihood.SummedLikelihood_getFreeDerivs(self, derivs)


    def syncParams(self):
        """syncParams(SummedLikelihood self)"""
        return _pyLikelihood.SummedLikelihood_syncParams(self)


    def NpredValue(self, srcname, weighted=False):
        """
        NpredValue(SummedLikelihood self, std::string const & srcname, bool weighted=False) -> double
        NpredValue(SummedLikelihood self, std::string const & srcname) -> double
        """
        return _pyLikelihood.SummedLikelihood_NpredValue(self, srcname, weighted)


    def tieParameters(self, par_indices):
        """tieParameters(SummedLikelihood self, SizetVector par_indices)"""
        return _pyLikelihood.SummedLikelihood_tieParameters(self, par_indices)


    def setErrors(self, errors):
        """setErrors(SummedLikelihood self, DoubleVector errors)"""
        return _pyLikelihood.SummedLikelihood_setErrors(self, errors)


    def findIndex(self, par_index):
        """findIndex(SummedLikelihood self, size_t par_index) -> int"""
        return _pyLikelihood.SummedLikelihood_findIndex(self, par_index)


    def getTiedParam(self, par_index):
        """getTiedParam(SummedLikelihood self, size_t par_index) -> TiedParameter"""
        return _pyLikelihood.SummedLikelihood_getTiedParam(self, par_index)


    def setTiedParamValue(self, par_index, value):
        """setTiedParamValue(SummedLikelihood self, size_t par_index, double value)"""
        return _pyLikelihood.SummedLikelihood_setTiedParamValue(self, par_index, value)

SummedLikelihood_swigregister = _pyLikelihood.SummedLikelihood_swigregister
SummedLikelihood_swigregister(SummedLikelihood)

class CountsSpectra(_object):
    """Proxy of C++ Likelihood::CountsSpectra class."""

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

    def __init__(self, logLike):
        """__init__(Likelihood::CountsSpectra self, LogLike logLike) -> CountsSpectra"""
        this = _pyLikelihood.new_CountsSpectra(logLike)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setEbounds(self, emin, emax, nbounds):
        """setEbounds(CountsSpectra self, double emin, double emax, size_t nbounds)"""
        return _pyLikelihood.CountsSpectra_setEbounds(self, emin, emax, nbounds)


    def getSrcCounts(self, srcName, srcCounts):
        """getSrcCounts(CountsSpectra self, std::string const & srcName, DoubleVector srcCounts)"""
        return _pyLikelihood.CountsSpectra_getSrcCounts(self, srcName, srcCounts)


    def getSrcFluxes(self, ptSrcName, srcFluxes):
        """getSrcFluxes(CountsSpectra self, std::string const & ptSrcName, DoubleVector srcFluxes)"""
        return _pyLikelihood.CountsSpectra_getSrcFluxes(self, ptSrcName, srcFluxes)


    def getTotalSrcCounts(self, srcCounts):
        """getTotalSrcCounts(CountsSpectra self, DoubleVector srcCounts)"""
        return _pyLikelihood.CountsSpectra_getTotalSrcCounts(self, srcCounts)


    def getObsCounts(self, counts):
        """getObsCounts(CountsSpectra self, DoubleVector counts)"""
        return _pyLikelihood.CountsSpectra_getObsCounts(self, counts)


    def writeTable(self, outfile):
        """writeTable(CountsSpectra self, std::string const & outfile)"""
        return _pyLikelihood.CountsSpectra_writeTable(self, outfile)


    def ebounds(self):
        """ebounds(CountsSpectra self) -> DoubleVector"""
        return _pyLikelihood.CountsSpectra_ebounds(self)

    __swig_destroy__ = _pyLikelihood.delete_CountsSpectra
    __del__ = lambda self: None
CountsSpectra_swigregister = _pyLikelihood.CountsSpectra_swigregister
CountsSpectra_swigregister(CountsSpectra)

class Aeff(_object):
    """Proxy of C++ pyLikelihood::Aeff class."""

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

    def __init__(self, irfName):
        """__init__(pyLikelihood::Aeff self, std::string const & irfName) -> Aeff"""
        this = _pyLikelihood.new_Aeff(irfName)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyLikelihood.delete_Aeff
    __del__ = lambda self: None

    def __call__(self, energy, theta, convtype, phi=0):
        """
        __call__(Aeff self, double energy, double theta, int convtype, double phi=0) -> double
        __call__(Aeff self, double energy, double theta, int convtype) -> double
        """
        return _pyLikelihood.Aeff___call__(self, energy, theta, convtype, phi)

Aeff_swigregister = _pyLikelihood.Aeff_swigregister
Aeff_swigregister(Aeff)


def enableFPE():
    """enableFPE()"""
    return _pyLikelihood.enableFPE()
# This file is compatible with both classic and new-style classes.


