python-gyoto 1.0.2-2ubuntu1 / usr / lib / python2.7 / dist-packages / gyoto.py

"""
The General relativitY Orbit Tracer of paris Observatory
"""
# This is necessary at least on Linux to let the libgyoto symbols be
# visible from the libgyoto-stdplug (and other plug-ins) symbols.
import sys, ctypes
sys.setdlopenflags(sys.getdlopenflags() | ctypes.RTLD_GLOBAL)
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""The General relativitY Orbit Tracer of paris Observatory"""


from sys import version_info
if 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('_gyoto', [dirname(__file__)])
        except ImportError:
            import _gyoto
            return _gyoto
        if fp is not None:
            try:
                _mod = imp.load_module('_gyoto', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _gyoto = swig_import_helper()
    del swig_import_helper
else:
    import _gyoto
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class."""

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

    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _gyoto.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _gyoto.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _gyoto.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _gyoto.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _gyoto.SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _gyoto.SwigPyIterator_copy(self)


    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _gyoto.SwigPyIterator_next(self)


    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _gyoto.SwigPyIterator___next__(self)


    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _gyoto.SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _gyoto.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _gyoto.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _gyoto.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _gyoto.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _gyoto.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _gyoto.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _gyoto.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _gyoto.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class vector_double(_object):
    """Proxy of C++ std::vector<(double)> class."""

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

    def iterator(self):
        """iterator(vector_double self) -> SwigPyIterator"""
        return _gyoto.vector_double_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(vector_double self) -> bool"""
        return _gyoto.vector_double___nonzero__(self)


    def __bool__(self):
        """__bool__(vector_double self) -> bool"""
        return _gyoto.vector_double___bool__(self)


    def __len__(self):
        """__len__(vector_double self) -> std::vector< double >::size_type"""
        return _gyoto.vector_double___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vector_double"""
        return _gyoto.vector_double___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vector_double v)
        """
        return _gyoto.vector_double___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _gyoto.vector_double___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vector_double self, std::vector< double >::difference_type i)
        __delitem__(vector_double self, PySliceObject * slice)
        """
        return _gyoto.vector_double___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vector_double self, PySliceObject * slice) -> vector_double
        __getitem__(vector_double self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _gyoto.vector_double___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vector_double self, PySliceObject * slice, vector_double v)
        __setitem__(vector_double self, PySliceObject * slice)
        __setitem__(vector_double self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _gyoto.vector_double___setitem__(self, *args)


    def pop(self):
        """pop(vector_double self) -> std::vector< double >::value_type"""
        return _gyoto.vector_double_pop(self)


    def append(self, x):
        """append(vector_double self, std::vector< double >::value_type const & x)"""
        return _gyoto.vector_double_append(self, x)


    def empty(self):
        """empty(vector_double self) -> bool"""
        return _gyoto.vector_double_empty(self)


    def size(self):
        """size(vector_double self) -> std::vector< double >::size_type"""
        return _gyoto.vector_double_size(self)


    def swap(self, v):
        """swap(vector_double self, vector_double v)"""
        return _gyoto.vector_double_swap(self, v)


    def begin(self):
        """begin(vector_double self) -> std::vector< double >::iterator"""
        return _gyoto.vector_double_begin(self)


    def end(self):
        """end(vector_double self) -> std::vector< double >::iterator"""
        return _gyoto.vector_double_end(self)


    def rbegin(self):
        """rbegin(vector_double self) -> std::vector< double >::reverse_iterator"""
        return _gyoto.vector_double_rbegin(self)


    def rend(self):
        """rend(vector_double self) -> std::vector< double >::reverse_iterator"""
        return _gyoto.vector_double_rend(self)


    def clear(self):
        """clear(vector_double self)"""
        return _gyoto.vector_double_clear(self)


    def get_allocator(self):
        """get_allocator(vector_double self) -> std::vector< double >::allocator_type"""
        return _gyoto.vector_double_get_allocator(self)


    def pop_back(self):
        """pop_back(vector_double self)"""
        return _gyoto.vector_double_pop_back(self)


    def erase(self, *args):
        """
        erase(vector_double self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(vector_double self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _gyoto.vector_double_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> vector_double
        __init__(std::vector<(double)> self, vector_double arg2) -> vector_double
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> vector_double
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vector_double
        """
        this = _gyoto.new_vector_double(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vector_double self, std::vector< double >::value_type const & x)"""
        return _gyoto.vector_double_push_back(self, x)


    def front(self):
        """front(vector_double self) -> std::vector< double >::value_type const &"""
        return _gyoto.vector_double_front(self)


    def back(self):
        """back(vector_double self) -> std::vector< double >::value_type const &"""
        return _gyoto.vector_double_back(self)


    def assign(self, n, x):
        """assign(vector_double self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _gyoto.vector_double_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vector_double self, std::vector< double >::size_type new_size)
        resize(vector_double self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _gyoto.vector_double_resize(self, *args)


    def insert(self, *args):
        """
        insert(vector_double self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(vector_double self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _gyoto.vector_double_insert(self, *args)


    def reserve(self, n):
        """reserve(vector_double self, std::vector< double >::size_type n)"""
        return _gyoto.vector_double_reserve(self, n)


    def capacity(self):
        """capacity(vector_double self) -> std::vector< double >::size_type"""
        return _gyoto.vector_double_capacity(self)

    __swig_destroy__ = _gyoto.delete_vector_double
    __del__ = lambda self: None
vector_double_swigregister = _gyoto.vector_double_swigregister
vector_double_swigregister(vector_double)

class vector_unsigned_long(_object):
    """Proxy of C++ std::vector<(unsigned long)> class."""

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

    def iterator(self):
        """iterator(vector_unsigned_long self) -> SwigPyIterator"""
        return _gyoto.vector_unsigned_long_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(vector_unsigned_long self) -> bool"""
        return _gyoto.vector_unsigned_long___nonzero__(self)


    def __bool__(self):
        """__bool__(vector_unsigned_long self) -> bool"""
        return _gyoto.vector_unsigned_long___bool__(self)


    def __len__(self):
        """__len__(vector_unsigned_long self) -> std::vector< unsigned long >::size_type"""
        return _gyoto.vector_unsigned_long___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vector_unsigned_long self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_unsigned_long"""
        return _gyoto.vector_unsigned_long___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vector_unsigned_long self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
        __setslice__(vector_unsigned_long self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_unsigned_long v)
        """
        return _gyoto.vector_unsigned_long___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vector_unsigned_long self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"""
        return _gyoto.vector_unsigned_long___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vector_unsigned_long self, std::vector< unsigned long >::difference_type i)
        __delitem__(vector_unsigned_long self, PySliceObject * slice)
        """
        return _gyoto.vector_unsigned_long___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vector_unsigned_long self, PySliceObject * slice) -> vector_unsigned_long
        __getitem__(vector_unsigned_long self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
        """
        return _gyoto.vector_unsigned_long___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vector_unsigned_long self, PySliceObject * slice, vector_unsigned_long v)
        __setitem__(vector_unsigned_long self, PySliceObject * slice)
        __setitem__(vector_unsigned_long self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
        """
        return _gyoto.vector_unsigned_long___setitem__(self, *args)


    def pop(self):
        """pop(vector_unsigned_long self) -> std::vector< unsigned long >::value_type"""
        return _gyoto.vector_unsigned_long_pop(self)


    def append(self, x):
        """append(vector_unsigned_long self, std::vector< unsigned long >::value_type const & x)"""
        return _gyoto.vector_unsigned_long_append(self, x)


    def empty(self):
        """empty(vector_unsigned_long self) -> bool"""
        return _gyoto.vector_unsigned_long_empty(self)


    def size(self):
        """size(vector_unsigned_long self) -> std::vector< unsigned long >::size_type"""
        return _gyoto.vector_unsigned_long_size(self)


    def swap(self, v):
        """swap(vector_unsigned_long self, vector_unsigned_long v)"""
        return _gyoto.vector_unsigned_long_swap(self, v)


    def begin(self):
        """begin(vector_unsigned_long self) -> std::vector< unsigned long >::iterator"""
        return _gyoto.vector_unsigned_long_begin(self)


    def end(self):
        """end(vector_unsigned_long self) -> std::vector< unsigned long >::iterator"""
        return _gyoto.vector_unsigned_long_end(self)


    def rbegin(self):
        """rbegin(vector_unsigned_long self) -> std::vector< unsigned long >::reverse_iterator"""
        return _gyoto.vector_unsigned_long_rbegin(self)


    def rend(self):
        """rend(vector_unsigned_long self) -> std::vector< unsigned long >::reverse_iterator"""
        return _gyoto.vector_unsigned_long_rend(self)


    def clear(self):
        """clear(vector_unsigned_long self)"""
        return _gyoto.vector_unsigned_long_clear(self)


    def get_allocator(self):
        """get_allocator(vector_unsigned_long self) -> std::vector< unsigned long >::allocator_type"""
        return _gyoto.vector_unsigned_long_get_allocator(self)


    def pop_back(self):
        """pop_back(vector_unsigned_long self)"""
        return _gyoto.vector_unsigned_long_pop_back(self)


    def erase(self, *args):
        """
        erase(vector_unsigned_long self, std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator
        erase(vector_unsigned_long self, std::vector< unsigned long >::iterator first, std::vector< unsigned long >::iterator last) -> std::vector< unsigned long >::iterator
        """
        return _gyoto.vector_unsigned_long_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(unsigned long)> self) -> vector_unsigned_long
        __init__(std::vector<(unsigned long)> self, vector_unsigned_long arg2) -> vector_unsigned_long
        __init__(std::vector<(unsigned long)> self, std::vector< unsigned long >::size_type size) -> vector_unsigned_long
        __init__(std::vector<(unsigned long)> self, std::vector< unsigned long >::size_type size, std::vector< unsigned long >::value_type const & value) -> vector_unsigned_long
        """
        this = _gyoto.new_vector_unsigned_long(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vector_unsigned_long self, std::vector< unsigned long >::value_type const & x)"""
        return _gyoto.vector_unsigned_long_push_back(self, x)


    def front(self):
        """front(vector_unsigned_long self) -> std::vector< unsigned long >::value_type const &"""
        return _gyoto.vector_unsigned_long_front(self)


    def back(self):
        """back(vector_unsigned_long self) -> std::vector< unsigned long >::value_type const &"""
        return _gyoto.vector_unsigned_long_back(self)


    def assign(self, n, x):
        """assign(vector_unsigned_long self, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)"""
        return _gyoto.vector_unsigned_long_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vector_unsigned_long self, std::vector< unsigned long >::size_type new_size)
        resize(vector_unsigned_long self, std::vector< unsigned long >::size_type new_size, std::vector< unsigned long >::value_type const & x)
        """
        return _gyoto.vector_unsigned_long_resize(self, *args)


    def insert(self, *args):
        """
        insert(vector_unsigned_long self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::value_type const & x) -> std::vector< unsigned long >::iterator
        insert(vector_unsigned_long self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)
        """
        return _gyoto.vector_unsigned_long_insert(self, *args)


    def reserve(self, n):
        """reserve(vector_unsigned_long self, std::vector< unsigned long >::size_type n)"""
        return _gyoto.vector_unsigned_long_reserve(self, n)


    def capacity(self):
        """capacity(vector_unsigned_long self) -> std::vector< unsigned long >::size_type"""
        return _gyoto.vector_unsigned_long_capacity(self)

    __swig_destroy__ = _gyoto.delete_vector_unsigned_long
    __del__ = lambda self: None
vector_unsigned_long_swigregister = _gyoto.vector_unsigned_long_swigregister
vector_unsigned_long_swigregister(vector_unsigned_long)

class array_double(_object):
    """Proxy of C++ array_double class."""

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

    def __init__(self, nelements):
        """__init__(array_double self, size_t nelements) -> array_double"""
        this = _gyoto.new_array_double(nelements)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_array_double
    __del__ = lambda self: None

    def __getitem__(self, index):
        """__getitem__(array_double self, size_t index) -> double"""
        return _gyoto.array_double___getitem__(self, index)


    def __setitem__(self, index, value):
        """__setitem__(array_double self, size_t index, double value)"""
        return _gyoto.array_double___setitem__(self, index, value)


    def cast(self):
        """cast(array_double self) -> double *"""
        return _gyoto.array_double_cast(self)


    def frompointer(t):
        """frompointer(double * t) -> array_double"""
        return _gyoto.array_double_frompointer(t)

    if _newclass:
        frompointer = staticmethod(frompointer)
    __swig_getmethods__["frompointer"] = lambda x: frompointer

    def fromnumpy1(IN_ARRAY1):
        """fromnumpy1(double * IN_ARRAY1) -> array_double"""
        return _gyoto.array_double_fromnumpy1(IN_ARRAY1)

    if _newclass:
        fromnumpy1 = staticmethod(fromnumpy1)
    __swig_getmethods__["fromnumpy1"] = lambda x: fromnumpy1

    def fromnumpy2(IN_ARRAY2):
        """fromnumpy2(double * IN_ARRAY2) -> array_double"""
        return _gyoto.array_double_fromnumpy2(IN_ARRAY2)

    if _newclass:
        fromnumpy2 = staticmethod(fromnumpy2)
    __swig_getmethods__["fromnumpy2"] = lambda x: fromnumpy2

    def fromnumpy3(IN_ARRAY3):
        """fromnumpy3(double * IN_ARRAY3) -> array_double"""
        return _gyoto.array_double_fromnumpy3(IN_ARRAY3)

    if _newclass:
        fromnumpy3 = staticmethod(fromnumpy3)
    __swig_getmethods__["fromnumpy3"] = lambda x: fromnumpy3

    def fromnumpy4(IN_ARRAY4):
        """fromnumpy4(double * IN_ARRAY4) -> array_double"""
        return _gyoto.array_double_fromnumpy4(IN_ARRAY4)

    if _newclass:
        fromnumpy4 = staticmethod(fromnumpy4)
    __swig_getmethods__["fromnumpy4"] = lambda x: fromnumpy4
array_double_swigregister = _gyoto.array_double_swigregister
array_double_swigregister(array_double)

def array_double_frompointer(t):
    """array_double_frompointer(double * t) -> array_double"""
    return _gyoto.array_double_frompointer(t)

def array_double_fromnumpy1(IN_ARRAY1):
    """array_double_fromnumpy1(double * IN_ARRAY1) -> array_double"""
    return _gyoto.array_double_fromnumpy1(IN_ARRAY1)

def array_double_fromnumpy2(IN_ARRAY2):
    """array_double_fromnumpy2(double * IN_ARRAY2) -> array_double"""
    return _gyoto.array_double_fromnumpy2(IN_ARRAY2)

def array_double_fromnumpy3(IN_ARRAY3):
    """array_double_fromnumpy3(double * IN_ARRAY3) -> array_double"""
    return _gyoto.array_double_fromnumpy3(IN_ARRAY3)

def array_double_fromnumpy4(IN_ARRAY4):
    """array_double_fromnumpy4(double * IN_ARRAY4) -> array_double"""
    return _gyoto.array_double_fromnumpy4(IN_ARRAY4)

class array_size_t(_object):
    """Proxy of C++ array_size_t class."""

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

    def __init__(self, nelements):
        """__init__(array_size_t self, size_t nelements) -> array_size_t"""
        this = _gyoto.new_array_size_t(nelements)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_array_size_t
    __del__ = lambda self: None

    def __getitem__(self, index):
        """__getitem__(array_size_t self, size_t index) -> size_t"""
        return _gyoto.array_size_t___getitem__(self, index)


    def __setitem__(self, index, value):
        """__setitem__(array_size_t self, size_t index, size_t value)"""
        return _gyoto.array_size_t___setitem__(self, index, value)


    def cast(self):
        """cast(array_size_t self) -> size_t *"""
        return _gyoto.array_size_t_cast(self)


    def frompointer(t):
        """frompointer(size_t * t) -> array_size_t"""
        return _gyoto.array_size_t_frompointer(t)

    if _newclass:
        frompointer = staticmethod(frompointer)
    __swig_getmethods__["frompointer"] = lambda x: frompointer

    def fromnumpy1(IN_ARRAY1):
        """fromnumpy1(size_t * IN_ARRAY1) -> array_size_t"""
        return _gyoto.array_size_t_fromnumpy1(IN_ARRAY1)

    if _newclass:
        fromnumpy1 = staticmethod(fromnumpy1)
    __swig_getmethods__["fromnumpy1"] = lambda x: fromnumpy1

    def fromnumpy2(IN_ARRAY2):
        """fromnumpy2(size_t * IN_ARRAY2) -> array_size_t"""
        return _gyoto.array_size_t_fromnumpy2(IN_ARRAY2)

    if _newclass:
        fromnumpy2 = staticmethod(fromnumpy2)
    __swig_getmethods__["fromnumpy2"] = lambda x: fromnumpy2

    def fromnumpy3(IN_ARRAY3):
        """fromnumpy3(size_t * IN_ARRAY3) -> array_size_t"""
        return _gyoto.array_size_t_fromnumpy3(IN_ARRAY3)

    if _newclass:
        fromnumpy3 = staticmethod(fromnumpy3)
    __swig_getmethods__["fromnumpy3"] = lambda x: fromnumpy3

    def fromnumpy4(IN_ARRAY4):
        """fromnumpy4(size_t * IN_ARRAY4) -> array_size_t"""
        return _gyoto.array_size_t_fromnumpy4(IN_ARRAY4)

    if _newclass:
        fromnumpy4 = staticmethod(fromnumpy4)
    __swig_getmethods__["fromnumpy4"] = lambda x: fromnumpy4
array_size_t_swigregister = _gyoto.array_size_t_swigregister
array_size_t_swigregister(array_size_t)

def array_size_t_frompointer(t):
    """array_size_t_frompointer(size_t * t) -> array_size_t"""
    return _gyoto.array_size_t_frompointer(t)

def array_size_t_fromnumpy1(IN_ARRAY1):
    """array_size_t_fromnumpy1(size_t * IN_ARRAY1) -> array_size_t"""
    return _gyoto.array_size_t_fromnumpy1(IN_ARRAY1)

def array_size_t_fromnumpy2(IN_ARRAY2):
    """array_size_t_fromnumpy2(size_t * IN_ARRAY2) -> array_size_t"""
    return _gyoto.array_size_t_fromnumpy2(IN_ARRAY2)

def array_size_t_fromnumpy3(IN_ARRAY3):
    """array_size_t_fromnumpy3(size_t * IN_ARRAY3) -> array_size_t"""
    return _gyoto.array_size_t_fromnumpy3(IN_ARRAY3)

def array_size_t_fromnumpy4(IN_ARRAY4):
    """array_size_t_fromnumpy4(size_t * IN_ARRAY4) -> array_size_t"""
    return _gyoto.array_size_t_fromnumpy4(IN_ARRAY4)

class array_unsigned_long(_object):
    """Proxy of C++ array_unsigned_long class."""

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

    def __init__(self, nelements):
        """__init__(array_unsigned_long self, size_t nelements) -> array_unsigned_long"""
        this = _gyoto.new_array_unsigned_long(nelements)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_array_unsigned_long
    __del__ = lambda self: None

    def __getitem__(self, index):
        """__getitem__(array_unsigned_long self, size_t index) -> unsigned long"""
        return _gyoto.array_unsigned_long___getitem__(self, index)


    def __setitem__(self, index, value):
        """__setitem__(array_unsigned_long self, size_t index, unsigned long value)"""
        return _gyoto.array_unsigned_long___setitem__(self, index, value)


    def cast(self):
        """cast(array_unsigned_long self) -> unsigned long *"""
        return _gyoto.array_unsigned_long_cast(self)


    def frompointer(t):
        """frompointer(unsigned long * t) -> array_unsigned_long"""
        return _gyoto.array_unsigned_long_frompointer(t)

    if _newclass:
        frompointer = staticmethod(frompointer)
    __swig_getmethods__["frompointer"] = lambda x: frompointer

    def fromnumpy1(IN_ARRAY1, DIM1):
        """fromnumpy1(unsigned long * IN_ARRAY1, size_t DIM1) -> array_unsigned_long"""
        return _gyoto.array_unsigned_long_fromnumpy1(IN_ARRAY1, DIM1)

    if _newclass:
        fromnumpy1 = staticmethod(fromnumpy1)
    __swig_getmethods__["fromnumpy1"] = lambda x: fromnumpy1

    def fromnumpy2(IN_ARRAY2, DIM1, DIM2):
        """fromnumpy2(unsigned long * IN_ARRAY2, size_t DIM1, size_t DIM2) -> array_unsigned_long"""
        return _gyoto.array_unsigned_long_fromnumpy2(IN_ARRAY2, DIM1, DIM2)

    if _newclass:
        fromnumpy2 = staticmethod(fromnumpy2)
    __swig_getmethods__["fromnumpy2"] = lambda x: fromnumpy2

    def fromnumpy3(IN_ARRAY3, DIM1, DIM2, DIM3):
        """fromnumpy3(unsigned long * IN_ARRAY3, size_t DIM1, size_t DIM2, size_t DIM3) -> array_unsigned_long"""
        return _gyoto.array_unsigned_long_fromnumpy3(IN_ARRAY3, DIM1, DIM2, DIM3)

    if _newclass:
        fromnumpy3 = staticmethod(fromnumpy3)
    __swig_getmethods__["fromnumpy3"] = lambda x: fromnumpy3

    def fromnumpy4(IN_ARRAY4, DIM1, DIM2, DIM3, DIM4):
        """fromnumpy4(unsigned long * IN_ARRAY4, size_t DIM1, size_t DIM2, size_t DIM3, size_t DIM4) -> array_unsigned_long"""
        return _gyoto.array_unsigned_long_fromnumpy4(IN_ARRAY4, DIM1, DIM2, DIM3, DIM4)

    if _newclass:
        fromnumpy4 = staticmethod(fromnumpy4)
    __swig_getmethods__["fromnumpy4"] = lambda x: fromnumpy4
array_unsigned_long_swigregister = _gyoto.array_unsigned_long_swigregister
array_unsigned_long_swigregister(array_unsigned_long)

def array_unsigned_long_frompointer(t):
    """array_unsigned_long_frompointer(unsigned long * t) -> array_unsigned_long"""
    return _gyoto.array_unsigned_long_frompointer(t)

def array_unsigned_long_fromnumpy1(IN_ARRAY1, DIM1):
    """array_unsigned_long_fromnumpy1(unsigned long * IN_ARRAY1, size_t DIM1) -> array_unsigned_long"""
    return _gyoto.array_unsigned_long_fromnumpy1(IN_ARRAY1, DIM1)

def array_unsigned_long_fromnumpy2(IN_ARRAY2, DIM1, DIM2):
    """array_unsigned_long_fromnumpy2(unsigned long * IN_ARRAY2, size_t DIM1, size_t DIM2) -> array_unsigned_long"""
    return _gyoto.array_unsigned_long_fromnumpy2(IN_ARRAY2, DIM1, DIM2)

def array_unsigned_long_fromnumpy3(IN_ARRAY3, DIM1, DIM2, DIM3):
    """array_unsigned_long_fromnumpy3(unsigned long * IN_ARRAY3, size_t DIM1, size_t DIM2, size_t DIM3) -> array_unsigned_long"""
    return _gyoto.array_unsigned_long_fromnumpy3(IN_ARRAY3, DIM1, DIM2, DIM3)

def array_unsigned_long_fromnumpy4(IN_ARRAY4, DIM1, DIM2, DIM3, DIM4):
    """array_unsigned_long_fromnumpy4(unsigned long * IN_ARRAY4, size_t DIM1, size_t DIM2, size_t DIM3, size_t DIM4) -> array_unsigned_long"""
    return _gyoto.array_unsigned_long_fromnumpy4(IN_ARRAY4, DIM1, DIM2, DIM3, DIM4)


_gyoto.GYOTO_DEBUG_ENABLED_swigconstant(_gyoto)
GYOTO_DEBUG_ENABLED = _gyoto.GYOTO_DEBUG_ENABLED

_gyoto.GYOTO_PLUGIN_SFX_swigconstant(_gyoto)
GYOTO_PLUGIN_SFX = _gyoto.GYOTO_PLUGIN_SFX

_gyoto.GYOTO_SIZE__T_IS_UNSIGNED_LONG_swigconstant(_gyoto)
GYOTO_SIZE__T_IS_UNSIGNED_LONG = _gyoto.GYOTO_SIZE__T_IS_UNSIGNED_LONG

_gyoto.GYOTO_SOVERS_swigconstant(_gyoto)
GYOTO_SOVERS = _gyoto.GYOTO_SOVERS

_gyoto.GYOTO_USE_CFITSIO_swigconstant(_gyoto)
GYOTO_USE_CFITSIO = _gyoto.GYOTO_USE_CFITSIO

_gyoto.GYOTO_USE_XERCES_swigconstant(_gyoto)
GYOTO_USE_XERCES = _gyoto.GYOTO_USE_XERCES

_gyoto.HAVE_DLFCN_H_swigconstant(_gyoto)
HAVE_DLFCN_H = _gyoto.HAVE_DLFCN_H

_gyoto.HAVE_INTTYPES_H_swigconstant(_gyoto)
HAVE_INTTYPES_H = _gyoto.HAVE_INTTYPES_H

_gyoto.HAVE_LIBDL_swigconstant(_gyoto)
HAVE_LIBDL = _gyoto.HAVE_LIBDL

_gyoto.HAVE_MEMORY_H_swigconstant(_gyoto)
HAVE_MEMORY_H = _gyoto.HAVE_MEMORY_H

_gyoto.HAVE_MPI_swigconstant(_gyoto)
HAVE_MPI = _gyoto.HAVE_MPI

_gyoto.HAVE_PTHREAD_swigconstant(_gyoto)
HAVE_PTHREAD = _gyoto.HAVE_PTHREAD

_gyoto.HAVE_PTHREAD_PRIO_INHERIT_swigconstant(_gyoto)
HAVE_PTHREAD_PRIO_INHERIT = _gyoto.HAVE_PTHREAD_PRIO_INHERIT

_gyoto.HAVE_SINCOS_swigconstant(_gyoto)
HAVE_SINCOS = _gyoto.HAVE_SINCOS

_gyoto.HAVE_STDINT_H_swigconstant(_gyoto)
HAVE_STDINT_H = _gyoto.HAVE_STDINT_H

_gyoto.HAVE_STDLIB_H_swigconstant(_gyoto)
HAVE_STDLIB_H = _gyoto.HAVE_STDLIB_H

_gyoto.HAVE_STRINGS_H_swigconstant(_gyoto)
HAVE_STRINGS_H = _gyoto.HAVE_STRINGS_H

_gyoto.HAVE_STRING_H_swigconstant(_gyoto)
HAVE_STRING_H = _gyoto.HAVE_STRING_H

_gyoto.HAVE_SYS_STAT_H_swigconstant(_gyoto)
HAVE_SYS_STAT_H = _gyoto.HAVE_SYS_STAT_H

_gyoto.HAVE_SYS_TYPES_H_swigconstant(_gyoto)
HAVE_SYS_TYPES_H = _gyoto.HAVE_SYS_TYPES_H

_gyoto.HAVE_UDUNITS_swigconstant(_gyoto)
HAVE_UDUNITS = _gyoto.HAVE_UDUNITS

_gyoto.HAVE_BOOST_MULTIPRECISION_CPP_DEC_FLOAT_HPP_swigconstant(_gyoto)
HAVE_BOOST_MULTIPRECISION_CPP_DEC_FLOAT_HPP = _gyoto.HAVE_BOOST_MULTIPRECISION_CPP_DEC_FLOAT_HPP

_gyoto.HAVE_BOOST_ARRAY_HPP_swigconstant(_gyoto)
HAVE_BOOST_ARRAY_HPP = _gyoto.HAVE_BOOST_ARRAY_HPP

_gyoto.GYOTO_HAVE_BOOST_INTEGRATORS_swigconstant(_gyoto)
GYOTO_HAVE_BOOST_INTEGRATORS = _gyoto.GYOTO_HAVE_BOOST_INTEGRATORS

_gyoto.HAVE_UNISTD_H_swigconstant(_gyoto)
HAVE_UNISTD_H = _gyoto.HAVE_UNISTD_H

_gyoto.HAVE_FENV_H_swigconstant(_gyoto)
HAVE_FENV_H = _gyoto.HAVE_FENV_H

_gyoto.STDC_HEADERS_swigconstant(_gyoto)
STDC_HEADERS = _gyoto.STDC_HEADERS

_gyoto.GYOTO_QUANTITY_NONE_swigconstant(_gyoto)
GYOTO_QUANTITY_NONE = _gyoto.GYOTO_QUANTITY_NONE

_gyoto.GYOTO_QUANTITY_INTENSITY_swigconstant(_gyoto)
GYOTO_QUANTITY_INTENSITY = _gyoto.GYOTO_QUANTITY_INTENSITY

_gyoto.GYOTO_QUANTITY_EMISSIONTIME_swigconstant(_gyoto)
GYOTO_QUANTITY_EMISSIONTIME = _gyoto.GYOTO_QUANTITY_EMISSIONTIME

_gyoto.GYOTO_QUANTITY_MIN_DISTANCE_swigconstant(_gyoto)
GYOTO_QUANTITY_MIN_DISTANCE = _gyoto.GYOTO_QUANTITY_MIN_DISTANCE

_gyoto.GYOTO_QUANTITY_FIRST_DMIN_swigconstant(_gyoto)
GYOTO_QUANTITY_FIRST_DMIN = _gyoto.GYOTO_QUANTITY_FIRST_DMIN

_gyoto.GYOTO_QUANTITY_REDSHIFT_swigconstant(_gyoto)
GYOTO_QUANTITY_REDSHIFT = _gyoto.GYOTO_QUANTITY_REDSHIFT

_gyoto.GYOTO_QUANTITY_IMPACTCOORDS_swigconstant(_gyoto)
GYOTO_QUANTITY_IMPACTCOORDS = _gyoto.GYOTO_QUANTITY_IMPACTCOORDS

_gyoto.GYOTO_QUANTITY_SPECTRUM_swigconstant(_gyoto)
GYOTO_QUANTITY_SPECTRUM = _gyoto.GYOTO_QUANTITY_SPECTRUM

_gyoto.GYOTO_QUANTITY_BINSPECTRUM_swigconstant(_gyoto)
GYOTO_QUANTITY_BINSPECTRUM = _gyoto.GYOTO_QUANTITY_BINSPECTRUM

_gyoto.GYOTO_QUANTITY_USER1_swigconstant(_gyoto)
GYOTO_QUANTITY_USER1 = _gyoto.GYOTO_QUANTITY_USER1

_gyoto.GYOTO_QUANTITY_USER2_swigconstant(_gyoto)
GYOTO_QUANTITY_USER2 = _gyoto.GYOTO_QUANTITY_USER2

_gyoto.GYOTO_QUANTITY_USER3_swigconstant(_gyoto)
GYOTO_QUANTITY_USER3 = _gyoto.GYOTO_QUANTITY_USER3

_gyoto.GYOTO_QUANTITY_USER4_swigconstant(_gyoto)
GYOTO_QUANTITY_USER4 = _gyoto.GYOTO_QUANTITY_USER4

_gyoto.GYOTO_QUANTITY_USER5_swigconstant(_gyoto)
GYOTO_QUANTITY_USER5 = _gyoto.GYOTO_QUANTITY_USER5

_gyoto.GYOTO_DEFAULT_DEBUG_MODE_swigconstant(_gyoto)
GYOTO_DEFAULT_DEBUG_MODE = _gyoto.GYOTO_DEFAULT_DEBUG_MODE

_gyoto.GYOTO_QUIET_VERBOSITY_swigconstant(_gyoto)
GYOTO_QUIET_VERBOSITY = _gyoto.GYOTO_QUIET_VERBOSITY

_gyoto.GYOTO_SEVERE_VERBOSITY_swigconstant(_gyoto)
GYOTO_SEVERE_VERBOSITY = _gyoto.GYOTO_SEVERE_VERBOSITY

_gyoto.GYOTO_WARNING_VERBOSITY_swigconstant(_gyoto)
GYOTO_WARNING_VERBOSITY = _gyoto.GYOTO_WARNING_VERBOSITY

_gyoto.GYOTO_DEFAULT_VERBOSITY_swigconstant(_gyoto)
GYOTO_DEFAULT_VERBOSITY = _gyoto.GYOTO_DEFAULT_VERBOSITY

_gyoto.GYOTO_INFO_VERBOSITY_swigconstant(_gyoto)
GYOTO_INFO_VERBOSITY = _gyoto.GYOTO_INFO_VERBOSITY

_gyoto.GYOTO_DEBUG_VERBOSITY_swigconstant(_gyoto)
GYOTO_DEBUG_VERBOSITY = _gyoto.GYOTO_DEBUG_VERBOSITY

_gyoto.GYOTO_COORDKIND_UNSPECIFIED_swigconstant(_gyoto)
GYOTO_COORDKIND_UNSPECIFIED = _gyoto.GYOTO_COORDKIND_UNSPECIFIED

_gyoto.GYOTO_COORDKIND_CARTESIAN_swigconstant(_gyoto)
GYOTO_COORDKIND_CARTESIAN = _gyoto.GYOTO_COORDKIND_CARTESIAN

_gyoto.GYOTO_COORDKIND_SPHERICAL_swigconstant(_gyoto)
GYOTO_COORDKIND_SPHERICAL = _gyoto.GYOTO_COORDKIND_SPHERICAL

_gyoto.GYOTO_DEFAULT_X_SIZE_swigconstant(_gyoto)
GYOTO_DEFAULT_X_SIZE = _gyoto.GYOTO_DEFAULT_X_SIZE

_gyoto.GYOTO_DEFAULT_DELTA_swigconstant(_gyoto)
GYOTO_DEFAULT_DELTA = _gyoto.GYOTO_DEFAULT_DELTA

_gyoto.GYOTO_DEFAULT_DELTA_MAX_OVER_R_swigconstant(_gyoto)
GYOTO_DEFAULT_DELTA_MAX_OVER_R = _gyoto.GYOTO_DEFAULT_DELTA_MAX_OVER_R

_gyoto.GYOTO_DEFAULT_ABSTOL_swigconstant(_gyoto)
GYOTO_DEFAULT_ABSTOL = _gyoto.GYOTO_DEFAULT_ABSTOL

_gyoto.GYOTO_DEFAULT_RELTOL_swigconstant(_gyoto)
GYOTO_DEFAULT_RELTOL = _gyoto.GYOTO_DEFAULT_RELTOL

_gyoto.GYOTO_DEFAULT_MAXITER_swigconstant(_gyoto)
GYOTO_DEFAULT_MAXITER = _gyoto.GYOTO_DEFAULT_MAXITER

_gyoto.GYOTO_T_TOL_swigconstant(_gyoto)
GYOTO_T_TOL = _gyoto.GYOTO_T_TOL

_gyoto.GYOTO_KERR_HORIZON_SECURITY_swigconstant(_gyoto)
GYOTO_KERR_HORIZON_SECURITY = _gyoto.GYOTO_KERR_HORIZON_SECURITY

_gyoto.GYOTO_PREC_swigconstant(_gyoto)
GYOTO_PREC = _gyoto.GYOTO_PREC

_gyoto.GYOTO_WIDTH_swigconstant(_gyoto)
GYOTO_WIDTH = _gyoto.GYOTO_WIDTH

_gyoto.GYOTO_DEFAULT_PLUGINS_swigconstant(_gyoto)
GYOTO_DEFAULT_PLUGINS = _gyoto.GYOTO_DEFAULT_PLUGINS

_gyoto.GYOTO_C_swigconstant(_gyoto)
GYOTO_C = _gyoto.GYOTO_C

_gyoto.GYOTO_C_CGS_swigconstant(_gyoto)
GYOTO_C_CGS = _gyoto.GYOTO_C_CGS

_gyoto.GYOTO_G_swigconstant(_gyoto)
GYOTO_G = _gyoto.GYOTO_G

_gyoto.GYOTO_G_CGS_swigconstant(_gyoto)
GYOTO_G_CGS = _gyoto.GYOTO_G_CGS

_gyoto.GYOTO_G_OVER_C_SQUARE_swigconstant(_gyoto)
GYOTO_G_OVER_C_SQUARE = _gyoto.GYOTO_G_OVER_C_SQUARE

_gyoto.GYOTO_PLANCK_swigconstant(_gyoto)
GYOTO_PLANCK = _gyoto.GYOTO_PLANCK

_gyoto.GYOTO_PLANCK_CGS_swigconstant(_gyoto)
GYOTO_PLANCK_CGS = _gyoto.GYOTO_PLANCK_CGS

_gyoto.GYOTO_PLANCK_OVER_C_SQUARE_swigconstant(_gyoto)
GYOTO_PLANCK_OVER_C_SQUARE = _gyoto.GYOTO_PLANCK_OVER_C_SQUARE

_gyoto.GYOTO_BOLTZMANN_swigconstant(_gyoto)
GYOTO_BOLTZMANN = _gyoto.GYOTO_BOLTZMANN

_gyoto.GYOTO_BOLTZMANN_CGS_swigconstant(_gyoto)
GYOTO_BOLTZMANN_CGS = _gyoto.GYOTO_BOLTZMANN_CGS

_gyoto.GYOTO_STEFANBOLTZMANN_CGS_swigconstant(_gyoto)
GYOTO_STEFANBOLTZMANN_CGS = _gyoto.GYOTO_STEFANBOLTZMANN_CGS

_gyoto.GYOTO_PLANCK_OVER_BOLTZMANN_swigconstant(_gyoto)
GYOTO_PLANCK_OVER_BOLTZMANN = _gyoto.GYOTO_PLANCK_OVER_BOLTZMANN

_gyoto.GYOTO_GAS_CST_swigconstant(_gyoto)
GYOTO_GAS_CST = _gyoto.GYOTO_GAS_CST

_gyoto.GYOTO_GAS_CST_CGS_swigconstant(_gyoto)
GYOTO_GAS_CST_CGS = _gyoto.GYOTO_GAS_CST_CGS

_gyoto.GYOTO_AVOGADRO_swigconstant(_gyoto)
GYOTO_AVOGADRO = _gyoto.GYOTO_AVOGADRO

_gyoto.GYOTO_THOMSON_CGS_swigconstant(_gyoto)
GYOTO_THOMSON_CGS = _gyoto.GYOTO_THOMSON_CGS

_gyoto.GYOTO_ALPHA_F_swigconstant(_gyoto)
GYOTO_ALPHA_F = _gyoto.GYOTO_ALPHA_F

_gyoto.GYOTO_PROTON_MASS_CGS_swigconstant(_gyoto)
GYOTO_PROTON_MASS_CGS = _gyoto.GYOTO_PROTON_MASS_CGS

_gyoto.GYOTO_ELECTRON_MASS_CGS_swigconstant(_gyoto)
GYOTO_ELECTRON_MASS_CGS = _gyoto.GYOTO_ELECTRON_MASS_CGS

_gyoto.GYOTO_ELECTRON_CLASSICAL_RADIUS_CGS_swigconstant(_gyoto)
GYOTO_ELECTRON_CLASSICAL_RADIUS_CGS = _gyoto.GYOTO_ELECTRON_CLASSICAL_RADIUS_CGS

_gyoto.GYOTO_ELEMENTARY_CHARGE_CGS_swigconstant(_gyoto)
GYOTO_ELEMENTARY_CHARGE_CGS = _gyoto.GYOTO_ELEMENTARY_CHARGE_CGS

_gyoto.GYOTO_EULER_MASCHERONI_swigconstant(_gyoto)
GYOTO_EULER_MASCHERONI = _gyoto.GYOTO_EULER_MASCHERONI

_gyoto.GYOTO_ATOMIC_MASS_UNIT_CGS_swigconstant(_gyoto)
GYOTO_ATOMIC_MASS_UNIT_CGS = _gyoto.GYOTO_ATOMIC_MASS_UNIT_CGS

_gyoto.GYOTO_INU_CGS_TO_SI_swigconstant(_gyoto)
GYOTO_INU_CGS_TO_SI = _gyoto.GYOTO_INU_CGS_TO_SI

_gyoto.GYOTO_SUN_MASS_swigconstant(_gyoto)
GYOTO_SUN_MASS = _gyoto.GYOTO_SUN_MASS

_gyoto.GYOTO_SUN_MASS_CGS_swigconstant(_gyoto)
GYOTO_SUN_MASS_CGS = _gyoto.GYOTO_SUN_MASS_CGS

_gyoto.GYOTO_SUN_RADIUS_swigconstant(_gyoto)
GYOTO_SUN_RADIUS = _gyoto.GYOTO_SUN_RADIUS

_gyoto.GYOTO_KPC_swigconstant(_gyoto)
GYOTO_KPC = _gyoto.GYOTO_KPC

_gyoto.GYOTO_ASTRONOMICAL_UNIT_swigconstant(_gyoto)
GYOTO_ASTRONOMICAL_UNIT = _gyoto.GYOTO_ASTRONOMICAL_UNIT

_gyoto.GYOTO_LIGHT_YEAR_swigconstant(_gyoto)
GYOTO_LIGHT_YEAR = _gyoto.GYOTO_LIGHT_YEAR

_gyoto.GYOTO_RADEG_swigconstant(_gyoto)
GYOTO_RADEG = _gyoto.GYOTO_RADEG

_gyoto.GYOTO_DEGRAD_swigconstant(_gyoto)
GYOTO_DEGRAD = _gyoto.GYOTO_DEGRAD

_gyoto.GYOTO_MINRAD_swigconstant(_gyoto)
GYOTO_MINRAD = _gyoto.GYOTO_MINRAD

_gyoto.GYOTO_SECRAD_swigconstant(_gyoto)
GYOTO_SECRAD = _gyoto.GYOTO_SECRAD

_gyoto.GYOTO_MASRAD_swigconstant(_gyoto)
GYOTO_MASRAD = _gyoto.GYOTO_MASRAD

_gyoto.GYOTO_MUASRAD_swigconstant(_gyoto)
GYOTO_MUASRAD = _gyoto.GYOTO_MUASRAD

_gyoto.GYOTO_eV2Hz_swigconstant(_gyoto)
GYOTO_eV2Hz = _gyoto.GYOTO_eV2Hz
class Error(_object):
    """


    Class for thowing exceptions.

    Gyoto dlopens its plug-ins. The throw/catch C++ mechanism cannot pass
    the dlopen boundary. The Gyoto::Error mechanism alleviates this C++
    language limitation.

    Every Gyoto method (either in the main Gyoto library or in a Gyoto
    plug-in) should check for possible error conditions and throw adequate
    Gyoto::Error exceptions through the Gyoto::throwError() function. For
    instance:

    If the main code has set Gyoto::Error::handler_t error handler using
    Gyoto::Error::setHandler(), these errors will then be passed to it.
    Else, the Error is C++-thrown at the main Gyoto library level, above
    the dlopen boundary.

    The main code can then catch these exceptions and act appropriately,
    for instance:

    C++ includes: GyotoError.h 
    """

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

    def __init__(self, m):
        """
        __init__(Gyoto::Error self, std::string const m) -> Error



        Constructor with an error message. 
        """
        this = _gyoto.new_Error(m)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def Report(self):
        """
        Report(Error self)



        Print-out error message on standard error. 
        """
        return _gyoto.Error_Report(self)


    def getErrcode(self):
        """
        getErrcode(Error self) -> int



        Retrieve error code.

        See also operator const char * () const and get_message().  Error code

        """
        return _gyoto.Error_getErrcode(self)


    def get_message(self):
        """
        get_message(Error self) -> std::string



        Retrieve error message for custom handling of the exception.

        See also operator const char * () const and getErrCode(). char*
        message : pointer to the error message 
        """
        return _gyoto.Error_get_message(self)


    def setHandler(phandler):
        """setHandler(Gyoto::Error::Handler_t * phandler)"""
        return _gyoto.Error_setHandler(phandler)

    if _newclass:
        setHandler = staticmethod(setHandler)
    __swig_getmethods__["setHandler"] = lambda x: setHandler
    __swig_destroy__ = _gyoto.delete_Error
    __del__ = lambda self: None
Error_swigregister = _gyoto.Error_swigregister
Error_swigregister(Error)

def Error_setHandler(phandler):
    """Error_setHandler(Gyoto::Error::Handler_t * phandler)"""
    return _gyoto.Error_setHandler(phandler)


def throwError(arg1):
    """throwError(std::string arg1)"""
    return _gyoto.throwError(arg1)
class SmartPointee(_object):
    """


    Can be pointed to by a SmartPointer.

    A class can be pointed to by a SmartPointer when it inherits from
    class SmartPointee.

    The SmartPointee methods need to be public to be accessed by all the
    SmartPointer < T > classes. However, it is a bad idea to manipulate
    the counter directly. To protect these methods inside your derive
    object, you can do as in the following example:

    C++ includes: GyotoSmartPointer.h 
    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SmartPointee, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SmartPointee, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _gyoto.delete_SmartPointee
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Gyoto::SmartPointee self) -> SmartPointee
        __init__(Gyoto::SmartPointee self, SmartPointee arg2) -> SmartPointee



        Copy constructor. 
        """
        this = _gyoto.new_SmartPointee(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def incRefCount(self):
        """
        incRefCount(SmartPointee self)



        Increment the reference counter. Warning: Don't mess with the counter.

        """
        return _gyoto.SmartPointee_incRefCount(self)


    def decRefCount(self):
        """
        decRefCount(SmartPointee self) -> int



        Decrement the reference counter and return current value. Warning:
        Don't mess with the counter. 
        """
        return _gyoto.SmartPointee_decRefCount(self)


    def getRefCount(self):
        """
        getRefCount(SmartPointee self) -> int



        Get the current number of references. 
        """
        return _gyoto.SmartPointee_getRefCount(self)

SmartPointee_swigregister = _gyoto.SmartPointee_swigregister
SmartPointee_swigregister(SmartPointee)


def initRegister(pluglist=None):
    """
    initRegister(char const * pluglist=None)
    initRegister()



    Initialise the various registers.

    Normally called once at application start-up, Register::init()
    initiaizes the registers, loads the plug-ins, and fills the registers
    as appropriate.

    Parameters:
    -----------

    pluglist:  Coma-separated list of plug-ins to load. If NULL, default
    to the environment variable GYOTO_PLUGINS, if it exists. Else use
    GYOTO_DEFAULT_PLUGINS. Failing to load a plug-in prepended with
    "nofail:" is not fatal. 
    """
    return _gyoto.initRegister(pluglist)

def listRegister():
    """
    listRegister()



    List the various registers. 
    """
    return _gyoto.listRegister()

def loadPlugin(plugname, nofail=0):
    """
    loadPlugin(char const *const plugname, int nofail=0)
    loadPlugin(char const *const plugname)
    """
    return _gyoto.loadPlugin(plugname, nofail)
class RegisterEntry(_object):
    """


    Entry in a register (or a full register)

    A register is actually a chained list of Register::Entry instances.

    C++ includes: GyotoRegister.h 
    """

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

    def __init__(self, name, subcontractor, next):
        """
        __init__(Gyoto::Register::Entry self, std::string name, Gyoto::SmartPointee::Subcontractor_t * subcontractor, RegisterEntry next) -> RegisterEntry



        Constructor. 
        """
        this = _gyoto.new_RegisterEntry(name, subcontractor, next)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_RegisterEntry
    __del__ = lambda self: None

    def getSubcontractor(self, name, errmode=0):
        """
        getSubcontractor(RegisterEntry self, std::string name, int errmode=0) -> Gyoto::SmartPointee::Subcontractor_t
        getSubcontractor(RegisterEntry self, std::string name) -> Gyoto::SmartPointee::Subcontractor_t *



        Get subcontractor for a given name.

        Search through the register for an Entry matching name and return the
        corresponding subcontractor.

        Parameters:
        -----------

        name:  Name of the kind to look for.

        errmode:  1 if getSubContractor() should return NULL upon failure.
        Else a Gyoto::Error is thrown.

        Pointer to subcontractor function. 
        """
        return _gyoto.RegisterEntry_getSubcontractor(self, name, errmode)

RegisterEntry_swigregister = _gyoto.RegisterEntry_swigregister
RegisterEntry_swigregister(RegisterEntry)

class Functor__Double_constDoubleArray(_object):
    """


    A functor like double (func) (double const data[])

    C++ includes: GyotoFunctors.h 
    """

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

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

    def __call__(self, data):
        """__call__(Functor__Double_constDoubleArray self, double const [] data) -> double"""
        return _gyoto.Functor__Double_constDoubleArray___call__(self, data)

    __swig_destroy__ = _gyoto.delete_Functor__Double_constDoubleArray
    __del__ = lambda self: None
Functor__Double_constDoubleArray_swigregister = _gyoto.Functor__Double_constDoubleArray_swigregister
Functor__Double_constDoubleArray_swigregister(Functor__Double_constDoubleArray)

class Functor__Double_Double_const(_object):
    """


    A functor like double (func) (double) const.

    C++ includes: GyotoFunctors.h 
    """

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["status"] = _gyoto.Functor__Double_Double_const_status_set
    __swig_getmethods__["status"] = _gyoto.Functor__Double_Double_const_status_get
    if _newclass:
        status = _swig_property(_gyoto.Functor__Double_Double_const_status_get, _gyoto.Functor__Double_Double_const_status_set)

    def __call__(self, arg2):
        """__call__(Functor__Double_Double_const self, double arg2) -> double"""
        return _gyoto.Functor__Double_Double_const___call__(self, arg2)


    def ridders(self, arg2, to):
        """
        ridders(Functor__Double_Double_const self, double arg2, double to) -> double



        Ridder's root-finding method applied on operator()()

        Parameters:
        -----------

        from:  to:  boundaries for root-searching

        the root 
        """
        return _gyoto.Functor__Double_Double_const_ridders(self, arg2, to)


    def secant(self, arg2, to):
        """
        secant(Functor__Double_Double_const self, double arg2, double to) -> double



        Secant root-finding method applied on operator()()

        Sets status to -0 in case of convergence -1 if two distinct inputs
        evaluated to the same output -2 if maximum number of iterations (20)
        reached

        Parameters:
        -----------

        from:  to:  boundaries for root-finding

        the root 
        """
        return _gyoto.Functor__Double_Double_const_secant(self, arg2, to)

    __swig_destroy__ = _gyoto.delete_Functor__Double_Double_const
    __del__ = lambda self: None
Functor__Double_Double_const_swigregister = _gyoto.Functor__Double_Double_const_swigregister
Functor__Double_Double_const_swigregister(Functor__Double_Double_const)

class Listener(_object):
    """


    I might listen to a Teller.

    Whisper to my ear by using my tell() method.

    C++ includes: GyotoHooks.h 
    """

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

    def __init__(self):
        """
        __init__(Gyoto::Hook::Listener self) -> Listener



        Constructor. 
        """
        this = _gyoto.new_Listener()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Listener
    __del__ = lambda self: None
Listener_swigregister = _gyoto.Listener_swigregister
Listener_swigregister(Listener)

class Teller(_object):
    """


    Listen to me and I'll warn you when I change.

    Listen to me by calling my hook() method.

    C++ includes: GyotoHooks.h 
    """

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

    def __init__(self, *args):
        """
        __init__(Gyoto::Hook::Teller self) -> Teller
        __init__(Gyoto::Hook::Teller self, Teller arg2) -> Teller



        Copy constructor. 
        """
        this = _gyoto.new_Teller(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Teller
    __del__ = lambda self: None

    def hook(self, listener):
        """
        hook(Teller self, Listener listener)



        Start listening.

        Use from a Hook::Listener object method: where "this" is a Listener
        and "teller" is a Teller.

        Use unhook() later to stop listening to a given Teller.

        Parameters:
        -----------

        listener:  pointer to the new listener 
        """
        return _gyoto.Teller_hook(self, listener)


    def unhook(self, listener):
        """
        unhook(Teller self, Listener listener)



        Stop listening.

        Use from a Hook::Listener object method:

        where "this" is a Listener, "teller" is a Teller, and "this" has
        called teller->hook(this) previously.

        Parameters:
        -----------

        listener:  pointer to the listener 
        """
        return _gyoto.Teller_unhook(self, listener)

Teller_swigregister = _gyoto.Teller_swigregister
Teller_swigregister(Teller)

class WIP(_object):
    """


    Base class for work in progress.

    The constructors of this class simply issue a warning that the
    (derived) class is work in progress.

    C++ includes: GyotoWIP.h 
    """

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

    def __init__(self, *args):
        """
        __init__(Gyoto::WIP self) -> WIP
        __init__(Gyoto::WIP self, std::string classname) -> WIP



        Issue a warning specifying the name of the derived class.

        If classname is the empty string (""), the warning is not issued.
        Use this to mark that a class is no more work in progress without
        breaking the ABI (i.e. in the Gyoto stable branch). 
        """
        this = _gyoto.new_WIP(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_WIP
    __del__ = lambda self: None
WIP_swigregister = _gyoto.WIP_swigregister
WIP_swigregister(WIP)

class Value(_object):
    """


    Container for the value of a Property.

    The Value class is very similar to the C union type (although not as
    memory efficient): it can hold several type of values, but only one at
    a time. Care must be taken to ensure only the member that was set is
    retrieved. The purpose of the Value class is to be used together with
    the Property class: code determines dynamicaly the type of a Property,
    reads the corresponding value appropriateley (e.g. from XML or from
    the Yorick prompt), stores the value in a Value instance, and sets the
    Property using the Object::set() method. Likewise, the Object::get()
    method returns a Gyoto::Value. Property::type must be used to
    determine which member of the Value is meaningful.

    Casting between Value and the various data type it can hold is
    normally automatic, but the members can also be accessed explicitly
    make code more easy to read and less ambiguous.

    C++ includes: GyotoValue.h 
    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Value, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Value, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _gyoto.delete_Value
    __del__ = lambda self: None

    def assign(self, arg2):
        """assign(Value self, Value arg2) -> Value"""
        return _gyoto.Value_assign(self, arg2)

    __swig_getmethods__["type"] = _gyoto.Value_type_get
    if _newclass:
        type = _swig_property(_gyoto.Value_type_get)

    def toDouble(self):
        """toDouble(Value self) -> double"""
        return _gyoto.Value_toDouble(self)


    def __nonzero__(self):
        return _gyoto.Value___nonzero__(self)
    __bool__ = __nonzero__



    def toLong(self):
        """toLong(Value self) -> long"""
        return _gyoto.Value_toLong(self)


    def toULong(self):
        """toULong(Value self) -> unsigned long"""
        return _gyoto.Value_toULong(self)


    def toString(self):
        """toString(Value self) -> std::string"""
        return _gyoto.Value_toString(self)


    def toVDouble(self):
        """toVDouble(Value self) -> vector_double"""
        return _gyoto.Value_toVDouble(self)


    def toVULong(self):
        """toVULong(Value self) -> std::vector< unsignedlong,std::allocator< unsignedlong > >"""
        return _gyoto.Value_toVULong(self)


    def toMetric(self):
        """toMetric(Value self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >"""
        return _gyoto.Value_toMetric(self)


    def toAstrobj(self):
        """toAstrobj(Value self) -> Gyoto::SmartPointer< Gyoto::Astrobj::Generic >"""
        return _gyoto.Value_toAstrobj(self)


    def toSpectrum(self):
        """toSpectrum(Value self) -> Gyoto::SmartPointer< Gyoto::Spectrum::Generic >"""
        return _gyoto.Value_toSpectrum(self)


    def toSpectrometer(self):
        """toSpectrometer(Value self) -> Gyoto::SmartPointer< Gyoto::Spectrometer::Generic >"""
        return _gyoto.Value_toSpectrometer(self)


    def __init__(self, *args):
        """
        __init__(Gyoto::Value self) -> Value
        __init__(Gyoto::Value self, double arg2) -> Value
        __init__(Gyoto::Value self, bool arg2) -> Value
        __init__(Gyoto::Value self, long arg2) -> Value
        __init__(Gyoto::Value self, unsigned long arg2) -> Value
        __init__(Gyoto::Value self, std::string arg2) -> Value
        __init__(Gyoto::Value self, vector_double arg2) -> Value
        __init__(Gyoto::Value self, vector_unsigned_long arg2) -> Value
        __init__(Gyoto::Value self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2) -> Value
        __init__(Gyoto::Value self, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > arg2) -> Value
        __init__(Gyoto::Value self, Gyoto::SmartPointer< Gyoto::Spectrum::Generic > arg2) -> Value
        __init__(Gyoto::Value self, Gyoto::SmartPointer< Gyoto::Spectrometer::Generic > arg2) -> Value
        __init__(Gyoto::Value self, Gyoto::SmartPointer< Gyoto::Screen > arg2) -> Value



        Cast from Screen. 
        """
        this = _gyoto.new_Value(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Value_swigregister = _gyoto.Value_swigregister
Value_swigregister(Value)

class Object(_object):
    """


    Object with properties.

    The Object API allows declaring a list of Properties that can be set
    and retrieved using a common, text-based interface. This interface
    simplifies a lot how to read and write XML, as well as writing
    bindings for interpreted langages (e.g. the Yorick interface).

    In fact, any class member that has an interface implemented as a
    Property can be readily read and written from/to XML as well as from
    the Yorick plug-in, without the need for any additional code.

    To declare a Property list: declare (in the class declaration, .h
    file) and define (.C file) the pair or quadruplet of accessors for
    your Property (see Property class documentation;

    call the GYOTO_OBJECT macro in in a public section of the class
    declaration (in the .h file):

    call the various GYOTO_PROPERTY_* macros in the corresponding .C file
    (see the documentation of the Property class).

    It is possible to get a Property by name (Assume A is a class deriving
    from Object): It then becomes possible to set or get the Property from
    or to a Value: Of course the type of the Value instance and of the
    Property instance must match. Refer to the documentation of these to
    classes for details.

    C++ includes: GyotoObject.h 
    """

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

    def getProperties(self):
        """
        getProperties(Object self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Object_getProperties(self)


    def __init__(self, *args):
        """
        __init__(Gyoto::Object self, std::string const & kind) -> Object
        __init__(Gyoto::Object self) -> Object
        __init__(Gyoto::Object self, Object orig) -> Object



        Deep copy constructor. 
        """
        this = _gyoto.new_Object(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Object
    __del__ = lambda self: None

    def set(self, *args):
        """
        set(Object self, Property p, Value val)
        set(Object self, Property p, Value val, std::string const & unit)
        set(Object self, std::string const & pname, Value val)
        set(Object self, std::string const & pname, Value val, std::string const & unit)



        Set Value (expressed in unit) of a Property. 
        """
        return _gyoto.Object_set(self, *args)


    def get(self, *args):
        """
        get(Object self, Property p) -> Value
        get(Object self, std::string const & pname) -> Value
        get(Object self, Property p, std::string const & unit) -> Value
        get(Object self, std::string const & pname, std::string const & unit) -> Value



        Get Value of a Property, converted to unit. 
        """
        return _gyoto.Object_get(self, *args)


    def property(self, pname):
        """
        property(Object self, std::string const pname) -> Property



        Find property by name.

        Look into the Property list for a Property whose name (or name_false,
        for a boolean Property) is pname. Return a const pointer to the first
        such property found, or NULL if none is found. 
        """
        return _gyoto.Object_property(self, pname)


    def fillProperty(self, fmp, p):
        """
        fillProperty(Object self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto.Object_fillProperty(self, fmp, p)


    def fillElement(self, fmp):
        """
        fillElement(Object self, FactoryMessenger fmp)



        Fill the XML element for this Object.

        The base implementation simply calls fillProperty() for each Property
        defined for the Object.

        Derived classes should avoid overriding fillElement(). It may make
        sense occasionally, e.g. to make sure that the metric is output first.

        To customize how a given Property is rendered, it is better to
        override fillProperty().

        If this method is overridden, the implementation should in general
        call fillElement() on the direct base. 
        """
        return _gyoto.Object_fillElement(self, fmp)


    def setParameters(self, fmp):
        """
        setParameters(Object self, FactoryMessenger fmp)



        Main loop for parsing Properties from XML description.

        This function queries the FactoryMessenger for elements to parse, and
        tries to matche each element to a Property to set it accordingly.

        Any class that tries to be buildable from XML must supply a
        subcontractor (for base classes such as Metric, Astrobj, Spectrum and
        Spectrometer, it is done as a template that must be specialized for
        each class).

        This subcontractor typically looks somewhat like this: Although this
        is discouraged, it is possible to override the following functions to
        customize how XML entities are parsed:    - setParameters() if low-
        level access to the      FactoryMessenger is required;    -
        setParameter(std::string name, std::string content,
        std::string unit)      to interpret an entity that does not match a
        Property      (e.g. alternative name);    -
        setParameter(Gyoto::Property const &p, std::string const &name,
        std::string const &content, std::string const &unit)      to change
        how a Property is interpreted. 
        """
        return _gyoto.Object_setParameters(self, fmp)


    def setParameter(self, *args):
        """
        setParameter(Object self, std::string name, std::string content, std::string unit) -> int
        setParameter(Object self, Property p, std::string const & name, std::string const & content, std::string const & unit)



        Set parameter by Property (and name)

        This function is used when parsing an XML description, if Property (
        p) of this name is found (i.e. either p.name or p.name_false is equal
        to name). Implementation should fall-back on calling the direct's
        parent implementation:

        Parameters:
        -----------

        p:   Property that matches name ( p.name == name or p.name_false ==
        name)

        name:  XML name of the parameter (XML entity)

        content:  string representation of the value

        unit:  string representation of the unit 
        """
        return _gyoto.Object_setParameter(self, *args)

Object_swigregister = _gyoto.Object_swigregister
Object_swigregister(Object)
cvar = _gyoto.cvar
Object.properties = _gyoto.cvar.Object_properties

class Worldline(_object):
    """


    Timelike or null geodesics.

    Their are two derived classes: Photon and Star. A Worldline can be
    integrated from an initial condition either backward or forward in
    time using xFill() ( Photon::hit() also integrates the Worldline).
    Member state_ holds the integration state as well as an integrator.
    There are several kinds of integration states, that derive from
    IntegState::Generic.

    The coordinates of the Worldline are stored in x0_, x1_, x2_, x3_,
    x0dot_, x1dot_, x2dot_ ans x3dot_. Those arrays are extended as needed
    using xExpand(). These coordinates can be retrieved using get_t(),
    get_xyz(), getCartesian(), getCoord() etc.

    Worldline does not derive from Object, and does not instanciate a
    Property list. This is because this would lead to multiple inheritance
    of the Object base in derived classes. Instead, #GyotoWorldline.h
    provides a few macros that can be used to include the Worldline
    properties in a derived classe's Property list:  GYOTO_WORLDLINE is to
    be used in a public section of the derived class declaration (.h
    file); it declares wrappers around the Worldline property accessors;

    GYOTO_WORLDLINE_ACCESSORS is to be used with the class definition (.C
    file; it defines the accessors declared by GYOTO_WORLDLINE;

    GYOTO_WORLDLINE_PROPERTIES declares the Properties that use these
    accessors. It must be used like e.g. GYOTO_PROPERTY_DOUBLE, between
    GYOTO_PROPERTY_START andf GYOTO_PROPERTY_END.

    Finally, GYOTO_WORLDLINE_PROPERTY_END is a drop-in replacement for
    GYOTO_PROPERTY_END that calls GYOTO_WORLDLINE_PROPERTIES and
    GYOTO_WORLDLINE_ACCESSORS.

    C++ includes: GyotoWorldline.h 
    """

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["stopcond"] = _gyoto.Worldline_stopcond_set
    __swig_getmethods__["stopcond"] = _gyoto.Worldline_stopcond_get
    if _newclass:
        stopcond = _swig_property(_gyoto.Worldline_stopcond_get, _gyoto.Worldline_stopcond_set)
    __swig_destroy__ = _gyoto.delete_Worldline
    __del__ = lambda self: None

    def getImin(self):
        """
        getImin(Worldline self) -> size_t



        Get imin_. 
        """
        return _gyoto.Worldline_getImin(self)


    def getImax(self):
        """
        getImax(Worldline self) -> size_t



        Get imax_. 
        """
        return _gyoto.Worldline_getImax(self)


    def getI0(self):
        """
        getI0(Worldline self) -> size_t



        Get i0_. 
        """
        return _gyoto.Worldline_getI0(self)


    def getMass(self):
        """
        getMass(Worldline self) -> double



        Get mass of particule. 
        """
        return _gyoto.Worldline_getMass(self)


    def metric(self, *args):
        """
        metric(Worldline self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(Worldline self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >



        Get metric. 
        """
        return _gyoto.Worldline_metric(self, *args)


    def initCoord(self, *args):
        """
        initCoord(Worldline self, vector_double arg2)
        initCoord(Worldline self) -> vector_double
        """
        return _gyoto.Worldline_initCoord(self, *args)


    def setInitCoord(self, *args):
        """
        setInitCoord(Worldline self, double const [8] coord, int dir=0)
        setInitCoord(Worldline self, double const [8] coord)
        setInitCoord(Worldline self, double [4] pos, double [3] vel, int dir=1)
        setInitCoord(Worldline self, double [4] pos, double [3] vel)



        Set initial coordinate.

        Parameters:
        -----------

        pos:  initial 4-position

        vel:  initial 3-velocity

        dir:  direction of integration 
        """
        return _gyoto.Worldline_setInitCoord(self, *args)


    def setPosition(self, pos):
        """
        setPosition(Worldline self, double [4] pos)



        Set initial 4-position. 
        """
        return _gyoto.Worldline_setPosition(self, pos)


    def setVelocity(self, vel):
        """
        setVelocity(Worldline self, double [3] vel)



        Set initial 3-velocity. 
        """
        return _gyoto.Worldline_setVelocity(self, vel)


    def reset(self):
        """
        reset(Worldline self)



        Forget integration, keeping initial contition. 
        """
        return _gyoto.Worldline_reset(self)


    def reInit(self):
        """
        reInit(Worldline self)



        Reset and recompute particle properties. 
        """
        return _gyoto.Worldline_reInit(self)


    def className(self):
        """
        className(Worldline self) -> std::string



        "Worldline" 
        """
        return _gyoto.Worldline_className(self)


    def className_l(self):
        """
        className_l(Worldline self) -> std::string



        "worldline" 
        """
        return _gyoto.Worldline_className_l(self)


    def integrator(self, *args):
        """
        integrator(Worldline self, std::string const & type)
        integrator(Worldline self) -> std::string



        Describe the integrator used by state_. 
        """
        return _gyoto.Worldline_integrator(self, *args)


    def deltaMin(self, *args):
        """
        deltaMin(Worldline self) -> double
        deltaMin(Worldline self, double h1)



        Set delta_min_. 
        """
        return _gyoto.Worldline_deltaMin(self, *args)


    def absTol(self, *args):
        """
        absTol(Worldline self, double arg2)
        absTol(Worldline self) -> double



        Get abstol_. 
        """
        return _gyoto.Worldline_absTol(self, *args)


    def relTol(self, *args):
        """
        relTol(Worldline self, double arg2)
        relTol(Worldline self) -> double



        Get reltol_. 
        """
        return _gyoto.Worldline_relTol(self, *args)


    def deltaMax(self, *args):
        """
        deltaMax(Worldline self) -> double
        deltaMax(Worldline self, double const [8] pos, double delta_max_external) -> double
        deltaMax(Worldline self, double h1)



        Set delta_max_ 
        """
        return _gyoto.Worldline_deltaMax(self, *args)


    def deltaMaxOverR(self, *args):
        """
        deltaMaxOverR(Worldline self) -> double
        deltaMaxOverR(Worldline self, double t)



        Set delta_max_over_r_. 
        """
        return _gyoto.Worldline_deltaMaxOverR(self, *args)


    def delta(self, *args):
        """
        delta(Worldline self, double const delta)
        delta(Worldline self, double arg2, std::string const & unit)
        delta(Worldline self) -> double
        delta(Worldline self, std::string const & unit) -> double



        Get delta_ in specified units. 
        """
        return _gyoto.Worldline_delta(self, *args)


    def tMin(self, *args):
        """
        tMin(Worldline self) -> double
        tMin(Worldline self, std::string const & unit) -> double
        tMin(Worldline self, double tlim)
        tMin(Worldline self, double arg2, std::string const & unit)



        Set tmin_ in specified unit. 
        """
        return _gyoto.Worldline_tMin(self, *args)


    def adaptive(self, *args):
        """
        adaptive(Worldline self, bool mode)
        adaptive(Worldline self) -> bool



        Get adaptive_. 
        """
        return _gyoto.Worldline_adaptive(self, *args)


    def secondary(self, *args):
        """
        secondary(Worldline self, bool sec)
        secondary(Worldline self) -> bool



        Get secondary_. 
        """
        return _gyoto.Worldline_secondary(self, *args)


    def maxiter(self, *args):
        """
        maxiter(Worldline self, size_t miter)
        maxiter(Worldline self) -> size_t



        Get maxiter_. 
        """
        return _gyoto.Worldline_maxiter(self, *args)


    def getCst(self):
        """
        getCst(Worldline self) -> double const *



        Returns the worldline's cst of motion (if any)

        Return pointer to array holding the previously set Metric-specific
        constants of motion 
        """
        return _gyoto.Worldline_getCst(self)


    def setCst(self, cst, ncsts):
        """
        setCst(Worldline self, double const * cst, size_t const ncsts)



        Set Metric-specific constants of motion.

        The will (re)allocate Worldline::cst_, copy cst into it, and set
        Worldline::cst_n_. 
        """
        return _gyoto.Worldline_setCst(self, cst, ncsts)


    def setInitialCondition(self, gg, coord, dir):
        """
        setInitialCondition(Worldline self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, double const [8] coord, int const dir)



        Set or re-set the initial condition prior to integration.

        Parameters:
        -----------

        gg:   Gyoto::SmartPointer to the Gyoto::Metric in this universe;

        coord:  8 element array containing the initial condition, i.e. the
        4-position and the 4-velocity of the Photon at the receiving end;

        dir:  direction: 1 for future, -1 for past. 
        """
        return _gyoto.Worldline_setInitialCondition(self, gg, coord, dir)


    def getInitialCoord(self, dest):
        """
        getInitialCoord(Worldline self, double [8] dest)



        Get initial coordinate. 
        """
        return _gyoto.Worldline_getInitialCoord(self, dest)


    def getCartesianPos(self, index, dest):
        """
        getCartesianPos(Worldline self, size_t index, double [4] dest)



        Get Cartesian expression of 4-position at index. 
        """
        return _gyoto.Worldline_getCartesianPos(self, index, dest)


    def xStore(self, ind, coord):
        """
        xStore(Worldline self, size_t ind, double [8] coord)



        Store coord at index ind. 
        """
        return _gyoto.Worldline_xStore(self, ind, coord)


    def xFill(self, tlim):
        """
        xFill(Worldline self, double tlim)



        Fill x0, x1... by integrating the Worldline from previously set
        inittial condition to time tlim. 
        """
        return _gyoto.Worldline_xFill(self, tlim)


    def get_nelements(self):
        """
        get_nelements(Worldline self) -> size_t



        Get number of computed dates. 
        """
        return _gyoto.Worldline_get_nelements(self)


    def get_t(self, dest):
        """
        get_t(Worldline self, double * dest)



        Get computed dates. 
        """
        return _gyoto.Worldline_get_t(self, dest)


    def getCartesian(self, dates, n_dates, x, y, z, xprime=None, yprime=None, zprime=None):
        """
        getCartesian(Worldline self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z, double *const xprime=None, double *const yprime=None, double *const zprime=None)
        getCartesian(Worldline self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z, double *const xprime=None, double *const yprime=None)
        getCartesian(Worldline self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z, double *const xprime=None)
        getCartesian(Worldline self, double const *const dates, size_t const n_dates, double *const x, double *const y, double *const z)



        Get the 6 Cartesian coordinates for specific dates.

        The 6 coordinates (x, y, z, dx/dt, dy/dt, dz/dt) will be computed
        using the integrator and interpolated if necessary, so they will be as
        accurate as possible. Transforming to Cartesian coordinates is not
        necessarily meaningful.

        Parameters:
        -----------

        dates:  List of dates for which the coordinates are to be computed;

        n_dates:  Number of dates to compute ;

        x:  y:  z:  xprime:  yprime:  zprime:  Arrays in which to store the
        result. These pointer may be set to NULL to retrieve only part of the
        information. Else, they must be pre- allocated. 
        """
        return _gyoto.Worldline_getCartesian(self, dates, n_dates, x, y, z, xprime, yprime, zprime)


    def get_xyz(self, x, y, z):
        """
        get_xyz(Worldline self, double * x, double * y, double * z)



        Get 3-position in cartesian coordinates for computed dates. 
        """
        return _gyoto.Worldline_get_xyz(self, x, y, z)


    def getCoord(self, *args):
        """
        getCoord(Worldline self, size_t index, double [8] dest)
        getCoord(Worldline self, double const *const dates, size_t const n_dates, double *const x1dest, double *const x2dest, double *const x3dest, double *const x0dot=None, double *const x1dot=None, double *const x2dot=None, double *const x3dot=None)
        getCoord(Worldline self, double const *const dates, size_t const n_dates, double *const x1dest, double *const x2dest, double *const x3dest, double *const x0dot=None, double *const x1dot=None, double *const x2dot=None)
        getCoord(Worldline self, double const *const dates, size_t const n_dates, double *const x1dest, double *const x2dest, double *const x3dest, double *const x0dot=None, double *const x1dot=None)
        getCoord(Worldline self, double const *const dates, size_t const n_dates, double *const x1dest, double *const x2dest, double *const x3dest, double *const x0dot=None)
        getCoord(Worldline self, double const *const dates, size_t const n_dates, double *const x1dest, double *const x2dest, double *const x3dest)
        getCoord(Worldline self, double * x0, double * x1, double * x2, double * x3)



        Get all computed positions.

        Get all the pre-computed 8 coordinates (e.g. thanks to a prior call to
        xFill()) of this worldline. 
        """
        return _gyoto.Worldline_getCoord(self, *args)


    def checkPhiTheta(self, coord):
        """
        checkPhiTheta(Worldline self, double [8] coord)



        Bring in [0,] and in [0,2].

        checkPhiTheta() Modifies coord if the corrdinates are spherical-like
        so that coord[2]=theta is in [0,pi] and coord[3]=phi is in [0,2pi].
        Important to use in all astrobj in spherical coordinates to prevent
        "z-axis problems". 
        """
        return _gyoto.Worldline_checkPhiTheta(self, coord)


    def getSkyPos(self, screen, dalpha, ddellta, dD):
        """
        getSkyPos(Worldline self, Gyoto::SmartPointer< Gyoto::Screen > screen, double * dalpha, double * ddellta, double * dD)



        Get computed positions in sky coordinates. 
        """
        return _gyoto.Worldline_getSkyPos(self, screen, dalpha, ddellta, dD)


    def get_dot(self, x0dot, x1dot, x2dot, x3dot):
        """
        get_dot(Worldline self, double * x0dot, double * x1dot, double * x2dot, double * x3dot)



        Get computed 4-velocities. 
        """
        return _gyoto.Worldline_get_dot(self, x0dot, x1dot, x2dot, x3dot)


    def get_prime(self, x1prime, x2prime, x3prime):
        """
        get_prime(Worldline self, double * x1prime, double * x2prime, double * x3prime)



        Get computed 3-velocities. 
        """
        return _gyoto.Worldline_get_prime(self, x1prime, x2prime, x3prime)


    def save_txyz(self, *args):
        """
        save_txyz(Worldline self, char * fichierxyz)
        save_txyz(Worldline self, char *const filename, double const t1, double const mass_sun, double const distance_kpc, std::string const unit, Gyoto::SmartPointer< Gyoto::Screen > sc=0)
        save_txyz(Worldline self, char *const filename, double const t1, double const mass_sun, double const distance_kpc, std::string const unit)



        Save, converted. 
        """
        return _gyoto.Worldline_save_txyz(self, *args)

Worldline_swigregister = _gyoto.Worldline_swigregister
Worldline_swigregister(Worldline)

class Screen(SmartPointee, Object):
    """


    The camera with which the Astrobj is observed.

    In the observer-centric point-of-view, the center of the Metric's
    coordinate system is positioned relatively to the observing Screen
    using three Euler angles and the distance (in meters). The three Euler
    angles are: position angle of the line of nodes (North of East);

    inclination (0 = face-on);

    argument of the X axis of the Metric's coordinate system. We use the
    z-x-z convention. Seehttp://en.wikipedia.org/wiki/Euler_angles

    In addition, the Screen conveys: the observing date (in geometrical
    units, but expect it to change to seconds in a future version);

    the field-of-view of the image;

    the resolution of the camera: number of pixels on each side (the
    camera is square);

    the observing frequency.

    The scalar FreqObs defines the observing frequency for Scenery
    quantity Intensity.

    Likewise, a Gyoto::Spectrometer defines for which frequencies spectra
    are computed (when the Quantity Spectrum is requested in the Scenery).

    For the sake of theoreticians, there is an alternate way of specifying
    the relative position of the Screen and Metric, by specifying the
    4-coordinates of the Screen in the Metric's coordinate system (in that
    case, eerything is specified in geometrical units).

    So an XML stanza for a Screen may look like that:

    or like that:

    Units can be specified using the unit attribute in the XML file, for
    instance:

    Possible units are (with [] noting the default): distance: [m],
    geometrical, cm, km, AU, ly, pc, kpc, Mpc;

    PALN, inclination, argument: [rad], deg.

    frequency: [Hz], µm, GeV...

    When the distance is really large and most of the ray-tracing would
    happen de facto in flat space, the camera is transported to a location
    at a reasonable distance from the metric and the images are scaled
    accordingly. The default value for this distance should be fine, but
    it can be customized using the "dmax" attribute of the "Distance"
    element. "dmax" is always expressed in geometrical units:

    Symptoms when dmax is too large include pixelization of the image
    (neighbouring photons are numerically identical) and other numerical
    overflows. dmax is too small when it is apparent that changing it
    yields projection effects. dmax must be large compared to rmax in the
    Astrobj and ideally, changing it by an order of magnitude should not
    yield significant changes in the ray-traced image.

    A mask may be used to limit ray-tracing to only some portions of the
    field. The Scenery checks whether a mask is to be used using
    Screen::operator()(size_t i, size_t j). The mask can be loaded from a
    FITS file as a square image of doubles: The mask needs to be have the
    same size as the Screen itself, so loading a mask also sets the
    resolution, and changing the resolution after setting a mask also
    removes the mask. The content of the Mask entity is parsed by
    Factory::fullPath(), so it can be an absolute path, a path relative to
    where the XML file is stored, or relative to the current working
    directory if prefixed with "`pwd`/".

    C++ includes: GyotoScreen.h 
    """

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

    def getProperties(self):
        """
        getProperties(Screen self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Screen_getProperties(self)


    def __init__(self, *args):
        """
        __init__(Gyoto::Screen self) -> Screen
        __init__(Gyoto::Screen self, Screen arg2) -> Screen



        Copy constructor. 
        """
        this = _gyoto.new_Screen(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def clone(self):
        """
        clone(Screen self) -> Screen



        Cloner. 
        """
        return _gyoto.Screen_clone(self)

    __swig_destroy__ = _gyoto.delete_Screen
    __del__ = lambda self: None

    def setProjection(self, *args):
        """
        setProjection(Screen self, double const paln, double const inclination, double const argument)
        setProjection(Screen self, double const distance, double const paln, double const inclination, double const argument)



        Set distance, inclination etc. 
        """
        return _gyoto.Screen_setProjection(self, *args)


    def spectrometer(self, *args):
        """
        spectrometer(Screen self, Gyoto::SmartPointer< Gyoto::Spectrometer::Generic > spectro)
        spectrometer(Screen self) -> Gyoto::SmartPointer< Gyoto::Spectrometer::Generic >



        Get Screen::spectro_. 
        """
        return _gyoto.Screen_spectrometer(self, *args)


    def freqObs(self, *args):
        """
        freqObs(Screen self, double fo)
        freqObs(Screen self, double fo, std::string const & unit)
        freqObs(Screen self) -> double
        freqObs(Screen self, std::string const & unit) -> double



        Get freq_obs_.

        Parameters:
        -----------

        unit:  string: unit in which freq_obs_ should be returned is
        expressed, convertable to Herz or meters or energy. 
        """
        return _gyoto.Screen_freqObs(self, *args)


    def setObserverPos(self, pos):
        """
        setObserverPos(Screen self, double const [4] pos)



        Alternative way to set projection.

        Beware : paln can not be set this way, setting later other parameters
        change the observer's coordinates. For observationnal ray-tracing
        purposes, prefer setProjection().

        Parameters:
        -----------

        pos:  position of observer in Screen's coordinate system. Content is
        copied. 
        """
        return _gyoto.Screen_setObserverPos(self, pos)


    def observerKind(self, *args):
        """
        observerKind(Screen self, std::string const & kind)
        observerKind(Screen self) -> std::string
        """
        return _gyoto.Screen_observerKind(self, *args)


    def setFourVel(self, coord):
        """
        setFourVel(Screen self, double const [4] coord)



        Sets the observer's 4-velocity. 
        """
        return _gyoto.Screen_setFourVel(self, coord)


    def setScreen1(self, coord):
        """
        setScreen1(Screen self, double const [4] coord)



        Sets the screen vector e1. 
        """
        return _gyoto.Screen_setScreen1(self, coord)


    def setScreen2(self, coord):
        """
        setScreen2(Screen self, double const [4] coord)



        Sets the screen vector e2. 
        """
        return _gyoto.Screen_setScreen2(self, coord)


    def setScreen3(self, coord):
        """
        setScreen3(Screen self, double const [4] coord)



        Sets the screen vector e3 (normal) 
        """
        return _gyoto.Screen_setScreen3(self, coord)


    def coordKind(self):
        """
        coordKind(Screen self) -> int



        Get coordinate kind.

        From Screen::gg_. 
        """
        return _gyoto.Screen_coordKind(self)


    def distance(self, *args):
        """
        distance(Screen self, double dist)
        distance(Screen self, double dist, std::string const & unit)
        distance(Screen self) -> double
        distance(Screen self, std::string const & arg2) -> double



        Get distance from observer.

        In specified unit.Get distance from observer 
        """
        return _gyoto.Screen_distance(self, *args)


    def dMax(self, *args):
        """
        dMax(Screen self, double dist)
        dMax(Screen self) -> double



        Get maximum ray-tracing distance.

        In geometrical units. 
        """
        return _gyoto.Screen_dMax(self, *args)


    def inclination(self, *args):
        """
        inclination(Screen self, double arg2)
        inclination(Screen self, double arg2, std::string const & unit)
        inclination(Screen self) -> double
        inclination(Screen self, std::string const & arg2) -> double



        Get inclination relative to line-of-sight.

        Inclination of z-axis relative to line-of-sight, or inclination of
        equatorial plane relative to plane of the sky, in specified unit. 
        """
        return _gyoto.Screen_inclination(self, *args)


    def PALN(self, *args):
        """
        PALN(Screen self, double arg2)
        PALN(Screen self, double arg2, std::string const & unit)
        PALN(Screen self) -> double
        PALN(Screen self, std::string const & arg2) -> double



        Get position angle of the line of nodes. 
        """
        return _gyoto.Screen_PALN(self, *args)


    def argument(self, *args):
        """
        argument(Screen self, double arg2)
        argument(Screen self, double arg2, std::string const & unit)
        argument(Screen self) -> double
        argument(Screen self, std::string const & arg2) -> double



        Get angle between line of nodes and X axis of object. 
        """
        return _gyoto.Screen_argument(self, *args)


    def metric(self, *args):
        """
        metric(Screen self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(Screen self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg)



        Set Screen::gg_. 
        """
        return _gyoto.Screen_metric(self, *args)


    def time(self, *args):
        """
        time(Screen self) -> double
        time(Screen self, std::string const & arg2) -> double
        time(Screen self, double arg2, std::string const & arg3)
        time(Screen self, double arg2)



        Set observing date in seconds. 
        """
        return _gyoto.Screen_time(self, *args)


    def fieldOfView(self, *args):
        """
        fieldOfView(Screen self) -> double
        fieldOfView(Screen self, std::string const & unit) -> double
        fieldOfView(Screen self, double arg2)
        fieldOfView(Screen self, double arg2, std::string const & unit)



        Set Screen::fov_ in specified unit. 
        """
        return _gyoto.Screen_fieldOfView(self, *args)


    def alpha0(self, *args):
        """
        alpha0(Screen self, double arg2)
        alpha0(Screen self, double arg2, std::string const & unit)
        alpha0(Screen self) -> double
        alpha0(Screen self, std::string const & unit) -> double



        Get direction of the center of the field in specified unit. 
        """
        return _gyoto.Screen_alpha0(self, *args)


    def delta0(self, *args):
        """
        delta0(Screen self, double arg2)
        delta0(Screen self, double arg2, std::string const & unit)
        delta0(Screen self) -> double
        delta0(Screen self, std::string const & unit) -> double



        Get direction of the center of the field in specified unit. 
        """
        return _gyoto.Screen_delta0(self, *args)


    def anglekind(self, *args):
        """
        anglekind(Screen self, int arg2)
        anglekind(Screen self, std::string const & arg2)
        anglekind(Screen self) -> std::string
        """
        return _gyoto.Screen_anglekind(self, *args)


    def resolution(self, *args):
        """
        resolution(Screen self) -> size_t
        resolution(Screen self, size_t arg2)



        Set Screen::npix_. 
        """
        return _gyoto.Screen_resolution(self, *args)


    def mask(self, *args):
        """
        mask(Screen self, double const *const mm, size_t resolution=0)
        mask(Screen self, double const *const mm)
        mask(Screen self) -> double const *



        Retrieve const pointer to mask_. 
        """
        return _gyoto.Screen_mask(self, *args)


    def maskFile(self, *args):
        """
        maskFile(Screen self, std::string const & fname)
        maskFile(Screen self) -> std::string
        """
        return _gyoto.Screen_maskFile(self, *args)


    def fitsReadMask(self, fname):
        """
        fitsReadMask(Screen self, std::string const & fname)



        Read mask_ from FITS file. 
        """
        return _gyoto.Screen_fitsReadMask(self, fname)


    def fitsWriteMask(self, fname):
        """
        fitsWriteMask(Screen self, std::string const & fname)



        Save mask_ from FITS file. 
        """
        return _gyoto.Screen_fitsWriteMask(self, fname)


    def __call__(self, arg2, arg3):
        """__call__(Screen self, size_t arg2, size_t arg3) -> bool"""
        return _gyoto.Screen___call__(self, arg2, arg3)


    def getObserverPos(self, coord):
        """
        getObserverPos(Screen self, double [] coord)



        4-Position of the observer relative to the metric

        A Screen is positioned relative to the observer with four elements:
        Screen::distance, Screen::inclination, Screen::paln and
        Screen::argument.

        This function returns the position of the observer relative to the
        metric system in Screen::gg_, using these parameters. The output
        parameter is coord.

        Parameters:
        -----------

        coord:  position of the observer. Must be preallocated. 
        """
        return _gyoto.Screen_getObserverPos(self, coord)


    def getFourVel(self, fourvel):
        """
        getFourVel(Screen self, double [] fourvel)



        Get copy of Screen::fourvel_.

        Parameters:
        -----------

        fourvel:  preallocated 4-element array 
        """
        return _gyoto.Screen_getFourVel(self, fourvel)


    def fourVel(self, *args):
        """
        fourVel(Screen self, vector_double arg2)
        fourVel(Screen self) -> vector_double
        """
        return _gyoto.Screen_fourVel(self, *args)


    def screenVector1(self, *args):
        """
        screenVector1(Screen self, vector_double arg2)
        screenVector1(Screen self) -> vector_double
        """
        return _gyoto.Screen_screenVector1(self, *args)


    def screenVector2(self, *args):
        """
        screenVector2(Screen self, vector_double arg2)
        screenVector2(Screen self) -> vector_double
        """
        return _gyoto.Screen_screenVector2(self, *args)


    def screenVector3(self, *args):
        """
        screenVector3(Screen self, vector_double arg2)
        screenVector3(Screen self) -> vector_double
        """
        return _gyoto.Screen_screenVector3(self, *args)


    def getScreen1(self, output):
        """
        getScreen1(Screen self, double [] output)



        Get copy of Screen::screen1_.

        Parameters:
        -----------

        output:  preallocated 4-element array 
        """
        return _gyoto.Screen_getScreen1(self, output)


    def getScreen2(self, output):
        """
        getScreen2(Screen self, double [] output)



        Get copy of Screen::screen2_.

        Parameters:
        -----------

        output:  preallocated 4-element array 
        """
        return _gyoto.Screen_getScreen2(self, output)


    def getScreen3(self, output):
        """
        getScreen3(Screen self, double [] output)



        Get copy of Screen::screen3_.

        Parameters:
        -----------

        output:  preallocated 4-element array 
        """
        return _gyoto.Screen_getScreen3(self, output)


    def getRayCoord(self, *args):
        """
        getRayCoord(Screen self, double x, double y, double [] coord)
        getRayCoord(Screen self, size_t const i, size_t const j, double [] coord)



        Get 8-coordinate of Photon hitting screen pixel.

        Similar to Screen::getObserverPos() but will return in addition the
        4-velocity of a photon corresponding to the sky direction given by x
        and y.

        Parameters:
        -----------

        i:  j:  pixel coordinates

        coord:  position-velocity of the Photon. Preallocated. 
        """
        return _gyoto.Screen_getRayCoord(self, *args)


    def coordToSky(self, pos, skypos):
        """
        coordToSky(Screen self, double const [4] pos, double [3] skypos)



        Convert 4-position to 3-sky position. 
        """
        return _gyoto.Screen_coordToSky(self, pos, skypos)


    def coordToXYZ(self, pos, xyz):
        """
        coordToXYZ(Screen self, double const [4] pos, double [3] xyz)



        Convert 4-position to 3-cartesian coordinates. 
        """
        return _gyoto.Screen_coordToXYZ(self, pos, xyz)


    def computeBaseVectors(self):
        """
        computeBaseVectors(Screen self)



        Compute base vectors according to projection parameters. 
        """
        return _gyoto.Screen_computeBaseVectors(self)


    def _print(self, arg2):
        """
        _print(Screen self, std::ostream & arg2) -> std::ostream &



        Display.

        Debug helper 
        """
        return _gyoto.Screen__print(self, arg2)


    def printBaseVectors(self, arg2):
        """
        printBaseVectors(Screen self, std::ostream & arg2) -> std::ostream &



        Debug helper. 
        """
        return _gyoto.Screen_printBaseVectors(self, arg2)


    def mapPixUnit(self):
        """
        mapPixUnit(Screen self)



        Map "pix" and "pixel" to angular pixel width in unit system.

        "pix" or "pixel" can then be used in units.

        There is only one unit system in Gyoto: "pix" can therefore be
        registered only for one Screen at a time. See Gyoto::Units.

        The unit must later be unmapped with unmapPixUnit(). 
        """
        return _gyoto.Screen_mapPixUnit(self)


    def unmapPixUnit(self):
        """
        unmapPixUnit(Screen self)



        Unmap "pix" and "pixel" from unit system.

        See also mapPixUnit(). 
        """
        return _gyoto.Screen_unmapPixUnit(self)


    def fillProperty(self, fmp, p):
        """
        fillProperty(Screen self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto.Screen_fillProperty(self, fmp, p)


    def Subcontractor(fmp):
        """Subcontractor(FactoryMessenger fmp) -> Gyoto::SmartPointer< Gyoto::Screen >"""
        return _gyoto.Screen_Subcontractor(fmp)

    if _newclass:
        Subcontractor = staticmethod(Subcontractor)
    __swig_getmethods__["Subcontractor"] = lambda x: Subcontractor
    angle = _gyoto.Screen_angle
    pixel = _gyoto.Screen_pixel
Screen_swigregister = _gyoto.Screen_swigregister
Screen_swigregister(Screen)
Screen.properties = _gyoto.cvar.Screen_properties

def Screen_Subcontractor(fmp):
    """Screen_Subcontractor(FactoryMessenger fmp) -> Gyoto::SmartPointer< Gyoto::Screen >"""
    return _gyoto.Screen_Subcontractor(fmp)

class Scenery(SmartPointee, Object):
    """


    Ray-tracing scene.

    An Scenery contains: a Metric: used in Astrobj, Screen and Photon;

    a Screen: sets the field-of-view, the position of the camera, the
    observation time, and the Spectrometer;

    an Astrobj: light emitter.

    In addition, Quantities may be specified (or the default Quantity will
    be produced: generally Intensity). Not all Astrobj implement all
    Quantities. The order in which Quantities are listed is not relevant
    (it is not stored). Possible Quantities:

    Intensity: the intensity that reaches the object, integrated over the
    line-of-sight;

    EmissionTime: date of emission;

    MinDistance: minimum distance between the Photon reaching each pixel
    and the Astrobj;

    FirstDistMin: last closest approach between Photon and Astrobj;

    Redshift;

    ImpactCoords: 8-coordinates of the object and photon at impact;

    Spectrum: I computed at various values frequencies, corresponding to
    the Screen's Spectrometer.

    BinSpectrum:12Id computed between various (1,2 pairs corresponding to
    the Screen's Spectrometer. This is what a physical spectrometer
    measures.

    In addition, it is possible to ray-trace an image using several cores
    on a single machine (if Gyoto has been compiled with POSIX threads
    support). The number of threads can be specified using NThreads
    entity. Setting NThreads to 0 is equivalent to setting it to 1. Beware
    that setting NThreads to a number higher than the actual number of
    cores available on the machine usually leads to a decrease in
    performance.

    Finally, Scenery accepts a number of numerical tuning parameters that
    are passed directly to the underlying photons (actually, the Scenery
    object holds a Photon instance which stores many parameters, including
    the Metric and Astrobj): Adaptive/NonAdaptive, Delta, MinimumTime,
    MaxIter, PrimaryOnly.

    Thus a fully populated Scenery XML looks like that (the values are
    examples, they are not necessary the default nor the best or even good
    values):

    C++ includes: GyotoScenery.h 
    """

    __swig_setmethods__ = {}
    for _s in [SmartPointee, Object]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scenery, name, value)
    __swig_getmethods__ = {}
    for _s in [SmartPointee, Object]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Scenery, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mpi_team_"] = _gyoto.Scenery_mpi_team__set
    __swig_getmethods__["mpi_team_"] = _gyoto.Scenery_mpi_team__get
    if _newclass:
        mpi_team_ = _swig_property(_gyoto.Scenery_mpi_team__get, _gyoto.Scenery_mpi_team__set)
    __swig_setmethods__["am_worker"] = _gyoto.Scenery_am_worker_set
    __swig_getmethods__["am_worker"] = _gyoto.Scenery_am_worker_get
    if _newclass:
        am_worker = _swig_property(_gyoto.Scenery_am_worker_get, _gyoto.Scenery_am_worker_set)

    def mpiSpawn(self, nbchildren):
        """
        mpiSpawn(Scenery self, int nbchildren)



        Spawn gyoto-mpi-worker processes.

        Also sets nprocesses_. If the right number of workers is already
        running, does nothing. Also does nothing if MPI_Init() has not been
        called yet. 
        """
        return _gyoto.Scenery_mpiSpawn(self, nbchildren)


    def mpiTerminate(self):
        """
        mpiTerminate(Scenery self)



        Terminate gyoto-mpi-worker-processes. 
        """
        return _gyoto.Scenery_mpiTerminate(self)


    def mpiClone(self):
        """
        mpiClone(Scenery self)



        Send a copy of self to the mpi workers.

        Always call mpiClone() before ray-tracing if workers are running. 
        """
        return _gyoto.Scenery_mpiClone(self)

    give_task = _gyoto.Scenery_give_task
    read_scenery = _gyoto.Scenery_read_scenery
    terminate = _gyoto.Scenery_terminate
    raytrace = _gyoto.Scenery_raytrace
    raytrace_done = _gyoto.Scenery_raytrace_done
    ready = _gyoto.Scenery_ready
    impactcoords = _gyoto.Scenery_impactcoords
    noimpactcoords = _gyoto.Scenery_noimpactcoords

    def mpiTask(self, tag):
        """
        mpiTask(Scenery self, Gyoto::Scenery::mpi_tag & tag)



        Send a tag to workers. 
        """
        return _gyoto.Scenery_mpiTask(self, tag)


    def getProperties(self):
        """
        getProperties(Scenery self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Scenery_getProperties(self)


    def _delta(self, *args):
        """
        _delta(Scenery self, double const delta)
        _delta(Scenery self, double arg2, std::string const & unit)
        _delta(Scenery self) -> double
        _delta(Scenery self, std::string const & unit) -> double
        """
        return _gyoto.Scenery__delta(self, *args)


    def _tMin(self, *args):
        """
        _tMin(Scenery self, double const tmin)
        _tMin(Scenery self, double arg2, std::string const & unit)
        _tMin(Scenery self) -> double
        _tMin(Scenery self, std::string const & unit) -> double
        """
        return _gyoto.Scenery__tMin(self, *args)


    def _adaptive(self, *args):
        """
        _adaptive(Scenery self, bool mode)
        _adaptive(Scenery self) -> bool
        """
        return _gyoto.Scenery__adaptive(self, *args)


    def _secondary(self, *args):
        """
        _secondary(Scenery self, bool sec)
        _secondary(Scenery self) -> bool
        """
        return _gyoto.Scenery__secondary(self, *args)


    def _maxiter(self, *args):
        """
        _maxiter(Scenery self, size_t miter)
        _maxiter(Scenery self) -> size_t
        """
        return _gyoto.Scenery__maxiter(self, *args)


    def _integrator(self, *args):
        """
        _integrator(Scenery self, std::string const & type)
        _integrator(Scenery self) -> std::string
        """
        return _gyoto.Scenery__integrator(self, *args)


    def _deltaMin(self, *args):
        """
        _deltaMin(Scenery self) -> double
        _deltaMin(Scenery self, double h1)
        """
        return _gyoto.Scenery__deltaMin(self, *args)


    def _absTol(self, *args):
        """
        _absTol(Scenery self, double arg2)
        _absTol(Scenery self) -> double
        """
        return _gyoto.Scenery__absTol(self, *args)


    def _relTol(self, *args):
        """
        _relTol(Scenery self, double arg2)
        _relTol(Scenery self) -> double
        """
        return _gyoto.Scenery__relTol(self, *args)


    def _deltaMax(self, *args):
        """
        _deltaMax(Scenery self, double h1)
        _deltaMax(Scenery self) -> double
        """
        return _gyoto.Scenery__deltaMax(self, *args)


    def _deltaMaxOverR(self, *args):
        """
        _deltaMaxOverR(Scenery self) -> double
        _deltaMaxOverR(Scenery self, double t)
        """
        return _gyoto.Scenery__deltaMaxOverR(self, *args)


    def _initCoord(self, *args):
        """
        _initCoord(Scenery self) -> vector_double
        _initCoord(Scenery self, vector_double f)
        """
        return _gyoto.Scenery__initCoord(self, *args)


    def _metric(self, *args):
        """
        _metric(Scenery self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        _metric(Scenery self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        """
        return _gyoto.Scenery__metric(self, *args)


    def clone(self):
        """
        clone(Scenery self) -> Scenery



        Cloner. 
        """
        return _gyoto.Scenery_clone(self)


    def __init__(self, *args):
        """
        __init__(Gyoto::Scenery self) -> Scenery
        __init__(Gyoto::Scenery self, Scenery o) -> Scenery
        __init__(Gyoto::Scenery self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2, Gyoto::SmartPointer< Gyoto::Screen > arg3, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > arg4) -> Scenery



        Constructor setting Scenery::gg_, Scenery::screen_, and Scenery::obj_.

        To ensure consistency, the Metric will be forcibly attached to the
        Screen and to the Astrobj (if they are not NULL). 
        """
        this = _gyoto.new_Scenery(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Scenery
    __del__ = lambda self: None

    def metric(self, *args):
        """
        metric(Scenery self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(Scenery self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)



        Set Scenery::gg_.

        The provided Metric will also be atached to the Screen and the
        Astrobj. 
        """
        return _gyoto.Scenery_metric(self, *args)


    def screen(self, *args):
        """
        screen(Scenery self) -> Gyoto::SmartPointer< Gyoto::Screen >
        screen(Scenery self, Gyoto::SmartPointer< Gyoto::Screen > arg2)



        Set Scenery::screen_.

        The Metric attached to the Scenery will be attached to the Screen 
        """
        return _gyoto.Scenery_screen(self, *args)


    def astrobj(self, *args):
        """
        astrobj(Scenery self) -> Gyoto::SmartPointer< Gyoto::Astrobj::Generic >
        astrobj(Scenery self, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > arg2)



        Set ph_.obj_.

        The Metric attached to the Scenery will be attached to the Astrobj 
        """
        return _gyoto.Scenery_astrobj(self, *args)


    def clonePhoton(self, *args):
        """
        clonePhoton(Scenery self) -> Gyoto::SmartPointer< Photon >
        clonePhoton(Scenery self, size_t i, size_t j) -> Gyoto::SmartPointer< Photon >
        clonePhoton(Scenery self, double a, double d) -> Gyoto::SmartPointer< Photon >



        Clone the internal Photon. 
        """
        return _gyoto.Scenery_clonePhoton(self, *args)


    def updatePhoton(self):
        """
        updatePhoton(Scenery self)



        Update values in cached Photon. 
        """
        return _gyoto.Scenery_updatePhoton(self)


    def delta(self, *args):
        """
        delta(Scenery self) -> double
        delta(Scenery self, std::string const & unit) -> double
        delta(Scenery self, double arg2)
        delta(Scenery self, double arg2, std::string const & unit)



        set default step in specified units 
        """
        return _gyoto.Scenery_delta(self, *args)


    def initCoord(self, *args):
        """
        initCoord(Scenery self, vector_double c)
        initCoord(Scenery self) -> vector_double
        """
        return _gyoto.Scenery_initCoord(self, *args)


    def setRequestedQuantities(self, quant):
        """
        setRequestedQuantities(Scenery self, Gyoto::Quantity_t quant)



        Set Scenery::quantities_.

        Parameters:
        -----------

        quant:  Bitwise OR of desired quantities, e.g. 
        """
        return _gyoto.Scenery_setRequestedQuantities(self, quant)


    def getRequestedQuantities(self):
        """
        getRequestedQuantities(Scenery self) -> Gyoto::Quantity_t



        Get Scenery::quantities_. 
        """
        return _gyoto.Scenery_getRequestedQuantities(self)


    def requestedQuantitiesString(self, *args):
        """
        requestedQuantitiesString(Scenery self, std::string const & squant)
        requestedQuantitiesString(Scenery self) -> std::string



        Get a string representation of Scenery::quantities_. 
        """
        return _gyoto.Scenery_requestedQuantitiesString(self, *args)


    def getScalarQuantitiesCount(self, q=None):
        """
        getScalarQuantitiesCount(Scenery self, Gyoto::Quantity_t * q=None) -> size_t
        getScalarQuantitiesCount(Scenery self) -> size_t



        Get number of requested quantities of scalar nature.

        This is all quantities except Spectrum, BinSpectrum and ImpactCoords.

        """
        return _gyoto.Scenery_getScalarQuantitiesCount(self, q)


    def tMin(self, *args):
        """
        tMin(Scenery self) -> double
        tMin(Scenery self, std::string const & unit) -> double
        tMin(Scenery self, double arg2)
        tMin(Scenery self, double arg2, std::string const & unit)



        Set ph_.tmin_ in specified unit. 
        """
        return _gyoto.Scenery_tMin(self, *args)


    def adaptive(self, *args):
        """
        adaptive(Scenery self, bool mode)
        adaptive(Scenery self) -> bool



        Get ph_.adaptive_. 
        """
        return _gyoto.Scenery_adaptive(self, *args)


    def integrator(self, *args):
        """
        integrator(Scenery self, std::string type)
        integrator(Scenery self) -> std::string



        Passed to ph_. 
        """
        return _gyoto.Scenery_integrator(self, *args)


    def deltaMin(self, *args):
        """
        deltaMin(Scenery self) -> double
        deltaMin(Scenery self, double h1)



        Passed to ph_. 
        """
        return _gyoto.Scenery_deltaMin(self, *args)


    def deltaMax(self, *args):
        """
        deltaMax(Scenery self) -> double
        deltaMax(Scenery self, double h1)



        Passed to ph_. 
        """
        return _gyoto.Scenery_deltaMax(self, *args)


    def deltaMaxOverR(self, *args):
        """
        deltaMaxOverR(Scenery self) -> double
        deltaMaxOverR(Scenery self, double t)



        Passed to ph_. 
        """
        return _gyoto.Scenery_deltaMaxOverR(self, *args)


    def absTol(self, *args):
        """
        absTol(Scenery self, double arg2)
        absTol(Scenery self) -> double



        Passed to ph_. 
        """
        return _gyoto.Scenery_absTol(self, *args)


    def relTol(self, *args):
        """
        relTol(Scenery self, double arg2)
        relTol(Scenery self) -> double



        Passed to ph_. 
        """
        return _gyoto.Scenery_relTol(self, *args)


    def secondary(self, *args):
        """
        secondary(Scenery self, bool sec)
        secondary(Scenery self) -> bool



        Get ph_.secondary_. 
        """
        return _gyoto.Scenery_secondary(self, *args)


    def maxiter(self, *args):
        """
        maxiter(Scenery self, size_t miter)
        maxiter(Scenery self) -> size_t



        Get ph_.maxiter_. 
        """
        return _gyoto.Scenery_maxiter(self, *args)


    def nThreads(self, *args):
        """
        nThreads(Scenery self, size_t arg2)
        nThreads(Scenery self) -> size_t



        Get nthreads_;. 
        """
        return _gyoto.Scenery_nThreads(self, *args)


    def nProcesses(self, *args):
        """
        nProcesses(Scenery self, size_t arg2)
        nProcesses(Scenery self) -> size_t



        Get nprocesses_;. 
        """
        return _gyoto.Scenery_nProcesses(self, *args)


    def intensityConverter(self, unit):
        """
        intensityConverter(Scenery self, std::string unit)



        Set Scenery::intensity_converter_. 
        """
        return _gyoto.Scenery_intensityConverter(self, unit)


    def spectrumConverter(self, unit):
        """
        spectrumConverter(Scenery self, std::string unit)



        Set Scenery::spectrum_converter_. 
        """
        return _gyoto.Scenery_spectrumConverter(self, unit)


    def binSpectrumConverter(self, unit):
        """
        binSpectrumConverter(Scenery self, std::string unit)



        Set Scenery::binspectrum_converter_. 
        """
        return _gyoto.Scenery_binSpectrumConverter(self, unit)


    def setPropertyConverters(self, prop):
        """
        setPropertyConverters(Scenery self, AstrobjProperties prop)



        Copy converters to Astrobj::Properties instance.

        Copy Scenery::intensity_converter_, Scenery::spectrum_converter_ and
        Scenery::binspectrum_converter_ to there alter ego in *prop. 
        """
        return _gyoto.Scenery_setPropertyConverters(self, prop)


    def rayTrace(self, ij, data, impactcoords=None):
        """
        rayTrace(Scenery self, Coord2dSet ij, AstrobjProperties data, double * impactcoords=None)
        rayTrace(Scenery self, Coord2dSet ij, AstrobjProperties data)



        Perform ray-tracing.

        For each directions specified, launch a Photon back in time to compute
        the various quantities.

        At this time, the computed quantities depend on on the pointers in
        *data which are not NULL.

        rayTrace() uses  setPropertyConverters() to set the converters in
        *data;

        Astrobj::Properties::init() to initialize each cell in *data;

        Astrobj::Properties::operator++() to step through the arrays in *data.

        data must have been instanciated prior to calling rayTrace and the
        various pointers in *data must be NULL or point to the first cell in
        an array of size at least Screen::npix_ squared.

        If MPI support is built-in, MPI_Init() has been called, and
        nprocesses_ is1, then rayTrace() will use several processes, launching
        them using mpiSpawn() if necessary.

        Else, if Scenery::nthreads_ is2 and Gyoto has been compiled with
        pthreads support, rayTrace() will use Scenery::nthreads_ threads and
        launch photons in parallel. This works only if the
        Astrobj::Generic::clone() and Metric::Generic::clone() methods have
        been properly implemented for the specific astrobj and metric kind,
        and if they are both thread-safe. At the moment, unfortunately, Lorene
        metrics are known to not be thread-safe.

        Parameters:
        -----------

        ij:   Screen::Coord2dSet specification of rays to trace. e.g.:

        Parameters:
        -----------

        data:  Pointer to a preallocated Astrobj::Properties instance which
        sets which quantities must be computed and where to store the output.

        impactcoords:  Optional pointer to an array of pre-computed impact
        coordinates. If impactcoords is provided, rayTracing is skipped and
        the quantities in *data are fill assuming that the impact coordinates
        are correct. This only makes sense in optically thick mode, when ray-
        tracing several sceneries for which the shape of the object is
        identical but their emission distributions are not. impactcoords can
        be computed using the ImpactCoords quantity. 
        """
        return _gyoto.Scenery_rayTrace(self, ij, data, impactcoords)


    def __call__(self, *args):
        """
        __call__(Scenery self, size_t i, size_t j, AstrobjProperties data, double * impactcoords=None, Photon * ph=None)
        __call__(Scenery self, size_t i, size_t j, AstrobjProperties data, double * impactcoords=None)
        __call__(Scenery self, size_t i, size_t j, AstrobjProperties data)
        __call__(Scenery self, double alpha, double delta, AstrobjProperties data, Photon * ph=None)
        __call__(Scenery self, double alpha, double delta, AstrobjProperties data)
        """
        return _gyoto.Scenery___call__(self, *args)


    def fillProperty(self, fmp, p):
        """
        fillProperty(Scenery self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto.Scenery_fillProperty(self, fmp, p)


    def fillElement(self, fmp):
        """
        fillElement(Scenery self, FactoryMessenger fmp)



        Fill the XML element for this Object.

        The base implementation simply calls fillProperty() for each Property
        defined for the Object.

        Derived classes should avoid overriding fillElement(). It may make
        sense occasionally, e.g. to make sure that the metric is output first.

        To customize how a given Property is rendered, it is better to
        override fillProperty().

        If this method is overridden, the implementation should in general
        call fillElement() on the direct base. 
        """
        return _gyoto.Scenery_fillElement(self, fmp)


    def Subcontractor(arg1):
        """Subcontractor(FactoryMessenger arg1) -> Gyoto::SmartPointer< Gyoto::Scenery >"""
        return _gyoto.Scenery_Subcontractor(arg1)

    if _newclass:
        Subcontractor = staticmethod(Subcontractor)
    __swig_getmethods__["Subcontractor"] = lambda x: Subcontractor
Scenery_swigregister = _gyoto.Scenery_swigregister
Scenery_swigregister(Scenery)
Scenery.properties = _gyoto.cvar.Scenery_properties

def Scenery_Subcontractor(arg2):
    """Scenery_Subcontractor(FactoryMessenger arg2) -> Gyoto::SmartPointer< Gyoto::Scenery >"""
    return _gyoto.Scenery_Subcontractor(arg2)

class Photon(Worldline, SmartPointee, Object):
    """


    A null geodesic transporting light.

    This is the central object for ray-tracing.

    C++ includes: GyotoPhoton.h 
    """

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

    def getProperties(self):
        """
        getProperties(Photon self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Photon_getProperties(self)


    def _delta(self, *args):
        """
        _delta(Photon self, double const delta)
        _delta(Photon self, double arg2, std::string const & unit)
        _delta(Photon self) -> double
        _delta(Photon self, std::string const & unit) -> double
        """
        return _gyoto.Photon__delta(self, *args)


    def _tMin(self, *args):
        """
        _tMin(Photon self, double const tmin)
        _tMin(Photon self, double arg2, std::string const & unit)
        _tMin(Photon self) -> double
        _tMin(Photon self, std::string const & unit) -> double
        """
        return _gyoto.Photon__tMin(self, *args)


    def _adaptive(self, *args):
        """
        _adaptive(Photon self, bool mode)
        _adaptive(Photon self) -> bool
        """
        return _gyoto.Photon__adaptive(self, *args)


    def _secondary(self, *args):
        """
        _secondary(Photon self, bool sec)
        _secondary(Photon self) -> bool
        """
        return _gyoto.Photon__secondary(self, *args)


    def _maxiter(self, *args):
        """
        _maxiter(Photon self, size_t miter)
        _maxiter(Photon self) -> size_t
        """
        return _gyoto.Photon__maxiter(self, *args)


    def _integrator(self, *args):
        """
        _integrator(Photon self, std::string const & type)
        _integrator(Photon self) -> std::string
        """
        return _gyoto.Photon__integrator(self, *args)


    def _deltaMin(self, *args):
        """
        _deltaMin(Photon self) -> double
        _deltaMin(Photon self, double h1)
        """
        return _gyoto.Photon__deltaMin(self, *args)


    def _absTol(self, *args):
        """
        _absTol(Photon self, double arg2)
        _absTol(Photon self) -> double
        """
        return _gyoto.Photon__absTol(self, *args)


    def _relTol(self, *args):
        """
        _relTol(Photon self, double arg2)
        _relTol(Photon self) -> double
        """
        return _gyoto.Photon__relTol(self, *args)


    def _deltaMax(self, *args):
        """
        _deltaMax(Photon self, double h1)
        _deltaMax(Photon self) -> double
        """
        return _gyoto.Photon__deltaMax(self, *args)


    def _deltaMaxOverR(self, *args):
        """
        _deltaMaxOverR(Photon self) -> double
        _deltaMaxOverR(Photon self, double t)
        """
        return _gyoto.Photon__deltaMaxOverR(self, *args)


    def _initCoord(self, *args):
        """
        _initCoord(Photon self) -> vector_double
        _initCoord(Photon self, vector_double f)
        """
        return _gyoto.Photon__initCoord(self, *args)


    def _metric(self, *args):
        """
        _metric(Photon self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        _metric(Photon self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        """
        return _gyoto.Photon__metric(self, *args)


    def className(self):
        """
        className(Photon self) -> std::string



        "Photon" 
        """
        return _gyoto.Photon_className(self)


    def className_l(self):
        """
        className_l(Photon self) -> std::string



        "photon" 
        """
        return _gyoto.Photon_className_l(self)


    def clone(self):
        """
        clone(Photon self) -> Photon



        Cloner. 
        """
        return _gyoto.Photon_clone(self)


    def __init__(self, *args):
        """
        __init__(Gyoto::Photon self) -> Photon
        __init__(Gyoto::Photon self, Photon arg2) -> Photon
        __init__(Gyoto::Photon self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > obj, double * coord) -> Photon
        __init__(Gyoto::Photon self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > obj, Gyoto::SmartPointer< Gyoto::Screen > screen, double d_alpha, double d_delta) -> Photon



        Same as Photon() followed by
        setInitialCondition(SmartPointer<Metric::Generic> gg,
        SmartPointer<Astrobj::Generic> obj, SmartPointer<Screen> screen,
        double d_alpha, double d_delta) 
        """
        this = _gyoto.new_Photon(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Photon
    __del__ = lambda self: None

    def getMass(self):
        """
        getMass(Photon self) -> double



        Return 0. 
        """
        return _gyoto.Photon_getMass(self)


    def astrobj(self, *args):
        """
        astrobj(Photon self, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > arg2)
        astrobj(Photon self) -> Gyoto::SmartPointer< Gyoto::Astrobj::Generic >



        Get Photon::object_. 
        """
        return _gyoto.Photon_astrobj(self, *args)


    def metric(self, *args):
        """
        metric(Photon self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        metric(Photon self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(Photon self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)



        Get metric. 
        """
        return _gyoto.Photon_metric(self, *args)


    def spectrometer(self, *args):
        """
        spectrometer(Photon self, Gyoto::SmartPointer< Gyoto::Spectrometer::Generic > spr)
        spectrometer(Photon self) -> Gyoto::SmartPointer< Gyoto::Spectrometer::Generic >



        Get Photon::spectro_. 
        """
        return _gyoto.Photon_spectrometer(self, *args)


    def freqObs(self, *args):
        """
        freqObs(Photon self, double arg2)
        freqObs(Photon self) -> double



        Get Photon::freq_obs__. 
        """
        return _gyoto.Photon_freqObs(self, *args)


    def setInitialCondition(self, *args):
        """
        setInitialCondition(Photon self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > obj, double const [8] coord)
        setInitialCondition(Photon self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > obj, Gyoto::SmartPointer< Gyoto::Screen > screen, double d_alpha, double d_delta)



        Set or re-set the initial condition prior to integration.

        Parameters:
        -----------

        gg:   Gyoto::SmartPointer to the Gyoto::Metric in this universe;

        coord:  8 element array containing the initial condition, i.e. the
        4-position and the 4-velocity of the Photon at the receiving end;

        dir:  direction: 1 for future, -1 for past. 
        """
        return _gyoto.Photon_setInitialCondition(self, *args)


    def hit(self, data=None):
        """
        hit(Photon self, AstrobjProperties data=None) -> int
        hit(Photon self) -> int



        Integrate the geodesic.

        Parameters:
        -----------

        data:  Optional Astrobj::Properties to fill with observational
        quantities.

        1 if object was hit, else 0. 
        """
        return _gyoto.Photon_hit(self, data)


    def findMin(self, *args):
        """
        findMin(Photon self, Functor__Double_constDoubleArray object, double t1, double t2, double & tmin, double threshold) -> double
        findMin(Photon self, Functor__Double_constDoubleArray object, double t1, double t2, double & tmin) -> double



        Find minimum of photonobject distance.

        Return the minimum of (*object)(this-> getCoord()) between t1 and t2.
        The date of this minimum is returned in tmin.

        Parameters:
        -----------

        object:  the distance to minimize is given by object->operator()().
        This method is in particular implemented by the subclasses of
        Astrobj::Standard.

        t1:  date

        t2:  date

        tmin:  on output, date correspondig to the minimum

        threshold:  stop searching for a minimum if a value < threshold is
        found (very often, we just want to find a date below the threshold,
        not the accurate minimum). 
        """
        return _gyoto.Photon_findMin(self, *args)


    def findValue(self, object, value, tinside, toutside):
        """
        findValue(Photon self, Functor__Double_constDoubleArray object, double value, double tinside, double & toutside)



        Find date for which the photon is at a given distance from the object.

        Parameters:
        -----------

        object:   Object, must implement operator() (e.g. Astrobj::Standard,
        ThinDisk::Standard)

        value:  The value to find

        tinside:  A date for which
        object->Astrobj::operator()(Photon::getCoord()) is < value

        toutside:  On input: a date for which
        object->Astrobj::operator()(Photon::getCoord()) is > value. on output,
        (*object)(getCoord(toutside)) is < value, very close to value.
        toutside is closer to tinside on output than on input. 
        """
        return _gyoto.Photon_findValue(self, object, value, tinside, toutside)


    def setParameters(self, fmp):
        """
        setParameters(Photon self, FactoryMessenger fmp)



        Main loop for parsing Properties from XML description.

        This function queries the FactoryMessenger for elements to parse, and
        tries to matche each element to a Property to set it accordingly.

        Any class that tries to be buildable from XML must supply a
        subcontractor (for base classes such as Metric, Astrobj, Spectrum and
        Spectrometer, it is done as a template that must be specialized for
        each class).

        This subcontractor typically looks somewhat like this: Although this
        is discouraged, it is possible to override the following functions to
        customize how XML entities are parsed:    - setParameters() if low-
        level access to the      FactoryMessenger is required;    -
        setParameter(std::string name, std::string content,
        std::string unit)      to interpret an entity that does not match a
        Property      (e.g. alternative name);    -
        setParameter(Gyoto::Property const &p, std::string const &name,
        std::string const &content, std::string const &unit)      to change
        how a Property is interpreted. 
        """
        return _gyoto.Photon_setParameters(self, fmp)


    def Subcontractor(arg1):
        """Subcontractor(FactoryMessenger arg1) -> Gyoto::SmartPointer< Gyoto::Photon >"""
        return _gyoto.Photon_Subcontractor(arg1)

    if _newclass:
        Subcontractor = staticmethod(Subcontractor)
    __swig_getmethods__["Subcontractor"] = lambda x: Subcontractor

    def resetTransmission(self):
        """
        resetTransmission(Photon self)



        Set transmission to 1 for each channel as well as scalar transmission.

        """
        return _gyoto.Photon_resetTransmission(self)


    def getTransmissionMax(self):
        """
        getTransmissionMax(Photon self) -> double



        Get maximum transmission;.

        Get current maximum of all the transmissions,
        Photon::transmission_freqobs_ or one elements of the
        Photon::transmission_ array. 
        """
        return _gyoto.Photon_getTransmissionMax(self)


    def getTransmission(self, *args):
        """
        getTransmission(Photon self, size_t i) -> double
        getTransmission(Photon self) -> double const *



        Get Photon::transmission_.

        getTansmission()[i] == getTransmission(size_t i) 
        """
        return _gyoto.Photon_getTransmission(self, *args)


    def transmit(self, i, t):
        """
        transmit(Photon self, size_t i, double t)



        Update transmission in a given channel.

        getTransmission(size_t i) *= t.

        Parameters:
        -----------

        i:  channel number. -1 for scalar Photon::transmission_freqobs_.

        t:  transmission of this fluid element. 
        """
        return _gyoto.Photon_transmit(self, i, t)

Photon_swigregister = _gyoto.Photon_swigregister
Photon_swigregister(Photon)
Photon.properties = _gyoto.cvar.Photon_properties

def Photon_Subcontractor(arg2):
    """Photon_Subcontractor(FactoryMessenger arg2) -> Gyoto::SmartPointer< Gyoto::Photon >"""
    return _gyoto.Photon_Subcontractor(arg2)


def getAstrobjRegister():
    """getAstrobjRegister() -> RegisterEntry"""
    return _gyoto.getAstrobjRegister()

def getAstrobjSubcontractor(name, errmode=0):
    """
    getAstrobjSubcontractor(std::string name, int errmode=0) -> Gyoto::Astrobj::Subcontractor_t
    getAstrobjSubcontractor(std::string name) -> Gyoto::Astrobj::Subcontractor_t *



    Query the Astrobj register.

    Query the Astrobj register to get the Astrobj::Subcontractor_t
    correspondig to a given kind name. This function is normally called
    only from the Factory.

    Parameters:
    -----------

    name:  e.g. "Star"

    errmode:  1 to return NULL in case of failure instead of throwing an
    Error.

    pointer to the corresponding subcontractor. 
    """
    return _gyoto.getAstrobjSubcontractor(name, errmode)

def initAstrobjRegister():
    """
    initAstrobjRegister()



    Empty the Astrobj register.

    This must be called once. 
    """
    return _gyoto.initAstrobjRegister()

def registerAstrobj(name, scp):
    """
    registerAstrobj(std::string name, Gyoto::Astrobj::Subcontractor_t * scp)



    Make an Astrobj kind known to the Factory.

    Register a new Astrobj::Generic sub-class so that the Gyoto::Factory
    knows it.

    Parameters:
    -----------

    name:  The kind name which identifies this object type in an XML file,
    as in < Astrobj kind="name">

    scp:  A pointer to the subcontractor, which will communicate whith the
    Gyoto::Factory to build an instance of the class from its XML
    description 
    """
    return _gyoto.registerAstrobj(name, scp)
class Astrobj(SmartPointee, Object):
    """


    Base class for astronomical object.

    See introduction in the Gyoto::Astrobj namespace.

    C++ includes: GyotoAstrobj.h 
    """

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

    def getProperties(self):
        """
        getProperties(Astrobj self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Astrobj_getProperties(self)


    def clone(self):
        """
        clone(Astrobj self) -> Astrobj



        Cloner.

        This method must be implemented by the various Astrobj::Generic
        subclasses in order to support cloning:

        Cloning is necessary for multi-threading, recommended for interaction
        with the Yorick plug-in etc.

        Implementing it is very straightforward, as long as the copy
        constructor Generic(const Generic& ) has been implemented: 
        """
        return _gyoto.Astrobj_clone(self)

    __swig_destroy__ = _gyoto.delete_Astrobj
    __del__ = lambda self: None

    def metric(self, *args):
        """
        metric(Astrobj self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(Astrobj self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)



        Set the Metric gg_. 
        """
        return _gyoto.Astrobj_metric(self, *args)


    def deltaMax(self, coord):
        """
        deltaMax(Astrobj self, double [8] coord) -> double



        Get max step constraint for adaptive integration.

        Parameters:
        -----------

        coord:  position

        max step to find this object reliably 
        """
        return _gyoto.Astrobj_deltaMax(self, coord)


    def kind(self):
        """
        kind(Astrobj self) -> std::string const



        Get the kind of the Astrobj (e.g. "Star") 
        """
        return _gyoto.Astrobj_kind(self)


    def rMax(self, *args):
        """
        rMax(Astrobj self) -> double
        rMax(Astrobj self) -> double
        rMax(Astrobj self, std::string const & unit) -> double
        rMax(Astrobj self, std::string const & unit) -> double
        rMax(Astrobj self, double val)
        rMax(Astrobj self, double val, std::string const & unit)



        Set maximal distance from center of coordinate system.

        Call Generic::rMax(double val) after converting val from unit to
        geometrical units.

        Parameters:
        -----------

        val:   rmax_ expressed in unit "unit";

        unit:  string... 
        """
        return _gyoto.Astrobj_rMax(self, *args)


    def opticallyThin(self, *args):
        """
        opticallyThin(Astrobj self, bool flag)
        opticallyThin(Astrobj self) -> bool



        Query whether object is optically thin.

        See opticallyThin(bool flag). 
        """
        return _gyoto.Astrobj_opticallyThin(self, *args)


    def redshift(self, *args):
        """
        redshift(Astrobj self, bool flag)
        redshift(Astrobj self) -> bool
        """
        return _gyoto.Astrobj_redshift(self, *args)


    def getDefaultQuantities(self):
        """
        getDefaultQuantities(Astrobj self) -> Gyoto::Quantity_t



        Which quantities to compute if know was requested.

        Return a Gyoto::Quantity_t suitable as input to
        Gyoto::Scenery::setRequestedQuantities() to set de default quantities
        to compute for this object. The default of these defaults
        GYOTO_QUANTITY_INTENSITY. 
        """
        return _gyoto.Astrobj_getDefaultQuantities(self)


    def setParameters(self, fmp):
        """
        setParameters(Astrobj self, FactoryMessenger fmp)



        Main loop for parsing Properties from XML description.

        This function queries the FactoryMessenger for elements to parse, and
        tries to matche each element to a Property to set it accordingly.

        Any class that tries to be buildable from XML must supply a
        subcontractor (for base classes such as Metric, Astrobj, Spectrum and
        Spectrometer, it is done as a template that must be specialized for
        each class).

        This subcontractor typically looks somewhat like this: Although this
        is discouraged, it is possible to override the following functions to
        customize how XML entities are parsed:    - setParameters() if low-
        level access to the      FactoryMessenger is required;    -
        setParameter(std::string name, std::string content,
        std::string unit)      to interpret an entity that does not match a
        Property      (e.g. alternative name);    -
        setParameter(Gyoto::Property const &p, std::string const &name,
        std::string const &content, std::string const &unit)      to change
        how a Property is interpreted. 
        """
        return _gyoto.Astrobj_setParameters(self, fmp)


    def Impact(self, ph, index, data=None):
        """
        Impact(Astrobj self, Photon ph, size_t index, AstrobjProperties data=None) -> int
        Impact(Astrobj self, Photon ph, size_t index) -> int



        Does a photon at these coordinates impact the object?

        Impact() checks whether a Photon impacts the object between two
        integration steps of the photon's trajectory (those two steps are
        photon->getCoord(index, coord1) and photon->getCoord(index+1,
        coord2)). Impact returns 1 if the photon impacts the object between
        these two steps, else 0. In many cases of geometrically thick obects,
        the implementation Astrobj::Standard::Impact() will be fine.

        Impact will call Generic::processHitQuantities() (which is virtual and
        may be re-implemented) to compute observable properties on demand: if
        the data pointer is non-NULL, the object will look in it for pointers
        to properties which apply to its kind. If a pointer to a property
        known to this object is present, then the property is computed and
        store at the pointed-to address. For instance, all objects know the
        "intensity" property. If data->intensity != NULL, the instensity is
        computed and stored in *data->intensity.

        If data is non-NULL and only in this case, processHitQuantities() will
        also call ph->transmit() to update the transmissions of the Photon
        (see Photon::transmit(size_t, double)). This must not be done if data
        is NULL (see Astrobj::Complex::Impact() for an explanation).

        Parameters:
        -----------

        ph:   Gyoto::Photon aimed at the object;

        index:  Index of the last photon step;

        data:  Pointer to a structure to hold the observables at impact.

        1 if impact, 0 if not. 
        """
        return _gyoto.Astrobj_Impact(self, ph, index, data)


    def processHitQuantities(self, ph, coord_ph_hit, coord_obj_hit, dt, data):
        """
        processHitQuantities(Astrobj self, Photon ph, double * coord_ph_hit, double * coord_obj_hit, double dt, AstrobjProperties data)



        Fills Astrobj::Properties.

        processHitQuantities fills the requested data in Impact. To use it,
        you need to call it in the Impact() method for your object in case of
        hit. It will fill Redshift, Intensity, Spectrum, BinSpectrum and
        update the Photon's transmission by calling Photon::transmit(), only
        if data==NULL.

        You can overload it for your Astrobj. The generic implementation calls
        emission(), integrateEmission() and transmission() below. 
        """
        return _gyoto.Astrobj_processHitQuantities(self, ph, coord_ph_hit, coord_obj_hit, dt, data)


    def emission(self, *args):
        """
        emission(Astrobj self, double nu_em, double dsem, double [8] coord_ph, double [8] coord_obj=0) -> double
        emission(Astrobj self, double nu_em, double dsem, double [8] coord_ph) -> double
        emission(Astrobj self, double [] Inu, double [] nu_em, size_t nbnu, double dsem, double [8] coord_ph, double [8] coord_obj=0)
        emission(Astrobj self, double [] Inu, double [] nu_em, size_t nbnu, double dsem, double [8] coord_ph)



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto.Astrobj_emission(self, *args)


    def radiativeQ(self, *args):
        """
        radiativeQ(Astrobj self, bool flag)
        radiativeQ(Astrobj self) -> bool
        radiativeQ(Astrobj self, double [] Inu, double [] Taunu, double [] nu_em, size_t nbnu, double dsem, double [8] coord_ph, double [8] coord_obj=0)
        radiativeQ(Astrobj self, double [] Inu, double [] Taunu, double [] nu_em, size_t nbnu, double dsem, double [8] coord_ph)
        """
        return _gyoto.Astrobj_radiativeQ(self, *args)


    def integrateEmission(self, *args):
        """
        integrateEmission(Astrobj self, double nu1, double nu2, double dsem, double [8] c_ph, double [8] c_obj=0) -> double
        integrateEmission(Astrobj self, double nu1, double nu2, double dsem, double [8] c_ph) -> double
        integrateEmission(Astrobj self, double * I, double const * boundaries, size_t const * chaninds, size_t nbnu, double dsem, double * cph, double * co)



        12 I d (or j)

        Like double integrateEmission(double nu1, double nu2, double dsem,
        double c_ph[8], double c_obj[8]) const for each Spectrometer channel.

        """
        return _gyoto.Astrobj_integrateEmission(self, *args)


    def transmission(self, nuem, dsem, coord):
        """
        transmission(Astrobj self, double nuem, double dsem, double [8] coord) -> double



        Transmission: exp( * dsem )

        transmission() computes the transmission of this fluid element or 0 if
        optically thick. The default implementation returns 1. (no
        attenuation) if optically thin, 0. if optically thick.

        Parameters:
        -----------

        nuem:  frequency in the fluid's frame

        coord:   Photon coordinate

        dsem:  geometrical length in geometrical units 
        """
        return _gyoto.Astrobj_transmission(self, nuem, dsem, coord)


    def __init__(self, nm):
        """
        __init__(Gyoto::Astrobj::Generic self, std::string nm) -> Astrobj



        Copy constructor.

        Make a deep copy of an Astrobj::Generic instance 
        """
        this = _gyoto.new_Astrobj(nm)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Astrobj_swigregister = _gyoto.Astrobj_swigregister
Astrobj_swigregister(Astrobj)
Astrobj.properties = _gyoto.cvar.Astrobj_properties

class AstrobjProperties(SmartPointee):
    """


    Observable properties of an Astronomical object.

    The sort of properties one wants to measure on a ray-traced
    Gyoto::Photon which hits a Gyoto::Astrobj. Not all Astrobj are able to
    fill all of these properties.

    An instance of Properties essentially contains a bunch of pointers to
    memory areas where the observable quantities (see Quantity_t) should
    be stored.

    Astrobj::Generic::processHitQuantities() fills the various arrays upon
    request. A quantity is ignored if the corresponding pointer is NULL.

    Scenery::operator()() increments the Properties between each Photon
    using Properties::operator++().

    The main application (gyoto, the yorick plug-in, or your user
    application) is responsible for allocating the various arrays, filling
    the various members of Properties, and doing whatever meaninful with
    the arrays after they have been filled with values by the ray-tracing
    code (e.g. saving them to disk or displaying them).

    Also see Gyoto::Scenery and Gyoto::Quantity_t.

    C++ includes: GyotoAstrobj.h 
    """

    __swig_setmethods__ = {}
    for _s in [SmartPointee]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AstrobjProperties, name, value)
    __swig_getmethods__ = {}
    for _s in [SmartPointee]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AstrobjProperties, name)
    __repr__ = _swig_repr
    __swig_setmethods__["intensity"] = _gyoto.AstrobjProperties_intensity_set
    __swig_getmethods__["intensity"] = _gyoto.AstrobjProperties_intensity_get
    if _newclass:
        intensity = _swig_property(_gyoto.AstrobjProperties_intensity_get, _gyoto.AstrobjProperties_intensity_set)
    __swig_setmethods__["time"] = _gyoto.AstrobjProperties_time_set
    __swig_getmethods__["time"] = _gyoto.AstrobjProperties_time_get
    if _newclass:
        time = _swig_property(_gyoto.AstrobjProperties_time_get, _gyoto.AstrobjProperties_time_set)
    __swig_setmethods__["distance"] = _gyoto.AstrobjProperties_distance_set
    __swig_getmethods__["distance"] = _gyoto.AstrobjProperties_distance_get
    if _newclass:
        distance = _swig_property(_gyoto.AstrobjProperties_distance_get, _gyoto.AstrobjProperties_distance_set)
    __swig_setmethods__["first_dmin"] = _gyoto.AstrobjProperties_first_dmin_set
    __swig_getmethods__["first_dmin"] = _gyoto.AstrobjProperties_first_dmin_get
    if _newclass:
        first_dmin = _swig_property(_gyoto.AstrobjProperties_first_dmin_get, _gyoto.AstrobjProperties_first_dmin_set)
    __swig_setmethods__["first_dmin_found"] = _gyoto.AstrobjProperties_first_dmin_found_set
    __swig_getmethods__["first_dmin_found"] = _gyoto.AstrobjProperties_first_dmin_found_get
    if _newclass:
        first_dmin_found = _swig_property(_gyoto.AstrobjProperties_first_dmin_found_get, _gyoto.AstrobjProperties_first_dmin_found_set)
    __swig_setmethods__["redshift"] = _gyoto.AstrobjProperties_redshift_set
    __swig_getmethods__["redshift"] = _gyoto.AstrobjProperties_redshift_get
    if _newclass:
        redshift = _swig_property(_gyoto.AstrobjProperties_redshift_get, _gyoto.AstrobjProperties_redshift_set)
    __swig_setmethods__["spectrum"] = _gyoto.AstrobjProperties_spectrum_set
    __swig_getmethods__["spectrum"] = _gyoto.AstrobjProperties_spectrum_get
    if _newclass:
        spectrum = _swig_property(_gyoto.AstrobjProperties_spectrum_get, _gyoto.AstrobjProperties_spectrum_set)
    __swig_setmethods__["binspectrum"] = _gyoto.AstrobjProperties_binspectrum_set
    __swig_getmethods__["binspectrum"] = _gyoto.AstrobjProperties_binspectrum_get
    if _newclass:
        binspectrum = _swig_property(_gyoto.AstrobjProperties_binspectrum_get, _gyoto.AstrobjProperties_binspectrum_set)
    __swig_setmethods__["offset"] = _gyoto.AstrobjProperties_offset_set
    __swig_getmethods__["offset"] = _gyoto.AstrobjProperties_offset_get
    if _newclass:
        offset = _swig_property(_gyoto.AstrobjProperties_offset_get, _gyoto.AstrobjProperties_offset_set)
    __swig_setmethods__["impactcoords"] = _gyoto.AstrobjProperties_impactcoords_set
    __swig_getmethods__["impactcoords"] = _gyoto.AstrobjProperties_impactcoords_get
    if _newclass:
        impactcoords = _swig_property(_gyoto.AstrobjProperties_impactcoords_get, _gyoto.AstrobjProperties_impactcoords_set)
    __swig_setmethods__["user1"] = _gyoto.AstrobjProperties_user1_set
    __swig_getmethods__["user1"] = _gyoto.AstrobjProperties_user1_get
    if _newclass:
        user1 = _swig_property(_gyoto.AstrobjProperties_user1_get, _gyoto.AstrobjProperties_user1_set)
    __swig_setmethods__["user2"] = _gyoto.AstrobjProperties_user2_set
    __swig_getmethods__["user2"] = _gyoto.AstrobjProperties_user2_get
    if _newclass:
        user2 = _swig_property(_gyoto.AstrobjProperties_user2_get, _gyoto.AstrobjProperties_user2_set)
    __swig_setmethods__["user3"] = _gyoto.AstrobjProperties_user3_set
    __swig_getmethods__["user3"] = _gyoto.AstrobjProperties_user3_get
    if _newclass:
        user3 = _swig_property(_gyoto.AstrobjProperties_user3_get, _gyoto.AstrobjProperties_user3_set)
    __swig_setmethods__["user4"] = _gyoto.AstrobjProperties_user4_set
    __swig_getmethods__["user4"] = _gyoto.AstrobjProperties_user4_get
    if _newclass:
        user4 = _swig_property(_gyoto.AstrobjProperties_user4_get, _gyoto.AstrobjProperties_user4_set)
    __swig_setmethods__["user5"] = _gyoto.AstrobjProperties_user5_set
    __swig_getmethods__["user5"] = _gyoto.AstrobjProperties_user5_get
    if _newclass:
        user5 = _swig_property(_gyoto.AstrobjProperties_user5_get, _gyoto.AstrobjProperties_user5_set)
    __swig_setmethods__["intensity_converter_"] = _gyoto.AstrobjProperties_intensity_converter__set
    __swig_getmethods__["intensity_converter_"] = _gyoto.AstrobjProperties_intensity_converter__get
    if _newclass:
        intensity_converter_ = _swig_property(_gyoto.AstrobjProperties_intensity_converter__get, _gyoto.AstrobjProperties_intensity_converter__set)
    __swig_setmethods__["spectrum_converter_"] = _gyoto.AstrobjProperties_spectrum_converter__set
    __swig_getmethods__["spectrum_converter_"] = _gyoto.AstrobjProperties_spectrum_converter__get
    if _newclass:
        spectrum_converter_ = _swig_property(_gyoto.AstrobjProperties_spectrum_converter__get, _gyoto.AstrobjProperties_spectrum_converter__set)
    __swig_setmethods__["binspectrum_converter_"] = _gyoto.AstrobjProperties_binspectrum_converter__set
    __swig_getmethods__["binspectrum_converter_"] = _gyoto.AstrobjProperties_binspectrum_converter__get
    if _newclass:
        binspectrum_converter_ = _swig_property(_gyoto.AstrobjProperties_binspectrum_converter__get, _gyoto.AstrobjProperties_binspectrum_converter__set)
    __swig_setmethods__["alloc"] = _gyoto.AstrobjProperties_alloc_set
    __swig_getmethods__["alloc"] = _gyoto.AstrobjProperties_alloc_get
    if _newclass:
        alloc = _swig_property(_gyoto.AstrobjProperties_alloc_get, _gyoto.AstrobjProperties_alloc_set)

    def __init__(self, *args):
        """
        Properties() -> AstrobjProperties
        __init__(Gyoto::Astrobj::Properties self, double * arg2, double * arg3) -> AstrobjProperties



        < Set intensity and time pointers. 
        """
        this = _gyoto.new_AstrobjProperties(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def init(self, nbnuobs=0):
        """
        init(AstrobjProperties self, size_t nbnuobs=0)
        init(AstrobjProperties self)



        Initialize observable quantities.

        The pointed-to values are initialized as follows (if the corresponding
        pointer is not NULL):

        intensity, firt_dmin_found, redshift, userN: 0

        time, distance, first_dmin: DBL_MAX

        for spectrum and binspectrum, nbnuobs values separated by offset in
        memory are initialized to 0

        for impactcoords, 16 contiguous values are initialized to DBL_MAX 
        """
        return _gyoto.AstrobjProperties_init(self, nbnuobs)


    def increment(self):
        """increment(AstrobjProperties self) -> AstrobjProperties"""
        return _gyoto.AstrobjProperties_increment(self)


    def __iadd__(self, offset):
        """__iadd__(AstrobjProperties self, ptrdiff_t offset) -> AstrobjProperties"""
        return _gyoto.AstrobjProperties___iadd__(self, offset)


    def binSpectrumConverter(self, *args):
        """
        binSpectrumConverter(AstrobjProperties self, Gyoto::SmartPointer< Gyoto::Units::Converter > arg2)
        binSpectrumConverter(AstrobjProperties self, std::string arg2)
        binSpectrumConverter(AstrobjProperties self) -> Converter



        Set Properties::binspectrum_converter_. 
        """
        return _gyoto.AstrobjProperties_binSpectrumConverter(self, *args)


    def intensityConverter(self, *args):
        """
        intensityConverter(AstrobjProperties self, Gyoto::SmartPointer< Gyoto::Units::Converter > arg2)
        intensityConverter(AstrobjProperties self, std::string arg2)
        intensityConverter(AstrobjProperties self) -> Converter



        Set Properties::intentity_converter_. 
        """
        return _gyoto.AstrobjProperties_intensityConverter(self, *args)


    def spectrumConverter(self, *args):
        """
        spectrumConverter(AstrobjProperties self, Gyoto::SmartPointer< Gyoto::Units::Converter > arg2)
        spectrumConverter(AstrobjProperties self, std::string arg2)
        spectrumConverter(AstrobjProperties self) -> Converter



        Set Properties::spectrum_converter_. 
        """
        return _gyoto.AstrobjProperties_spectrumConverter(self, *args)

    __swig_destroy__ = _gyoto.delete_AstrobjProperties
    __del__ = lambda self: None
AstrobjProperties_swigregister = _gyoto.AstrobjProperties_swigregister
AstrobjProperties_swigregister(AstrobjProperties)

class ThinDisk(Astrobj, Functor__Double_constDoubleArray):
    """


    Geometrically thin disks and rings.

    ThinDisk::setParameter() also takes care of calling
    Generic::setParameter().

    C++ includes: GyotoThinDisk.h 
    """

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

    def getProperties(self):
        """
        getProperties(ThinDisk self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.ThinDisk_getProperties(self)


    def clone(self):
        """
        clone(ThinDisk self) -> ThinDisk



        Cloner.

        This method must be implemented by the various Astrobj::Generic
        subclasses in order to support cloning:

        Cloning is necessary for multi-threading, recommended for interaction
        with the Yorick plug-in etc.

        Implementing it is very straightforward, as long as the copy
        constructor Generic(const Generic& ) has been implemented: 
        """
        return _gyoto.ThinDisk_clone(self)

    __swig_destroy__ = _gyoto.delete_ThinDisk
    __del__ = lambda self: None

    def innerRadius(self, *args):
        """
        innerRadius(ThinDisk self) -> double
        innerRadius(ThinDisk self, std::string const & arg2) -> double
        innerRadius(ThinDisk self, double arg2)
        innerRadius(ThinDisk self, double arg2, std::string const & arg3)



        Set rin_. 
        """
        return _gyoto.ThinDisk_innerRadius(self, *args)


    def outerRadius(self, *args):
        """
        outerRadius(ThinDisk self) -> double
        outerRadius(ThinDisk self, std::string const & arg2) -> double
        outerRadius(ThinDisk self, double arg2)
        outerRadius(ThinDisk self, double arg2, std::string const & arg3)



        Set rout_. 
        """
        return _gyoto.ThinDisk_outerRadius(self, *args)


    def thickness(self, *args):
        """
        thickness(ThinDisk self) -> double
        thickness(ThinDisk self, std::string const & arg2) -> double
        thickness(ThinDisk self, double arg2)
        thickness(ThinDisk self, double arg2, std::string const & arg3)



        Set thickness_. 
        """
        return _gyoto.ThinDisk_thickness(self, *args)


    def dir(self, *args):
        """
        dir(ThinDisk self) -> int
        dir(ThinDisk self, int arg2)



        Set dir_. 
        """
        return _gyoto.ThinDisk_dir(self, *args)


    def corotating(self, *args):
        """
        corotating(ThinDisk self) -> bool
        corotating(ThinDisk self, bool t)



        Get dir_==1. 
        """
        return _gyoto.ThinDisk_corotating(self, *args)


    def __call__(self, coord):
        """__call__(ThinDisk self, double const [] coord) -> double"""
        return _gyoto.ThinDisk___call__(self, coord)


    def projectedRadius(self, coord):
        """
        projectedRadius(ThinDisk self, double const [] coord) -> double



        Projected radius of position coord on the equatorial plane. 
        """
        return _gyoto.ThinDisk_projectedRadius(self, coord)


    def sphericalPhi(self, coord):
        """
        sphericalPhi(ThinDisk self, double const [] coord) -> double



        Longitude. 
        """
        return _gyoto.ThinDisk_sphericalPhi(self, coord)


    def getVelocity(self, pos, vel):
        """
        getVelocity(ThinDisk self, double const [4] pos, double [4] vel)



        Get fluid 4-velocity at point.

        Fill vel with the 4-vector velocity of the fluid at 4-position pos.
        getVelocity() should work at some distance from the equatorial plane.
        The default implementation calls Metric::Generic::circularVelocity().

        Parameters:
        -----------

        pos:  4-position at which to compute velocity;

        vel:  4-velocity at pos. 
        """
        return _gyoto.ThinDisk_getVelocity(self, pos, vel)


    def Impact(self, ph, index, data=None):
        """
        Impact(ThinDisk self, Photon ph, size_t index, AstrobjProperties data=None) -> int
        Impact(ThinDisk self, Photon ph, size_t index) -> int



        Does a photon at these coordinates impact the object?

        Impact() checks whether a Photon impacts the object between two
        integration steps of the photon's trajectory (those two steps are
        photon->getCoord(index, coord1) and photon->getCoord(index+1,
        coord2)). Impact returns 1 if the photon impacts the object between
        these two steps, else 0. In many cases of geometrically thick obects,
        the implementation Astrobj::Standard::Impact() will be fine.

        Impact will call Generic::processHitQuantities() (which is virtual and
        may be re-implemented) to compute observable properties on demand: if
        the data pointer is non-NULL, the object will look in it for pointers
        to properties which apply to its kind. If a pointer to a property
        known to this object is present, then the property is computed and
        store at the pointed-to address. For instance, all objects know the
        "intensity" property. If data->intensity != NULL, the instensity is
        computed and stored in *data->intensity.

        If data is non-NULL and only in this case, processHitQuantities() will
        also call ph->transmit() to update the transmissions of the Photon
        (see Photon::transmit(size_t, double)). This must not be done if data
        is NULL (see Astrobj::Complex::Impact() for an explanation).

        Parameters:
        -----------

        ph:   Gyoto::Photon aimed at the object;

        index:  Index of the last photon step;

        data:  Pointer to a structure to hold the observables at impact.

        1 if impact, 0 if not. 
        """
        return _gyoto.ThinDisk_Impact(self, ph, index, data)


    def emission(self, arg2, arg3, arg4, arg5):
        """
        emission(ThinDisk self, double arg2, double arg3, double * arg4, double arg5) -> double



        Specific intensity I for several values ofem

        Called by the default implementation for processHitQuantities().

        emission() computes the intensity I emitted by the small volume of
        length dsem. It should take self- absorption along dsem into account.

        Same as emission(double nu_em, double dsem, double coord_ph[8], double
        coord_obj[8]=NULL) const looping on several values of nu_em.

        Parameters:
        -----------

        Inu[nbnu]:  Output (must be set to a previously allocated array of
        doubles)

        nu_em[nbnu]:  Frequencies at emission

        nbnu:  Size of Inu[] and nu_em[]

        dsem:  Length over which to integrate inside the object

        coord_ph:   Photon coordinate

        coord_obj:  Emitter coordinate at current photon position

        I or dI [W m-2 sr-2] 
        """
        return _gyoto.ThinDisk_emission(self, arg2, arg3, arg4, arg5)


    def __init__(self, *args):
        """
        __init__(Gyoto::Astrobj::ThinDisk self, std::string kind) -> ThinDisk
        __init__(Gyoto::Astrobj::ThinDisk self) -> ThinDisk
        __init__(Gyoto::Astrobj::ThinDisk self, ThinDisk orig) -> ThinDisk
        __init__(Gyoto::Astrobj::ThinDisk self, Astrobj base) -> ThinDisk



        Copy constructor. 
        """
        this = _gyoto.new_ThinDisk(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
ThinDisk_swigregister = _gyoto.ThinDisk_swigregister
ThinDisk_swigregister(ThinDisk)
ThinDisk.properties = _gyoto.cvar.ThinDisk_properties


def getMetricRegister():
    """getMetricRegister() -> RegisterEntry"""
    return _gyoto.getMetricRegister()

def getMetricSubcontractor(name, errmode=0):
    """
    getMetricSubcontractor(std::string name, int errmode=0) -> Gyoto::Metric::Subcontractor_t
    getMetricSubcontractor(std::string name) -> Gyoto::Metric::Subcontractor_t *



    Query the Metric register.

    Query the Metric register to get the Metric::Subcontractor_t
    correspondig to a given kind name. This function is normally called
    only from the Factory.

    Parameters:
    -----------

    name:  e.g. "KerrBL"

    errmode:  int=0. If errmode==0, failure to find a registered Metric by
    that name is an error. Else, simply return NULL pointer in that case.

    pointer to the corresponding subcontractor. 
    """
    return _gyoto.getMetricSubcontractor(name, errmode)

def registerMetric(kind, scp):
    """
    registerMetric(std::string kind, Gyoto::Metric::Subcontractor_t * scp)



    Make a Metric kind known to the Factory.

    Register a new Metric::Generic sub-class so that the Gyoto::Factory
    knows it.

    Parameters:
    -----------

    kind:  The kind name which identifies this object type in an XML file,
    as in < Metric kind="name">

    scp:  A pointer to the subcontractor, which will communicate whith the
    Gyoto::Factory to build an instance of the class from its XML
    description 
    """
    return _gyoto.registerMetric(kind, scp)

def initMetricRegister():
    """
    initMetricRegister()



    Empty the Metric register.

    This must be called once. It is called by Gyoto::Register::init(). 
    """
    return _gyoto.initMetricRegister()
class Metric(SmartPointee, Object, Teller):
    """


    Base class for metrics.

    Example: class Gyoto::Metric::KerrBL

    See Gyoto::Metric for an introduction.

    C++ includes: GyotoMetric.h 
    """

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

    def getProperties(self):
        """
        getProperties(Metric self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Metric_getProperties(self)


    def kind(self):
        """
        kind(Metric self) -> std::string const



        Get kind_. 
        """
        return _gyoto.Metric_kind(self)


    def getRefCount(self):
        """getRefCount(Metric self) -> int"""
        return _gyoto.Metric_getRefCount(self)

    __swig_destroy__ = _gyoto.delete_Metric
    __del__ = lambda self: None

    def clone(self):
        """
        clone(Metric self) -> Metric



        Virtual copy constructor. 
        """
        return _gyoto.Metric_clone(self)


    def coordKind(self):
        """
        coordKind(Metric self) -> int



        Get coordinate kind. 
        """
        return _gyoto.Metric_coordKind(self)


    def mass(self, *args):
        """
        mass(Metric self, double const arg2)
        mass(Metric self, double const arg2, std::string const & unit)
        mass(Metric self) -> double
        mass(Metric self, std::string const & unit) -> double



        Get mass used in unitLength() 
        """
        return _gyoto.Metric_mass(self, *args)


    def unitLength(self, *args):
        """
        unitLength(Metric self) -> double
        unitLength(Metric self, std::string const & unit) -> double



        unitLength expressed in specified unit 
        """
        return _gyoto.Metric_unitLength(self, *args)


    def getRmb(self):
        """
        getRmb(Metric self) -> double



        Returns the marginally bound radius Should be implemented in derived
        classes if useful If called on the base class, returns an error 
        """
        return _gyoto.Metric_getRmb(self)


    def getRms(self):
        """
        getRms(Metric self) -> double



        Returns the marginally stable (ISCO) radius Should be implemented in
        derived classes if useful If called on the base class, returns an
        error 
        """
        return _gyoto.Metric_getRms(self)


    def getSpecificAngularMomentum(self, rr):
        """
        getSpecificAngularMomentum(Metric self, double rr) -> double



        Returns the specific angular momentum l=-u_phi/u_t Should be
        implemented in derived classes if useful If called on the base class,
        returns an error 
        """
        return _gyoto.Metric_getSpecificAngularMomentum(self, rr)


    def getPotential(self, pos, l_cst):
        """
        getPotential(Metric self, double [4] pos, double l_cst) -> double



        Returns potential W=-ln(|u_t|) for a cst specific angular momentum
        l_cst Should be implemented in derived classes if useful If called on
        the base class, returns an error 
        """
        return _gyoto.Metric_getPotential(self, pos, l_cst)


    def deltaMin(self, *args):
        """
        deltaMin(Metric self) -> double
        deltaMin(Metric self, double h1)



        Set delta_min_ 
        """
        return _gyoto.Metric_deltaMin(self, *args)


    def deltaMax(self, *args):
        """
        deltaMax(Metric self) -> double
        deltaMax(Metric self, double const [8] pos, double delta_max_external) -> double
        deltaMax(Metric self, double h1)



        Set delta_max_ 
        """
        return _gyoto.Metric_deltaMax(self, *args)


    def deltaMaxOverR(self, *args):
        """
        deltaMaxOverR(Metric self) -> double
        deltaMaxOverR(Metric self, double t)



        Set delta_max_over_r_. 
        """
        return _gyoto.Metric_deltaMaxOverR(self, *args)


    def keplerian(self, *args):
        """
        keplerian(Metric self) -> bool
        keplerian(Metric self, bool arg2)



        Set keplerian_. 
        """
        return _gyoto.Metric_keplerian(self, *args)


    def cartesianVelocity(self, coord, vel):
        """
        cartesianVelocity(Metric self, double const [8] coord, double [3] vel)



        Compute xprime, yprime and zprime from 8-coordinates. 
        """
        return _gyoto.Metric_cartesianVelocity(self, coord, vel)


    def SysPrimeToTdot(self, coord, v):
        """
        SysPrimeToTdot(Metric self, double const [4] coord, double const [3] v) -> double



        Compute tdot as a function of dr/dt, dtheta/dt and dphi/dt. Everything
        is in geometrical units.

        Parameters:
        -----------

        coord:  4-position (geometrical units);

        v:  3-velocity dx1/dx0, dx2/dx0, dx3/dx0;

        tdot = dx0/dtau. 
        """
        return _gyoto.Metric_SysPrimeToTdot(self, coord, v)


    def circularVelocity(self, pos, vel, dir=1.):
        """
        circularVelocity(Metric self, double const [4] pos, double [4] vel, double dir=1.)
        circularVelocity(Metric self, double const [4] pos, double [4] vel)



        Yield circular velocity at a given position.

        Give the velocity of a massive particle in circular orbit at the given
        position projected onto the equatorial plane. Such a velocity may not
        exist everywhere (or anywhere) for a given metric. This method is
        intended to be used by Astrobj classes such as Torus or ThinDisk.

        If keplerian_ is set to true, this method should return the Keplerian
        velcity instead (derived classes should ensure this, see
        KerrBL::circularVelocity() for instance).

        The default implementation throws an error if keplerian_ is set to
        false.

        Parameters:
        -----------

        pos:  input: position,

        vel:  output: velocity,

        dir:  1 for corotating, -1 for counterrotating. 
        """
        return _gyoto.Metric_circularVelocity(self, pos, vel, dir)


    def nullifyCoord(self, *args):
        """
        nullifyCoord(Metric self, double [8] coord)
        nullifyCoord(Metric self, double [8] coord, double & tdot2)



        Set tdot (coord[4]) such that coord is light-like and return other
        possible tdot.

        Set coord[4] so that the 4-velocity coord[4:7] is lightlike, i.e. of
        norm 0. There may be up to two solutions. coord[4] is set to the
        hightest. The lowest can be retrieved in tdot2. Everything is
        expressed in geometrical units.

        Parameters:
        -----------

        coord:  8-position, coord[4] will be set according to the other
        elements;

        tdot2:  will be set to the smallest solution 
        """
        return _gyoto.Metric_nullifyCoord(self, *args)


    def ScalarProd(self, pos, u1, u2):
        """
        ScalarProd(Metric self, double const [4] pos, double const [4] u1, double const [4] u2) -> double



        Scalar product.

        Compute the scalarproduct of the two quadrivectors u1 and u2 in this
        Metric, at point pos expressed in coordinate system sys.

        Parameters:
        -----------

        pos:  4-position;

        u1:  1st quadrivector;

        u2:  2nd quadrivector;

        u1*u2 
        """
        return _gyoto.Metric_ScalarProd(self, pos, u1, u2)


    def Norm3D(self, pos):
        """
        Norm3D(Metric self, double * pos) -> double



        not clear 
        """
        return _gyoto.Metric_Norm3D(self, pos)


    def observerTetrad(self, obskind, pos, fourvel, screen1, screen2, screen3):
        """
        observerTetrad(Metric self, std::string const obskind, double const [4] pos, double [4] fourvel, double [4] screen1, double [4] screen2, double [4] screen3)



        Computes the orthonormal local tetrad of the observer.

        Parameters:
        -----------

        obskind:  input: kind of observer (eg:
        "ZAMO","KeplerianObserver"...)

        pos:  input: position,

        fourvel:  output: observer 4-velocity (norm -1)

        screen1:  output: first vector in the screen plane

        screen2:  output: second vector in the screen plane

        screen3:  output: vector normal to the screen 
        """
        return _gyoto.Metric_observerTetrad(self, obskind, pos, fourvel, screen1, screen2, screen3)


    def gmunu(self, *args):
        """
        gmunu(Metric self, double const * x, int mu, int nu) -> double
        gmunu(Metric self, double [4][4] g, double const * pos)



        Metric coefficients.

        The default implementation calls double gmunu(const double * x, int
        mu, int nu) const.

        Parameters:
        -----------

        g:  4x4 array to store the coeefficients

        x:  4-position at which to compute the coefficients;

        Metric coefficient g, at point x 
        """
        return _gyoto.Metric_gmunu(self, *args)


    def christoffel(self, *args):
        """
        christoffel(Metric self, double const [8] coord, int const alpha, int const mu, int const nu) -> double
        christoffel(Metric self, double [4][4][4] dst, double const [8] coord) -> int



        Chistoffel symbol.

        Value of Christoffel symbol at point (x1, x2, x3). 
        """
        return _gyoto.Metric_christoffel(self, *args)


    def myrk4(self, line, coord, h, res):
        """
        myrk4(Metric self, Worldline line, double const [8] coord, double h, double [8] res) -> int



        RK4 integrator. 
        """
        return _gyoto.Metric_myrk4(self, line, coord, h, res)


    def myrk4_adaptive(self, *args):
        """
        myrk4_adaptive(Metric self, Worldline line, double const [8] coord, double lastnorm, double normref, double [8] coordnew, double h0, double & h1, double deltamax) -> int
        myrk4_adaptive(Metric self, Worldline line, double const [8] coord, double lastnorm, double normref, double [8] coordnew, double h0, double & h1) -> int



        RK4 integrator with adaptive step. 
        """
        return _gyoto.Metric_myrk4_adaptive(self, *args)


    def isStopCondition(self, coord):
        """
        isStopCondition(Metric self, double const *const coord) -> int



        Check whether integration should stop.

        The integrating loop will ask this the Metric through this method
        whether or not it is happy to conitnue the integration. Typically, the
        Metric should answer 0 when everything is fine, 1 when too close to
        the event horizon, inside the BH...

        Parameters:
        -----------

        coord:  8-coordinate vector to check. 
        """
        return _gyoto.Metric_isStopCondition(self, coord)


    def diff(self, y, res):
        """
        diff(Metric self, double const [8] y, double [8] res) -> int



        F function such as dy/dtau=F(y,cst) 
        """
        return _gyoto.Metric_diff(self, y, res)


    def setParticleProperties(self, line, coord):
        """
        setParticleProperties(Metric self, Worldline line, double const * coord)



        Set Metric-specific constants of motion. Used e.g. in KerrBL. 
        """
        return _gyoto.Metric_setParticleProperties(self, line, coord)


    def __init__(self, *args):
        """
        Generic(int const coordkind, std::string const & name) -> Metric
        __init__(Gyoto::Metric::Generic self, std::string nm) -> Metric



        Copy constructor. 
        """
        this = _gyoto.new_Metric(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Metric_swigregister = _gyoto.Metric_swigregister
Metric_swigregister(Metric)
Metric.properties = _gyoto.cvar.Metric_properties


def getSpectrumRegister():
    """getSpectrumRegister() -> RegisterEntry"""
    return _gyoto.getSpectrumRegister()

def registerSpectrum(kind, scp):
    """
    registerSpectrum(std::string kind, Gyoto::Spectrum::Subcontractor_t * scp)



    Make a Spectrum kind known to the Factory.

    Register a new Spectrum::Generic sub-class so that the Gyoto::Factory
    knows it.

    Parameters:
    -----------

    kind:  The kind name which identifies this object type in an XML file,
    as in < Spectrum kind="name">

    scp:  A pointer to the subcontractor, which will communicate whith the
    Gyoto::Factory to build an instance of the class from its XML
    description 
    """
    return _gyoto.registerSpectrum(kind, scp)

def getSpectrumSubcontractor(name, errmode=0):
    """
    getSpectrumSubcontractor(std::string name, int errmode=0) -> Gyoto::Spectrum::Subcontractor_t
    getSpectrumSubcontractor(std::string name) -> Gyoto::Spectrum::Subcontractor_t *



    Query the Spectrum register.

    Query the Spectrum register to get the Metric::Subcontractor_t
    correspondig to a given kind name. This function is normally called
    only from the Factory.

    Parameters:
    -----------

    name:  e.g. "PowerLaw"

    errmode:  int=0. If errmode==0, failure to find a registered Spectrum
    by that name is an error. Else, simply return NULL pointer in that
    case.

    pointer to the corresponding subcontractor. 
    """
    return _gyoto.getSpectrumSubcontractor(name, errmode)

def initSpectrumRegister():
    """
    initSpectrumRegister()



    Empty the Spectrum register.

    This must be called once. It is called by Gyoto::Register::init(). 
    """
    return _gyoto.initSpectrumRegister()
class Spectrum(SmartPointee, Object):
    """


    Spectrum emitted by an Astrobj.

    Light emitted by e.g. a Star

    C++ includes: GyotoSpectrum.h 
    """

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

    def getProperties(self):
        """
        getProperties(Spectrum self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Spectrum_getProperties(self)


    def clone(self):
        """
        clone(Spectrum self) -> Spectrum



        Cloner. 
        """
        return _gyoto.Spectrum_clone(self)

    __swig_destroy__ = _gyoto.delete_Spectrum
    __del__ = lambda self: None

    def kind(self):
        """
        kind(Spectrum self) -> std::string const



        Get spectrum kind. 
        """
        return _gyoto.Spectrum_kind(self)


    def __call__(self, *args):
        """
        __call__(Spectrum self, double nu) -> double
        __call__(Spectrum self, double nu, double opacity, double ds) -> double
        """
        return _gyoto.Spectrum___call__(self, *args)


    def integrate(self, *args):
        """
        integrate(Spectrum self, double nu1, double nu2) -> double
        integrate(Spectrum self, double nu1, double nu2, Spectrum opacity, double ds) -> double



        Integrate optically thin I_nu.

        See operator()(double nu, double opacity, double ds) const

        Parameters:
        -----------

        nu1:  nu2:  boundaries for the integration

        opacity:  the frequency-dependent opacity law given as a pointer to a
        Gyoto::Spectrum::Generic sub-class instance

        ds:  the element length for spatial integration

        I, the integral of I_nu between nu1 and nu2 
        """
        return _gyoto.Spectrum_integrate(self, *args)


    def __init__(self, nm):
        """__init__(Gyoto::Spectrum::Generic self, std::string nm) -> Spectrum"""
        this = _gyoto.new_Spectrum(nm)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Spectrum_swigregister = _gyoto.Spectrum_swigregister
Spectrum_swigregister(Spectrum)
Spectrum.properties = _gyoto.cvar.Spectrum_properties


def getSpectrometerRegister():
    """getSpectrometerRegister() -> RegisterEntry"""
    return _gyoto.getSpectrometerRegister()

def getSpectrometerSubcontractor(name, errmode=0):
    """
    getSpectrometerSubcontractor(std::string name, int errmode=0) -> Gyoto::Spectrometer::Subcontractor_t
    getSpectrometerSubcontractor(std::string name) -> Gyoto::Spectrometer::Subcontractor_t *



    Query the Spectrometer register.

    Get the Spectrometer::Subcontractor_t correspondig to a given kind
    name. This function is normally called only from the Gyoto::Factory.

    Parameters:
    -----------

    name:  Name of the subclass to build, e.g. "Complex" or "wave".

    errmode:  If name is not registered, getSubcontractor() return NULL
    errmode==1, throws a Gyoto::Error if errmode==0.

    pointer to the corresponding subcontractor. 
    """
    return _gyoto.getSpectrometerSubcontractor(name, errmode)

def initSpectrometerRegister():
    """
    initSpectrometerRegister()



    Initialize the Spectrometer register This must be called once. It
    initializes Register_ and registers the standard kinds ( Uniform and
    Complex). 
    """
    return _gyoto.initSpectrometerRegister()

def registerSpectrometer(name, scp):
    """
    registerSpectrometer(std::string name, Gyoto::Spectrometer::Subcontractor_t * scp)



    Register a new Spectrometer kind.

    Register a new Spectrometer::Generic sub-class so that the
    Gyoto::Factory knows it.

    Parameters:
    -----------

    name:  The kind name which identifies this object type in an XML file,
    as in < Spectrometer kind="name">. For clarity, this should be the
    same as the value of kindid_ for this object, but it is not mandatory.

    scp:  A pointer to the subcontractor, which will communicate whith the
    Gyoto::Factory to build an instance of the class from its XML
    description. If all parameters can be set using setParameter(), this
    can be: 
    """
    return _gyoto.registerSpectrometer(name, scp)
class Spectrometer(SmartPointee, Object, Teller):
    """


    Base class for spectrometers.

    Example: class Gyoto::Spectrometer::Uniform

    See Gyoto::Spectrometer for an introduction.

    Generic inherits from Gyoto::SmartPointee so that it is possible to
    create a SmartPointer to a Spectrometer.

    It also inherits from Gyoto::Hook::Teller. This allows a consistent
    implementation of Spectrometer::Complex (in particular). Any method
    which mutates a Spectrometer should call tellListeners().

    C++ includes: GyotoSpectrometer.h 
    """

    __swig_setmethods__ = {}
    for _s in [SmartPointee, Object, Teller]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spectrometer, name, value)
    __swig_getmethods__ = {}
    for _s in [SmartPointee, Object, Teller]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Spectrometer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nsamples_"] = _gyoto.Spectrometer_nsamples__set
    __swig_getmethods__["nsamples_"] = _gyoto.Spectrometer_nsamples__get
    if _newclass:
        nsamples_ = _swig_property(_gyoto.Spectrometer_nsamples__get, _gyoto.Spectrometer_nsamples__set)
    __swig_setmethods__["nboundaries_"] = _gyoto.Spectrometer_nboundaries__set
    __swig_getmethods__["nboundaries_"] = _gyoto.Spectrometer_nboundaries__get
    if _newclass:
        nboundaries_ = _swig_property(_gyoto.Spectrometer_nboundaries__get, _gyoto.Spectrometer_nboundaries__set)
    __swig_setmethods__["boundaries_"] = _gyoto.Spectrometer_boundaries__set
    __swig_getmethods__["boundaries_"] = _gyoto.Spectrometer_boundaries__get
    if _newclass:
        boundaries_ = _swig_property(_gyoto.Spectrometer_boundaries__get, _gyoto.Spectrometer_boundaries__set)
    __swig_setmethods__["chanind_"] = _gyoto.Spectrometer_chanind__set
    __swig_getmethods__["chanind_"] = _gyoto.Spectrometer_chanind__get
    if _newclass:
        chanind_ = _swig_property(_gyoto.Spectrometer_chanind__get, _gyoto.Spectrometer_chanind__set)
    __swig_setmethods__["midpoints_"] = _gyoto.Spectrometer_midpoints__set
    __swig_getmethods__["midpoints_"] = _gyoto.Spectrometer_midpoints__get
    if _newclass:
        midpoints_ = _swig_property(_gyoto.Spectrometer_midpoints__get, _gyoto.Spectrometer_midpoints__set)
    __swig_setmethods__["widths_"] = _gyoto.Spectrometer_widths__set
    __swig_getmethods__["widths_"] = _gyoto.Spectrometer_widths__get
    if _newclass:
        widths_ = _swig_property(_gyoto.Spectrometer_widths__get, _gyoto.Spectrometer_widths__set)

    def getProperties(self):
        """
        getProperties(Spectrometer self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.Spectrometer_getProperties(self)


    def clone(self):
        """
        clone(Spectrometer self) -> Spectrometer



        Clone an instance.

        Use this to get a deep copy of an instance;

        Most implementations will use the copy constructor: 
        """
        return _gyoto.Spectrometer_clone(self)

    __swig_destroy__ = _gyoto.delete_Spectrometer
    __del__ = lambda self: None

    def kindid(self, *args):
        """
        kindid(Spectrometer self) -> Gyoto::Spectrometer::kind_t
        kindid(Spectrometer self, Gyoto::Spectrometer::kind_t arg2)



        Set Generic::kindid_.

        This should rarely be used as the Generic::kindid_ attribute usually
        is set in the constructor and doesn't change after that.

        Always set to the address of a static variable, not to a temporary.
        Usually your class should have a static member for that purpose: 
        """
        return _gyoto.Spectrometer_kindid(self, *args)


    def nSamples(self):
        """
        nSamples(Spectrometer self) -> size_t



        Get Generic::nsamples_. 
        """
        return _gyoto.Spectrometer_nSamples(self)


    def getNBoundaries(self):
        """
        getNBoundaries(Spectrometer self) -> size_t



        Get Generic::nboundaries_. 
        """
        return _gyoto.Spectrometer_getNBoundaries(self)


    def getMidpoints(self, *args):
        """
        getMidpoints(Spectrometer self) -> double const
        getMidpoints(Spectrometer self, double [] data, std::string unit)



        Copy Generic::midpoints_, converting to unit.

        Parameters:
        -----------

        data:  an array of Generic::nsamples_ doubles to fill with result

        unit:  a string 
        """
        return _gyoto.Spectrometer_getMidpoints(self, *args)


    def getChannelBoundaries(self, *args):
        """
        getChannelBoundaries(Spectrometer self, double [] data, std::string unit)
        getChannelBoundaries(Spectrometer self) -> double const *



        Get Generic::boundaries_. 
        """
        return _gyoto.Spectrometer_getChannelBoundaries(self, *args)


    def getChannelIndices(self):
        """
        getChannelIndices(Spectrometer self) -> size_t const *



        Get Generic::chanind_. 
        """
        return _gyoto.Spectrometer_getChannelIndices(self)


    def getWidths(self, *args):
        """
        getWidths(Spectrometer self) -> double const
        getWidths(Spectrometer self, double [] data, std::string unit)



        Copy Generic::widths_, converting to unit.

        Think carefully before using: widths are often used to convert
        spectral flux density to flux. If flux density is per Herz, you don't
        need to convert widths.

        Parameters:
        -----------

        data:  an array of Generic::nboundaries_ doubles to fill with result

        unit:  a string 
        """
        return _gyoto.Spectrometer_getWidths(self, *args)


    def __init__(self, nm):
        """
        __init__(Gyoto::Spectrometer::Generic self, std::string nm) -> Spectrometer



        Copy constructor.

        Takes care of (deep) copying all the members known to the base class.

        """
        this = _gyoto.new_Spectrometer(nm)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
Spectrometer_swigregister = _gyoto.Spectrometer_swigregister
Spectrometer_swigregister(Spectrometer)
Spectrometer.properties = _gyoto.cvar.Spectrometer_properties

class ComplexSpectrometer(Spectrometer, Listener):
    """


    Complex spectrometer object.

    A Gyoto::Spectrometer::Generic whic contain several
    Gyoto::Spectrometer::Generic instances. It is essentially a
    SmartPointer<Spectrometer::Generic> array, which some methods arround.
    Indeed, the operator[](size_t i) method is implemented to retrieve the
    i-th element.

    In an XML description, the < Spectrometer> section is unique, its kind
    is "Complex". Each sub-spectrometer then appears as a
    <SubSpectrometer> subsection. For instance, to compute 10 channels ovr
    the K infrared band plus 10 channels in the high energy domain:

    C++ includes: GyotoComplexSpectrometer.h 
    """

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

    def clone(self):
        """
        clone(ComplexSpectrometer self) -> ComplexSpectrometer



        Clone an instance.

        Use this to get a deep copy of an instance;

        Most implementations will use the copy constructor: 
        """
        return _gyoto.ComplexSpectrometer_clone(self)

    __swig_destroy__ = _gyoto.delete_ComplexSpectrometer
    __del__ = lambda self: None

    def append(self, element):
        """
        append(ComplexSpectrometer self, Gyoto::SmartPointer< Gyoto::Spectrometer::Generic > element)



        Add element at the end of the array.

        If the Spectrometer::Complex itself does not have a metric already
        assigned, it takes it from the new element. Else, it sets the metric
        in the new element to its own. This ensures that all elements use the
        same metric (this heuristic is not entirely fool-proof, it's safer to
        set the metric directly in the Spectrometer::Complex). 
        """
        return _gyoto.ComplexSpectrometer_append(self, element)


    def remove(self, i):
        """
        remove(ComplexSpectrometer self, size_t i)



        Remove i-th element from the array. 
        """
        return _gyoto.ComplexSpectrometer_remove(self, i)


    def getCardinal(self):
        """
        getCardinal(ComplexSpectrometer self) -> size_t



        Get the number of elements in the array. 
        """
        return _gyoto.ComplexSpectrometer_getCardinal(self)


    def tell(self, msg):
        """
        tell(ComplexSpectrometer self, Teller msg)



        This is how a Teller tells.

        A teller will basically call listener->tell(this).

        Parameters:
        -----------

        msg:  Teller* the Teller who is telling... Useful if the Listener
        listens to several Tellers. 
        """
        return _gyoto.ComplexSpectrometer_tell(self, msg)


    def fillElement(self, fmp):
        """
        fillElement(ComplexSpectrometer self, FactoryMessenger fmp)



        Fill the XML element for this Object.

        The base implementation simply calls fillProperty() for each Property
        defined for the Object.

        Derived classes should avoid overriding fillElement(). It may make
        sense occasionally, e.g. to make sure that the metric is output first.

        To customize how a given Property is rendered, it is better to
        override fillProperty().

        If this method is overridden, the implementation should in general
        call fillElement() on the direct base. 
        """
        return _gyoto.ComplexSpectrometer_fillElement(self, fmp)


    def setParameters(self, fmp):
        """
        setParameters(ComplexSpectrometer self, FactoryMessenger fmp)



        Main loop for parsing Properties from XML description.

        This function queries the FactoryMessenger for elements to parse, and
        tries to matche each element to a Property to set it accordingly.

        Any class that tries to be buildable from XML must supply a
        subcontractor (for base classes such as Metric, Astrobj, Spectrum and
        Spectrometer, it is done as a template that must be specialized for
        each class).

        This subcontractor typically looks somewhat like this: Although this
        is discouraged, it is possible to override the following functions to
        customize how XML entities are parsed:    - setParameters() if low-
        level access to the      FactoryMessenger is required;    -
        setParameter(std::string name, std::string content,
        std::string unit)      to interpret an entity that does not match a
        Property      (e.g. alternative name);    -
        setParameter(Gyoto::Property const &p, std::string const &name,
        std::string const &content, std::string const &unit)      to change
        how a Property is interpreted. 
        """
        return _gyoto.ComplexSpectrometer_setParameters(self, fmp)


    def __getitem__(self, i):
        """__getitem__(ComplexSpectrometer self, int i) -> Spectrometer"""
        return _gyoto.ComplexSpectrometer___getitem__(self, i)


    def __setitem__(self, i, p):
        """__setitem__(ComplexSpectrometer self, int i, Spectrometer p)"""
        return _gyoto.ComplexSpectrometer___setitem__(self, i, p)


    def __init__(self, *args):
        """
        Complex() -> ComplexSpectrometer
        Complex(ComplexSpectrometer arg2) -> ComplexSpectrometer
        __init__(Gyoto::Spectrometer::Complex self, Spectrometer base) -> ComplexSpectrometer



        Copy constructor. 
        """
        this = _gyoto.new_ComplexSpectrometer(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
ComplexSpectrometer_swigregister = _gyoto.ComplexSpectrometer_swigregister
ComplexSpectrometer_swigregister(ComplexSpectrometer)
ComplexSpectrometer.Kind = _gyoto.cvar.ComplexSpectrometer_Kind

class UniformSpectrometer(Spectrometer):
    """


    Uniformly spaced spectrometers.

    Spectral channels are contiguous and uniformly spaced in either
    wavelength, frequency or log10 of either. Gyoto::Spectrometer::Uniform
    is registered four times in the factory: as kind="wave",
    "wavelog", "freq" and "freqlog". Example XML entity:

    The content of the entity yields the band pass expressed in "unit"
    or in log10(unit).

    C++ includes: GyotoUniformSpectrometer.h 
    """

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

    def getProperties(self):
        """
        getProperties(UniformSpectrometer self) -> Property



        Get list of properties.

        This method is declared automatically by the GYOTO_OBJECT macro and
        defined automatically by the GYOTO_PROPERTY_END macro. 
        """
        return _gyoto.UniformSpectrometer_getProperties(self)


    def clone(self):
        """
        clone(UniformSpectrometer self) -> Spectrometer



        Cloner. 
        """
        return _gyoto.UniformSpectrometer_clone(self)

    __swig_destroy__ = _gyoto.delete_UniformSpectrometer
    __del__ = lambda self: None

    def kindid(self, *args):
        """
        kindid(UniformSpectrometer self) -> Gyoto::Spectrometer::kind_t
        kindid(UniformSpectrometer self, Gyoto::Spectrometer::kind_t arg2)
        kindid(UniformSpectrometer self, Gyoto::Spectrometer::kind_t arg2)



        Get kindid_.

        You can check whether the Spectrometer sp is of a given kind MyKind
        with something like:

        See Uniform::WaveKind, Uniform::WaveLogKind, Uniform::FreqKind,
        Uniform::FreqLogKind and Complex::Kind. 
        """
        return _gyoto.UniformSpectrometer_kindid(self, *args)


    def kind(self, *args):
        """
        kind(UniformSpectrometer self, std::string const & name)
        kind(UniformSpectrometer self) -> std::string
        """
        return _gyoto.UniformSpectrometer_kind(self, *args)


    def nSamples(self, *args):
        """
        nSamples(UniformSpectrometer self) -> size_t
        nSamples(UniformSpectrometer self, size_t n)



        Get Generic::nsamples_. 
        """
        return _gyoto.UniformSpectrometer_nSamples(self, *args)


    def band(self, *args):
        """
        band(UniformSpectrometer self, vector_double nu)
        band(UniformSpectrometer self, vector_double nu, std::string const & unit)
        band(UniformSpectrometer self) -> vector_double
        band(UniformSpectrometer self, std::string const & unit) -> vector_double
        band(UniformSpectrometer self, double [2] nu)
        band(UniformSpectrometer self, double [2] nu, std::string const & unit, std::string const & kind)
        band(UniformSpectrometer self, double [] nu, std::string const & unit)
        """
        return _gyoto.UniformSpectrometer_band(self, *args)


    def getBand(self):
        """
        getBand(UniformSpectrometer self) -> double const *



        Get Uniform::band_. 
        """
        return _gyoto.UniformSpectrometer_getBand(self)


    def fillProperty(self, fmp, p):
        """
        fillProperty(UniformSpectrometer self, FactoryMessenger fmp, Property p)



        Output a single Property to XML.

        The base implementation decides what to do based on the p.type. The
        format matches how setParameters() an setParameter() would interpret
        the XML descition.

        Overriding this method should be avoided, but makes sense in some
        cases (for instance Screen::fillProperty() selects a different unit
        for Distance based on its magnitude, so that stellar sizes are
        expressed in solar radii while smaller sizes can be expressed in
        meters and larger sizes in parsecs).

        Overriding implementation should fall-back on calling the
        implementation in the direct parent class: 
        """
        return _gyoto.UniformSpectrometer_fillProperty(self, fmp, p)


    def setParameters(self, fmp):
        """
        setParameters(UniformSpectrometer self, FactoryMessenger fmp)



        Main loop for parsing Properties from XML description.

        This function queries the FactoryMessenger for elements to parse, and
        tries to matche each element to a Property to set it accordingly.

        Any class that tries to be buildable from XML must supply a
        subcontractor (for base classes such as Metric, Astrobj, Spectrum and
        Spectrometer, it is done as a template that must be specialized for
        each class).

        This subcontractor typically looks somewhat like this: Although this
        is discouraged, it is possible to override the following functions to
        customize how XML entities are parsed:    - setParameters() if low-
        level access to the      FactoryMessenger is required;    -
        setParameter(std::string name, std::string content,
        std::string unit)      to interpret an entity that does not match a
        Property      (e.g. alternative name);    -
        setParameter(Gyoto::Property const &p, std::string const &name,
        std::string const &content, std::string const &unit)      to change
        how a Property is interpreted. 
        """
        return _gyoto.UniformSpectrometer_setParameters(self, fmp)


    def __init__(self, *args):
        """
        Uniform() -> UniformSpectrometer
        Uniform(size_t nsamples, double band_min, double band_max, Gyoto::Spectrometer::kind_t kind) -> UniformSpectrometer
        Uniform(UniformSpectrometer arg2) -> UniformSpectrometer
        __init__(Gyoto::Spectrometer::Uniform self, Spectrometer base) -> UniformSpectrometer



        Copy constructor. 
        """
        this = _gyoto.new_UniformSpectrometer(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
UniformSpectrometer_swigregister = _gyoto.UniformSpectrometer_swigregister
UniformSpectrometer_swigregister(UniformSpectrometer)
UniformSpectrometer.properties = _gyoto.cvar.UniformSpectrometer_properties
UniformSpectrometer.WaveKind = _gyoto.cvar.UniformSpectrometer_WaveKind
UniformSpectrometer.WaveLogKind = _gyoto.cvar.UniformSpectrometer_WaveLogKind
UniformSpectrometer.FreqKind = _gyoto.cvar.UniformSpectrometer_FreqKind
UniformSpectrometer.FreqLogKind = _gyoto.cvar.UniformSpectrometer_FreqLogKind


def debug(*args):
    """
    debug(int mode)
    debug() -> int
    """
    return _gyoto.debug(*args)

def verbose(*args):
    """
    verbose(int mode)
    verbose() -> int
    """
    return _gyoto.verbose(*args)

def convert(x, nelem, mass_sun, distance_kpc, unit):
    """convert(double *const x, std::size_t const nelem, double const mass_sun, double const distance_kpc, std::string const unit)"""
    return _gyoto.convert(x, nelem, mass_sun, distance_kpc, unit)

def atof(str):
    """atof(char const * str) -> double"""
    return _gyoto.atof(str)

_gyoto.XERCES_INCLUDE_WCHAR_H_swigconstant(_gyoto)
XERCES_INCLUDE_WCHAR_H = _gyoto.XERCES_INCLUDE_WCHAR_H
class Factory(_object):
    """Proxy of C++ Gyoto::Factory class."""

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

    def __init__(self, *args):
        """
        __init__(Gyoto::Factory self, char * filename) -> Factory
        __init__(Gyoto::Factory self, Gyoto::SmartPointer< Gyoto::Scenery > sc) -> Factory
        __init__(Gyoto::Factory self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg) -> Factory
        __init__(Gyoto::Factory self, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > ao) -> Factory
        __init__(Gyoto::Factory self, Gyoto::SmartPointer< Gyoto::Spectrum::Generic > sp) -> Factory
        __init__(Gyoto::Factory self, Gyoto::SmartPointer< Gyoto::Screen > screen) -> Factory
        __init__(Gyoto::Factory self, Gyoto::SmartPointer< Gyoto::Photon > photon) -> Factory
        __init__(Gyoto::Factory self, Gyoto::SmartPointer< Gyoto::Spectrometer::Generic > Spectrometer) -> Factory
        """
        this = _gyoto.new_Factory(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Factory
    __del__ = lambda self: None

    def kind(self):
        """kind(Factory self) -> std::string const"""
        return _gyoto.Factory_kind(self)


    def getScenery(self):
        """getScenery(Factory self) -> Gyoto::SmartPointer< Gyoto::Scenery >"""
        return _gyoto.Factory_getScenery(self)


    def getPhoton(self):
        """getPhoton(Factory self) -> Gyoto::SmartPointer< Gyoto::Photon >"""
        return _gyoto.Factory_getPhoton(self)


    def spectrum(self):
        """spectrum(Factory self) -> Gyoto::SmartPointer< Gyoto::Spectrum::Generic >"""
        return _gyoto.Factory_spectrum(self)


    def spectrometer(self):
        """spectrometer(Factory self) -> Gyoto::SmartPointer< Gyoto::Spectrometer::Generic >"""
        return _gyoto.Factory_spectrometer(self)


    def write(self, fname=None):
        """
        write(Factory self, char const *const fname=None)
        write(Factory self)
        """
        return _gyoto.Factory_write(self, fname)


    def format(self):
        """format(Factory self) -> std::string"""
        return _gyoto.Factory_format(self)


    def metric(self, *args):
        """
        metric(Factory self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(Factory self, Gyoto::SmartPointer< Gyoto::Metric::Generic > gg, xercesc::DOMElement * el)
        """
        return _gyoto.Factory_metric(self, *args)


    def astrobj(self, *args):
        """
        astrobj(Factory self) -> Gyoto::SmartPointer< Gyoto::Astrobj::Generic >
        astrobj(Factory self, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > ao, xercesc::DOMElement * el)
        """
        return _gyoto.Factory_astrobj(self, *args)


    def screen(self, *args):
        """
        screen(Factory self) -> Gyoto::SmartPointer< Gyoto::Screen >
        screen(Factory self, Gyoto::SmartPointer< Gyoto::Screen > scr, xercesc::DOMElement * el)
        """
        return _gyoto.Factory_screen(self, *args)


    def setContent(self, content, el):
        """setContent(Factory self, std::string content, xercesc::DOMElement * el)"""
        return _gyoto.Factory_setContent(self, content, el)


    def setParameter(self, *args):
        """
        setParameter(Factory self, std::string name, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, double value, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, int value, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, unsigned int value, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, long value, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, unsigned long value, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, std::string value, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, double [] val, size_t nelem, xercesc::DOMElement * pel, Gyoto::FactoryMessenger ** child=None)
        setParameter(Factory self, std::string name, double [] val, size_t nelem, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, vector_double val, xercesc::DOMElement * pel, Gyoto::FactoryMessenger ** child=None)
        setParameter(Factory self, std::string name, vector_double val, xercesc::DOMElement * pel)
        setParameter(Factory self, std::string name, vector_unsigned_long val, xercesc::DOMElement * pel, Gyoto::FactoryMessenger ** child=None)
        setParameter(Factory self, std::string name, vector_unsigned_long val, xercesc::DOMElement * pel)
        """
        return _gyoto.Factory_setParameter(self, *args)


    def fullPath(self, relpath):
        """fullPath(Factory self, std::string relpath) -> std::string"""
        return _gyoto.Factory_fullPath(self, relpath)

Factory_swigregister = _gyoto.Factory_swigregister
Factory_swigregister(Factory)

class FactoryMessenger(_object):
    """Proxy of C++ Gyoto::FactoryMessenger class."""

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

    def __init__(self, *args):
        """
        __init__(Gyoto::FactoryMessenger self, Factory arg2, xercesc::DOMElement * arg3) -> FactoryMessenger
        __init__(Gyoto::FactoryMessenger self, FactoryMessenger parent, std::string arg3) -> FactoryMessenger
        """
        this = _gyoto.new_FactoryMessenger(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def reset(self):
        """reset(FactoryMessenger self)"""
        return _gyoto.FactoryMessenger_reset(self)


    def getPhoton(self):
        """getPhoton(FactoryMessenger self) -> Gyoto::SmartPointer< Gyoto::Photon >"""
        return _gyoto.FactoryMessenger_getPhoton(self)


    def getNextParameter(self, name, content, unit=None):
        """
        getNextParameter(FactoryMessenger self, std::string * name, std::string * content, std::string * unit=None) -> int
        getNextParameter(FactoryMessenger self, std::string * name, std::string * content) -> int
        """
        return _gyoto.FactoryMessenger_getNextParameter(self, name, content, unit)


    def getSelfAttribute(self, attrname):
        """getSelfAttribute(FactoryMessenger self, std::string attrname) -> std::string"""
        return _gyoto.FactoryMessenger_getSelfAttribute(self, attrname)


    def getAttribute(self, attrname):
        """getAttribute(FactoryMessenger self, std::string attrname) -> std::string"""
        return _gyoto.FactoryMessenger_getAttribute(self, attrname)


    def getFullContent(self):
        """getFullContent(FactoryMessenger self) -> std::string"""
        return _gyoto.FactoryMessenger_getFullContent(self)


    def getChild(self):
        """getChild(FactoryMessenger self) -> FactoryMessenger"""
        return _gyoto.FactoryMessenger_getChild(self)


    def fullPath(self, relpath):
        """fullPath(FactoryMessenger self, std::string relpath) -> std::string"""
        return _gyoto.FactoryMessenger_fullPath(self, relpath)


    def metric(self, *args):
        """
        metric(FactoryMessenger self) -> Gyoto::SmartPointer< Gyoto::Metric::Generic >
        metric(FactoryMessenger self, Gyoto::SmartPointer< Gyoto::Metric::Generic > arg2)
        """
        return _gyoto.FactoryMessenger_metric(self, *args)


    def astrobj(self, *args):
        """
        astrobj(FactoryMessenger self) -> Gyoto::SmartPointer< Gyoto::Astrobj::Generic >
        astrobj(FactoryMessenger self, Gyoto::SmartPointer< Gyoto::Astrobj::Generic > arg2)
        """
        return _gyoto.FactoryMessenger_astrobj(self, *args)


    def screen(self, *args):
        """
        screen(FactoryMessenger self) -> Gyoto::SmartPointer< Gyoto::Screen >
        screen(FactoryMessenger self, Gyoto::SmartPointer< Gyoto::Screen > arg2)
        """
        return _gyoto.FactoryMessenger_screen(self, *args)


    def setParameter(self, *args):
        """
        setParameter(FactoryMessenger self, std::string name)
        setParameter(FactoryMessenger self, std::string name, double value)
        setParameter(FactoryMessenger self, std::string name, long value)
        setParameter(FactoryMessenger self, std::string name, unsigned int value)
        setParameter(FactoryMessenger self, std::string name, unsigned long value)
        setParameter(FactoryMessenger self, std::string name, int value)
        setParameter(FactoryMessenger self, std::string name, std::string value)
        setParameter(FactoryMessenger self, std::string name, double [] val, size_t n, Gyoto::FactoryMessenger ** child=None)
        setParameter(FactoryMessenger self, std::string name, double [] val, size_t n)
        setParameter(FactoryMessenger self, std::string name, vector_double val, Gyoto::FactoryMessenger ** child=None)
        setParameter(FactoryMessenger self, std::string name, vector_double val)
        setParameter(FactoryMessenger self, std::string name, vector_unsigned_long val, Gyoto::FactoryMessenger ** child=None)
        setParameter(FactoryMessenger self, std::string name, vector_unsigned_long val)
        """
        return _gyoto.FactoryMessenger_setParameter(self, *args)


    def setSelfAttribute(self, *args):
        """
        setSelfAttribute(FactoryMessenger self, std::string attrname, std::string value)
        setSelfAttribute(FactoryMessenger self, std::string attrname, unsigned long value)
        setSelfAttribute(FactoryMessenger self, std::string attrname, unsigned int value)
        setSelfAttribute(FactoryMessenger self, std::string attrname, double value)
        """
        return _gyoto.FactoryMessenger_setSelfAttribute(self, *args)


    def setFullContent(self, value):
        """setFullContent(FactoryMessenger self, std::string value)"""
        return _gyoto.FactoryMessenger_setFullContent(self, value)


    def makeChild(self, name):
        """makeChild(FactoryMessenger self, std::string name) -> FactoryMessenger"""
        return _gyoto.FactoryMessenger_makeChild(self, name)


    def parseArray(*args):
        """
        parseArray(std::string src, double [] dst, size_t max_tokens) -> size_t
        parseArray(std::string src) -> vector_double
        """
        return _gyoto.FactoryMessenger_parseArray(*args)

    if _newclass:
        parseArray = staticmethod(parseArray)
    __swig_getmethods__["parseArray"] = lambda x: parseArray

    def parseArrayULong(src):
        """parseArrayULong(std::string src) -> vector_unsigned_long"""
        return _gyoto.FactoryMessenger_parseArrayULong(src)

    if _newclass:
        parseArrayULong = staticmethod(parseArrayULong)
    __swig_getmethods__["parseArrayULong"] = lambda x: parseArrayULong
    __swig_destroy__ = _gyoto.delete_FactoryMessenger
    __del__ = lambda self: None
FactoryMessenger_swigregister = _gyoto.FactoryMessenger_swigregister
FactoryMessenger_swigregister(FactoryMessenger)

def FactoryMessenger_parseArray(*args):
    """
    parseArray(std::string src, double [] dst, size_t max_tokens) -> size_t
    FactoryMessenger_parseArray(std::string src) -> vector_double
    """
    return _gyoto.FactoryMessenger_parseArray(*args)

def FactoryMessenger_parseArrayULong(src):
    """FactoryMessenger_parseArrayULong(std::string src) -> vector_unsigned_long"""
    return _gyoto.FactoryMessenger_parseArrayULong(src)

class ARRAY_double_2(_object):
    """Proxy of C++ boost::array<(double,2)> class."""

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

    def __getitem__(self, c):
        """__getitem__(ARRAY_double_2 self, size_t c) -> double"""
        return _gyoto.ARRAY_double_2___getitem__(self, c)


    def __init__(self):
        """__init__(boost::array<(double,2)> self) -> ARRAY_double_2"""
        this = _gyoto.new_ARRAY_double_2()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_ARRAY_double_2
    __del__ = lambda self: None
ARRAY_double_2_swigregister = _gyoto.ARRAY_double_2_swigregister
ARRAY_double_2_swigregister(ARRAY_double_2)

class ARRAY_size_t_2(_object):
    """Proxy of C++ boost::array<(size_t,2)> class."""

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

    def __getitem__(self, c):
        """__getitem__(ARRAY_size_t_2 self, size_t c) -> size_t"""
        return _gyoto.ARRAY_size_t_2___getitem__(self, c)


    def __init__(self):
        """__init__(boost::array<(size_t,2)> self) -> ARRAY_size_t_2"""
        this = _gyoto.new_ARRAY_size_t_2()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_ARRAY_size_t_2
    __del__ = lambda self: None
ARRAY_size_t_2_swigregister = _gyoto.ARRAY_size_t_2_swigregister
ARRAY_size_t_2_swigregister(ARRAY_size_t_2)

class Coord1dSet(_object):
    """


    Set of 1-d coordinates: indices or angles.

    Acts like a container (array-like) of either size_t (pixel coordinate)
    or double (angle) values. This container can be iterated-through using
    the operator++(), derefenced using the operator*() (if containing
    pixel coordinates) or angle() (in containing angles).

    C++ includes: GyotoScreen.h 
    """

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_getmethods__["kind"] = _gyoto.Coord1dSet_kind_get
    if _newclass:
        kind = _swig_property(_gyoto.Coord1dSet_kind_get)

    def begin(self):
        """
        begin(Coord1dSet self)



        Reset specifier to point to the first value. 
        """
        return _gyoto.Coord1dSet_begin(self)


    def valid(self):
        """
        valid(Coord1dSet self) -> bool



        True if pointing to something, false if end has been reached. 
        """
        return _gyoto.Coord1dSet_valid(self)


    def size(self):
        """
        size(Coord1dSet self) -> size_t



        Number of values in this container. 
        """
        return _gyoto.Coord1dSet_size(self)


    def __ref__(self):
        """__ref__(Coord1dSet self) -> size_t"""
        return _gyoto.Coord1dSet___ref__(self)


    def angle(self):
        """
        angle(Coord1dSet self) -> double



        Get double value currently pointed to. 
        """
        return _gyoto.Coord1dSet_angle(self)


    def increment(self):
        """increment(Coord1dSet self) -> Coord1dSet"""
        return _gyoto.Coord1dSet_increment(self)

    __swig_destroy__ = _gyoto.delete_Coord1dSet
    __del__ = lambda self: None
Coord1dSet_swigregister = _gyoto.Coord1dSet_swigregister
Coord1dSet_swigregister(Coord1dSet)

class Coord2dSet(_object):
    """


    Class to specify a set of points on the Screen.

    Container (array-like) holding several 2D points. Can be a 2D grid of
    pixel coordinates or a vector of floating-point (alpha, delta) pairs,
    for instance.

    C++ includes: GyotoScreen.h 
    """

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_getmethods__["kind"] = _gyoto.Coord2dSet_kind_get
    if _newclass:
        kind = _swig_property(_gyoto.Coord2dSet_kind_get)

    def increment(self):
        """increment(Coord2dSet self) -> Coord2dSet"""
        return _gyoto.Coord2dSet_increment(self)


    def __ref__(self):
        """__ref__(Coord2dSet self) -> ARRAY_size_t_2"""
        return _gyoto.Coord2dSet___ref__(self)


    def angles(self):
        """
        angles(Coord2dSet self) -> ARRAY_double_2



        Get angle coordinates. 
        """
        return _gyoto.Coord2dSet_angles(self)


    def begin(self):
        """
        begin(Coord2dSet self)



        Reset pointer. 
        """
        return _gyoto.Coord2dSet_begin(self)


    def valid(self):
        """
        valid(Coord2dSet self) -> bool



        Whether the end has not been passed. 
        """
        return _gyoto.Coord2dSet_valid(self)


    def size(self):
        """
        size(Coord2dSet self) -> size_t



        Number of positions contained. 
        """
        return _gyoto.Coord2dSet_size(self)

    __swig_destroy__ = _gyoto.delete_Coord2dSet
    __del__ = lambda self: None
Coord2dSet_swigregister = _gyoto.Coord2dSet_swigregister
Coord2dSet_swigregister(Coord2dSet)

class Grid(Coord2dSet):
    """


    Class containing 2D-points organized in a grid.

    C++ includes: GyotoScreen.h 
    """

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

    def __init__(self, iset, jset, p=None):
        """
        __init__(Grid self, Coord1dSet iset, Coord1dSet jset, char const *const p=None) -> Grid
        __init__(Grid self, Coord1dSet iset, Coord1dSet jset) -> Grid
        """
        this = _gyoto.new_Grid(iset, jset, p)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def increment(self):
        """increment(Grid self) -> Coord2dSet"""
        return _gyoto.Grid_increment(self)


    def __ref__(self):
        """__ref__(Grid self) -> ARRAY_size_t_2"""
        return _gyoto.Grid___ref__(self)


    def begin(self):
        """
        begin(Grid self)



        Reset pointer. 
        """
        return _gyoto.Grid_begin(self)


    def valid(self):
        """
        valid(Grid self) -> bool



        Whether the end has not been passed. 
        """
        return _gyoto.Grid_valid(self)


    def size(self):
        """
        size(Grid self) -> size_t



        Number of positions contained. 
        """
        return _gyoto.Grid_size(self)

    __swig_destroy__ = _gyoto.delete_Grid
    __del__ = lambda self: None
Grid_swigregister = _gyoto.Grid_swigregister
Grid_swigregister(Grid)

class Bucket(Coord2dSet):
    """


    Class containing arbitrary 2D-points.

    ispec_ and jspec_ must be the same size.

    C++ includes: GyotoScreen.h 
    """

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

    def __init__(self, iset, jset):
        """__init__(Bucket self, Coord1dSet iset, Coord1dSet jset) -> Bucket"""
        this = _gyoto.new_Bucket(iset, jset)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def increment(self):
        """increment(Bucket self) -> Coord2dSet"""
        return _gyoto.Bucket_increment(self)


    def angles(self):
        """
        angles(Bucket self) -> ARRAY_double_2



        Get angle coordinates. 
        """
        return _gyoto.Bucket_angles(self)


    def __ref__(self):
        """__ref__(Bucket self) -> ARRAY_size_t_2"""
        return _gyoto.Bucket___ref__(self)


    def begin(self):
        """
        begin(Bucket self)



        Reset pointer. 
        """
        return _gyoto.Bucket_begin(self)


    def valid(self):
        """
        valid(Bucket self) -> bool



        Whether the end has not been passed. 
        """
        return _gyoto.Bucket_valid(self)


    def size(self):
        """
        size(Bucket self) -> size_t



        Number of positions contained. 
        """
        return _gyoto.Bucket_size(self)

    __swig_destroy__ = _gyoto.delete_Bucket
    __del__ = lambda self: None
Bucket_swigregister = _gyoto.Bucket_swigregister
Bucket_swigregister(Bucket)

class Empty(Coord2dSet):
    """


    A dummy, empty 2D set.

    C++ includes: GyotoScreen.h 
    """

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

    def __init__(self):
        """__init__(Empty self) -> Empty"""
        this = _gyoto.new_Empty()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def increment(self):
        """increment(Empty self) -> Coord2dSet"""
        return _gyoto.Empty_increment(self)


    def begin(self):
        """
        begin(Empty self)



        Reset pointer. 
        """
        return _gyoto.Empty_begin(self)


    def valid(self):
        """
        valid(Empty self) -> bool



        Whether the end has not been passed. 
        """
        return _gyoto.Empty_valid(self)


    def size(self):
        """
        size(Empty self) -> size_t



        Number of positions contained. 
        """
        return _gyoto.Empty_size(self)

    __swig_destroy__ = _gyoto.delete_Empty
    __del__ = lambda self: None
Empty_swigregister = _gyoto.Empty_swigregister
Empty_swigregister(Empty)

class Range(Coord1dSet):
    """


    1D coordinated specifier for a range

    C++ includes: GyotoScreen.h 
    """

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

    def __init__(self, mi, ma, d):
        """
        __init__(Range self, size_t mi, size_t ma, size_t d) -> Range



        Specify min, max and step of this range. 
        """
        this = _gyoto.new_Range(mi, ma, d)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def begin(self):
        """
        begin(Range self)



        Reset specifier to point to the first value. 
        """
        return _gyoto.Range_begin(self)


    def valid(self):
        """
        valid(Range self) -> bool



        True if pointing to something, false if end has been reached. 
        """
        return _gyoto.Range_valid(self)


    def size(self):
        """
        size(Range self) -> size_t



        Number of values in this container. 
        """
        return _gyoto.Range_size(self)


    def increment(self):
        """increment(Range self) -> Coord1dSet"""
        return _gyoto.Range_increment(self)


    def __ref__(self):
        """__ref__(Range self) -> size_t"""
        return _gyoto.Range___ref__(self)

    __swig_destroy__ = _gyoto.delete_Range
    __del__ = lambda self: None
Range_swigregister = _gyoto.Range_swigregister
Range_swigregister(Range)

class Indices(Coord1dSet):
    """


    1D specifier for an arbitrary pixel coordinate set.

    C++ includes: GyotoScreen.h 
    """

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

    def begin(self):
        """
        begin(Indices self)



        Reset specifier to point to the first value. 
        """
        return _gyoto.Indices_begin(self)


    def valid(self):
        """
        valid(Indices self) -> bool



        True if pointing to something, false if end has been reached. 
        """
        return _gyoto.Indices_valid(self)


    def size(self):
        """
        size(Indices self) -> size_t



        Number of values in this container. 
        """
        return _gyoto.Indices_size(self)


    def increment(self):
        """increment(Indices self) -> Coord1dSet"""
        return _gyoto.Indices_increment(self)


    def __ref__(self):
        """__ref__(Indices self) -> size_t"""
        return _gyoto.Indices___ref__(self)


    def __init__(self, *args):
        """
        __init__(Indices self, size_t * carray, size_t nel) -> Indices
        __init__(Indices self, size_t DIM1) -> Indices
        """
        this = _gyoto.new_Indices(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Indices
    __del__ = lambda self: None
Indices_swigregister = _gyoto.Indices_swigregister
Indices_swigregister(Indices)

class Angles(Coord1dSet):
    """


    1D specifier for an arbitrary angle coordinate set.

    C++ includes: GyotoScreen.h 
    """

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

    def begin(self):
        """
        begin(Angles self)



        Reset specifier to point to the first value. 
        """
        return _gyoto.Angles_begin(self)


    def valid(self):
        """
        valid(Angles self) -> bool



        True if pointing to something, false if end has been reached. 
        """
        return _gyoto.Angles_valid(self)


    def size(self):
        """
        size(Angles self) -> size_t



        Number of values in this container. 
        """
        return _gyoto.Angles_size(self)


    def increment(self):
        """increment(Angles self) -> Coord1dSet"""
        return _gyoto.Angles_increment(self)


    def angle(self):
        """
        angle(Angles self) -> double



        Get double value currently pointed to. 
        """
        return _gyoto.Angles_angle(self)


    def __init__(self, *args):
        """
        __init__(Angles self, double * carray, size_t nel) -> Angles
        __init__(Angles self, size_t DIM1) -> Angles
        """
        this = _gyoto.new_Angles(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Angles
    __del__ = lambda self: None
Angles_swigregister = _gyoto.Angles_swigregister
Angles_swigregister(Angles)

class RepeatAngle(Coord1dSet):
    """


    1D specifier for an angle that is repeated.

    C++ includes: GyotoScreen.h 
    """

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

    def __init__(self, val, sz):
        """__init__(RepeatAngle self, double val, size_t sz) -> RepeatAngle"""
        this = _gyoto.new_RepeatAngle(val, sz)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def begin(self):
        """
        begin(RepeatAngle self)



        Reset specifier to point to the first value. 
        """
        return _gyoto.RepeatAngle_begin(self)


    def valid(self):
        """
        valid(RepeatAngle self) -> bool



        True if pointing to something, false if end has been reached. 
        """
        return _gyoto.RepeatAngle_valid(self)


    def size(self):
        """
        size(RepeatAngle self) -> size_t



        Number of values in this container. 
        """
        return _gyoto.RepeatAngle_size(self)


    def increment(self):
        """increment(RepeatAngle self) -> Coord1dSet"""
        return _gyoto.RepeatAngle_increment(self)


    def angle(self):
        """
        angle(RepeatAngle self) -> double



        Get double value currently pointed to. 
        """
        return _gyoto.RepeatAngle_angle(self)

    __swig_destroy__ = _gyoto.delete_RepeatAngle
    __del__ = lambda self: None
RepeatAngle_swigregister = _gyoto.RepeatAngle_swigregister
RepeatAngle_swigregister(RepeatAngle)

class Property(_object):
    """


    Property that can be set and got using standard methods.

    The Property API makes it easy to declare the parameters that can be
    set in a class.

    Developpers who simply write classes (deriving from Astrobj::Generic,
    , Metric::Generic, Spectrum::Generic) need not know the inners of the
    Property class and interact with it only using macros to declare the
    parameters they need to read from XML.

    To make use of the Property framework, a class must derive from
    Gyoto::Object and use the GYOTO_OBJECT in a public section of the
    class declaration (i.e. in the .h file). Then, in the corresponding .C
    file, the GYOTO_PROPERTY_* macros are used as follows (note the
    absence of punctuation after the macros):

    In the above, GYOTO_PROPERTY_START starts the definition of the static
    member MyClass::properties. Each GYOTO_PROPERTY_<type> macro declares
    a new property. GYOTO_PROPERTY_END ends the definition of the property
    list, with an optional pointer to the parent's class Property list,
    and defines the MyClass::getProperties() method.

    The underlying accessors must always be defined, both to set and to
    get the property. For the sake of simplicity, only a limited number of
    data types are allowed: double: see GYOTO_PROPERTY_DOUBLE,
    GYOTO_PROPERTY_DOUBLE_UNIT;

    long: see GYOTO_PROPERTY_LONG;

    unsigned long: see GYOTO_PROPERTY_UNSIGNED_LONG (a.k.a. size_t: see
    #GYOTO_PROPERTY_SIZE_T, this may break on architectures where size_t
    is not the same as unsigned long);

    bool: see GYOTO_PROPERTY_BOOL;

    std::vector<double>: see GYOTO_PROPERTY_VECTOR_DOUBLE and
    GYOTO_PROPERTY_VECTOR_DOUBLE_UNIT;

    std::vector<unsigned long>: see GYOTO_PROPERTY_VECTOR_UNSIGNED_LONG;

    Gyoto::SmartPointers to various base classes: Screen, Metric::Generic,
    Astrobj::Generic, Spectrum::Generic and Spectrometer::Generic. See
    GYOTO_PROPERTY_METRIC, GYOTO_PROPERTY_SCREEN, GYOTO_PROPERTY_ASTROBJ,
    GYOTO_PROPERTY_SPECTRUM and GYOTO_PROPERTY_SPECTROMETER.

    For the floating point data-types (double and vector<double>), two
    additional accessors supporting units can be provided. The accessors
    must have the same name and have specific prototypes, see the various
    function pointer typedefs, e.g. set_double_t and get_double_t.

    The type used in these accessors may not be the same as the type of
    the underlying class member. For instance, to read an array, it was
    chosen to use the std::vector<type> type because it is easy to read
    such a vector from XML and to thus determine dynamically the number of
    elements provided. But this type is slow, so it is expected that the
    class member will rather be a C-style array (double arr[]) or
    something else entirely. It is not forbidden to have a set of high-
    level accessors for the Property interface on top of lower-level, more
    efficient accessors to be used in compiled, static code:

    In this example, assuming MyClass is based directly on Object and
    member_ is the only parameter to read from XML, the Property list may
    be defined as:

    Again, nothing more is required to read and write ArrayMember from XML
    and from Yorick.

    C++ includes: GyotoProperty.h 
    """

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    double_t = _gyoto.Property_double_t
    long_t = _gyoto.Property_long_t
    unsigned_long_t = _gyoto.Property_unsigned_long_t
    bool_t = _gyoto.Property_bool_t
    string_t = _gyoto.Property_string_t
    filename_t = _gyoto.Property_filename_t
    vector_double_t = _gyoto.Property_vector_double_t
    vector_unsigned_long_t = _gyoto.Property_vector_unsigned_long_t
    metric_t = _gyoto.Property_metric_t
    screen_t = _gyoto.Property_screen_t
    astrobj_t = _gyoto.Property_astrobj_t
    spectrum_t = _gyoto.Property_spectrum_t
    spectrometer_t = _gyoto.Property_spectrometer_t
    empty_t = _gyoto.Property_empty_t
    __swig_setmethods__["name"] = _gyoto.Property_name_set
    __swig_getmethods__["name"] = _gyoto.Property_name_get
    if _newclass:
        name = _swig_property(_gyoto.Property_name_get, _gyoto.Property_name_set)
    __swig_setmethods__["name_false"] = _gyoto.Property_name_false_set
    __swig_getmethods__["name_false"] = _gyoto.Property_name_false_get
    if _newclass:
        name_false = _swig_property(_gyoto.Property_name_false_get, _gyoto.Property_name_false_set)
    __swig_setmethods__["type"] = _gyoto.Property_type_set
    __swig_getmethods__["type"] = _gyoto.Property_type_get
    if _newclass:
        type = _swig_property(_gyoto.Property_type_get, _gyoto.Property_type_set)
    __swig_setmethods__["setter"] = _gyoto.Property_setter_set
    __swig_getmethods__["setter"] = _gyoto.Property_setter_get
    if _newclass:
        setter = _swig_property(_gyoto.Property_setter_get, _gyoto.Property_setter_set)
    __swig_setmethods__["getter"] = _gyoto.Property_getter_set
    __swig_getmethods__["getter"] = _gyoto.Property_getter_get
    if _newclass:
        getter = _swig_property(_gyoto.Property_getter_get, _gyoto.Property_getter_set)
    __swig_setmethods__["setter_unit"] = _gyoto.Property_setter_unit_set
    __swig_getmethods__["setter_unit"] = _gyoto.Property_setter_unit_get
    if _newclass:
        setter_unit = _swig_property(_gyoto.Property_setter_unit_get, _gyoto.Property_setter_unit_set)
    __swig_setmethods__["getter_unit"] = _gyoto.Property_getter_unit_set
    __swig_getmethods__["getter_unit"] = _gyoto.Property_getter_unit_get
    if _newclass:
        getter_unit = _swig_property(_gyoto.Property_getter_unit_get, _gyoto.Property_getter_unit_set)

    def __nonzero__(self):
        return _gyoto.Property___nonzero__(self)
    __bool__ = __nonzero__


    __swig_getmethods__["parent"] = _gyoto.Property_parent_get
    if _newclass:
        parent = _swig_property(_gyoto.Property_parent_get)
    __swig_destroy__ = _gyoto.delete_Property
    __del__ = lambda self: None
Property_swigregister = _gyoto.Property_swigregister
Property_swigregister(Property)


def getSystem():
    """
    getSystem() -> ut_system *



    Retrieve the unit system used in all of Gyoto. 
    """
    return _gyoto.getSystem()

def Init():
    """
    Init()



    Load and initialize all (non-context-sensitive) units.

    If udunits is used (preprocessor macro HAVE_UDUNITS), Init()
    initializes the ut_system used throughout Gyoto and maps a few
    additional units to the unit system. 
    """
    return _gyoto.Init()

def ToMeters(value, unit, gg=0):
    """
    ToMeters(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg=0) -> double
    ToMeters(double value, std::string const & unit) -> double



    Convert from arbitrary length unit to meters.

    Convert value from unit represented by "unit" to meters.

    If gg is provided (and not NULL), use it to interpret the string
    "geometrical" as representing gg->
    Gyoto::Metric::Generic::unitLength().

    ToMeters() will also convert time, frequency and energy units to
    meters (as in frequency -> wavelength).

    Parameters:
    -----------

    value:  (double) the value to convert, expressed according to "unit"

    unit:  (std::string) the "unit" from which to convert, e.g. "km",
    "sunradius" or "geometrical". More units are supported if Gyoto
    was compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &, NULL if not
    specified) optional metric to interpret "geometrical".

    value, expressed in meters. 
    """
    return _gyoto.ToMeters(value, unit, gg)

def FromMeters(value, unit, gg=0):
    """
    FromMeters(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg=0) -> double
    FromMeters(double value, std::string const & unit) -> double



    Convert to arbitrary length unit from meters.

    Convert value to unit represented by "unit" from meters.

    If gg is provided (and not NULL), use it to interpret the string
    "geometrical" as representing gg->
    Gyoto::Metric::Generic::unitLength().

    ToMeters() will also convert to time, frequency and energy units (as
    in wavelength -> frequency).

    Parameters:
    -----------

    value:  (double) the value to convert, expressed in meters.

    unit:  (std::string) the "unit" to which to convert, e.g. "km",
    "sunradius" or "geometrical". More units are supported if Gyoto
    was compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &, NULL if not
    specified) optional metric to interpret "geometrical".

    value, expressed in "unit". 
    """
    return _gyoto.FromMeters(value, unit, gg)

def ToSeconds(value, unit, gg=0):
    """
    ToSeconds(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg=0) -> double
    ToSeconds(double value, std::string const & unit) -> double



    Convert from arbitrary time unit to seconds.

    Convert value from unit represented by "unit" to seconds.

    If gg is provided (and not NULL), use it to interpret the string
    "geometrical_time" as representing gg->
    Gyoto::Metric::Generic::unitLength()/GYOTO_C.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed according to "unit"

    unit:  (std::string) the "unit" from which to convert, e.g. "s",
    "yr" or "geometrical_time". More units are supported if Gyoto was
    compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &, NULL if not
    specified) optional metric to interpret "geometrical".

    value, expressed in seconds. 
    """
    return _gyoto.ToSeconds(value, unit, gg)

def FromSeconds(value, unit, gg=0):
    """
    FromSeconds(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg=0) -> double
    FromSeconds(double value, std::string const & unit) -> double



    Convert to arbitrary time unit from seconds.

    Convert value to unit represented by "unit" from seconds.

    If gg is provided (and not NULL), use it to interpret the string
    "geometrical_time" as representing gg->
    Gyoto::Metric::Generic::unitLength()/GYOTO_C.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed in seconds.

    unit:  (std::string) the "unit" to which to convert, e.g. "s",
    "yr" or "geometrical_time". More units are supported if Gyoto was
    compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &, NULL if not
    specified) optional metric to interpret "geometrical".

    value, expressed in "unit". 
    """
    return _gyoto.FromSeconds(value, unit, gg)

def ToKilograms(value, unit):
    """
    ToKilograms(double value, std::string const & unit) -> double



    Convert from arbitrary mass unit to kilograms.

    Convert value from unit represented by "unit" to kilograms.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed according to "unit"

    unit:  (std::string) the "unit" from which to convert, e.g. "g",
    "kg" or "sunmass". More units are supported if Gyoto was compiled
    with udunits support.

    value, expressed in kilograms. 
    """
    return _gyoto.ToKilograms(value, unit)

def FromKilograms(value, unit):
    """
    FromKilograms(double value, std::string const & unit) -> double



    Convert to arbitrary mass unit from kilograms.

    Convert value from unit represented by "unit" from kilograms.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed inkilograms.

    unit:  (std::string) the "unit" to which to convert, e.g. "g",
    "kg" or "sunmass". More units are supported if Gyoto was compiled
    with udunits support.

    value, expressed in "unit". 
    """
    return _gyoto.FromKilograms(value, unit)

def ToGeometrical(value, unit, gg):
    """
    ToGeometrical(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg) -> double



    Convert from arbitrary length unit to geometrical units.

    Convert value from unit represented by "unit" to geometrical units.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed according to
    "unit".

    unit:  (std::string) the "unit" from which to convert, e.g. "km",
    "sunradius" or "geometrical". More units are supported if Gyoto
    was compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &) metric to
    interpret "geometrical".

    value, expressed in geometrical units. 
    """
    return _gyoto.ToGeometrical(value, unit, gg)

def FromGeometrical(value, unit, gg):
    """
    FromGeometrical(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg) -> double



    Convert to arbitrary length unit from geometrical units.

    Convert value to unit represented by "unit" from geometrical units.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed in geometrical units.

    unit:  (std::string) the "unit" to which to convert, e.g. "km",
    "sunradius" or "geometrical". More units are supported if Gyoto
    was compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &) metric to
    interpret "geometrical".

    value, expressed in "unit". 
    """
    return _gyoto.FromGeometrical(value, unit, gg)

def ToGeometricalTime(value, unit, gg):
    """
    ToGeometricalTime(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg) -> double



    Convert from arbitrary time unit to geometrical units.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed according to
    "unit".

    unit:  (std::string) the "unit" from which to convert, e.g. "s",
    "kyr" or "geometrical_time". More units are supported if Gyoto was
    compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &) metric to
    interpret "geometrical_time".

    value, expressed in geometrical (time) units. 
    """
    return _gyoto.ToGeometricalTime(value, unit, gg)

def FromGeometricalTime(value, unit, gg):
    """
    FromGeometricalTime(double value, std::string const & unit, Gyoto::SmartPointer< Gyoto::Metric::Generic > const & gg) -> double



    Convert to arbitrary time unit from geometrical units.

    Parameters:
    -----------

    value:  (double) the value to convert, expressed in geometrical units.

    unit:  (std::string) the "unit" to which to convert, e.g. "yr",
    "s" or "geometrical_time". More units are supported if Gyoto was
    compiled with udunits support.

    gg:  (const Gyoto::SmartPointer<Gyoto::Metric::Generic> &) metric to
    interpret "geometrical_time".

    value, expressed in "unit". 
    """
    return _gyoto.FromGeometricalTime(value, unit, gg)

def ToHerz(value, unit):
    """
    ToHerz(double value, std::string const & unit) -> double



    Convert from arbitrary frequency unit to Herz.

    ToHerz will also convert from length and energy units (such as
    "eV").

    Parameters:
    -----------

    value:  (double) the value to convert, expressed according to
    "unit".

    unit:  (std::string) the "unit" from which to convert, e.g. "MHz",
    "keV"

    value, expressed in "Hz". 
    """
    return _gyoto.ToHerz(value, unit)

def FromHerz(value, unit):
    """
    FromHerz(double value, std::string const & unit) -> double



    Convert to arbitrary frequency unit from Herz.

    FromHerz will also convert to length and energy units (such as
    "eV").

    Parameters:
    -----------

    value:  (double) the value to convert, expressed according in "Hz".

    unit:  (std::string) the "unit" from which to convert, e.g. "MHz",
    "keV"

    value, expressed in "units". 
    """
    return _gyoto.FromHerz(value, unit)

def areConvertible(unit1, unit2):
    """
    areConvertible(Unit unit1, Unit unit2) -> bool



    Is it possible to convert between unit1 and unit2?

    e.g. areConvertible("m", "kg") == 0; areConvertible("m",
    "km")==1.

    Warning: angle units are dimensionless, therefore e.g.
    areConvertible("Jy", "Jy/microacsec2")==1. Numerically, "Jy" is
    the same as "Jy/sr2".

    Parameters:
    -----------

    unit1:  ( Gyoto::Units::Unit) first unit

    unit2:  ( Gyoto::Units::Unit) second unit

    bool, True if it is possible to convert between the two units, 0
    otherwise. 
    """
    return _gyoto.areConvertible(unit1, unit2)
class Unit(SmartPointee):
    """


    Wrapper around ut_unit from udunits.

    Gyoto::Units::Unit objects usually cast seamlessly to and from
    udunits2 ut_unit* and std::string.

    C++ includes: GyotoConverters.h 
    """

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

    def __init__(self, *args):
        """
        __init__(Gyoto::Units::Unit self, std::string const & unit) -> Unit
        __init__(Gyoto::Units::Unit self, char const *const unit) -> Unit



        Build Unit described by C string.

        Throws a Gyoto::Error if anything goes wrong.

        Parameters:
        -----------

        unit:  char const * const description of the unit, e.g. "mJy/sr2" or
        "sunmass". 
        """
        this = _gyoto.new_Unit(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Unit
    __del__ = lambda self: None

    def To(self, val, from_unit):
        """
        To(Unit self, double val, Unit from_unit) -> double



        Convert to Unit.

        Parameters:
        -----------

        val:  double to convert

        from_unit:   Unit from which to convert

        value converted to unit_. 
        """
        return _gyoto.Unit_To(self, val, from_unit)


    def From(self, val, to_unit):
        """
        From(Unit self, double val, Unit to_unit) -> double



        Convert from Unit.

        Parameters:
        -----------

        val:  double to convert

        to_unit:   Unit to which to convert

        value converted to "to_unit". 
        """
        return _gyoto.Unit_From(self, val, to_unit)

Unit_swigregister = _gyoto.Unit_swigregister
Unit_swigregister(Unit)

class Converter(SmartPointee):
    """


    Wrapper around ut_converter from udunits.

    A Gyoto::Units::Converter object is a functor and can be used to
    convert efficiently between the two units specified at instantiation
    time:

    Since std::string cast automatically to Gyoto::Units::Unit object,
    this is equivalent:

    C++ includes: GyotoConverters.h 
    """

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

    def __init__(self, *args):
        """
        __init__(Gyoto::Units::Converter self) -> Converter
        __init__(Gyoto::Units::Converter self, Unit arg2, Unit to) -> Converter



        Construct Converter from two Unit. 
        """
        this = _gyoto.new_Converter(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _gyoto.delete_Converter
    __del__ = lambda self: None

    def reset(self, *args):
        """
        reset(Converter self)
        reset(Converter self, Unit arg2, Unit to)



        Reset to converter from "from" to "to". 
        """
        return _gyoto.Converter_reset(self, *args)


    def __call__(self, value):
        """__call__(Converter self, double value) -> double"""
        return _gyoto.Converter___call__(self, value)

Converter_swigregister = _gyoto.Converter_swigregister
Converter_swigregister(Converter)

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