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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __nonzero__(self):
        return _hklfile.UnsignedIntVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.UnsignedIntVector___bool__(self)

    def __len__(self):
        return _hklfile.UnsignedIntVector___len__(self)

    def pop(self):
        return _hklfile.UnsignedIntVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.UnsignedIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.UnsignedIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.UnsignedIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.UnsignedIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.UnsignedIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.UnsignedIntVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.UnsignedIntVector_append(self, x)

    def empty(self):
        return _hklfile.UnsignedIntVector_empty(self)

    def size(self):
        return _hklfile.UnsignedIntVector_size(self)

    def clear(self):
        return _hklfile.UnsignedIntVector_clear(self)

    def swap(self, v):
        return _hklfile.UnsignedIntVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.UnsignedIntVector_get_allocator(self)

    def begin(self):
        return _hklfile.UnsignedIntVector_begin(self)

    def end(self):
        return _hklfile.UnsignedIntVector_end(self)

    def rbegin(self):
        return _hklfile.UnsignedIntVector_rbegin(self)

    def rend(self):
        return _hklfile.UnsignedIntVector_rend(self)

    def pop_back(self):
        return _hklfile.UnsignedIntVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.UnsignedIntVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_UnsignedIntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.UnsignedIntVector_push_back(self, x)

    def front(self):
        return _hklfile.UnsignedIntVector_front(self)

    def back(self):
        return _hklfile.UnsignedIntVector_back(self)

    def assign(self, n, x):
        return _hklfile.UnsignedIntVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.UnsignedIntVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.UnsignedIntVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.UnsignedIntVector_reserve(self, n)

    def capacity(self):
        return _hklfile.UnsignedIntVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_UnsignedIntVector
    __del__ = lambda self: None
UnsignedIntVector_swigregister = _hklfile.UnsignedIntVector_swigregister
UnsignedIntVector_swigregister(UnsignedIntVector)

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

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

    def __nonzero__(self):
        return _hklfile.IntVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.IntVector___bool__(self)

    def __len__(self):
        return _hklfile.IntVector___len__(self)

    def pop(self):
        return _hklfile.IntVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.IntVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.IntVector_append(self, x)

    def empty(self):
        return _hklfile.IntVector_empty(self)

    def size(self):
        return _hklfile.IntVector_size(self)

    def clear(self):
        return _hklfile.IntVector_clear(self)

    def swap(self, v):
        return _hklfile.IntVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.IntVector_get_allocator(self)

    def begin(self):
        return _hklfile.IntVector_begin(self)

    def end(self):
        return _hklfile.IntVector_end(self)

    def rbegin(self):
        return _hklfile.IntVector_rbegin(self)

    def rend(self):
        return _hklfile.IntVector_rend(self)

    def pop_back(self):
        return _hklfile.IntVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_IntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.IntVector_push_back(self, x)

    def front(self):
        return _hklfile.IntVector_front(self)

    def back(self):
        return _hklfile.IntVector_back(self)

    def assign(self, n, x):
        return _hklfile.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.IntVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.IntVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.IntVector_reserve(self, n)

    def capacity(self):
        return _hklfile.IntVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _hklfile.IntVector_swigregister
IntVector_swigregister(IntVector)

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

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

    def __nonzero__(self):
        return _hklfile.IntIntVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.IntIntVector___bool__(self)

    def __len__(self):
        return _hklfile.IntIntVector___len__(self)

    def pop(self):
        return _hklfile.IntIntVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.IntIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.IntIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.IntIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.IntIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.IntIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.IntIntVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.IntIntVector_append(self, x)

    def empty(self):
        return _hklfile.IntIntVector_empty(self)

    def size(self):
        return _hklfile.IntIntVector_size(self)

    def clear(self):
        return _hklfile.IntIntVector_clear(self)

    def swap(self, v):
        return _hklfile.IntIntVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.IntIntVector_get_allocator(self)

    def begin(self):
        return _hklfile.IntIntVector_begin(self)

    def end(self):
        return _hklfile.IntIntVector_end(self)

    def rbegin(self):
        return _hklfile.IntIntVector_rbegin(self)

    def rend(self):
        return _hklfile.IntIntVector_rend(self)

    def pop_back(self):
        return _hklfile.IntIntVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.IntIntVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_IntIntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.IntIntVector_push_back(self, x)

    def front(self):
        return _hklfile.IntIntVector_front(self)

    def back(self):
        return _hklfile.IntIntVector_back(self)

    def assign(self, n, x):
        return _hklfile.IntIntVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.IntIntVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.IntIntVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.IntIntVector_reserve(self, n)

    def capacity(self):
        return _hklfile.IntIntVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_IntIntVector
    __del__ = lambda self: None
IntIntVector_swigregister = _hklfile.IntIntVector_swigregister
IntIntVector_swigregister(IntIntVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __nonzero__(self):
        return _hklfile.DoubleDoubleVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.DoubleDoubleVector___bool__(self)

    def __len__(self):
        return _hklfile.DoubleDoubleVector___len__(self)

    def pop(self):
        return _hklfile.DoubleDoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.DoubleDoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.DoubleDoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.DoubleDoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.DoubleDoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.DoubleDoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.DoubleDoubleVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.DoubleDoubleVector_append(self, x)

    def empty(self):
        return _hklfile.DoubleDoubleVector_empty(self)

    def size(self):
        return _hklfile.DoubleDoubleVector_size(self)

    def clear(self):
        return _hklfile.DoubleDoubleVector_clear(self)

    def swap(self, v):
        return _hklfile.DoubleDoubleVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.DoubleDoubleVector_get_allocator(self)

    def begin(self):
        return _hklfile.DoubleDoubleVector_begin(self)

    def end(self):
        return _hklfile.DoubleDoubleVector_end(self)

    def rbegin(self):
        return _hklfile.DoubleDoubleVector_rbegin(self)

    def rend(self):
        return _hklfile.DoubleDoubleVector_rend(self)

    def pop_back(self):
        return _hklfile.DoubleDoubleVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.DoubleDoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_DoubleDoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.DoubleDoubleVector_push_back(self, x)

    def front(self):
        return _hklfile.DoubleDoubleVector_front(self)

    def back(self):
        return _hklfile.DoubleDoubleVector_back(self)

    def assign(self, n, x):
        return _hklfile.DoubleDoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.DoubleDoubleVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.DoubleDoubleVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.DoubleDoubleVector_reserve(self, n)

    def capacity(self):
        return _hklfile.DoubleDoubleVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_DoubleDoubleVector
    __del__ = lambda self: None
DoubleDoubleVector_swigregister = _hklfile.DoubleDoubleVector_swigregister
DoubleDoubleVector_swigregister(DoubleDoubleVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __nonzero__(self):
        return _hklfile.XtalDatasetInfoVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.XtalDatasetInfoVector___bool__(self)

    def __len__(self):
        return _hklfile.XtalDatasetInfoVector___len__(self)

    def pop(self):
        return _hklfile.XtalDatasetInfoVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.XtalDatasetInfoVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.XtalDatasetInfoVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.XtalDatasetInfoVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.XtalDatasetInfoVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.XtalDatasetInfoVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.XtalDatasetInfoVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.XtalDatasetInfoVector_append(self, x)

    def empty(self):
        return _hklfile.XtalDatasetInfoVector_empty(self)

    def size(self):
        return _hklfile.XtalDatasetInfoVector_size(self)

    def clear(self):
        return _hklfile.XtalDatasetInfoVector_clear(self)

    def swap(self, v):
        return _hklfile.XtalDatasetInfoVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.XtalDatasetInfoVector_get_allocator(self)

    def begin(self):
        return _hklfile.XtalDatasetInfoVector_begin(self)

    def end(self):
        return _hklfile.XtalDatasetInfoVector_end(self)

    def rbegin(self):
        return _hklfile.XtalDatasetInfoVector_rbegin(self)

    def rend(self):
        return _hklfile.XtalDatasetInfoVector_rend(self)

    def pop_back(self):
        return _hklfile.XtalDatasetInfoVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.XtalDatasetInfoVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_XtalDatasetInfoVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.XtalDatasetInfoVector_push_back(self, x)

    def front(self):
        return _hklfile.XtalDatasetInfoVector_front(self)

    def back(self):
        return _hklfile.XtalDatasetInfoVector_back(self)

    def assign(self, n, x):
        return _hklfile.XtalDatasetInfoVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.XtalDatasetInfoVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.XtalDatasetInfoVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.XtalDatasetInfoVector_reserve(self, n)

    def capacity(self):
        return _hklfile.XtalDatasetInfoVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_XtalDatasetInfoVector
    __del__ = lambda self: None
XtalDatasetInfoVector_swigregister = _hklfile.XtalDatasetInfoVector_swigregister
XtalDatasetInfoVector_swigregister(XtalDatasetInfoVector)

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

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

    def __nonzero__(self):
        return _hklfile.ColumnDataVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.ColumnDataVector___bool__(self)

    def __len__(self):
        return _hklfile.ColumnDataVector___len__(self)

    def pop(self):
        return _hklfile.ColumnDataVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.ColumnDataVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.ColumnDataVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.ColumnDataVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.ColumnDataVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.ColumnDataVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.ColumnDataVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.ColumnDataVector_append(self, x)

    def empty(self):
        return _hklfile.ColumnDataVector_empty(self)

    def size(self):
        return _hklfile.ColumnDataVector_size(self)

    def clear(self):
        return _hklfile.ColumnDataVector_clear(self)

    def swap(self, v):
        return _hklfile.ColumnDataVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.ColumnDataVector_get_allocator(self)

    def begin(self):
        return _hklfile.ColumnDataVector_begin(self)

    def end(self):
        return _hklfile.ColumnDataVector_end(self)

    def rbegin(self):
        return _hklfile.ColumnDataVector_rbegin(self)

    def rend(self):
        return _hklfile.ColumnDataVector_rend(self)

    def pop_back(self):
        return _hklfile.ColumnDataVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.ColumnDataVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_ColumnDataVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.ColumnDataVector_push_back(self, x)

    def front(self):
        return _hklfile.ColumnDataVector_front(self)

    def back(self):
        return _hklfile.ColumnDataVector_back(self)

    def assign(self, n, x):
        return _hklfile.ColumnDataVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.ColumnDataVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.ColumnDataVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.ColumnDataVector_reserve(self, n)

    def capacity(self):
        return _hklfile.ColumnDataVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_ColumnDataVector
    __del__ = lambda self: None
ColumnDataVector_swigregister = _hklfile.ColumnDataVector_swigregister
ColumnDataVector_swigregister(ColumnDataVector)

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

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

    def __nonzero__(self):
        return _hklfile.ColumnStatisticsVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.ColumnStatisticsVector___bool__(self)

    def __len__(self):
        return _hklfile.ColumnStatisticsVector___len__(self)

    def pop(self):
        return _hklfile.ColumnStatisticsVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.ColumnStatisticsVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.ColumnStatisticsVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.ColumnStatisticsVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.ColumnStatisticsVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.ColumnStatisticsVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.ColumnStatisticsVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.ColumnStatisticsVector_append(self, x)

    def empty(self):
        return _hklfile.ColumnStatisticsVector_empty(self)

    def size(self):
        return _hklfile.ColumnStatisticsVector_size(self)

    def clear(self):
        return _hklfile.ColumnStatisticsVector_clear(self)

    def swap(self, v):
        return _hklfile.ColumnStatisticsVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.ColumnStatisticsVector_get_allocator(self)

    def begin(self):
        return _hklfile.ColumnStatisticsVector_begin(self)

    def end(self):
        return _hklfile.ColumnStatisticsVector_end(self)

    def rbegin(self):
        return _hklfile.ColumnStatisticsVector_rbegin(self)

    def rend(self):
        return _hklfile.ColumnStatisticsVector_rend(self)

    def pop_back(self):
        return _hklfile.ColumnStatisticsVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.ColumnStatisticsVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_ColumnStatisticsVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.ColumnStatisticsVector_push_back(self, x)

    def front(self):
        return _hklfile.ColumnStatisticsVector_front(self)

    def back(self):
        return _hklfile.ColumnStatisticsVector_back(self)

    def assign(self, n, x):
        return _hklfile.ColumnStatisticsVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.ColumnStatisticsVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.ColumnStatisticsVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.ColumnStatisticsVector_reserve(self, n)

    def capacity(self):
        return _hklfile.ColumnStatisticsVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_ColumnStatisticsVector
    __del__ = lambda self: None
ColumnStatisticsVector_swigregister = _hklfile.ColumnStatisticsVector_swigregister
ColumnStatisticsVector_swigregister(ColumnStatisticsVector)

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

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

    def Valid(self):
        return _hklfile.ColumnGroupBase_Valid(self)
    __swig_destroy__ = _hklfile.delete_ColumnGroupBase
    __del__ = lambda self: None

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.ColumnGroupBase_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.ColumnGroupBase_GetData(self, ih, Missing)

    def Index1(self):
        return _hklfile.ColumnGroupBase_Index1(self)

    def Ncol(self):
        return _hklfile.ColumnGroupBase_Ncol(self)

    def ColumnIndices(self):
        return _hklfile.ColumnGroupBase_ColumnIndices(self)

    def Xdtsindex(self, *args):
        return _hklfile.ColumnGroupBase_Xdtsindex(self, *args)

    def format(self):
        return _hklfile.ColumnGroupBase_format(self)

    def format_labels(self):
        return _hklfile.ColumnGroupBase_format_labels(self)

    def GroupType(self):
        return _hklfile.ColumnGroupBase_GroupType(self)
ColumnGroupBase_swigregister = _hklfile.ColumnGroupBase_swigregister
ColumnGroupBase_swigregister(ColumnGroupBase)

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

    def __init__(self, *args):
        this = _hklfile.new_HKLColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def format(self):
        return _hklfile.HKLColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_HKLColumnGroup
    __del__ = lambda self: None
HKLColumnGroup_swigregister = _hklfile.HKLColumnGroup_swigregister
HKLColumnGroup_swigregister(HKLColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_IsigIColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.IsigIColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.IsigIColumnGroup_GetData(self, ih, Missing)

    def DataArray(self):
        return _hklfile.IsigIColumnGroup_DataArray(self)

    def format(self):
        return _hklfile.IsigIColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_IsigIColumnGroup
    __del__ = lambda self: None
IsigIColumnGroup_swigregister = _hklfile.IsigIColumnGroup_swigregister
IsigIColumnGroup_swigregister(IsigIColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_IsigAnoColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.IsigAnoColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.IsigAnoColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.IsigAnoColumnGroup_format(self)

    def LabelSignsMatch(self):
        return _hklfile.IsigAnoColumnGroup_LabelSignsMatch(self)
    __swig_destroy__ = _hklfile.delete_IsigAnoColumnGroup
    __del__ = lambda self: None
IsigAnoColumnGroup_swigregister = _hklfile.IsigAnoColumnGroup_swigregister
IsigAnoColumnGroup_swigregister(IsigAnoColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_FsigFColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.FsigFColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.FsigFColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.FsigFColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_FsigFColumnGroup
    __del__ = lambda self: None
FsigFColumnGroup_swigregister = _hklfile.FsigFColumnGroup_swigregister
FsigFColumnGroup_swigregister(FsigFColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_DsigDColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.DsigDColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.DsigDColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.DsigDColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_DsigDColumnGroup
    __del__ = lambda self: None
DsigDColumnGroup_swigregister = _hklfile.DsigDColumnGroup_swigregister
DsigDColumnGroup_swigregister(DsigDColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_FsigAnoColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.FsigAnoColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.FsigAnoColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.FsigAnoColumnGroup_format(self)

    def LabelSignsMatch(self):
        return _hklfile.FsigAnoColumnGroup_LabelSignsMatch(self)
    __swig_destroy__ = _hklfile.delete_FsigAnoColumnGroup
    __del__ = lambda self: None
FsigAnoColumnGroup_swigregister = _hklfile.FsigAnoColumnGroup_swigregister
FsigAnoColumnGroup_swigregister(FsigAnoColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_PhiColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.PhiColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.PhiColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.PhiColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_PhiColumnGroup
    __del__ = lambda self: None
PhiColumnGroup_swigregister = _hklfile.PhiColumnGroup_swigregister
PhiColumnGroup_swigregister(PhiColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_FlagColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.FlagColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.FlagColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.FlagColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_FlagColumnGroup
    __del__ = lambda self: None
FlagColumnGroup_swigregister = _hklfile.FlagColumnGroup_swigregister
FlagColumnGroup_swigregister(FlagColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_ABCDColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.ABCDColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.ABCDColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.ABCDColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_ABCDColumnGroup
    __del__ = lambda self: None
ABCDColumnGroup_swigregister = _hklfile.ABCDColumnGroup_swigregister
ABCDColumnGroup_swigregister(ABCDColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_FloatColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.FloatColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.FloatColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.FloatColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_FloatColumnGroup
    __del__ = lambda self: None
FloatColumnGroup_swigregister = _hklfile.FloatColumnGroup_swigregister
FloatColumnGroup_swigregister(FloatColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_WeightColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.WeightColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.WeightColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.WeightColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_WeightColumnGroup
    __del__ = lambda self: None
WeightColumnGroup_swigregister = _hklfile.WeightColumnGroup_swigregister
WeightColumnGroup_swigregister(WeightColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_IsymColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.IsymColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.IsymColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.IsymColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_IsymColumnGroup
    __del__ = lambda self: None
IsymColumnGroup_swigregister = _hklfile.IsymColumnGroup_swigregister
IsymColumnGroup_swigregister(IsymColumnGroup)

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

    def __init__(self, *args):
        this = _hklfile.new_BatchColumnGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ImportData(self, mtzin, hklinfo, cell):
        return _hklfile.BatchColumnGroup_ImportData(self, mtzin, hklinfo, cell)

    def GetData(self, ih, Missing):
        return _hklfile.BatchColumnGroup_GetData(self, ih, Missing)

    def format(self):
        return _hklfile.BatchColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_BatchColumnGroup
    __del__ = lambda self: None
BatchColumnGroup_swigregister = _hklfile.BatchColumnGroup_swigregister
BatchColumnGroup_swigregister(BatchColumnGroup)

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

    def __init__(self):
        this = _hklfile.new_ColumnStatistics()
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetColumnNames(self, Type, Label):
        return _hklfile.ColumnStatistics_SetColumnNames(self, Type, Label)

    def Add(self, *args):
        return _hklfile.ColumnStatistics_Add(self, *args)

    def min(self):
        return _hklfile.ColumnStatistics_min(self)

    def max(self):
        return _hklfile.ColumnStatistics_max(self)

    def NumMissing(self):
        return _hklfile.ColumnStatistics_NumMissing(self)

    def Number(self):
        return _hklfile.ColumnStatistics_Number(self)

    def Mean(self):
        return _hklfile.ColumnStatistics_Mean(self)

    def MeanAbs(self):
        return _hklfile.ColumnStatistics_MeanAbs(self)

    def ResRange(self):
        return _hklfile.ColumnStatistics_ResRange(self)

    def Type(self):
        return _hklfile.ColumnStatistics_Type(self)

    def Label(self):
        return _hklfile.ColumnStatistics_Label(self)

    def integerColumn(self):
        return _hklfile.ColumnStatistics_integerColumn(self)
    __swig_destroy__ = _hklfile.delete_ColumnStatistics
    __del__ = lambda self: None
ColumnStatistics_swigregister = _hklfile.ColumnStatistics_swigregister
ColumnStatistics_swigregister(ColumnStatistics)

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

    def __init__(self, *args):
        this = _hklfile.new_ColumnStatisticsTable(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def formatHeader(self):
        return _hklfile.ColumnStatisticsTable_formatHeader(self)

    def formatTable(self):
        return _hklfile.ColumnStatisticsTable_formatTable(self)
    __swig_destroy__ = _hklfile.delete_ColumnStatisticsTable
    __del__ = lambda self: None
ColumnStatisticsTable_swigregister = _hklfile.ColumnStatisticsTable_swigregister
ColumnStatisticsTable_swigregister(ColumnStatisticsTable)


def formatClipperCell(cell):
    return _hklfile.formatClipperCell(cell)
formatClipperCell = _hklfile.formatClipperCell
class Float_type(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Float_type, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Float_type, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _hklfile.new_Float_type(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _hklfile.Float_type_set_null(self)
    __swig_getmethods__["type"] = lambda x: _hklfile.Float_type_type
    if _newclass:
        type = staticmethod(_hklfile.Float_type_type)

    def friedel(self):
        return _hklfile.Float_type_friedel(self)

    def shift_phase(self, dphi):
        return _hklfile.Float_type_shift_phase(self, dphi)

    def missing(self):
        return _hklfile.Float_type_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _hklfile.Float_type_data_size
    if _newclass:
        data_size = staticmethod(_hklfile.Float_type_data_size)
    __swig_getmethods__["data_names"] = lambda x: _hklfile.Float_type_data_names
    if _newclass:
        data_names = staticmethod(_hklfile.Float_type_data_names)

    def data_export(self, array):
        return _hklfile.Float_type_data_export(self, array)

    def data_import(self, array):
        return _hklfile.Float_type_data_import(self, array)

    def float_type(self, *args):
        return _hklfile.Float_type_float_type(self, *args)
    __swig_destroy__ = _hklfile.delete_Float_type
    __del__ = lambda self: None
Float_type_swigregister = _hklfile.Float_type_swigregister
Float_type_swigregister(Float_type)

def Float_type_type():
    return _hklfile.Float_type_type()
Float_type_type = _hklfile.Float_type_type

def Float_type_data_size():
    return _hklfile.Float_type_data_size()
Float_type_data_size = _hklfile.Float_type_data_size

def Float_type_data_names():
    return _hklfile.Float_type_data_names()
Float_type_data_names = _hklfile.Float_type_data_names

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

    def __init__(self, *args):
        this = _hklfile.new_Weight_type(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _hklfile.Weight_type_set_null(self)
    __swig_getmethods__["type"] = lambda x: _hklfile.Weight_type_type
    if _newclass:
        type = staticmethod(_hklfile.Weight_type_type)

    def friedel(self):
        return _hklfile.Weight_type_friedel(self)

    def shift_phase(self, dphi):
        return _hklfile.Weight_type_shift_phase(self, dphi)

    def missing(self):
        return _hklfile.Weight_type_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _hklfile.Weight_type_data_size
    if _newclass:
        data_size = staticmethod(_hklfile.Weight_type_data_size)
    __swig_getmethods__["data_names"] = lambda x: _hklfile.Weight_type_data_names
    if _newclass:
        data_names = staticmethod(_hklfile.Weight_type_data_names)

    def data_export(self, array):
        return _hklfile.Weight_type_data_export(self, array)

    def data_import(self, array):
        return _hklfile.Weight_type_data_import(self, array)

    def weight_type(self, *args):
        return _hklfile.Weight_type_weight_type(self, *args)
    __swig_destroy__ = _hklfile.delete_Weight_type
    __del__ = lambda self: None
Weight_type_swigregister = _hklfile.Weight_type_swigregister
Weight_type_swigregister(Weight_type)

def Weight_type_type():
    return _hklfile.Weight_type_type()
Weight_type_type = _hklfile.Weight_type_type

def Weight_type_data_size():
    return _hklfile.Weight_type_data_size()
Weight_type_data_size = _hklfile.Weight_type_data_size

def Weight_type_data_names():
    return _hklfile.Weight_type_data_names()
Weight_type_data_names = _hklfile.Weight_type_data_names

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

    def __init__(self, *args):
        this = _hklfile.new_Isym(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _hklfile.Isym_set_null(self)
    __swig_getmethods__["type"] = lambda x: _hklfile.Isym_type
    if _newclass:
        type = staticmethod(_hklfile.Isym_type)

    def friedel(self):
        return _hklfile.Isym_friedel(self)

    def shift_phase(self, dphi):
        return _hklfile.Isym_shift_phase(self, dphi)

    def missing(self):
        return _hklfile.Isym_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _hklfile.Isym_data_size
    if _newclass:
        data_size = staticmethod(_hklfile.Isym_data_size)
    __swig_getmethods__["data_names"] = lambda x: _hklfile.Isym_data_names
    if _newclass:
        data_names = staticmethod(_hklfile.Isym_data_names)

    def data_export(self, array):
        return _hklfile.Isym_data_export(self, array)

    def data_import(self, array):
        return _hklfile.Isym_data_import(self, array)

    def isym(self, *args):
        return _hklfile.Isym_isym(self, *args)
    __swig_destroy__ = _hklfile.delete_Isym
    __del__ = lambda self: None
Isym_swigregister = _hklfile.Isym_swigregister
Isym_swigregister(Isym)

def Isym_type():
    return _hklfile.Isym_type()
Isym_type = _hklfile.Isym_type

def Isym_data_size():
    return _hklfile.Isym_data_size()
Isym_data_size = _hklfile.Isym_data_size

def Isym_data_names():
    return _hklfile.Isym_data_names()
Isym_data_names = _hklfile.Isym_data_names

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

    def __init__(self, *args):
        this = _hklfile.new_clipper_Batch(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _hklfile.clipper_Batch_set_null(self)
    __swig_getmethods__["type"] = lambda x: _hklfile.clipper_Batch_type
    if _newclass:
        type = staticmethod(_hklfile.clipper_Batch_type)

    def friedel(self):
        return _hklfile.clipper_Batch_friedel(self)

    def shift_phase(self, dphi):
        return _hklfile.clipper_Batch_shift_phase(self, dphi)

    def missing(self):
        return _hklfile.clipper_Batch_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _hklfile.clipper_Batch_data_size
    if _newclass:
        data_size = staticmethod(_hklfile.clipper_Batch_data_size)
    __swig_getmethods__["data_names"] = lambda x: _hklfile.clipper_Batch_data_names
    if _newclass:
        data_names = staticmethod(_hklfile.clipper_Batch_data_names)

    def data_export(self, array):
        return _hklfile.clipper_Batch_data_export(self, array)

    def data_import(self, array):
        return _hklfile.clipper_Batch_data_import(self, array)

    def batch(self, *args):
        return _hklfile.clipper_Batch_batch(self, *args)
    __swig_destroy__ = _hklfile.delete_clipper_Batch
    __del__ = lambda self: None
clipper_Batch_swigregister = _hklfile.clipper_Batch_swigregister
clipper_Batch_swigregister(clipper_Batch)

def clipper_Batch_type():
    return _hklfile.clipper_Batch_type()
clipper_Batch_type = _hklfile.clipper_Batch_type

def clipper_Batch_data_size():
    return _hklfile.clipper_Batch_data_size()
clipper_Batch_data_size = _hklfile.clipper_Batch_data_size

def clipper_Batch_data_names():
    return _hklfile.clipper_Batch_data_names()
clipper_Batch_data_names = _hklfile.clipper_Batch_data_names

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

    def __init__(self):
        this = _hklfile.new_New_MTZ_type_registry()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hklfile.delete_New_MTZ_type_registry
    __del__ = lambda self: None
New_MTZ_type_registry_swigregister = _hklfile.New_MTZ_type_registry_swigregister
New_MTZ_type_registry_swigregister(New_MTZ_type_registry)

class HklZone(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HklZone, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HklZone, name)
    __repr__ = _swig_repr
    EMPTY = _hklfile.HklZone_EMPTY
    INVALIDCOLUMNGROUP = _hklfile.HklZone_INVALIDCOLUMNGROUP
    INVALIDCOLUMNGROUPINDEX = _hklfile.HklZone_INVALIDCOLUMNGROUPINDEX
    INVALIDZONE = _hklfile.HklZone_INVALIDZONE
    FILLED = _hklfile.HklZone_FILLED

    def Status(self):
        return _hklfile.HklZone_Status(self)

    def setExpand(self, expandFlag):
        return _hklfile.HklZone_setExpand(self, expandFlag)

    def Spacegroup(self):
        return _hklfile.HklZone_Spacegroup(self)

    def Cell(self):
        return _hklfile.HklZone_Cell(self)

    def IorFflagI(self):
        return _hklfile.HklZone_IorFflagI(self)

    def MaxValue(self):
        return _hklfile.HklZone_MaxValue(self)

    def GroupType(self):
        return _hklfile.HklZone_GroupType(self)

    def GroupLabels(self):
        return _hklfile.HklZone_GroupLabels(self)

    def Resolution(self):
        return _hklfile.HklZone_Resolution(self)

    def SetResolutionLimit(self, ResolLimit):
        return _hklfile.HklZone_SetResolutionLimit(self, ResolLimit)

    def ResolutionLimit(self):
        return _hklfile.HklZone_ResolutionLimit(self)

    def MaximumZoneLevel(self):
        return _hklfile.HklZone_MaximumZoneLevel(self)

    def NumberReflections(self):
        return _hklfile.HklZone_NumberReflections(self)

    def NumberBasicReflections(self):
        return _hklfile.HklZone_NumberBasicReflections(self)

    def ZoneLabel(self):
        return _hklfile.HklZone_ZoneLabel(self)

    def HorizontalAxis(self):
        return _hklfile.HklZone_HorizontalAxis(self)

    def VerticalAxis(self):
        return _hklfile.HklZone_VerticalAxis(self)

    def ShortestScaledLatticeSpacing(self):
        return _hklfile.HklZone_ShortestScaledLatticeSpacing(self)

    def H0(self):
        return _hklfile.HklZone_H0(self)

    def X0(self):
        return _hklfile.HklZone_X0(self)

    def GetResolutionCircle(self, resol):
        return _hklfile.HklZone_GetResolutionCircle(self, resol)

    def ResolutionFromRadius(self, radius):
        return _hklfile.HklZone_ResolutionFromRadius(self, radius)

    def rewind(self):
        return _hklfile.HklZone_rewind(self)

    def NextReflection(self, refl, getF):
        return _hklfile.HklZone_NextReflection(self, refl, getF)

    def XYZtoHKL(self, coord):
        return _hklfile.HklZone_XYZtoHKL(self, coord)

    def NearestHKL(self, coord, refl):
        return _hklfile.HklZone_NearestHKL(self, coord, refl)

    def __init__(self, *args):
        this = _hklfile.new_HklZone(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, Rvec, Nr, Merged, Expand=True):
        return _hklfile.HklZone_init(self, Rvec, Nr, Merged, Expand)

    def SetStatus(self, Status):
        return _hklfile.HklZone_SetStatus(self, Status)

    def SetCellSpacegroup(self, Cell, Spacegroup):
        return _hklfile.HklZone_SetCellSpacegroup(self, Cell, Spacegroup)

    def IorFflag(self, *args):
        return _hklfile.HklZone_IorFflag(self, *args)

    def StoreGroupInfo(self, groupType, groupLabels):
        return _hklfile.HklZone_StoreGroupInfo(self, groupType, groupLabels)

    def AddReflection(self, Hkl, Invresolsq, value, sigvalue):
        return _hklfile.HklZone_AddReflection(self, Hkl, Invresolsq, value, sigvalue)

    def CloseReflectionList(self):
        return _hklfile.HklZone_CloseReflectionList(self)

    def IsInZone(self, Hkl):
        return _hklfile.HklZone_IsInZone(self, Hkl)

    def AreAnyInZone(self, Hkl):
        return _hklfile.HklZone_AreAnyInZone(self, Hkl)
    __swig_destroy__ = _hklfile.delete_HklZone
    __del__ = lambda self: None
HklZone_swigregister = _hklfile.HklZone_swigregister
HklZone_swigregister(HklZone)

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

    def __init__(self, *args):
        this = _hklfile.new_ZoneAxis(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["label"] = _hklfile.ZoneAxis_label_set
    __swig_getmethods__["label"] = _hklfile.ZoneAxis_label_get
    if _newclass:
        label = _swig_property(_hklfile.ZoneAxis_label_get, _hklfile.ZoneAxis_label_set)
    __swig_setmethods__["endpoints"] = _hklfile.ZoneAxis_endpoints_set
    __swig_getmethods__["endpoints"] = _hklfile.ZoneAxis_endpoints_get
    if _newclass:
        endpoints = _swig_property(_hklfile.ZoneAxis_endpoints_get, _hklfile.ZoneAxis_endpoints_set)
    __swig_destroy__ = _hklfile.delete_ZoneAxis
    __del__ = lambda self: None
ZoneAxis_swigregister = _hklfile.ZoneAxis_swigregister
ZoneAxis_swigregister(ZoneAxis)

class MtzMerged(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MtzMerged, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MtzMerged, name)
    __repr__ = _swig_repr
    NONE = _hklfile.MtzMerged_NONE
    MERGED = _hklfile.MtzMerged_MERGED
    UNMERGED = _hklfile.MtzMerged_UNMERGED
    __swig_destroy__ = _hklfile.delete_MtzMerged
    __del__ = lambda self: None

    def PurgeData(self):
        return _hklfile.MtzMerged_PurgeData(self)

    def __init__(self, *args):
        this = _hklfile.new_MtzMerged(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, hklinName):
        return _hklfile.MtzMerged_init(self, hklinName)

    def ListType(self):
        return _hklfile.MtzMerged_ListType(self)

    def MisymColumn(self):
        return _hklfile.MtzMerged_MisymColumn(self)

    def Title(self):
        return _hklfile.MtzMerged_Title(self)

    def History(self):
        return _hklfile.MtzMerged_History(self)

    def NumberDatasets(self):
        return _hklfile.MtzMerged_NumberDatasets(self)

    def NumberColumns(self):
        return _hklfile.MtzMerged_NumberColumns(self)

    def GetDatasets(self):
        return _hklfile.MtzMerged_GetDatasets(self)

    def GetColumnData(self):
        return _hklfile.MtzMerged_GetColumnData(self)

    def GetColumnDataset(self):
        return _hklfile.MtzMerged_GetColumnDataset(self)

    def Spacegroup(self):
        return _hklfile.MtzMerged_Spacegroup(self)

    def CCP4_SpacegroupNumber(self):
        return _hklfile.MtzMerged_CCP4_SpacegroupNumber(self)

    def SpacegroupConfidence(self):
        return _hklfile.MtzMerged_SpacegroupConfidence(self)

    def Cell(self):
        return _hklfile.MtzMerged_Cell(self)

    def NumberReflections(self):
        return _hklfile.MtzMerged_NumberReflections(self)

    def SortOrder(self):
        return _hklfile.MtzMerged_SortOrder(self)

    def HighResolutionLimit(self):
        return _hklfile.MtzMerged_HighResolutionLimit(self)

    def LowResolutionLimit(self):
        return _hklfile.MtzMerged_LowResolutionLimit(self)

    def ColumnGroup(self, Xdtsindex):
        return _hklfile.MtzMerged_ColumnGroup(self, Xdtsindex)

    def ColumnGroupIndex(self):
        return _hklfile.MtzMerged_ColumnGroupIndex(self)

    def ReadData(self):
        return _hklfile.MtzMerged_ReadData(self)

    def rewind(self):
        return _hklfile.MtzMerged_rewind(self)

    def SetReflectionStart(self, *args):
        return _hklfile.MtzMerged_SetReflectionStart(self, *args)

    def NextReflection(self, *args):
        return _hklfile.MtzMerged_NextReflection(self, *args)
MtzMerged_swigregister = _hklfile.MtzMerged_swigregister
MtzMerged_swigregister(MtzMerged)

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

    def __init__(self, *args):
        this = _hklfile.new_CrystalDataset(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, Cxtl, Cset):
        return _hklfile.CrystalDataset_init(self, Cxtl, Cset)

    def Cell(self):
        return _hklfile.CrystalDataset_Cell(self)

    def Wavelength(self):
        return _hklfile.CrystalDataset_Wavelength(self)

    def Crystal(self):
        return _hklfile.CrystalDataset_Crystal(self)

    def Dataset(self):
        return _hklfile.CrystalDataset_Dataset(self)

    def format(self):
        return _hklfile.CrystalDataset_format(self)

    def formatPXD(self):
        return _hklfile.CrystalDataset_formatPXD(self)

    def formatCell(self):
        return _hklfile.CrystalDataset_formatCell(self)

    def formatWavelength(self):
        return _hklfile.CrystalDataset_formatWavelength(self)
    __swig_destroy__ = _hklfile.delete_CrystalDataset
    __del__ = lambda self: None
CrystalDataset_swigregister = _hklfile.CrystalDataset_swigregister
CrystalDataset_swigregister(CrystalDataset)

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

    def __init__(self, *args):
        this = _hklfile.new_XtalDatasetInfo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, Cxtl, Cset):
        return _hklfile.XtalDatasetInfo_init(self, Cxtl, Cset)

    def GetCrystalDataset(self):
        return _hklfile.XtalDatasetInfo_GetCrystalDataset(self)

    def AddColumn(self, icol, cd):
        return _hklfile.XtalDatasetInfo_AddColumn(self, icol, cd)

    def AddColumnGroup(self, pgroup):
        return _hklfile.XtalDatasetInfo_AddColumnGroup(self, pgroup)

    def ColumnIndices(self):
        return _hklfile.XtalDatasetInfo_ColumnIndices(self)

    def GetColumnData(self):
        return _hklfile.XtalDatasetInfo_GetColumnData(self)

    def NumberColumnGroups(self):
        return _hklfile.XtalDatasetInfo_NumberColumnGroups(self)

    def Cell(self):
        return _hklfile.XtalDatasetInfo_Cell(self)

    def Wavelength(self):
        return _hklfile.XtalDatasetInfo_Wavelength(self)

    def format_dataset(self):
        return _hklfile.XtalDatasetInfo_format_dataset(self)

    def Pname(self):
        return _hklfile.XtalDatasetInfo_Pname(self)

    def Xname(self):
        return _hklfile.XtalDatasetInfo_Xname(self)

    def Dname(self):
        return _hklfile.XtalDatasetInfo_Dname(self)

    def format_columns(self):
        return _hklfile.XtalDatasetInfo_format_columns(self)

    def format_groups(self):
        return _hklfile.XtalDatasetInfo_format_groups(self)

    def format_group_labels(self):
        return _hklfile.XtalDatasetInfo_format_group_labels(self)

    def DatasetID(self, *args):
        return _hklfile.XtalDatasetInfo_DatasetID(self, *args)
    __swig_destroy__ = _hklfile.delete_XtalDatasetInfo
    __del__ = lambda self: None
XtalDatasetInfo_swigregister = _hklfile.XtalDatasetInfo_swigregister
XtalDatasetInfo_swigregister(XtalDatasetInfo)

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

    def Version(self):
        return _hklfile.ReflectionList_Version(self)

    def __init__(self, *args):
        this = _hklfile.new_ReflectionList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, hklinName):
        return _hklfile.ReflectionList_init(self, hklinName)

    def ReadData(self):
        return _hklfile.ReflectionList_ReadData(self)

    def FileType(self):
        return _hklfile.ReflectionList_FileType(self)

    def Title(self):
        return _hklfile.ReflectionList_Title(self)

    def History(self):
        return _hklfile.ReflectionList_History(self)

    def Spacegroup(self):
        return _hklfile.ReflectionList_Spacegroup(self)

    def CCP4_SpacegroupNumber(self):
        return _hklfile.ReflectionList_CCP4_SpacegroupNumber(self)

    def SpacegroupConfidence(self):
        return _hklfile.ReflectionList_SpacegroupConfidence(self)

    def Cell(self):
        return _hklfile.ReflectionList_Cell(self)

    def Merged(self):
        return _hklfile.ReflectionList_Merged(self)

    def NumberReflections(self):
        return _hklfile.ReflectionList_NumberReflections(self)

    def Resolution(self):
        return _hklfile.ReflectionList_Resolution(self)

    def SortOrder(self):
        return _hklfile.ReflectionList_SortOrder(self)

    def NumberDatasets(self):
        return _hklfile.ReflectionList_NumberDatasets(self)

    def GetDatasets(self):
        return _hklfile.ReflectionList_GetDatasets(self)

    def GetDsetPnames(self):
        return _hklfile.ReflectionList_GetDsetPnames(self)

    def GetDsetXnames(self):
        return _hklfile.ReflectionList_GetDsetXnames(self)

    def GetDsetDnames(self):
        return _hklfile.ReflectionList_GetDsetDnames(self)

    def GetDsetCells(self):
        return _hklfile.ReflectionList_GetDsetCells(self)

    def GetDsetWavelengths(self):
        return _hklfile.ReflectionList_GetDsetWavelengths(self)

    def GetDsetColumnIndices(self):
        return _hklfile.ReflectionList_GetDsetColumnIndices(self)

    def ColumnGroup(self, Xdtsindex):
        return _hklfile.ReflectionList_ColumnGroup(self, Xdtsindex)

    def NumberBatches(self):
        return _hklfile.ReflectionList_NumberBatches(self)

    def formatBatchNumberlist(self, datasetid=0):
        return _hklfile.ReflectionList_formatBatchNumberlist(self, datasetid)

    def formatAllBatchData(self):
        return _hklfile.ReflectionList_formatAllBatchData(self)

    def Batches(self):
        return _hklfile.ReflectionList_Batches(self)

    def BatchNumberRanges(self, datasetid=0):
        return _hklfile.ReflectionList_BatchNumberRanges(self, datasetid)

    def NumberRuns(self):
        return _hklfile.ReflectionList_NumberRuns(self)

    def NumberLattices(self):
        return _hklfile.ReflectionList_NumberLattices(self)

    def NumberofMainLattices(self):
        return _hklfile.ReflectionList_NumberofMainLattices(self)

    def formatNumberofLattices(self):
        return _hklfile.ReflectionList_formatNumberofLattices(self)

    def NumberColumns(self):
        return _hklfile.ReflectionList_NumberColumns(self)

    def NumberDataColumns(self):
        return _hklfile.ReflectionList_NumberDataColumns(self)

    def ColumnLabels(self):
        return _hklfile.ReflectionList_ColumnLabels(self)

    def ColumnTypes(self):
        return _hklfile.ReflectionList_ColumnTypes(self)

    def ColumnGroupIndex(self):
        return _hklfile.ReflectionList_ColumnGroupIndex(self)

    def GetColumnStatistics(self):
        return _hklfile.ReflectionList_GetColumnStatistics(self)

    def GetColumnDataset(self):
        return _hklfile.ReflectionList_GetColumnDataset(self)

    def Columnfields(self):
        return _hklfile.ReflectionList_Columnfields(self)

    def rewind(self):
        return _hklfile.ReflectionList_rewind(self)

    def SetReflectionStart(self, *args):
        return _hklfile.ReflectionList_SetReflectionStart(self, *args)

    def NextReflection(self, refl):
        return _hklfile.ReflectionList_NextReflection(self, refl)

    def FormatReflection(self, refl):
        return _hklfile.ReflectionList_FormatReflection(self, refl)

    def Zone(self, Rvec, Nr, SelectionIndex=-1, Expand=True):
        return _hklfile.ReflectionList_Zone(self, Rvec, Nr, SelectionIndex, Expand)

    def MaximumZoneLevel(self, Rvec):
        return _hklfile.ReflectionList_MaximumZoneLevel(self, Rvec)

    def MaxIntensity(self):
        return _hklfile.ReflectionList_MaxIntensity(self)
    __swig_destroy__ = _hklfile.delete_ReflectionList
    __del__ = lambda self: None
ReflectionList_swigregister = _hklfile.ReflectionList_swigregister
ReflectionList_swigregister(ReflectionList)

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

    def __init__(self, *args):
        this = _hklfile.new_ReflectionData(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _hklfile.ReflectionData_init(self, *args)

    def Hkl(self):
        return _hklfile.ReflectionData_Hkl(self)

    def Invresolsq(self):
        return _hklfile.ReflectionData_Invresolsq(self)

    def Data(self):
        return _hklfile.ReflectionData_Data(self)

    def Missing(self):
        return _hklfile.ReflectionData_Missing(self)

    def AllMissing(self):
        return _hklfile.ReflectionData_AllMissing(self)

    def StoreOriginalHkl(self, hkl):
        return _hklfile.ReflectionData_StoreOriginalHkl(self, hkl)

    def ReducedHkl(self):
        return _hklfile.ReflectionData_ReducedHkl(self)

    def OriginalHkl(self):
        return _hklfile.ReflectionData_OriginalHkl(self)
    __swig_destroy__ = _hklfile.delete_ReflectionData
    __del__ = lambda self: None
ReflectionData_swigregister = _hklfile.ReflectionData_swigregister
ReflectionData_swigregister(ReflectionData)

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

    def __init__(self, *args):
        this = _hklfile.new_ReflectionInfo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, Hkl, Invresolsq, Value, Fvalue, Sigfvalue, Coordorth):
        return _hklfile.ReflectionInfo_init(self, Hkl, Invresolsq, Value, Fvalue, Sigfvalue, Coordorth)
    __swig_setmethods__["hkl"] = _hklfile.ReflectionInfo_hkl_set
    __swig_getmethods__["hkl"] = _hklfile.ReflectionInfo_hkl_get
    if _newclass:
        hkl = _swig_property(_hklfile.ReflectionInfo_hkl_get, _hklfile.ReflectionInfo_hkl_set)
    __swig_setmethods__["invresolsq"] = _hklfile.ReflectionInfo_invresolsq_set
    __swig_getmethods__["invresolsq"] = _hklfile.ReflectionInfo_invresolsq_get
    if _newclass:
        invresolsq = _swig_property(_hklfile.ReflectionInfo_invresolsq_get, _hklfile.ReflectionInfo_invresolsq_set)
    __swig_setmethods__["value"] = _hklfile.ReflectionInfo_value_set
    __swig_getmethods__["value"] = _hklfile.ReflectionInfo_value_get
    if _newclass:
        value = _swig_property(_hklfile.ReflectionInfo_value_get, _hklfile.ReflectionInfo_value_set)
    __swig_setmethods__["fvalue"] = _hklfile.ReflectionInfo_fvalue_set
    __swig_getmethods__["fvalue"] = _hklfile.ReflectionInfo_fvalue_get
    if _newclass:
        fvalue = _swig_property(_hklfile.ReflectionInfo_fvalue_get, _hklfile.ReflectionInfo_fvalue_set)
    __swig_setmethods__["sigfvalue"] = _hklfile.ReflectionInfo_sigfvalue_set
    __swig_getmethods__["sigfvalue"] = _hklfile.ReflectionInfo_sigfvalue_get
    if _newclass:
        sigfvalue = _swig_property(_hklfile.ReflectionInfo_sigfvalue_get, _hklfile.ReflectionInfo_sigfvalue_set)
    __swig_setmethods__["coordorth"] = _hklfile.ReflectionInfo_coordorth_set
    __swig_getmethods__["coordorth"] = _hklfile.ReflectionInfo_coordorth_get
    if _newclass:
        coordorth = _swig_property(_hklfile.ReflectionInfo_coordorth_get, _hklfile.ReflectionInfo_coordorth_set)
    __swig_destroy__ = _hklfile.delete_ReflectionInfo
    __del__ = lambda self: None
ReflectionInfo_swigregister = _hklfile.ReflectionInfo_swigregister
ReflectionInfo_swigregister(ReflectionInfo)


_hklfile.PROGRAM_VERSION_swigconstant(_hklfile)
PROGRAM_VERSION = _hklfile.PROGRAM_VERSION

_hklfile.PROGRAM_DATE_swigconstant(_hklfile)
PROGRAM_DATE = _hklfile.PROGRAM_DATE

_hklfile.PROGRAM_DATE2_swigconstant(_hklfile)
PROGRAM_DATE2 = _hklfile.PROGRAM_DATE2
class ReflectionFileType(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReflectionFileType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ReflectionFileType, name)
    __repr__ = _swig_repr
    NOTSET = _hklfile.ReflectionFileType_NOTSET
    ABSENT = _hklfile.ReflectionFileType_ABSENT
    UNKNOWN = _hklfile.ReflectionFileType_UNKNOWN
    MTZ = _hklfile.ReflectionFileType_MTZ
    SCA_MERGED = _hklfile.ReflectionFileType_SCA_MERGED
    SCA_UNMERGED = _hklfile.ReflectionFileType_SCA_UNMERGED
    SHELX = _hklfile.ReflectionFileType_SHELX
    SAINT = _hklfile.ReflectionFileType_SAINT
    XDS_INTEGRATE = _hklfile.ReflectionFileType_XDS_INTEGRATE
    XDS_XSCALE = _hklfile.ReflectionFileType_XDS_XSCALE
    XDS_ASCII = _hklfile.ReflectionFileType_XDS_ASCII
    XDS_MERGED = _hklfile.ReflectionFileType_XDS_MERGED
    SCA_FREE = _hklfile.ReflectionFileType_SCA_FREE
    CIF = _hklfile.ReflectionFileType_CIF

    def __init__(self, *args):
        this = _hklfile.new_ReflectionFileType(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetTypeCode(self, code):
        return _hklfile.ReflectionFileType_SetTypeCode(self, code)

    def SetType(self, filetypename):
        return _hklfile.ReflectionFileType_SetType(self, filetypename)

    def FileType(self):
        return _hklfile.ReflectionFileType_FileType(self)

    def IsTypeMTZ(self):
        return _hklfile.ReflectionFileType_IsTypeMTZ(self)

    def IsTypeXDS(self):
        return _hklfile.ReflectionFileType_IsTypeXDS(self)

    def IsTypeXDS_ASCII(self):
        return _hklfile.ReflectionFileType_IsTypeXDS_ASCII(self)

    def IsTypeXDS_MERGED(self):
        return _hklfile.ReflectionFileType_IsTypeXDS_MERGED(self)

    def IsTypeSCA(self):
        return _hklfile.ReflectionFileType_IsTypeSCA(self)

    def IsTypeSHELX(self):
        return _hklfile.ReflectionFileType_IsTypeSHELX(self)

    def IsTypeSAINT(self):
        return _hklfile.ReflectionFileType_IsTypeSAINT(self)

    def IsTypeFREE(self):
        return _hklfile.ReflectionFileType_IsTypeFREE(self)

    def IsTypeCIF(self):
        return _hklfile.ReflectionFileType_IsTypeCIF(self)

    def IsTypeSSS(self):
        return _hklfile.ReflectionFileType_IsTypeSSS(self)

    def Unmerged(self):
        return _hklfile.ReflectionFileType_Unmerged(self)

    def format(self):
        return _hklfile.ReflectionFileType_format(self)
    __swig_destroy__ = _hklfile.delete_ReflectionFileType
    __del__ = lambda self: None
ReflectionFileType_swigregister = _hklfile.ReflectionFileType_swigregister
ReflectionFileType_swigregister(ReflectionFileType)


def CheckCompatibleSymmetry(RefSym, TestSym, TestDataMerged):
    return _hklfile.CheckCompatibleSymmetry(RefSym, TestSym, TestDataMerged)
CheckCompatibleSymmetry = _hklfile.CheckCompatibleSymmetry
class run_controls(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, run_controls, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, run_controls, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _hklfile.new_run_controls()
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetStatus(self, Status):
        return _hklfile.run_controls_SetStatus(self, Status)

    def Status(self):
        return _hklfile.run_controls_Status(self)

    def Set(self):
        return _hklfile.run_controls_Set(self)

    def StoreRunBatchSelection(self, runselection):
        return _hklfile.run_controls_StoreRunBatchSelection(self, runselection)

    def RunNumber(self, batchnumber):
        return _hklfile.run_controls_RunNumber(self, batchnumber)

    def RunNumberList(self):
        return _hklfile.run_controls_RunNumberList(self)

    def BatchRanges(self, RunNumber):
        return _hklfile.run_controls_BatchRanges(self, RunNumber)

    def InSelection(self, runnum, batchnum, originalbatchnum, filenum):
        return _hklfile.run_controls_InSelection(self, runnum, batchnum, originalbatchnum, filenum)

    def Explicit(self):
        return _hklfile.run_controls_Explicit(self)

    def Byfile(self):
        return _hklfile.run_controls_Byfile(self)

    def Auto(self):
        return _hklfile.run_controls_Auto(self)

    def StoreUseRun(self, userun):
        return _hklfile.run_controls_StoreUseRun(self, userun)

    def UseRun(self):
        return _hklfile.run_controls_UseRun(self)

    def StoreResoByRun(self, Run_resolution_ranges):
        return _hklfile.run_controls_StoreResoByRun(self, Run_resolution_ranges)

    def GetResoByRun(self):
        return _hklfile.run_controls_GetResoByRun(self)

    def ClearResoByRun(self):
        return _hklfile.run_controls_ClearResoByRun(self)

    def IsResoByRun(self):
        return _hklfile.run_controls_IsResoByRun(self)
    __swig_destroy__ = _hklfile.delete_run_controls
    __del__ = lambda self: None
run_controls_swigregister = _hklfile.run_controls_swigregister
run_controls_swigregister(run_controls)

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

    def __init__(self, *args):
        this = _hklfile.new_partial_controls(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def format(self):
        return _hklfile.partial_controls_format(self)

    def accept_fract_min(self, *args):
        return _hklfile.partial_controls_accept_fract_min(self, *args)

    def accept_fract_max(self, *args):
        return _hklfile.partial_controls_accept_fract_max(self, *args)

    def correct_fract_min(self, *args):
        return _hklfile.partial_controls_correct_fract_min(self, *args)

    def check(self, *args):
        return _hklfile.partial_controls_check(self, *args)

    def maxgap(self, *args):
        return _hklfile.partial_controls_maxgap(self, *args)

    def Clear(self):
        return _hklfile.partial_controls_Clear(self)

    def IncrementNrejGap(self):
        return _hklfile.partial_controls_IncrementNrejGap(self)

    def NrejGap(self):
        return _hklfile.partial_controls_NrejGap(self)

    def IncrementNrejFractionTooSmall(self):
        return _hklfile.partial_controls_IncrementNrejFractionTooSmall(self)

    def NrejFractionTooSmall(self):
        return _hklfile.partial_controls_NrejFractionTooSmall(self)

    def IncrementNrejFractionTooLarge(self):
        return _hklfile.partial_controls_IncrementNrejFractionTooLarge(self)

    def NrejFractionTooLarge(self):
        return _hklfile.partial_controls_NrejFractionTooLarge(self)

    def setNoPartials(self, noPartials):
        return _hklfile.partial_controls_setNoPartials(self, noPartials)

    def noPartials(self):
        return _hklfile.partial_controls_noPartials(self)
    __swig_destroy__ = _hklfile.delete_partial_controls
    __del__ = lambda self: None
partial_controls_swigregister = _hklfile.partial_controls_swigregister
partial_controls_swigregister(partial_controls)

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

    def __init__(self):
        this = _hklfile.new_col_controls()
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetIcolFlag(self, IcolFlag, Imid, Ipower=3):
        return _hklfile.col_controls_SetIcolFlag(self, IcolFlag, Imid, Ipower)

    def SetupColSelection(self, col_Ipr=1):
        return _hklfile.col_controls_SetupColSelection(self, col_Ipr)

    def IcolFlag(self):
        return _hklfile.col_controls_IcolFlag(self)

    def IsImidSet(self):
        return _hklfile.col_controls_IsImidSet(self)

    def BothIpresent(self):
        return _hklfile.col_controls_BothIpresent(self)
    __swig_destroy__ = _hklfile.delete_col_controls
    __del__ = lambda self: None
col_controls_swigregister = _hklfile.col_controls_swigregister
col_controls_swigregister(col_controls)

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

    def __init__(self, *args):
        this = _hklfile.new_AnalysisControls(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def NresoBins(self):
        return _hklfile.AnalysisControls_NresoBins(self)

    def NiBins(self):
        return _hklfile.AnalysisControls_NiBins(self)

    def ConeAngle(self):
        return _hklfile.AnalysisControls_ConeAngle(self)

    def MinimumHalfdatasetCC(self):
        return _hklfile.AnalysisControls_MinimumHalfdatasetCC(self)

    def MinimumHalfdatasetAnomCC(self):
        return _hklfile.AnalysisControls_MinimumHalfdatasetAnomCC(self)

    def MinimumIoverSigma(self):
        return _hklfile.AnalysisControls_MinimumIoverSigma(self)

    def MinimumBatchIoverSigma(self):
        return _hklfile.AnalysisControls_MinimumBatchIoverSigma(self)

    def NbatchSmooth(self):
        return _hklfile.AnalysisControls_NbatchSmooth(self)

    def SetNbatchSmooth(self, Nbatchsmooth):
        return _hklfile.AnalysisControls_SetNbatchSmooth(self, Nbatchsmooth)

    def DetectorAnalysis(self):
        return _hklfile.AnalysisControls_DetectorAnalysis(self)
    __swig_destroy__ = _hklfile.delete_AnalysisControls
    __del__ = lambda self: None
AnalysisControls_swigregister = _hklfile.AnalysisControls_swigregister
AnalysisControls_swigregister(AnalysisControls)

class RejectFlags(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RejectFlags, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RejectFlags, name)
    __repr__ = _swig_repr
    REJECT = _hklfile.RejectFlags_REJECT
    KEEP = _hklfile.RejectFlags_KEEP
    REJECTLARGER = _hklfile.RejectFlags_REJECTLARGER
    REJECTSMALLER = _hklfile.RejectFlags_REJECTSMALLER

    def __init__(self, *args):
        this = _hklfile.new_RejectFlags(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def format(self):
        return _hklfile.RejectFlags_format(self)

    def formatReject2Policy(self):
        return _hklfile.RejectFlags_formatReject2Policy(self)
    __swig_setmethods__["sdrej"] = _hklfile.RejectFlags_sdrej_set
    __swig_getmethods__["sdrej"] = _hklfile.RejectFlags_sdrej_get
    if _newclass:
        sdrej = _swig_property(_hklfile.RejectFlags_sdrej_get, _hklfile.RejectFlags_sdrej_set)
    __swig_setmethods__["sdrej2"] = _hklfile.RejectFlags_sdrej2_set
    __swig_getmethods__["sdrej2"] = _hklfile.RejectFlags_sdrej2_get
    if _newclass:
        sdrej2 = _swig_property(_hklfile.RejectFlags_sdrej2_get, _hklfile.RejectFlags_sdrej2_set)
    __swig_setmethods__["rej2policy"] = _hklfile.RejectFlags_rej2policy_set
    __swig_getmethods__["rej2policy"] = _hklfile.RejectFlags_rej2policy_get
    if _newclass:
        rej2policy = _swig_property(_hklfile.RejectFlags_rej2policy_get, _hklfile.RejectFlags_rej2policy_set)
    __swig_setmethods__["batchrejectfactor"] = _hklfile.RejectFlags_batchrejectfactor_set
    __swig_getmethods__["batchrejectfactor"] = _hklfile.RejectFlags_batchrejectfactor_get
    if _newclass:
        batchrejectfactor = _swig_property(_hklfile.RejectFlags_batchrejectfactor_get, _hklfile.RejectFlags_batchrejectfactor_set)
    __swig_destroy__ = _hklfile.delete_RejectFlags
    __del__ = lambda self: None
RejectFlags_swigregister = _hklfile.RejectFlags_swigregister
RejectFlags_swigregister(RejectFlags)

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

    def __init__(self, *args):
        this = _hklfile.new_OutlierControl(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Combine(self, *args):
        return _hklfile.OutlierControl_Combine(self, *args)

    def Anom(self):
        return _hklfile.OutlierControl_Anom(self)

    def SetNdatasets(self, Ndatasets):
        return _hklfile.OutlierControl_SetNdatasets(self, Ndatasets)

    def SetReject(self, flags, selclass, dts_index=-1):
        return _hklfile.OutlierControl_SetReject(self, flags, selclass, dts_index)

    def Reject(self, selclass, dts_index=0):
        return _hklfile.OutlierControl_Reject(self, selclass, dts_index)

    def SetEmax(self, Emax):
        return _hklfile.OutlierControl_SetEmax(self, Emax)

    def EMaxTest(self):
        return _hklfile.OutlierControl_EMaxTest(self)
    __swig_destroy__ = _hklfile.delete_OutlierControl
    __del__ = lambda self: None
OutlierControl_swigregister = _hklfile.OutlierControl_swigregister
OutlierControl_swigregister(OutlierControl)

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

    def __init__(self):
        this = _hklfile.new_RefineControl()
        try:
            self.this.append(this)
        except:
            self.this = this

    def BFGS(self, *args):
        return _hklfile.RefineControl_BFGS(self, *args)

    def Ncyc1(self, *args):
        return _hklfile.RefineControl_Ncyc1(self, *args)

    def Ncycles(self, *args):
        return _hklfile.RefineControl_Ncycles(self, *args)

    def Converge(self, *args):
        return _hklfile.RefineControl_Converge(self, *args)

    def IovSDmin(self, *args):
        return _hklfile.RefineControl_IovSDmin(self, *args)

    def E2min(self, *args):
        return _hklfile.RefineControl_E2min(self, *args)

    def E2max(self, *args):
        return _hklfile.RefineControl_E2max(self, *args)

    def Nprocs(self, *args):
        return _hklfile.RefineControl_Nprocs(self, *args)

    def SetNprocs(self, fproc):
        return _hklfile.RefineControl_SetNprocs(self, fproc)

    def format(self):
        return _hklfile.RefineControl_format(self)
    __swig_destroy__ = _hklfile.delete_RefineControl
    __del__ = lambda self: None
RefineControl_swigregister = _hklfile.RefineControl_swigregister
RefineControl_swigregister(RefineControl)

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

    def __init__(self):
        this = _hklfile.new_DatasetControl()
        try:
            self.this.append(this)
        except:
            self.this = this

    def BaseDataset(self):
        return _hklfile.DatasetControl_BaseDataset(self)
    __swig_destroy__ = _hklfile.delete_DatasetControl
    __del__ = lambda self: None
DatasetControl_swigregister = _hklfile.DatasetControl_swigregister
DatasetControl_swigregister(DatasetControl)

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

    def __init__(self):
        this = _hklfile.new_PolarizationControl()
        try:
            self.this.append(this)
        except:
            self.this = this

    def setFraction(self, Polarizationfraction):
        return _hklfile.PolarizationControl_setFraction(self, Polarizationfraction)

    def setDirection(self, PN):
        return _hklfile.PolarizationControl_setDirection(self, PN)

    def Factor(self):
        return _hklfile.PolarizationControl_Factor(self)

    def Fraction(self):
        return _hklfile.PolarizationControl_Fraction(self)

    def Normal(self):
        return _hklfile.PolarizationControl_Normal(self)

    def setEprimePi(self, Eprimepi):
        return _hklfile.PolarizationControl_setEprimePi(self, Eprimepi)

    def EprimePi(self):
        return _hklfile.PolarizationControl_EprimePi(self)

    def IsFractionSet(self):
        return _hklfile.PolarizationControl_IsFractionSet(self)

    def IsNormalSet(self):
        return _hklfile.PolarizationControl_IsNormalSet(self)
    __swig_getmethods__["Default"] = lambda x: _hklfile.PolarizationControl_Default
    if _newclass:
        Default = staticmethod(_hklfile.PolarizationControl_Default)
    __swig_destroy__ = _hklfile.delete_PolarizationControl
    __del__ = lambda self: None
PolarizationControl_swigregister = _hklfile.PolarizationControl_swigregister
PolarizationControl_swigregister(PolarizationControl)

def PolarizationControl_Default():
    return _hklfile.PolarizationControl_Default()
PolarizationControl_Default = _hklfile.PolarizationControl_Default

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

    def __init__(self):
        this = _hklfile.new_AnomalousControl()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["FlagInput"] = _hklfile.AnomalousControl_FlagInput_set
    __swig_getmethods__["FlagInput"] = _hklfile.AnomalousControl_FlagInput_get
    if _newclass:
        FlagInput = _swig_property(_hklfile.AnomalousControl_FlagInput_get, _hklfile.AnomalousControl_FlagInput_set)
    __swig_setmethods__["Anomalous"] = _hklfile.AnomalousControl_Anomalous_set
    __swig_getmethods__["Anomalous"] = _hklfile.AnomalousControl_Anomalous_get
    if _newclass:
        Anomalous = _swig_property(_hklfile.AnomalousControl_Anomalous_get, _hklfile.AnomalousControl_Anomalous_set)
    __swig_setmethods__["AnomalousSDcorr"] = _hklfile.AnomalousControl_AnomalousSDcorr_set
    __swig_getmethods__["AnomalousSDcorr"] = _hklfile.AnomalousControl_AnomalousSDcorr_get
    if _newclass:
        AnomalousSDcorr = _swig_property(_hklfile.AnomalousControl_AnomalousSDcorr_get, _hklfile.AnomalousControl_AnomalousSDcorr_set)
    __swig_setmethods__["anomslopethreshold"] = _hklfile.AnomalousControl_anomslopethreshold_set
    __swig_getmethods__["anomslopethreshold"] = _hklfile.AnomalousControl_anomslopethreshold_get
    if _newclass:
        anomslopethreshold = _swig_property(_hklfile.AnomalousControl_anomslopethreshold_get, _hklfile.AnomalousControl_anomslopethreshold_set)
    __swig_setmethods__["anomCCthreshold"] = _hklfile.AnomalousControl_anomCCthreshold_set
    __swig_getmethods__["anomCCthreshold"] = _hklfile.AnomalousControl_anomCCthreshold_get
    if _newclass:
        anomCCthreshold = _swig_property(_hklfile.AnomalousControl_anomCCthreshold_get, _hklfile.AnomalousControl_anomCCthreshold_set)
    __swig_setmethods__["anomRCRthreshold"] = _hklfile.AnomalousControl_anomRCRthreshold_set
    __swig_getmethods__["anomRCRthreshold"] = _hklfile.AnomalousControl_anomRCRthreshold_get
    if _newclass:
        anomRCRthreshold = _swig_property(_hklfile.AnomalousControl_anomRCRthreshold_get, _hklfile.AnomalousControl_anomRCRthreshold_set)
    __swig_setmethods__["anomNbinthreshold"] = _hklfile.AnomalousControl_anomNbinthreshold_set
    __swig_getmethods__["anomNbinthreshold"] = _hklfile.AnomalousControl_anomNbinthreshold_get
    if _newclass:
        anomNbinthreshold = _swig_property(_hklfile.AnomalousControl_anomNbinthreshold_get, _hklfile.AnomalousControl_anomNbinthreshold_set)
    __swig_destroy__ = _hklfile.delete_AnomalousControl
    __del__ = lambda self: None
AnomalousControl_swigregister = _hklfile.AnomalousControl_swigregister
AnomalousControl_swigregister(AnomalousControl)

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

    def __init__(self):
        this = _hklfile.new_all_controls()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["runs"] = _hklfile.all_controls_runs_set
    __swig_getmethods__["runs"] = _hklfile.all_controls_runs_get
    if _newclass:
        runs = _swig_property(_hklfile.all_controls_runs_get, _hklfile.all_controls_runs_set)
    __swig_setmethods__["partials"] = _hklfile.all_controls_partials_set
    __swig_getmethods__["partials"] = _hklfile.all_controls_partials_get
    if _newclass:
        partials = _swig_property(_hklfile.all_controls_partials_get, _hklfile.all_controls_partials_set)
    __swig_setmethods__["observationflagcontrol"] = _hklfile.all_controls_observationflagcontrol_set
    __swig_getmethods__["observationflagcontrol"] = _hklfile.all_controls_observationflagcontrol_get
    if _newclass:
        observationflagcontrol = _swig_property(_hklfile.all_controls_observationflagcontrol_get, _hklfile.all_controls_observationflagcontrol_set)
    __swig_setmethods__["analysis"] = _hklfile.all_controls_analysis_set
    __swig_getmethods__["analysis"] = _hklfile.all_controls_analysis_get
    if _newclass:
        analysis = _swig_property(_hklfile.all_controls_analysis_get, _hklfile.all_controls_analysis_set)
    __swig_setmethods__["outlierScale"] = _hklfile.all_controls_outlierScale_set
    __swig_getmethods__["outlierScale"] = _hklfile.all_controls_outlierScale_get
    if _newclass:
        outlierScale = _swig_property(_hklfile.all_controls_outlierScale_get, _hklfile.all_controls_outlierScale_set)
    __swig_setmethods__["outlierMerge"] = _hklfile.all_controls_outlierMerge_set
    __swig_getmethods__["outlierMerge"] = _hklfile.all_controls_outlierMerge_get
    if _newclass:
        outlierMerge = _swig_property(_hklfile.all_controls_outlierMerge_get, _hklfile.all_controls_outlierMerge_set)
    __swig_setmethods__["refinecontrol"] = _hklfile.all_controls_refinecontrol_set
    __swig_getmethods__["refinecontrol"] = _hklfile.all_controls_refinecontrol_get
    if _newclass:
        refinecontrol = _swig_property(_hklfile.all_controls_refinecontrol_get, _hklfile.all_controls_refinecontrol_set)
    __swig_setmethods__["anomalouscontrol"] = _hklfile.all_controls_anomalouscontrol_set
    __swig_getmethods__["anomalouscontrol"] = _hklfile.all_controls_anomalouscontrol_get
    if _newclass:
        anomalouscontrol = _swig_property(_hklfile.all_controls_anomalouscontrol_get, _hklfile.all_controls_anomalouscontrol_set)
    __swig_setmethods__["datasetcontrol"] = _hklfile.all_controls_datasetcontrol_set
    __swig_getmethods__["datasetcontrol"] = _hklfile.all_controls_datasetcontrol_get
    if _newclass:
        datasetcontrol = _swig_property(_hklfile.all_controls_datasetcontrol_get, _hklfile.all_controls_datasetcontrol_set)
    __swig_setmethods__["polarizationcontrol"] = _hklfile.all_controls_polarizationcontrol_set
    __swig_getmethods__["polarizationcontrol"] = _hklfile.all_controls_polarizationcontrol_get
    if _newclass:
        polarizationcontrol = _swig_property(_hklfile.all_controls_polarizationcontrol_get, _hklfile.all_controls_polarizationcontrol_set)
    __swig_destroy__ = _hklfile.delete_all_controls
    __del__ = lambda self: None
all_controls_swigregister = _hklfile.all_controls_swigregister
all_controls_swigregister(all_controls)

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

    def __init__(self, *args):
        this = _hklfile.new_EProb(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, Emax):
        return _hklfile.EProb_init(self, Emax)

    def Clear(self):
        return _hklfile.EProb_Clear(self)

    def Null(self):
        return _hklfile.EProb_Null(self)

    def TooBig(self, E2, Centric):
        return _hklfile.EProb_TooBig(self, E2, Centric)

    def format(self):
        return _hklfile.EProb_format(self)
    __swig_destroy__ = _hklfile.delete_EProb
    __del__ = lambda self: None
EProb_swigregister = _hklfile.EProb_swigregister
EProb_swigregister(EProb)

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

    def __init__(self, *args):
        this = _hklfile.new_hash_table(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_size(self, size):
        return _hklfile.hash_table_set_size(self, size)

    def Size(self):
        return _hklfile.hash_table_Size(self)

    def add(self, Nstore, Nfind):
        return _hklfile.hash_table_add(self, Nstore, Nfind)

    def lookup(self, Nstore):
        return _hklfile.hash_table_lookup(self, Nstore)

    def number(self, index):
        return _hklfile.hash_table_number(self, index)
    __swig_getmethods__["prime"] = lambda x: _hklfile.hash_table_prime
    if _newclass:
        prime = staticmethod(_hklfile.hash_table_prime)

    def Clear(self):
        return _hklfile.hash_table_Clear(self)

    def FormatSave(self):
        return _hklfile.hash_table_FormatSave(self)
    __swig_destroy__ = _hklfile.delete_hash_table
    __del__ = lambda self: None
hash_table_swigregister = _hklfile.hash_table_swigregister
hash_table_swigregister(hash_table)

def hash_table_prime(min_value):
    return _hklfile.hash_table_prime(min_value)
hash_table_prime = _hklfile.hash_table_prime

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

    def __init__(self):
        this = _hklfile.new_file_select()
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_reslimits(self, resrange):
        return _hklfile.file_select_set_reslimits(self, resrange)

    def reslimits(self):
        return _hklfile.file_select_reslimits(self)

    def in_reslimits(self, s):
        return _hklfile.file_select_in_reslimits(self, s)

    def accept_dataset(self, pxdname):
        return _hklfile.file_select_accept_dataset(self, pxdname)

    def accept_batch(self, batch_number, fileSeries):
        return _hklfile.file_select_accept_batch(self, batch_number, fileSeries)

    def BatchExclude(self):
        return _hklfile.file_select_BatchExclude(self)

    def incr_rej_mflag(self):
        return _hklfile.file_select_incr_rej_mflag(self)

    def incr_rej_reso(self):
        return _hklfile.file_select_incr_rej_reso(self)

    def Nrej_mflag(self):
        return _hklfile.file_select_Nrej_mflag(self)

    def Nrej_reso(self):
        return _hklfile.file_select_Nrej_reso(self)

    def InputScale(self, *args):
        return _hklfile.file_select_InputScale(self, *args)

    def NullResFrac(self, *args):
        return _hklfile.file_select_NullResFrac(self, *args)

    def NullNegativeReject(self, *args):
        return _hklfile.file_select_NullNegativeReject(self, *args)
    __swig_destroy__ = _hklfile.delete_file_select
    __del__ = lambda self: None
file_select_swigregister = _hklfile.file_select_swigregister
file_select_swigregister(file_select)


_hklfile.UNKNOWN_swigconstant(_hklfile)
UNKNOWN = _hklfile.UNKNOWN

_hklfile.CHIRAL_swigconstant(_hklfile)
CHIRAL = _hklfile.CHIRAL

_hklfile.NONCHIRAL_swigconstant(_hklfile)
NONCHIRAL = _hklfile.NONCHIRAL

_hklfile.CENTROSYMMETRIC_swigconstant(_hklfile)
CENTROSYMMETRIC = _hklfile.CENTROSYMMETRIC

def Chiral_as_string(chiral):
    return _hklfile.Chiral_as_string(chiral)
Chiral_as_string = _hklfile.Chiral_as_string

_hklfile.ALL_swigconstant(_hklfile)
ALL = _hklfile.ALL

_hklfile.BOTH_swigconstant(_hklfile)
BOTH = _hklfile.BOTH

_hklfile.IPLUS_swigconstant(_hklfile)
IPLUS = _hklfile.IPLUS

_hklfile.IMINUS_swigconstant(_hklfile)
IMINUS = _hklfile.IMINUS

def SpindleToPrincipleAxes(DUB):
    return _hklfile.SpindleToPrincipleAxes(DUB)
SpindleToPrincipleAxes = _hklfile.SpindleToPrincipleAxes

def SmallestComponent(v):
    return _hklfile.SmallestComponent(v)
SmallestComponent = _hklfile.SmallestComponent

def FormatSpindleToPrincipleAxes(DUB):
    return _hklfile.FormatSpindleToPrincipleAxes(DUB)
FormatSpindleToPrincipleAxes = _hklfile.FormatSpindleToPrincipleAxes
class IsigI(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IsigI, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IsigI, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _hklfile.new_IsigI(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def I(self, *args):
        return _hklfile.IsigI_I(self, *args)

    def sigI(self, *args):
        return _hklfile.IsigI_sigI(self, *args)

    def scale(self, *args):
        return _hklfile.IsigI_scale(self, *args)

    def scaleIs(self, *args):
        return _hklfile.IsigI_scaleIs(self, *args)

    def missing(self):
        return _hklfile.IsigI_missing(self)

    def missingI(self):
        return _hklfile.IsigI_missingI(self)

    def missingsigI(self):
        return _hklfile.IsigI_missingsigI(self)

    def is_null(self):
        return _hklfile.IsigI_is_null(self)
    __swig_destroy__ = _hklfile.delete_IsigI
    __del__ = lambda self: None
IsigI_swigregister = _hklfile.IsigI_swigregister
IsigI_swigregister(IsigI)

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

    def __init__(self, *args):
        this = _hklfile.new_ReindexOp(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetStrict(self, Strict):
        return _hklfile.ReindexOp_SetStrict(self, Strict)

    def Strict(self):
        return _hklfile.ReindexOp_Strict(self)

    def SetDeviation(self, Deviation):
        return _hklfile.ReindexOp_SetDeviation(self, Deviation)

    def Deviation(self):
        return _hklfile.ReindexOp_Deviation(self)

    def transpose(self):
        return _hklfile.ReindexOp_transpose(self)

    def inverse(self):
        return _hklfile.ReindexOp_inverse(self)

    def as_Dvec(self):
        return _hklfile.ReindexOp_as_Dvec(self)

    def IsIdentity(self):
        return _hklfile.ReindexOp_IsIdentity(self)

    def Positive(self):
        return _hklfile.ReindexOp_Positive(self)

    def IsTranslation(self):
        return _hklfile.ReindexOp_IsTranslation(self)

    def Symop(self, symop):
        return _hklfile.ReindexOp_Symop(self, symop)

    def as_hkl(self):
        return _hklfile.ReindexOp_as_hkl(self)

    def as_matrix(self):
        return _hklfile.ReindexOp_as_matrix(self)

    def as_XML(self):
        return _hklfile.ReindexOp_as_XML(self)

    def as_hkl_XML(self):
        return _hklfile.ReindexOp_as_hkl_XML(self)

    def equals(self, b, tol=1.0e-6):
        return _hklfile.ReindexOp_equals(self, b, tol)

    def FindSimplest(self, symm):
        return _hklfile.ReindexOp_FindSimplest(self, symm)
    __swig_destroy__ = _hklfile.delete_ReindexOp
    __del__ = lambda self: None
ReindexOp_swigregister = _hklfile.ReindexOp_swigregister
ReindexOp_swigregister(ReindexOp)

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

    def __init__(self, *args):
        this = _hklfile.new_MetricTensor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def lengthsq(self, *args):
        return _hklfile.MetricTensor_lengthsq(self, *args)

    def cell(self):
        return _hklfile.MetricTensor_cell(self)

    def inverse(self):
        return _hklfile.MetricTensor_inverse(self)

    def matrix(self):
        return _hklfile.MetricTensor_matrix(self)

    def format(self):
        return _hklfile.MetricTensor_format(self)
    __swig_destroy__ = _hklfile.delete_MetricTensor
    __del__ = lambda self: None
MetricTensor_swigregister = _hklfile.MetricTensor_swigregister
MetricTensor_swigregister(MetricTensor)

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

    def __init__(self, *args):
        this = _hklfile.new_Scell(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, rcell):
        return _hklfile.Scell_init(self, rcell)

    def formatPrint(self, newline=True):
        return _hklfile.Scell_formatPrint(self, newline)

    def dump(self):
        return _hklfile.Scell_dump(self)

    def Bmat(self):
        return _hklfile.Scell_Bmat(self)

    def rec_metric_tensor(self):
        return _hklfile.Scell_rec_metric_tensor(self)

    def UnitCell(self):
        return _hklfile.Scell_UnitCell(self)

    def ReciprocalCell(self):
        return _hklfile.Scell_ReciprocalCell(self)

    def change_basis(self, reindex_op):
        return _hklfile.Scell_change_basis(self, reindex_op)

    def format(self, w=7, p=2):
        return _hklfile.Scell_format(self, w, p)

    def xml(self, *args):
        return _hklfile.Scell_xml(self, *args)

    def ClipperCell(self):
        return _hklfile.Scell_ClipperCell(self)

    def Volume(self):
        return _hklfile.Scell_Volume(self)

    def AngleTest(self, AlphaTest, BetaTest, GammaTest, Tol=0.2):
        return _hklfile.Scell_AngleTest(self, AlphaTest, BetaTest, GammaTest, Tol)

    def equals(self, other, tolA=0.02, tolD=0.02):
        return _hklfile.Scell_equals(self, other, tolA, tolD)

    def equalsTol(self, other, AngularTolerance):
        return _hklfile.Scell_equalsTol(self, other, AngularTolerance)

    def Difference(self, other):
        return _hklfile.Scell_Difference(self, other)

    def null(self):
        return _hklfile.Scell_null(self)
    __swig_destroy__ = _hklfile.delete_Scell
    __del__ = lambda self: None
Scell_swigregister = _hklfile.Scell_swigregister
Scell_swigregister(Scell)

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

    def __init__(self, *args):
        this = _hklfile.new_UnitCellSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, Cells):
        return _hklfile.UnitCellSet_init(self, Cells)

    def clear(self):
        return _hklfile.UnitCellSet_clear(self)

    def AddCell(self, Cell):
        return _hklfile.UnitCellSet_AddCell(self, Cell)

    def AddCellSet(self, CellSet):
        return _hklfile.UnitCellSet_AddCellSet(self, CellSet)

    def Number(self):
        return _hklfile.UnitCellSet_Number(self)

    def Cells(self):
        return _hklfile.UnitCellSet_Cells(self)

    def AverageCell(self):
        return _hklfile.UnitCellSet_AverageCell(self)

    def Deviations(self):
        return _hklfile.UnitCellSet_Deviations(self)

    def WorstDeviation(self):
        return _hklfile.UnitCellSet_WorstDeviation(self)

    def RmsD(self):
        return _hklfile.UnitCellSet_RmsD(self)

    def Average(self, idxexclude=-1):
        return _hklfile.UnitCellSet_Average(self, idxexclude)

    def format(self):
        return _hklfile.UnitCellSet_format(self)
    __swig_destroy__ = _hklfile.delete_UnitCellSet
    __del__ = lambda self: None
UnitCellSet_swigregister = _hklfile.UnitCellSet_swigregister
UnitCellSet_swigregister(UnitCellSet)

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

    def __init__(self, *args):
        this = _hklfile.new_Hkl(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def h(self, *args):
        return _hklfile.Hkl_h(self, *args)

    def k(self, *args):
        return _hklfile.Hkl_k(self, *args)

    def l(self, *args):
        return _hklfile.Hkl_l(self, *args)

    def IsGeneral(self):
        return _hklfile.Hkl_IsGeneral(self)

    def HKL(self):
        return _hklfile.Hkl_HKL(self)

    def real(self):
        return _hklfile.Hkl_real(self)

    def invresolsq(self, cell):
        return _hklfile.Hkl_invresolsq(self, cell)

    def change_basis(self, *args):
        return _hklfile.Hkl_change_basis(self, *args)

    def orth(self, cell):
        return _hklfile.Hkl_orth(self, cell)

    def format(self):
        return _hklfile.Hkl_format(self)

    def code(self):
        return _hklfile.Hkl_code(self)
    __swig_destroy__ = _hklfile.delete_Hkl
    __del__ = lambda self: None
Hkl_swigregister = _hklfile.Hkl_swigregister
Hkl_swigregister(Hkl)


def HklDecode(kode):
    return _hklfile.HklDecode(kode)
HklDecode = _hklfile.HklDecode
class PxdName(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PxdName, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PxdName, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _hklfile.new_PxdName(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def pname(self, *args):
        return _hklfile.PxdName_pname(self, *args)

    def xname(self, *args):
        return _hklfile.PxdName_xname(self, *args)

    def dname(self, *args):
        return _hklfile.PxdName_dname(self, *args)

    def update(self, NewPxd):
        return _hklfile.PxdName_update(self, NewPxd)

    def formatPrint(self):
        return _hklfile.PxdName_formatPrint(self)

    def format(self):
        return _hklfile.PxdName_format(self)

    def is_blank(self):
        return _hklfile.PxdName_is_blank(self)
    __swig_destroy__ = _hklfile.delete_PxdName
    __del__ = lambda self: None
PxdName_swigregister = _hklfile.PxdName_swigregister
PxdName_swigregister(PxdName)

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

    def __init__(self, *args):
        this = _hklfile.new_Xdataset(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_batch(self, batch_num):
        return _hklfile.Xdataset_add_batch(self, batch_num)

    def ClearBatchList(self):
        return _hklfile.Xdataset_ClearBatchList(self)

    def num_batches(self):
        return _hklfile.Xdataset_num_batches(self)

    def change_basis(self, reindex_op):
        return _hklfile.Xdataset_change_basis(self, reindex_op)

    def AddRunIndex(self, RunIndex):
        return _hklfile.Xdataset_AddRunIndex(self, RunIndex)

    def ClearRunList(self):
        return _hklfile.Xdataset_ClearRunList(self)

    def RunIndexList(self):
        return _hklfile.Xdataset_RunIndexList(self)

    def pxdname(self):
        return _hklfile.Xdataset_pxdname(self)

    def setid(self, *args):
        return _hklfile.Xdataset_setid(self, *args)

    def cell(self, *args):
        return _hklfile.Xdataset_cell(self, *args)

    def SetCellWavelength(self, cell, wavel):
        return _hklfile.Xdataset_SetCellWavelength(self, cell, wavel)

    def wavelength(self):
        return _hklfile.Xdataset_wavelength(self)

    def Mosaicity(self, *args):
        return _hklfile.Xdataset_Mosaicity(self, *args)

    def formatPrint(self, first=True):
        return _hklfile.Xdataset_formatPrint(self, first)

    def AddCellWavelength(self, newcell, wavel):
        return _hklfile.Xdataset_AddCellWavelength(self, newcell, wavel)

    def AverageCellWavelength(self):
        return _hklfile.Xdataset_AverageCellWavelength(self)

    def NumberofCells(self):
        return _hklfile.Xdataset_NumberofCells(self)

    def AllCells(self):
        return _hklfile.Xdataset_AllCells(self)

    def AllWavelengths(self):
        return _hklfile.Xdataset_AllWavelengths(self)

    def formatAllCells(self):
        return _hklfile.Xdataset_formatAllCells(self)

    def WorstDeviation(self):
        return _hklfile.Xdataset_WorstDeviation(self)

    def ResRange(self, *args):
        return _hklfile.Xdataset_ResRange(self, *args)
    __swig_destroy__ = _hklfile.delete_Xdataset
    __del__ = lambda self: None
Xdataset_swigregister = _hklfile.Xdataset_swigregister
Xdataset_swigregister(Xdataset)

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

    def __init__(self, *args):
        this = _hklfile.new_BatchNumber(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Number(self):
        return _hklfile.BatchNumber_Number(self)

    def OriginalNumber(self):
        return _hklfile.BatchNumber_OriginalNumber(self)
    __swig_destroy__ = _hklfile.delete_BatchNumber
    __del__ = lambda self: None
BatchNumber_swigregister = _hklfile.BatchNumber_swigregister
BatchNumber_swigregister(BatchNumber)

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

    def __init__(self, *args):
        this = _hklfile.new_Batch(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def change_basis(self, reindex_op):
        return _hklfile.Batch_change_basis(self, reindex_op)

    def SetCellConstraint(self, lbcell):
        return _hklfile.Batch_SetCellConstraint(self, lbcell)

    def SetCell(self, newcell):
        return _hklfile.Batch_SetCell(self, newcell)

    def FileNumber(self, *args):
        return _hklfile.Batch_FileNumber(self, *args)

    def OffsetPhi(self, Phioffset):
        return _hklfile.Batch_OffsetPhi(self, Phioffset)

    def PhiOffset(self):
        return _hklfile.Batch_PhiOffset(self)

    def SetRunIndex(self, RunIndex):
        return _hklfile.Batch_SetRunIndex(self, RunIndex)

    def RunIndex(self):
        return _hklfile.Batch_RunIndex(self)

    def num(self, *args):
        return _hklfile.Batch_num(self, *args)

    def OffsetNum(self, Offset):
        return _hklfile.Batch_OffsetNum(self, Offset)

    def BatchNumberOffset(self):
        return _hklfile.Batch_BatchNumberOffset(self)

    def datasetindex(self, *args):
        return _hklfile.Batch_datasetindex(self, *args)

    def DatasetID(self, *args):
        return _hklfile.Batch_DatasetID(self, *args)

    def PXDname(self, *args):
        return _hklfile.Batch_PXDname(self, *args)

    def Phi1(self):
        return _hklfile.Batch_Phi1(self)

    def Phi2(self):
        return _hklfile.Batch_Phi2(self)

    def MidPhi(self):
        return _hklfile.Batch_MidPhi(self)

    def ValidPhi(self):
        return _hklfile.Batch_ValidPhi(self)

    def PhiRange(self):
        return _hklfile.Batch_PhiRange(self)

    def phiInRange(self, phitest, tolerance):
        return _hklfile.Batch_phiInRange(self, phitest, tolerance)

    def Time1(self):
        return _hklfile.Batch_Time1(self)

    def Time2(self):
        return _hklfile.Batch_Time2(self)

    def MidTime(self):
        return _hklfile.Batch_MidTime(self)

    def IsValidTime(self):
        return _hklfile.Batch_IsValidTime(self)

    def IsTimePhi(self):
        return _hklfile.Batch_IsTimePhi(self)

    def SetTimeColumnPresent(self):
        return _hklfile.Batch_SetTimeColumnPresent(self)

    def SetTimeColumnAbsent(self):
        return _hklfile.Batch_SetTimeColumnAbsent(self)

    def SetPhiAsProxyTime(self):
        return _hklfile.Batch_SetPhiAsProxyTime(self)

    def SetTimeReversedFromPhi(self):
        return _hklfile.Batch_SetTimeReversedFromPhi(self)

    def OffsetTime(self, Timeoffset):
        return _hklfile.Batch_OffsetTime(self, Timeoffset)

    def StoreTimeRange(self, Time1, Time2):
        return _hklfile.Batch_StoreTimeRange(self, Time1, Time2)

    def Accepted(self):
        return _hklfile.Batch_Accepted(self)

    def SetAccept(self, accept):
        return _hklfile.Batch_SetAccept(self, accept)

    def cell(self):
        return _hklfile.Batch_cell(self)

    def Mosaicity(self):
        return _hklfile.Batch_Mosaicity(self)

    def Wavelength(self):
        return _hklfile.Batch_Wavelength(self)

    def SetWavelength(self, wvl):
        return _hklfile.Batch_SetWavelength(self, wvl)

    def ValidOrientation(self):
        return _hklfile.Batch_ValidOrientation(self)

    def HtoSr(self, hkl, phi):
        return _hklfile.Batch_HtoSr(self, hkl, phi)

    def HtoSr0(self, hkl):
        return _hklfile.Batch_HtoSr0(self, hkl)

    def SrtoSr0(self, sr, phi):
        return _hklfile.Batch_SrtoSr0(self, sr, phi)

    def Sr0toP(self, sr0):
        return _hklfile.Batch_Sr0toP(self, sr0)

    def Umat(self):
        return _hklfile.Batch_Umat(self)

    def SpindleToPrincipleAxis(self):
        return _hklfile.Batch_SpindleToPrincipleAxis(self)

    def Source(self):
        return _hklfile.Batch_Source(self)

    def PhiScan(self):
        return _hklfile.Batch_PhiScan(self)

    def SetPole(self, Pole):
        return _hklfile.Batch_SetPole(self, Pole)

    def Pole(self):
        return _hklfile.Batch_Pole(self)

    def DetectorCoordinateRange(self):
        return _hklfile.Batch_DetectorCoordinateRange(self)

    def Ndet(self):
        return _hklfile.Batch_Ndet(self)

    def batchdata(self):
        return _hklfile.Batch_batchdata(self)

    def format(self):
        return _hklfile.Batch_format(self)

    def _print(self):
        return _hklfile.Batch__print(self)

    def SetLatticeNumber(self, latticenumber):
        return _hklfile.Batch_SetLatticeNumber(self, latticenumber)

    def LatticeNumber(self):
        return _hklfile.Batch_LatticeNumber(self)
    __swig_destroy__ = _hklfile.delete_Batch
    __del__ = lambda self: None
Batch_swigregister = _hklfile.Batch_swigregister
Batch_swigregister(Batch)


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

    def __init__(self):
        this = _hklfile.new_BatchSelection()
        try:
            self.this.append(this)
        except:
            self.this = this

    def clear(self):
        return _hklfile.BatchSelection_clear(self)

    def Null(self):
        return _hklfile.BatchSelection_Null(self)

    def AddBatch(self, batch, fileSeriesList):
        return _hklfile.BatchSelection_AddBatch(self, batch, fileSeriesList)

    def AddRange(self, batch1, batch2, fileSeriesList, flag=-1):
        return _hklfile.BatchSelection_AddRange(self, batch1, batch2, fileSeriesList, flag)

    def FindInSelection(self, batch, fileSeriesTest, testfinal=False):
        return _hklfile.BatchSelection_FindInSelection(self, batch, fileSeriesTest, testfinal)

    def FlagNumber(self, batch):
        return _hklfile.BatchSelection_FlagNumber(self, batch)

    def UniqueFlags(self):
        return _hklfile.BatchSelection_UniqueFlags(self)

    def BatchRanges(self, flag):
        return _hklfile.BatchSelection_BatchRanges(self, flag)

    def CheckSeries(self, NumFileSeries):
        return _hklfile.BatchSelection_CheckSeries(self, NumFileSeries)

    def InSelection(self, *args):
        return _hklfile.BatchSelection_InSelection(self, *args)
    __swig_destroy__ = _hklfile.delete_BatchSelection
    __del__ = lambda self: None
BatchSelection_swigregister = _hklfile.BatchSelection_swigregister
BatchSelection_swigregister(BatchSelection)

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

    def __init__(self, *args):
        this = _hklfile.new_FileRead(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Opened(self):
        return _hklfile.FileRead_Opened(self)

    def Read(self):
        return _hklfile.FileRead_Read(self)

    def SymmetrySet(self):
        return _hklfile.FileRead_SymmetrySet(self)

    def Nexcluded(self):
        return _hklfile.FileRead_Nexcluded(self)
    __swig_destroy__ = _hklfile.delete_FileRead
    __del__ = lambda self: None
FileRead_swigregister = _hklfile.FileRead_swigregister
FileRead_swigregister(FileRead)


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

    def __init__(self, *args):
        this = _hklfile.new_SpaceGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _hklfile.SpaceGroup_init(self, *args)

    def Null(self):
        return _hklfile.SpaceGroup_Null(self)

    def Symop(self, symN):
        return _hklfile.SpaceGroup_Symop(self, symN)

    def RotSymop(self, symN):
        return _hklfile.SpaceGroup_RotSymop(self, symN)

    def InvRotSymop(self, symN):
        return _hklfile.SpaceGroup_InvRotSymop(self, symN)

    def SymopFromIsym(self, isym):
        return _hklfile.SpaceGroup_SymopFromIsym(self, isym)

    def RotSymopCode(self, symN):
        return _hklfile.SpaceGroup_RotSymopCode(self, symN)

    def InvRotSymopCode(self, symN):
        return _hklfile.SpaceGroup_InvRotSymopCode(self, symN)

    def PattersonGroup(self):
        return _hklfile.SpaceGroup_PattersonGroup(self)

    def PointGroup(self):
        return _hklfile.SpaceGroup_PointGroup(self)

    def LatType(self):
        return _hklfile.SpaceGroup_LatType(self)

    def NewLatticePointGroup(self, Lattype):
        return _hklfile.SpaceGroup_NewLatticePointGroup(self, Lattype)

    def SymopCodes(self):
        return _hklfile.SpaceGroup_SymopCodes(self)

    def IsSymopIdentity(self, symN):
        return _hklfile.SpaceGroup_IsSymopIdentity(self, symN)

    def formatAllSymops_as_xyz(self):
        return _hklfile.SpaceGroup_formatAllSymops_as_xyz(self)

    def formatAllSymops_as_hkl(self):
        return _hklfile.SpaceGroup_formatAllSymops_as_hkl(self)

    def formatISYM_as_hkl(self):
        return _hklfile.SpaceGroup_formatISYM_as_hkl(self)

    def Symbol_hm(self):
        return _hklfile.SpaceGroup_Symbol_hm(self)

    def Symbol_hall(self):
        return _hklfile.SpaceGroup_Symbol_hall(self)

    def Spacegroup_number(self):
        return _hklfile.SpaceGroup_Spacegroup_number(self)

    def CCP4_Spacegroup_number(self):
        return _hklfile.SpaceGroup_CCP4_Spacegroup_number(self)

    def put_in_asu(self, hkl, isym):
        return _hklfile.SpaceGroup_put_in_asu(self, hkl, isym)

    def get_from_asu(self, hkl, isym):
        return _hklfile.SpaceGroup_get_from_asu(self, hkl, isym)

    def ChangeBasis(self, reindex):
        return _hklfile.SpaceGroup_ChangeBasis(self, reindex)
    __swig_getmethods__["isNameCentredTriclinic"] = lambda x: _hklfile.SpaceGroup_isNameCentredTriclinic
    if _newclass:
        isNameCentredTriclinic = staticmethod(_hklfile.SpaceGroup_isNameCentredTriclinic)
    __swig_destroy__ = _hklfile.delete_SpaceGroup
    __del__ = lambda self: None
SpaceGroup_swigregister = _hklfile.SpaceGroup_swigregister
SpaceGroup_swigregister(SpaceGroup)

def SpaceGroup_isNameCentredTriclinic(name):
    return _hklfile.SpaceGroup_isNameCentredTriclinic(name)
SpaceGroup_isNameCentredTriclinic = _hklfile.SpaceGroup_isNameCentredTriclinic

class SymElement(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymElement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymElement, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Nfold"] = _hklfile.SymElement_Nfold_set
    __swig_getmethods__["Nfold"] = _hklfile.SymElement_Nfold_get
    if _newclass:
        Nfold = _swig_property(_hklfile.SymElement_Nfold_get, _hklfile.SymElement_Nfold_set)
    __swig_setmethods__["iaxis"] = _hklfile.SymElement_iaxis_set
    __swig_getmethods__["iaxis"] = _hklfile.SymElement_iaxis_get
    if _newclass:
        iaxis = _swig_property(_hklfile.SymElement_iaxis_get, _hklfile.SymElement_iaxis_set)
    __swig_setmethods__["symops"] = _hklfile.SymElement_symops_set
    __swig_getmethods__["symops"] = _hklfile.SymElement_symops_get
    if _newclass:
        symops = _swig_property(_hklfile.SymElement_symops_get, _hklfile.SymElement_symops_set)

    def __init__(self):
        this = _hklfile.new_SymElement()
        try:
            self.this.append(this)
        except:
            self.this = this

    def _print(self):
        return _hklfile.SymElement__print(self)
    __swig_destroy__ = _hklfile.delete_SymElement
    __del__ = lambda self: None
SymElement_swigregister = _hklfile.SymElement_swigregister
SymElement_swigregister(SymElement)

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

    def __init__(self, *args):
        this = _hklfile.new_hkl_symmetry(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def IsNull(self):
        return _hklfile.hkl_symmetry_IsNull(self)

    def set_reindex(self, op):
        return _hklfile.hkl_symmetry_set_reindex(self, op)

    def GetSpaceGroup(self):
        return _hklfile.hkl_symmetry_GetSpaceGroup(self)

    def ClipperGroup(self):
        return _hklfile.hkl_symmetry_ClipperGroup(self)

    def get_from_asu(self, hkl, isym):
        return _hklfile.hkl_symmetry_get_from_asu(self, hkl, isym)

    def is_centric(self, hkl):
        return _hklfile.hkl_symmetry_is_centric(self, hkl)

    def epsilon(self, hkl):
        return _hklfile.hkl_symmetry_epsilon(self, hkl)

    def IsCentro(self):
        return _hklfile.hkl_symmetry_IsCentro(self)

    def IsChiral(self):
        return _hklfile.hkl_symmetry_IsChiral(self)

    def LatticePresent(self, hkl):
        return _hklfile.hkl_symmetry_LatticePresent(self, hkl)

    def ChangeBasis(self, reindex):
        return _hklfile.hkl_symmetry_ChangeBasis(self, reindex)

    def Nelement(self):
        return _hklfile.hkl_symmetry_Nelement(self)

    def IsElementIdent(self, kelement):
        return _hklfile.hkl_symmetry_IsElementIdent(self, kelement)
    __swig_getmethods__["AxisDirection"] = lambda x: _hklfile.hkl_symmetry_AxisDirection
    if _newclass:
        AxisDirection = staticmethod(_hklfile.hkl_symmetry_AxisDirection)

    def AxisString(self, *args):
        return _hklfile.hkl_symmetry_AxisString(self, *args)

    def format_element(self, kelement):
        return _hklfile.hkl_symmetry_format_element(self, kelement)

    def XML_element(self, kelement):
        return _hklfile.hkl_symmetry_XML_element(self, kelement)

    def print_element(self, idx):
        return _hklfile.hkl_symmetry_print_element(self, idx)

    def print_elements(self):
        return _hklfile.hkl_symmetry_print_elements(self)

    def NopInElement(self, kelement):
        return _hklfile.hkl_symmetry_NopInElement(self, kelement)

    def SymopInElement(self, j, kelement):
        return _hklfile.hkl_symmetry_SymopInElement(self, j, kelement)

    def ClipperSymopInElement(self, lsym, kelement):
        return _hklfile.hkl_symmetry_ClipperSymopInElement(self, lsym, kelement)

    def get_symelmt(self, *args):
        return _hklfile.hkl_symmetry_get_symelmt(self, *args)

    def symbol_Hall(self):
        return _hklfile.hkl_symmetry_symbol_Hall(self)

    def symbol_xHM(self, *args):
        return _hklfile.hkl_symmetry_symbol_xHM(self, *args)

    def symbol(self):
        return _hklfile.hkl_symmetry_symbol(self)

    def lattice_type(self):
        return _hklfile.hkl_symmetry_lattice_type(self)

    def NsymP(self):
        return _hklfile.hkl_symmetry_NsymP(self)

    def Nsym(self):
        return _hklfile.hkl_symmetry_Nsym(self)

    def RotSymopsInElement(self, kelement):
        return _hklfile.hkl_symmetry_RotSymopsInElement(self, kelement)

    def PrimRotSymops(self):
        return _hklfile.hkl_symmetry_PrimRotSymops(self)

    def CrysSys(self):
        return _hklfile.hkl_symmetry_CrysSys(self)

    def formatCrysSys(self):
        return _hklfile.hkl_symmetry_formatCrysSys(self)

    def CellConstraint(self):
        return _hklfile.hkl_symmetry_CellConstraint(self)

    def equals_rt(self, other):
        return _hklfile.hkl_symmetry_equals_rt(self, other)

    def equals_r(self, other):
        return _hklfile.hkl_symmetry_equals_r(self, other)

    def equals_r_order(self, other):
        return _hklfile.hkl_symmetry_equals_r_order(self, other)

    def __eq__(self, other):
        return _hklfile.hkl_symmetry___eq__(self, other)

    def __ne__(self, other):
        return _hklfile.hkl_symmetry___ne__(self, other)

    def equalElement(self, jel, other, jel2):
        return _hklfile.hkl_symmetry_equalElement(self, jel, other, jel2)
    __swig_destroy__ = _hklfile.delete_hkl_symmetry
    __del__ = lambda self: None
hkl_symmetry_swigregister = _hklfile.hkl_symmetry_swigregister
hkl_symmetry_swigregister(hkl_symmetry)

def hkl_symmetry_AxisDirection(*args):
    return _hklfile.hkl_symmetry_AxisDirection(*args)
hkl_symmetry_AxisDirection = _hklfile.hkl_symmetry_AxisDirection

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

    def __init__(self, Resolution, width):
        this = _hklfile.new_IceRing(Resolution, width)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Dstar(self):
        return _hklfile.IceRing_Dstar(self)

    def InRing(self, invresolsq):
        return _hklfile.IceRing_InRing(self, invresolsq)

    def ClearSums(self):
        return _hklfile.IceRing_ClearSums(self)

    def AddObs(self, I_sigI, invresolsq):
        return _hklfile.IceRing_AddObs(self, I_sigI, invresolsq)

    def SetReject(self, *args):
        return _hklfile.IceRing_SetReject(self, *args)

    def MeanI(self):
        return _hklfile.IceRing_MeanI(self)

    def MeanSigI(self):
        return _hklfile.IceRing_MeanSigI(self)

    def MeanSSqr(self):
        return _hklfile.IceRing_MeanSSqr(self)

    def N(self):
        return _hklfile.IceRing_N(self)

    def Reject(self):
        return _hklfile.IceRing_Reject(self)
    __swig_destroy__ = _hklfile.delete_IceRing
    __del__ = lambda self: None
IceRing_swigregister = _hklfile.IceRing_swigregister
IceRing_swigregister(IceRing)

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

    def __init__(self):
        this = _hklfile.new_Rings()
        try:
            self.this.append(this)
        except:
            self.this = this

    def AddRing(self, Resolution, width):
        return _hklfile.Rings_AddRing(self, Resolution, width)

    def DefaultIceRings(self):
        return _hklfile.Rings_DefaultIceRings(self)

    def Clear(self):
        return _hklfile.Rings_Clear(self)

    def Nrings(self):
        return _hklfile.Rings_Nrings(self)

    def Dstar(self, iring):
        return _hklfile.Rings_Dstar(self, iring)

    def CopyRejRings(self, other):
        return _hklfile.Rings_CopyRejRings(self, other)

    def InRing(self, invresolsq):
        return _hklfile.Rings_InRing(self, invresolsq)

    def ClearSums(self):
        return _hklfile.Rings_ClearSums(self)

    def AddObs(self, Iring, I_sigI, invresolsq):
        return _hklfile.Rings_AddObs(self, Iring, I_sigI, invresolsq)

    def SetReject(self, *args):
        return _hklfile.Rings_SetReject(self, *args)

    def MeanI(self, Iring):
        return _hklfile.Rings_MeanI(self, Iring)

    def MeanSigI(self, Iring):
        return _hklfile.Rings_MeanSigI(self, Iring)

    def MeanSSqr(self, Iring):
        return _hklfile.Rings_MeanSSqr(self, Iring)

    def Reject(self, Iring):
        return _hklfile.Rings_Reject(self, Iring)

    def N(self, Iring):
        return _hklfile.Rings_N(self, Iring)
    __swig_destroy__ = _hklfile.delete_Rings
    __del__ = lambda self: None
Rings_swigregister = _hklfile.Rings_swigregister
Rings_swigregister(Rings)


def SetCMat33(*args):
    return _hklfile.SetCMat33(*args)
SetCMat33 = _hklfile.SetCMat33

def SetDiagCMat33(v):
    return _hklfile.SetDiagCMat33(v)
SetDiagCMat33 = _hklfile.SetDiagCMat33

def SetVMat33(*args):
    return _hklfile.SetVMat33(*args)
SetVMat33 = _hklfile.SetVMat33

def is_mat33_ident(*args):
    return _hklfile.is_mat33_ident(*args)
is_mat33_ident = _hklfile.is_mat33_ident

def is_rtop_ident(R):
    return _hklfile.is_rtop_ident(R)
is_rtop_ident = _hklfile.is_rtop_ident

def FormatSymop_as_hkl(*args):
    return _hklfile.FormatSymop_as_hkl(*args)
FormatSymop_as_hkl = _hklfile.FormatSymop_as_hkl

def FormatReindex_as_hkl(*args):
    return _hklfile.FormatReindex_as_hkl(*args)
FormatReindex_as_hkl = _hklfile.FormatReindex_as_hkl

def IntVec(vector):
    return _hklfile.IntVec(vector)
IntVec = _hklfile.IntVec

def LsqTransform(x, y, E, AvoidPlanar=False):
    return _hklfile.LsqTransform(x, y, E, AvoidPlanar)
LsqTransform = _hklfile.LsqTransform

def AxisDirection(R):
    return _hklfile.AxisDirection(R)
AxisDirection = _hklfile.AxisDirection
class MtzUnmrgFile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MtzUnmrgFile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MtzUnmrgFile, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _hklfile.delete_MtzUnmrgFile
    __del__ = lambda self: None

    def clear(self):
        return _hklfile.MtzUnmrgFile_clear(self)

    def __init__(self, *args):
        this = _hklfile.new_MtzUnmrgFile(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def open_read(self, filename_in):
        return _hklfile.MtzUnmrgFile_open_read(self, filename_in)

    def close_read(self):
        return _hklfile.MtzUnmrgFile_close_read(self)

    def FillHklList(self, mtzname, output, verbose, hkl_list):
        return _hklfile.MtzUnmrgFile_FillHklList(self, mtzname, output, verbose, hkl_list)

    def AddHklList(self, fileSeries, mtzname, file_sel, column_selection, column_label_list, controls, InputPxdName, cell, cellTolerance, output, verbose, hkl_list):
        return _hklfile.MtzUnmrgFile_AddHklList(self, fileSeries, mtzname, file_sel, column_selection, column_label_list, controls, InputPxdName, cell, cellTolerance, output, verbose, hkl_list)

    def Nrec(self):
        return _hklfile.MtzUnmrgFile_Nrec(self)

    def Ncols(self):
        return _hklfile.MtzUnmrgFile_Ncols(self)

    def Sorted(self):
        return _hklfile.MtzUnmrgFile_Sorted(self)

    def Merged(self):
        return _hklfile.MtzUnmrgFile_Merged(self)

    def Spacegroup(self):
        return _hklfile.MtzUnmrgFile_Spacegroup(self)

    def BatchList(self):
        return _hklfile.MtzUnmrgFile_BatchList(self)

    def Cell(self):
        return _hklfile.MtzUnmrgFile_Cell(self)

    def mtz_file(self):
        return _hklfile.MtzUnmrgFile_mtz_file(self)

    def ResRangeFile(self):
        return _hklfile.MtzUnmrgFile_ResRangeFile(self)

    def ResRange(self):
        return _hklfile.MtzUnmrgFile_ResRange(self)

    def Rewind(self):
        return _hklfile.MtzUnmrgFile_Rewind(self)

    def Rrefl(self, cols, col_mnf):
        return _hklfile.MtzUnmrgFile_Rrefl(self, cols, col_mnf)

    def get_dataset(self, kdataset, this_dataset):
        return _hklfile.MtzUnmrgFile_get_dataset(self, kdataset, this_dataset)

    def get_batch(self, kbatch, this_batch):
        return _hklfile.MtzUnmrgFile_get_batch(self, kbatch, this_batch)

    def get_title(self):
        return _hklfile.MtzUnmrgFile_get_title(self)

    def FilenameIn(self):
        return _hklfile.MtzUnmrgFile_FilenameIn(self)

    def ColumnSelect(self):
        return _hklfile.MtzUnmrgFile_ColumnSelect(self)

    def ColumnLabels(self):
        return _hklfile.MtzUnmrgFile_ColumnLabels(self)

    def NumberofLattices(self):
        return _hklfile.MtzUnmrgFile_NumberofLattices(self)

    def NumberofMainLattices(self):
        return _hklfile.MtzUnmrgFile_NumberofMainLattices(self)

    def NumberinLattice(self):
        return _hklfile.MtzUnmrgFile_NumberinLattice(self)

    def LatticeNumber(self):
        return _hklfile.MtzUnmrgFile_LatticeNumber(self)

    def LatticeNumberRange(self):
        return _hklfile.MtzUnmrgFile_LatticeNumberRange(self)

    def MainLatticeNumberRange(self):
        return _hklfile.MtzUnmrgFile_MainLatticeNumberRange(self)
MtzUnmrgFile_swigregister = _hklfile.MtzUnmrgFile_swigregister
MtzUnmrgFile_swigregister(MtzUnmrgFile)


def ClipperSymopsFromMtzSYMGRP(mtzsym):
    return _hklfile.ClipperSymopsFromMtzSYMGRP(mtzsym)
ClipperSymopsFromMtzSYMGRP = _hklfile.ClipperSymopsFromMtzSYMGRP

def spg_to_mtz(cspgp, HorR, spg_status):
    return _hklfile.spg_to_mtz(cspgp, HorR, spg_status)
spg_to_mtz = _hklfile.spg_to_mtz

def CmtzSymgrpEqual(sg1, sg2):
    return _hklfile.CmtzSymgrpEqual(sg1, sg2)
CmtzSymgrpEqual = _hklfile.CmtzSymgrpEqual

def ccp4_write_spacegroup(mtzout, sg, spg_status):
    return _hklfile.ccp4_write_spacegroup(mtzout, sg, spg_status)
ccp4_write_spacegroup = _hklfile.ccp4_write_spacegroup

def addToHistory(oldhistory):
    return _hklfile.addToHistory(oldhistory)
addToHistory = _hklfile.addToHistory

def MTZaddHistory(oldhistory, mtzout):
    return _hklfile.MTZaddHistory(oldhistory, mtzout)
MTZaddHistory = _hklfile.MTZaddHistory

def PackFlagValues(BGratio, PKratio, Gradient):
    return _hklfile.PackFlagValues(BGratio, PKratio, Gradient)
PackFlagValues = _hklfile.PackFlagValues
class ObservationFlag(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObservationFlag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ObservationFlag, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _hklfile.new_ObservationFlag(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def AddFlag(self, other):
        return _hklfile.ObservationFlag_AddFlag(self, other)

    def OK(self):
        return _hklfile.ObservationFlag_OK(self)

    def Flags(self):
        return _hklfile.ObservationFlag_Flags(self)

    def BgPk(self):
        return _hklfile.ObservationFlag_BgPk(self)

    def BgPkValues(self, BGratio, PKratio, Gradient):
        return _hklfile.ObservationFlag_BgPkValues(self, BGratio, PKratio, Gradient)

    def TestBGratio(self):
        return _hklfile.ObservationFlag_TestBGratio(self)

    def TestPKratio(self):
        return _hklfile.ObservationFlag_TestPKratio(self)

    def TestTooNeg(self):
        return _hklfile.ObservationFlag_TestTooNeg(self)

    def TestGradient(self):
        return _hklfile.ObservationFlag_TestGradient(self)

    def TestOverload(self):
        return _hklfile.ObservationFlag_TestOverload(self)

    def TestEdge(self):
        return _hklfile.ObservationFlag_TestEdge(self)

    def TestMisfit(self):
        return _hklfile.ObservationFlag_TestMisfit(self)

    def format(self):
        return _hklfile.ObservationFlag_format(self)
    __swig_destroy__ = _hklfile.delete_ObservationFlag
    __del__ = lambda self: None
ObservationFlag_swigregister = _hklfile.ObservationFlag_swigregister
ObservationFlag_swigregister(ObservationFlag)
cvar = _hklfile.cvar
ObservationFlag.FLAG_BGRATIO = _hklfile.cvar.ObservationFlag_FLAG_BGRATIO
ObservationFlag.FLAG_PKRATIO = _hklfile.cvar.ObservationFlag_FLAG_PKRATIO
ObservationFlag.FLAG_TOONEGATIVE = _hklfile.cvar.ObservationFlag_FLAG_TOONEGATIVE
ObservationFlag.FLAG_GRADIENT = _hklfile.cvar.ObservationFlag_FLAG_GRADIENT
ObservationFlag.FLAG_OVERLOAD = _hklfile.cvar.ObservationFlag_FLAG_OVERLOAD
ObservationFlag.FLAG_EDGE = _hklfile.cvar.ObservationFlag_FLAG_EDGE
ObservationFlag.FLAG_MISFIT = _hklfile.cvar.ObservationFlag_FLAG_MISFIT

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

    def __init__(self, *args):
        this = _hklfile.new_ObservationFlagControl(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetBGRlimit(self, BGrlim):
        return _hklfile.ObservationFlagControl_SetBGRlimit(self, BGrlim)

    def SetPKRlimit(self, PKrlim):
        return _hklfile.ObservationFlagControl_SetPKRlimit(self, PKrlim)

    def SetGradlimit(self, Gradlim):
        return _hklfile.ObservationFlagControl_SetGradlimit(self, Gradlim)

    def SetAcceptOverload(self):
        return _hklfile.ObservationFlagControl_SetAcceptOverload(self)

    def SetAcceptEdge(self):
        return _hklfile.ObservationFlagControl_SetAcceptEdge(self)

    def SetAcceptMisfit(self):
        return _hklfile.ObservationFlagControl_SetAcceptMisfit(self)

    def IsAccepted(self, flag):
        return _hklfile.ObservationFlagControl_IsAccepted(self, flag)

    def Init(self):
        return _hklfile.ObservationFlagControl_Init(self)

    def Clear(self):
        return _hklfile.ObservationFlagControl_Clear(self)

    def PrintCounts(self):
        return _hklfile.ObservationFlagControl_PrintCounts(self)

    def asXML(self):
        return _hklfile.ObservationFlagControl_asXML(self)

    def NumAccOverload(self):
        return _hklfile.ObservationFlagControl_NumAccOverload(self)
    __swig_destroy__ = _hklfile.delete_ObservationFlagControl
    __del__ = lambda self: None
ObservationFlagControl_swigregister = _hklfile.ObservationFlagControl_swigregister
ObservationFlagControl_swigregister(ObservationFlagControl)

class ObservationStatus(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObservationStatus, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ObservationStatus, name)
    __repr__ = _swig_repr
    OBSSTAT_FLAG = _hklfile.ObservationStatus_OBSSTAT_FLAG
    OBSSTAT_RESOLUTION = _hklfile.ObservationStatus_OBSSTAT_RESOLUTION
    OBSSTAT_OUTLIER = _hklfile.ObservationStatus_OBSSTAT_OUTLIER
    OBSSTAT_OUTLIERANOM = _hklfile.ObservationStatus_OBSSTAT_OUTLIERANOM
    OBSSTAT_EMAX = _hklfile.ObservationStatus_OBSSTAT_EMAX
    OBSSTAT_STRONG = _hklfile.ObservationStatus_OBSSTAT_STRONG
    OBSSTAT_WEAK = _hklfile.ObservationStatus_OBSSTAT_WEAK
    OBSSTAT_OVERLAP = _hklfile.ObservationStatus_OBSSTAT_OVERLAP
    OBSSTAT_RUN = _hklfile.ObservationStatus_OBSSTAT_RUN
    OBSSTAT_BATCH = _hklfile.ObservationStatus_OBSSTAT_BATCH

    def __init__(self, *args):
        this = _hklfile.new_ObservationStatus(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Clear(self):
        return _hklfile.ObservationStatus_Clear(self)

    def IsAccepted(self):
        return _hklfile.ObservationStatus_IsAccepted(self)

    def ResetStatus(self):
        return _hklfile.ObservationStatus_ResetStatus(self)

    def ResetStatusAll(self):
        return _hklfile.ObservationStatus_ResetStatusAll(self)

    def IsOKforRogues(self):
        return _hklfile.ObservationStatus_IsOKforRogues(self)

    def Bitflags(self):
        return _hklfile.ObservationStatus_Bitflags(self)

    def SetObsFlag(self):
        return _hklfile.ObservationStatus_SetObsFlag(self)

    def UnsetObsFlag(self):
        return _hklfile.ObservationStatus_UnsetObsFlag(self)

    def TestObsFlag(self):
        return _hklfile.ObservationStatus_TestObsFlag(self)

    def SetResolution(self):
        return _hklfile.ObservationStatus_SetResolution(self)

    def UnSetResolution(self):
        return _hklfile.ObservationStatus_UnSetResolution(self)

    def TestResolution(self):
        return _hklfile.ObservationStatus_TestResolution(self)

    def SetOutlier(self):
        return _hklfile.ObservationStatus_SetOutlier(self)

    def UnsetOutlier(self):
        return _hklfile.ObservationStatus_UnsetOutlier(self)

    def TestOutlier(self):
        return _hklfile.ObservationStatus_TestOutlier(self)

    def SetOutlierAnom(self):
        return _hklfile.ObservationStatus_SetOutlierAnom(self)

    def UnsetOutlierAnom(self):
        return _hklfile.ObservationStatus_UnsetOutlierAnom(self)

    def TestOutlierAnom(self):
        return _hklfile.ObservationStatus_TestOutlierAnom(self)

    def SetEmax(self):
        return _hklfile.ObservationStatus_SetEmax(self)

    def UnsetEmax(self):
        return _hklfile.ObservationStatus_UnsetEmax(self)

    def TestEmax(self):
        return _hklfile.ObservationStatus_TestEmax(self)

    def SetTooStrong(self):
        return _hklfile.ObservationStatus_SetTooStrong(self)

    def UnsetTooStrong(self):
        return _hklfile.ObservationStatus_UnsetTooStrong(self)

    def TestTooStrong(self):
        return _hklfile.ObservationStatus_TestTooStrong(self)

    def SetTooWeak(self):
        return _hklfile.ObservationStatus_SetTooWeak(self)

    def UnsetTooWeak(self):
        return _hklfile.ObservationStatus_UnsetTooWeak(self)

    def TestTooWeak(self):
        return _hklfile.ObservationStatus_TestTooWeak(self)

    def SetRejectOverlap(self):
        return _hklfile.ObservationStatus_SetRejectOverlap(self)

    def UnsetRejectOverlap(self):
        return _hklfile.ObservationStatus_UnsetRejectOverlap(self)

    def TestRejectOverlap(self):
        return _hklfile.ObservationStatus_TestRejectOverlap(self)

    def SetRejectRun(self):
        return _hklfile.ObservationStatus_SetRejectRun(self)

    def UnsetRejectRun(self):
        return _hklfile.ObservationStatus_UnsetRejectRun(self)

    def TestRejectRun(self):
        return _hklfile.ObservationStatus_TestRejectRun(self)

    def SetRejectBatch(self):
        return _hklfile.ObservationStatus_SetRejectBatch(self)

    def UnsetRejectBatch(self):
        return _hklfile.ObservationStatus_UnsetRejectBatch(self)

    def TestRejectBatch(self):
        return _hklfile.ObservationStatus_TestRejectBatch(self)

    def format(self):
        return _hklfile.ObservationStatus_format(self)
    __swig_destroy__ = _hklfile.delete_ObservationStatus
    __del__ = lambda self: None
ObservationStatus_swigregister = _hklfile.ObservationStatus_swigregister
ObservationStatus_swigregister(ObservationStatus)

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

    def __init__(self):
        this = _hklfile.new_ObservationStatusSet()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hklfile.delete_ObservationStatusSet
    __del__ = lambda self: None
ObservationStatusSet_swigregister = _hklfile.ObservationStatusSet_swigregister
ObservationStatusSet_swigregister(ObservationStatusSet)


def setup_columns():
    return _hklfile.setup_columns()
setup_columns = _hklfile.setup_columns
class Range(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Range, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Range, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _hklfile.new_Range(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hklfile.delete_Range
    __del__ = lambda self: None

    def AllowDescending(self):
        return _hklfile.Range_AllowDescending(self)

    def SetRange(self, Rfirst, Rlast, Ascending=True, Nbin=0):
        return _hklfile.Range_SetRange(self, Rfirst, Rlast, Ascending, Nbin)

    def SetNbin(self, Nbin):
        return _hklfile.Range_SetNbin(self, Nbin)

    def clear(self):
        return _hklfile.Range_clear(self)

    def update(self, value):
        return _hklfile.Range_update(self, value)

    def first(self, *args):
        return _hklfile.Range_first(self, *args)

    def last(self, *args):
        return _hklfile.Range_last(self, *args)

    def min(self):
        return _hklfile.Range_min(self)

    def max(self):
        return _hklfile.Range_max(self)

    def AbsRange(self):
        return _hklfile.Range_AbsRange(self)

    def bin(self, value):
        return _hklfile.Range_bin(self, value)

    def tbin(self, value):
        return _hklfile.Range_tbin(self, value)

    def Nbins(self):
        return _hklfile.Range_Nbins(self)

    def bounds(self, bin):
        return _hklfile.Range_bounds(self, bin)

    def middle(self, bin):
        return _hklfile.Range_middle(self, bin)

    def Valid(self):
        return _hklfile.Range_Valid(self)

    def format(self):
        return _hklfile.Range_format(self)
Range_swigregister = _hklfile.Range_swigregister
Range_swigregister(Range)
MAXNCOLUMNS = cvar.MAXNCOLUMNS

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

    def __init__(self, *args):
        this = _hklfile.new_ResoRange(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init_range(self, range):
        return _hklfile.ResoRange_init_range(self, range)

    def isSet(self):
        return _hklfile.ResoRange_isSet(self)

    def Set(self):
        return _hklfile.ResoRange_Set(self)

    def SetRange(self, *args):
        return _hklfile.ResoRange_SetRange(self, *args)

    def ExtendRange(self):
        return _hklfile.ResoRange_ExtendRange(self)

    def SetNbins(self, NumBin):
        return _hklfile.ResoRange_SetNbins(self, NumBin)

    def Nbins(self):
        return _hklfile.ResoRange_Nbins(self)

    def SetWidth(self, width):
        return _hklfile.ResoRange_SetWidth(self, width)

    def Width(self):
        return _hklfile.ResoRange_Width(self)

    def ResLow(self):
        return _hklfile.ResoRange_ResLow(self)

    def ResHigh(self):
        return _hklfile.ResoRange_ResHigh(self)

    def SResLow(self):
        return _hklfile.ResoRange_SResLow(self)

    def SResHigh(self):
        return _hklfile.ResoRange_SResHigh(self)

    def RRange(self):
        return _hklfile.ResoRange_RRange(self)

    def SRange(self):
        return _hklfile.ResoRange_SRange(self)

    def middleA(self, bin):
        return _hklfile.ResoRange_middleA(self, bin)

    def boundsA(self, bin):
        return _hklfile.ResoRange_boundsA(self, bin)

    def boundsS(self, bin):
        return _hklfile.ResoRange_boundsS(self, bin)

    def BinRange(self, bin):
        return _hklfile.ResoRange_BinRange(self, bin)

    def MaxRange(self, other):
        return _hklfile.ResoRange_MaxRange(self, other)

    def MinRange(self, other):
        return _hklfile.ResoRange_MinRange(self, other)

    def format(self):
        return _hklfile.ResoRange_format(self)
    __swig_destroy__ = _hklfile.delete_ResoRange
    __del__ = lambda self: None
ResoRange_swigregister = _hklfile.ResoRange_swigregister
ResoRange_swigregister(ResoRange)

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

    def __init__(self, *args):
        this = _hklfile.new_IntRange(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetRange(self, Imin, Imax):
        return _hklfile.IntRange_SetRange(self, Imin, Imax)

    def clear(self):
        return _hklfile.IntRange_clear(self)

    def update(self, *args):
        return _hklfile.IntRange_update(self, *args)

    def min(self):
        return _hklfile.IntRange_min(self)

    def max(self):
        return _hklfile.IntRange_max(self)

    def InRange(self, value):
        return _hklfile.IntRange_InRange(self, value)

    def MaxRange(self, other):
        return _hklfile.IntRange_MaxRange(self, other)

    def midrange(self):
        return _hklfile.IntRange_midrange(self)

    def AbsRange(self):
        return _hklfile.IntRange_AbsRange(self)

    def __eq__(self, other):
        return _hklfile.IntRange___eq__(self, other)

    def __ne__(self, other):
        return _hklfile.IntRange___ne__(self, other)

    def Overlap(self, other):
        return _hklfile.IntRange_Overlap(self, other)
    __swig_destroy__ = _hklfile.delete_IntRange
    __del__ = lambda self: None
IntRange_swigregister = _hklfile.IntRange_swigregister
IntRange_swigregister(IntRange)

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

    def __init__(self, *args):
        this = _hklfile.new_Euler_ccp4(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def alpha(self):
        return _hklfile.Euler_ccp4_alpha(self)

    def beta(self):
        return _hklfile.Euler_ccp4_beta(self)

    def gamma(self):
        return _hklfile.Euler_ccp4_gamma(self)

    def format(self):
        return _hklfile.Euler_ccp4_format(self)
    __swig_destroy__ = _hklfile.delete_Euler_ccp4
    __del__ = lambda self: None
Euler_ccp4_swigregister = _hklfile.Euler_ccp4_swigregister
Euler_ccp4_swigregister(Euler_ccp4)

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

    def __init__(self, *args):
        this = _hklfile.new_Euler_explicit(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def SetAngles(self, phi1, phi2, phi3):
        return _hklfile.Euler_explicit_SetAngles(self, phi1, phi2, phi3)

    def e1(self):
        return _hklfile.Euler_explicit_e1(self)

    def e2(self):
        return _hklfile.Euler_explicit_e2(self)

    def e3(self):
        return _hklfile.Euler_explicit_e3(self)

    def phi1(self):
        return _hklfile.Euler_explicit_phi1(self)

    def phi2(self):
        return _hklfile.Euler_explicit_phi2(self)

    def phi3(self):
        return _hklfile.Euler_explicit_phi3(self)

    def format(self):
        return _hklfile.Euler_explicit_format(self)
    __swig_destroy__ = _hklfile.delete_Euler_explicit
    __del__ = lambda self: None
Euler_explicit_swigregister = _hklfile.Euler_explicit_swigregister
Euler_explicit_swigregister(Euler_explicit)

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

    def __init__(self, *args):
        this = _hklfile.new_Polar_ccp4(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def psi(self):
        return _hklfile.Polar_ccp4_psi(self)

    def omega(self):
        return _hklfile.Polar_ccp4_omega(self)

    def phi(self):
        return _hklfile.Polar_ccp4_phi(self)

    def kappa(self):
        return _hklfile.Polar_ccp4_kappa(self)

    def format(self):
        return _hklfile.Polar_ccp4_format(self)
    __swig_destroy__ = _hklfile.delete_Polar_ccp4
    __del__ = lambda self: None
Polar_ccp4_swigregister = _hklfile.Polar_ccp4_swigregister
Polar_ccp4_swigregister(Polar_ccp4)

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

    def __init__(self, *args):
        this = _hklfile.new_Rotation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def w(self):
        return _hklfile.Rotation_w(self)

    def x(self):
        return _hklfile.Rotation_x(self)

    def y(self):
        return _hklfile.Rotation_y(self)

    def z(self):
        return _hklfile.Rotation_z(self)

    def euler_ccp4(self):
        return _hklfile.Rotation_euler_ccp4(self)

    def euler_explicit(self, euler_explicit, SolutionNumber=1):
        return _hklfile.Rotation_euler_explicit(self, euler_explicit, SolutionNumber)

    def polar_ccp4(self):
        return _hklfile.Rotation_polar_ccp4(self)

    def matrix(self):
        return _hklfile.Rotation_matrix(self)

    def norm(self):
        return _hklfile.Rotation_norm(self)

    def inverse(self):
        return _hklfile.Rotation_inverse(self)
    __swig_getmethods__["zero"] = lambda x: _hklfile.Rotation_zero
    if _newclass:
        zero = staticmethod(_hklfile.Rotation_zero)
    __swig_getmethods__["null"] = lambda x: _hklfile.Rotation_null
    if _newclass:
        null = staticmethod(_hklfile.Rotation_null)

    def is_null(self):
        return _hklfile.Rotation_is_null(self)

    def format(self):
        return _hklfile.Rotation_format(self)
    EulerXYZr = _hklfile.Rotation_EulerXYZr
    EulerXYZs = _hklfile.Rotation_EulerXYZs
    EulerXYXr = _hklfile.Rotation_EulerXYXr
    EulerXYXs = _hklfile.Rotation_EulerXYXs
    EulerXZXr = _hklfile.Rotation_EulerXZXr
    EulerXZXs = _hklfile.Rotation_EulerXZXs
    EulerXZYr = _hklfile.Rotation_EulerXZYr
    EulerXZYs = _hklfile.Rotation_EulerXZYs
    EulerYZXr = _hklfile.Rotation_EulerYZXr
    EulerYZXs = _hklfile.Rotation_EulerYZXs
    EulerYZYr = _hklfile.Rotation_EulerYZYr
    EulerYZYs = _hklfile.Rotation_EulerYZYs
    EulerYXYr = _hklfile.Rotation_EulerYXYr
    EulerYXYs = _hklfile.Rotation_EulerYXYs
    EulerYXZr = _hklfile.Rotation_EulerYXZr
    EulerYXZs = _hklfile.Rotation_EulerYXZs
    EulerZXYr = _hklfile.Rotation_EulerZXYr
    EulerZXYs = _hklfile.Rotation_EulerZXYs
    EulerZXZr = _hklfile.Rotation_EulerZXZr
    EulerZXZs = _hklfile.Rotation_EulerZXZs
    EulerZYZr = _hklfile.Rotation_EulerZYZr
    EulerZYZs = _hklfile.Rotation_EulerZYZs
    EulerZYXr = _hklfile.Rotation_EulerZYXr
    EulerZYXs = _hklfile.Rotation_EulerZYXs
    __swig_destroy__ = _hklfile.delete_Rotation
    __del__ = lambda self: None
Rotation_swigregister = _hklfile.Rotation_swigregister
Rotation_swigregister(Rotation)

def Rotation_zero():
    return _hklfile.Rotation_zero()
Rotation_zero = _hklfile.Rotation_zero

def Rotation_null():
    return _hklfile.Rotation_null()
Rotation_null = _hklfile.Rotation_null

class RunSelection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RunSelection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RunSelection, name)
    __repr__ = _swig_repr
    AUTO = _hklfile.RunSelection_AUTO
    BYFILE = _hklfile.RunSelection_BYFILE
    EXPLICIT = _hklfile.RunSelection_EXPLICIT

    def __init__(self, *args):
        this = _hklfile.new_RunSelection(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, Runsettype, Batchranges):
        return _hklfile.RunSelection_init(self, Runsettype, Batchranges)

    def specified(self):
        return _hklfile.RunSelection_specified(self)
    __swig_setmethods__["runsettype"] = _hklfile.RunSelection_runsettype_set
    __swig_getmethods__["runsettype"] = _hklfile.RunSelection_runsettype_get
    if _newclass:
        runsettype = _swig_property(_hklfile.RunSelection_runsettype_get, _hklfile.RunSelection_runsettype_set)
    __swig_setmethods__["batchranges"] = _hklfile.RunSelection_batchranges_set
    __swig_getmethods__["batchranges"] = _hklfile.RunSelection_batchranges_get
    if _newclass:
        batchranges = _swig_property(_hklfile.RunSelection_batchranges_get, _hklfile.RunSelection_batchranges_set)
    __swig_destroy__ = _hklfile.delete_RunSelection
    __del__ = lambda self: None
RunSelection_swigregister = _hklfile.RunSelection_swigregister
RunSelection_swigregister(RunSelection)

class Run(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Run, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Run, name)
    __repr__ = _swig_repr
    FULLSANDPARTIALS = _hklfile.Run_FULLSANDPARTIALS
    ONLYFULLS = _hklfile.Run_ONLYFULLS
    ONLYPARTIALS = _hklfile.Run_ONLYPARTIALS
    FEWFULLS = _hklfile.Run_FEWFULLS
    FEWPARTIALS = _hklfile.Run_FEWPARTIALS

    def __init__(self, *args):
        this = _hklfile.new_Run(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def clear(self):
        return _hklfile.Run_clear(self)

    def clearCounts(self):
        return _hklfile.Run_clearCounts(self)

    def AddBatch(self, Batch, accept=True):
        return _hklfile.Run_AddBatch(self, Batch, accept)

    def SortList(self):
        return _hklfile.Run_SortList(self)

    def IsInList(self, Batchnum):
        return _hklfile.Run_IsInList(self, Batchnum)

    def BatchList(self, Accepted=False):
        return _hklfile.Run_BatchList(self, Accepted)

    def DatasetIndex(self):
        return _hklfile.Run_DatasetIndex(self)

    def DatasetID(self):
        return _hklfile.Run_DatasetID(self)

    def PXDname(self):
        return _hklfile.Run_PXDname(self)

    def BatchRange(self):
        return _hklfile.Run_BatchRange(self)

    def Batch0(self):
        return _hklfile.Run_Batch0(self)

    def SetBatchSerial0(self, BatchSerial):
        return _hklfile.Run_SetBatchSerial0(self, BatchSerial)

    def BatchSerial0(self):
        return _hklfile.Run_BatchSerial0(self)

    def SetBatchAccept(self, Batchnum, Accepted):
        return _hklfile.Run_SetBatchAccept(self, Batchnum, Accepted)

    def IsBatchAccepted(self, Batchnum):
        return _hklfile.Run_IsBatchAccepted(self, Batchnum)

    def Nbatches(self):
        return _hklfile.Run_Nbatches(self)

    def OffsetBatchNumbers(self, offset):
        return _hklfile.Run_OffsetBatchNumbers(self, offset)

    def BatchNumberOffset(self, *args):
        return _hklfile.Run_BatchNumberOffset(self, *args)

    def RunNumber(self, *args):
        return _hklfile.Run_RunNumber(self, *args)

    def FileNumber(self, *args):
        return _hklfile.Run_FileNumber(self, *args)

    def PhiRange(self, *args):
        return _hklfile.Run_PhiRange(self, *args)

    def TimeRange(self, *args):
        return _hklfile.Run_TimeRange(self, *args)

    def ValidTime(self, *args):
        return _hklfile.Run_ValidTime(self, *args)

    def SetValidOrientation(self, validOrientation):
        return _hklfile.Run_SetValidOrientation(self, validOrientation)

    def ValidOrientation(self):
        return _hklfile.Run_ValidOrientation(self)

    def StoreSpindleToPrincipleAxis(self, Spindletoprincipleaxis):
        return _hklfile.Run_StoreSpindleToPrincipleAxis(self, Spindletoprincipleaxis)

    def SpindleToPrincipleAxis(self):
        return _hklfile.Run_SpindleToPrincipleAxis(self)
    __swig_getmethods__["MaximumBatchNumber"] = lambda x: _hklfile.Run_MaximumBatchNumber
    if _newclass:
        MaximumBatchNumber = staticmethod(_hklfile.Run_MaximumBatchNumber)

    def formatPrint(self, datasets):
        return _hklfile.Run_formatPrint(self, datasets)

    def formatPrintBrief(self):
        return _hklfile.Run_formatPrintBrief(self)

    def Nfulls(self, *args):
        return _hklfile.Run_Nfulls(self, *args)

    def Npartials(self, *args):
        return _hklfile.Run_Npartials(self, *args)

    def SetFullsAndPartials(self):
        return _hklfile.Run_SetFullsAndPartials(self)

    def fullsAndPartials(self):
        return _hklfile.Run_fullsAndPartials(self)

    def FormatSave(self):
        return _hklfile.Run_FormatSave(self)

    def StoreResoRange(self, Resrange):
        return _hklfile.Run_StoreResoRange(self, Resrange)

    def GetResoRange(self):
        return _hklfile.Run_GetResoRange(self)

    def IsResoRange(self):
        return _hklfile.Run_IsResoRange(self)

    def InResoRange(self, invresolsq, batch):
        return _hklfile.Run_InResoRange(self, invresolsq, batch)

    def SetLatticeNumber(self, latticenumber):
        return _hklfile.Run_SetLatticeNumber(self, latticenumber)

    def LatticeNumber(self):
        return _hklfile.Run_LatticeNumber(self)

    def StoreUse(self, userun):
        return _hklfile.Run_StoreUse(self, userun)

    def Use(self):
        return _hklfile.Run_Use(self)
    __swig_destroy__ = _hklfile.delete_Run
    __del__ = lambda self: None
Run_swigregister = _hklfile.Run_swigregister
Run_swigregister(Run)

def Run_MaximumBatchNumber():
    return _hklfile.Run_MaximumBatchNumber()
Run_MaximumBatchNumber = _hklfile.Run_MaximumBatchNumber

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

    def __init__(self, *args):
        this = _hklfile.new_RunRange(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Encloses(self, *args):
        return _hklfile.RunRange_Encloses(self, *args)

    def Adjacent(self, test):
        return _hklfile.RunRange_Adjacent(self, test)

    def IncrementOffset(self, offset):
        return _hklfile.RunRange_IncrementOffset(self, offset)
    __swig_setmethods__["LowBatchNumber"] = _hklfile.RunRange_LowBatchNumber_set
    __swig_getmethods__["LowBatchNumber"] = _hklfile.RunRange_LowBatchNumber_get
    if _newclass:
        LowBatchNumber = _swig_property(_hklfile.RunRange_LowBatchNumber_get, _hklfile.RunRange_LowBatchNumber_set)
    __swig_setmethods__["HighBatchNumber"] = _hklfile.RunRange_HighBatchNumber_set
    __swig_getmethods__["HighBatchNumber"] = _hklfile.RunRange_HighBatchNumber_get
    if _newclass:
        HighBatchNumber = _swig_property(_hklfile.RunRange_HighBatchNumber_get, _hklfile.RunRange_HighBatchNumber_set)
    __swig_setmethods__["Offset"] = _hklfile.RunRange_Offset_set
    __swig_getmethods__["Offset"] = _hklfile.RunRange_Offset_get
    if _newclass:
        Offset = _swig_property(_hklfile.RunRange_Offset_get, _hklfile.RunRange_Offset_set)
    __swig_destroy__ = _hklfile.delete_RunRange
    __del__ = lambda self: None
RunRange_swigregister = _hklfile.RunRange_swigregister
RunRange_swigregister(RunRange)


def CompareRunRanges(refruns, testruns):
    return _hklfile.CompareRunRanges(refruns, testruns)
CompareRunRanges = _hklfile.CompareRunRanges

def FindRunIndex(runNumber, runList):
    return _hklfile.FindRunIndex(runNumber, runList)
FindRunIndex = _hklfile.FindRunIndex

def BaseFileName(Name, NoExt=True):
    return _hklfile.BaseFileName(Name, NoExt)
BaseFileName = _hklfile.BaseFileName

def FileNameNoExtension(Name):
    return _hklfile.FileNameNoExtension(Name)
FileNameNoExtension = _hklfile.FileNameNoExtension

def FileNameExtension(name):
    return _hklfile.FileNameExtension(name)
FileNameExtension = _hklfile.FileNameExtension

def AddFileExtension(name, ext):
    return _hklfile.AddFileExtension(name, ext)
AddFileExtension = _hklfile.AddFileExtension

def Directory(Name):
    return _hklfile.Directory(Name)
Directory = _hklfile.Directory

def FormatCell(*args):
    return _hklfile.FormatCell(*args)
FormatCell = _hklfile.FormatCell

def MnSd(val):
    return _hklfile.MnSd(val)
MnSd = _hklfile.MnSd

def IRandom(MaxVal):
    return _hklfile.IRandom(MaxVal)
IRandom = _hklfile.IRandom

def FRandom(*args):
    return _hklfile.FRandom(*args)
FRandom = _hklfile.FRandom

def SafeSqrt(a):
    return _hklfile.SafeSqrt(a)
SafeSqrt = _hklfile.SafeSqrt

def AverageDsetCell(datasets):
    return _hklfile.AverageDsetCell(datasets)
AverageDsetCell = _hklfile.AverageDsetCell

def AverageBatchCell(batches, Ndatasets, averageMosaicity, averageWavelength):
    return _hklfile.AverageBatchCell(batches, Ndatasets, averageMosaicity, averageWavelength)
AverageBatchCell = _hklfile.AverageBatchCell

def AverageBatchCellforDataset(batches, idts):
    return _hklfile.AverageBatchCellforDataset(batches, idts)
AverageBatchCellforDataset = _hklfile.AverageBatchCellforDataset

def AverageDsetWavelength(datasets):
    return _hklfile.AverageDsetWavelength(datasets)
AverageDsetWavelength = _hklfile.AverageDsetWavelength

def AverageWavelength(allwavelengths, idxexclude=-1):
    return _hklfile.AverageWavelength(allwavelengths, idxexclude)
AverageWavelength = _hklfile.AverageWavelength
class MeanSD(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MeanSD, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MeanSD, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _hklfile.new_MeanSD(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def initExclude(self, *args):
        return _hklfile.MeanSD_initExclude(self, *args)

    def Add(self, *args):
        return _hklfile.MeanSD_Add(self, *args)

    def clear(self):
        return _hklfile.MeanSD_clear(self)

    def Mean(self):
        return _hklfile.MeanSD_Mean(self)

    def SD(self):
        return _hklfile.MeanSD_SD(self)

    def Var(self):
        return _hklfile.MeanSD_Var(self)

    def Count(self):
        return _hklfile.MeanSD_Count(self)

    def format(self):
        return _hklfile.MeanSD_format(self)

    def __iadd__(self, other):
        return _hklfile.MeanSD___iadd__(self, other)
    __swig_getmethods__["MeanSDsmallerSD"] = lambda x: _hklfile.MeanSD_MeanSDsmallerSD
    if _newclass:
        MeanSDsmallerSD = staticmethod(_hklfile.MeanSD_MeanSDsmallerSD)
    __swig_destroy__ = _hklfile.delete_MeanSD
    __del__ = lambda self: None
MeanSD_swigregister = _hklfile.MeanSD_swigregister
MeanSD_swigregister(MeanSD)

def MeanSD_MeanSDsmallerSD(a, b):
    return _hklfile.MeanSD_MeanSDsmallerSD(a, b)
MeanSD_MeanSDsmallerSD = _hklfile.MeanSD_MeanSDsmallerSD

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

    def __init__(self, *args):
        this = _hklfile.new_MeanValue(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Add(self, *args):
        return _hklfile.MeanValue_Add(self, *args)

    def clear(self):
        return _hklfile.MeanValue_clear(self)

    def Mean(self):
        return _hklfile.MeanValue_Mean(self)

    def Count(self):
        return _hklfile.MeanValue_Count(self)

    def format(self):
        return _hklfile.MeanValue_format(self)

    def __iadd__(self, other):
        return _hklfile.MeanValue___iadd__(self, other)
    __swig_destroy__ = _hklfile.delete_MeanValue
    __del__ = lambda self: None
MeanValue_swigregister = _hklfile.MeanValue_swigregister
MeanValue_swigregister(MeanValue)

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

    def __init__(self, *args):
        this = _hklfile.new_MeanVariance(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def Add(self, *args):
        return _hklfile.MeanVariance_Add(self, *args)

    def clear(self):
        return _hklfile.MeanVariance_clear(self)

    def Mean(self):
        return _hklfile.MeanVariance_Mean(self)

    def VarianceFromWeights(self):
        return _hklfile.MeanVariance_VarianceFromWeights(self)

    def SDfromWeights(self):
        return _hklfile.MeanVariance_SDfromWeights(self)

    def Variance(self):
        return _hklfile.MeanVariance_Variance(self)

    def SD(self):
        return _hklfile.MeanVariance_SD(self)

    def SampleVariance(self):
        return _hklfile.MeanVariance_SampleVariance(self)

    def SampleVarianceOmit1(self, v, w):
        return _hklfile.MeanVariance_SampleVarianceOmit1(self, v, w)

    def SampleSD(self):
        return _hklfile.MeanVariance_SampleSD(self)

    def Count(self):
        return _hklfile.MeanVariance_Count(self)

    def format(self):
        return _hklfile.MeanVariance_format(self)

    def __iadd__(self, other):
        return _hklfile.MeanVariance___iadd__(self, other)
    __swig_destroy__ = _hklfile.delete_MeanVariance
    __del__ = lambda self: None
MeanVariance_swigregister = _hklfile.MeanVariance_swigregister
MeanVariance_swigregister(MeanVariance)

class StringUtil(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringUtil, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringUtil, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Strip"] = lambda x: _hklfile.StringUtil_Strip
    if _newclass:
        Strip = staticmethod(_hklfile.StringUtil_Strip)
    __swig_getmethods__["StripNull"] = lambda x: _hklfile.StringUtil_StripNull
    if _newclass:
        StripNull = staticmethod(_hklfile.StringUtil_StripNull)
    __swig_getmethods__["Trim"] = lambda x: _hklfile.StringUtil_Trim
    if _newclass:
        Trim = staticmethod(_hklfile.StringUtil_Trim)
    __swig_getmethods__["Unquote"] = lambda x: _hklfile.StringUtil_Unquote
    if _newclass:
        Unquote = staticmethod(_hklfile.StringUtil_Unquote)
    __swig_getmethods__["isquoted"] = lambda x: _hklfile.StringUtil_isquoted
    if _newclass:
        isquoted = staticmethod(_hklfile.StringUtil_isquoted)
    __swig_getmethods__["isanumber"] = lambda x: _hklfile.StringUtil_isanumber
    if _newclass:
        isanumber = staticmethod(_hklfile.StringUtil_isanumber)
    __swig_getmethods__["CentreString"] = lambda x: _hklfile.StringUtil_CentreString
    if _newclass:
        CentreString = staticmethod(_hklfile.StringUtil_CentreString)
    __swig_getmethods__["PadString"] = lambda x: _hklfile.StringUtil_PadString
    if _newclass:
        PadString = staticmethod(_hklfile.StringUtil_PadString)
    __swig_getmethods__["RightString"] = lambda x: _hklfile.StringUtil_RightString
    if _newclass:
        RightString = staticmethod(_hklfile.StringUtil_RightString)
    __swig_getmethods__["LeftString"] = lambda x: _hklfile.StringUtil_LeftString
    if _newclass:
        LeftString = staticmethod(_hklfile.StringUtil_LeftString)
    __swig_getmethods__["split"] = lambda x: _hklfile.StringUtil_split
    if _newclass:
        split = staticmethod(_hklfile.StringUtil_split)
    __swig_getmethods__["onespace"] = lambda x: _hklfile.StringUtil_onespace
    if _newclass:
        onespace = staticmethod(_hklfile.StringUtil_onespace)
    __swig_getmethods__["removespaces"] = lambda x: _hklfile.StringUtil_removespaces
    if _newclass:
        removespaces = staticmethod(_hklfile.StringUtil_removespaces)
    __swig_getmethods__["valueSD"] = lambda x: _hklfile.StringUtil_valueSD
    if _newclass:
        valueSD = staticmethod(_hklfile.StringUtil_valueSD)
    __swig_getmethods__["MakeXMLwithclass"] = lambda x: _hklfile.StringUtil_MakeXMLwithclass
    if _newclass:
        MakeXMLwithclass = staticmethod(_hklfile.StringUtil_MakeXMLwithclass)
    __swig_getmethods__["MakeXMLwarning"] = lambda x: _hklfile.StringUtil_MakeXMLwarning
    if _newclass:
        MakeXMLwarning = staticmethod(_hklfile.StringUtil_MakeXMLwarning)
    __swig_getmethods__["MakeXMLtag"] = lambda x: _hklfile.StringUtil_MakeXMLtag
    if _newclass:
        MakeXMLtag = staticmethod(_hklfile.StringUtil_MakeXMLtag)
    __swig_getmethods__["XMLstring"] = lambda x: _hklfile.StringUtil_XMLstring
    if _newclass:
        XMLstring = staticmethod(_hklfile.StringUtil_XMLstring)
    __swig_getmethods__["FormatXMLcrossTable"] = lambda x: _hklfile.StringUtil_FormatXMLcrossTable
    if _newclass:
        FormatXMLcrossTable = staticmethod(_hklfile.StringUtil_FormatXMLcrossTable)
    __swig_getmethods__["itos"] = lambda x: _hklfile.StringUtil_itos
    if _newclass:
        itos = staticmethod(_hklfile.StringUtil_itos)
    __swig_getmethods__["etos"] = lambda x: _hklfile.StringUtil_etos
    if _newclass:
        etos = staticmethod(_hklfile.StringUtil_etos)
    __swig_getmethods__["ftos"] = lambda x: _hklfile.StringUtil_ftos
    if _newclass:
        ftos = staticmethod(_hklfile.StringUtil_ftos)
    __swig_getmethods__["WrapLine"] = lambda x: _hklfile.StringUtil_WrapLine
    if _newclass:
        WrapLine = staticmethod(_hklfile.StringUtil_WrapLine)
    __swig_getmethods__["formatFraction"] = lambda x: _hklfile.StringUtil_formatFraction
    if _newclass:
        formatFraction = staticmethod(_hklfile.StringUtil_formatFraction)
    __swig_getmethods__["ToUpper"] = lambda x: _hklfile.StringUtil_ToUpper
    if _newclass:
        ToUpper = staticmethod(_hklfile.StringUtil_ToUpper)
    __swig_getmethods__["BuftoLine"] = lambda x: _hklfile.StringUtil_BuftoLine
    if _newclass:
        BuftoLine = staticmethod(_hklfile.StringUtil_BuftoLine)
    __swig_getmethods__["FormatSaveVector"] = lambda x: _hklfile.StringUtil_FormatSaveVector
    if _newclass:
        FormatSaveVector = staticmethod(_hklfile.StringUtil_FormatSaveVector)
    __swig_getmethods__["FormatSaveArray"] = lambda x: _hklfile.StringUtil_FormatSaveArray
    if _newclass:
        FormatSaveArray = staticmethod(_hklfile.StringUtil_FormatSaveArray)

    def __init__(self):
        this = _hklfile.new_StringUtil()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hklfile.delete_StringUtil
    __del__ = lambda self: None
StringUtil_swigregister = _hklfile.StringUtil_swigregister
StringUtil_swigregister(StringUtil)

def StringUtil_Strip(*args):
    return _hklfile.StringUtil_Strip(*args)
StringUtil_Strip = _hklfile.StringUtil_Strip

def StringUtil_StripNull(s):
    return _hklfile.StringUtil_StripNull(s)
StringUtil_StripNull = _hklfile.StringUtil_StripNull

def StringUtil_Trim(s):
    return _hklfile.StringUtil_Trim(s)
StringUtil_Trim = _hklfile.StringUtil_Trim

def StringUtil_Unquote(s):
    return _hklfile.StringUtil_Unquote(s)
StringUtil_Unquote = _hklfile.StringUtil_Unquote

def StringUtil_isquoted(s):
    return _hklfile.StringUtil_isquoted(s)
StringUtil_isquoted = _hklfile.StringUtil_isquoted

def StringUtil_isanumber(s):
    return _hklfile.StringUtil_isanumber(s)
StringUtil_isanumber = _hklfile.StringUtil_isanumber

def StringUtil_CentreString(text, fieldwidth, cenpos=0):
    return _hklfile.StringUtil_CentreString(text, fieldwidth, cenpos)
StringUtil_CentreString = _hklfile.StringUtil_CentreString

def StringUtil_PadString(text, fieldwidth):
    return _hklfile.StringUtil_PadString(text, fieldwidth)
StringUtil_PadString = _hklfile.StringUtil_PadString

def StringUtil_RightString(text, fieldwidth):
    return _hklfile.StringUtil_RightString(text, fieldwidth)
StringUtil_RightString = _hklfile.StringUtil_RightString

def StringUtil_LeftString(text, fieldwidth):
    return _hklfile.StringUtil_LeftString(text, fieldwidth)
StringUtil_LeftString = _hklfile.StringUtil_LeftString

def StringUtil_split(*args):
    return _hklfile.StringUtil_split(*args)
StringUtil_split = _hklfile.StringUtil_split

def StringUtil_onespace(s):
    return _hklfile.StringUtil_onespace(s)
StringUtil_onespace = _hklfile.StringUtil_onespace

def StringUtil_removespaces(s):
    return _hklfile.StringUtil_removespaces(s)
StringUtil_removespaces = _hklfile.StringUtil_removespaces

def StringUtil_valueSD(v, sd, totalfw, fw, fd):
    return _hklfile.StringUtil_valueSD(v, sd, totalfw, fw, fd)
StringUtil_valueSD = _hklfile.StringUtil_valueSD

def StringUtil_MakeXMLwithclass(tag, data, edit, messageclass):
    return _hklfile.StringUtil_MakeXMLwithclass(tag, data, edit, messageclass)
StringUtil_MakeXMLwithclass = _hklfile.StringUtil_MakeXMLwithclass

def StringUtil_MakeXMLwarning(tag, data, edit=True):
    return _hklfile.StringUtil_MakeXMLwarning(tag, data, edit)
StringUtil_MakeXMLwarning = _hklfile.StringUtil_MakeXMLwarning

def StringUtil_MakeXMLtag(*args):
    return _hklfile.StringUtil_MakeXMLtag(*args)
StringUtil_MakeXMLtag = _hklfile.StringUtil_MakeXMLtag

def StringUtil_XMLstring(s0):
    return _hklfile.StringUtil_XMLstring(s0)
StringUtil_XMLstring = _hklfile.StringUtil_XMLstring

def StringUtil_FormatXMLcrossTable(elementid, tableid, names, valTag, valCount):
    return _hklfile.StringUtil_FormatXMLcrossTable(elementid, tableid, names, valTag, valCount)
StringUtil_FormatXMLcrossTable = _hklfile.StringUtil_FormatXMLcrossTable

def StringUtil_itos(*args):
    return _hklfile.StringUtil_itos(*args)
StringUtil_itos = _hklfile.StringUtil_itos

def StringUtil_etos(*args):
    return _hklfile.StringUtil_etos(*args)
StringUtil_etos = _hklfile.StringUtil_etos

def StringUtil_ftos(*args):
    return _hklfile.StringUtil_ftos(*args)
StringUtil_ftos = _hklfile.StringUtil_ftos

def StringUtil_WrapLine(*args):
    return _hklfile.StringUtil_WrapLine(*args)
StringUtil_WrapLine = _hklfile.StringUtil_WrapLine

def StringUtil_formatFraction(fr, width):
    return _hklfile.StringUtil_formatFraction(fr, width)
StringUtil_formatFraction = _hklfile.StringUtil_formatFraction

def StringUtil_ToUpper(s):
    return _hklfile.StringUtil_ToUpper(s)
StringUtil_ToUpper = _hklfile.StringUtil_ToUpper

def StringUtil_BuftoLine(buf):
    return _hklfile.StringUtil_BuftoLine(buf)
StringUtil_BuftoLine = _hklfile.StringUtil_BuftoLine

def StringUtil_FormatSaveVector(*args):
    return _hklfile.StringUtil_FormatSaveVector(*args)
StringUtil_FormatSaveVector = _hklfile.StringUtil_FormatSaveVector

def StringUtil_FormatSaveArray(VC):
    return _hklfile.StringUtil_FormatSaveArray(VC)
StringUtil_FormatSaveArray = _hklfile.StringUtil_FormatSaveArray

class FormatOutput(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FormatOutput, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FormatOutput, name)
    __repr__ = _swig_repr
    __swig_getmethods__["logTab"] = lambda x: _hklfile.FormatOutput_logTab
    if _newclass:
        logTab = staticmethod(_hklfile.FormatOutput_logTab)
    __swig_getmethods__["logTabPrintf"] = lambda x: _hklfile.FormatOutput_logTabPrintf
    if _newclass:
        logTabPrintf = staticmethod(_hklfile.FormatOutput_logTabPrintf)
    __swig_getmethods__["logWarning"] = lambda x: _hklfile.FormatOutput_logWarning
    if _newclass:
        logWarning = staticmethod(_hklfile.FormatOutput_logWarning)

    def __init__(self):
        this = _hklfile.new_FormatOutput()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hklfile.delete_FormatOutput
    __del__ = lambda self: None
FormatOutput_swigregister = _hklfile.FormatOutput_swigregister
FormatOutput_swigregister(FormatOutput)

def FormatOutput_logTab(tab, text, add_return=True):
    return _hklfile.FormatOutput_logTab(tab, text, add_return)
FormatOutput_logTab = _hklfile.FormatOutput_logTab

def FormatOutput_logTabPrintf(tab, formattext):
    return _hklfile.FormatOutput_logTabPrintf(tab, formattext)
FormatOutput_logTabPrintf = _hklfile.FormatOutput_logTabPrintf

def FormatOutput_logWarning(text):
    return _hklfile.FormatOutput_logWarning(text)
FormatOutput_logWarning = _hklfile.FormatOutput_logWarning

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

    def __init__(self, *args):
        this = _hklfile.new_Numberfield(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _hklfile.Numberfield_init(self, *args)
    __swig_setmethods__["type"] = _hklfile.Numberfield_type_set
    __swig_getmethods__["type"] = _hklfile.Numberfield_type_get
    if _newclass:
        type = _swig_property(_hklfile.Numberfield_type_get, _hklfile.Numberfield_type_set)
    __swig_setmethods__["width"] = _hklfile.Numberfield_width_set
    __swig_getmethods__["width"] = _hklfile.Numberfield_width_get
    if _newclass:
        width = _swig_property(_hklfile.Numberfield_width_get, _hklfile.Numberfield_width_set)
    __swig_setmethods__["dec"] = _hklfile.Numberfield_dec_set
    __swig_getmethods__["dec"] = _hklfile.Numberfield_dec_get
    if _newclass:
        dec = _swig_property(_hklfile.Numberfield_dec_get, _hklfile.Numberfield_dec_set)
    __swig_setmethods__["range"] = _hklfile.Numberfield_range_set
    __swig_getmethods__["range"] = _hklfile.Numberfield_range_get
    if _newclass:
        range = _swig_property(_hklfile.Numberfield_range_get, _hklfile.Numberfield_range_set)
    __swig_setmethods__["label1"] = _hklfile.Numberfield_label1_set
    __swig_getmethods__["label1"] = _hklfile.Numberfield_label1_get
    if _newclass:
        label1 = _swig_property(_hklfile.Numberfield_label1_get, _hklfile.Numberfield_label1_set)
    __swig_setmethods__["label2"] = _hklfile.Numberfield_label2_set
    __swig_getmethods__["label2"] = _hklfile.Numberfield_label2_get
    if _newclass:
        label2 = _swig_property(_hklfile.Numberfield_label2_get, _hklfile.Numberfield_label2_set)
    __swig_destroy__ = _hklfile.delete_Numberfield
    __del__ = lambda self: None
Numberfield_swigregister = _hklfile.Numberfield_swigregister
Numberfield_swigregister(Numberfield)

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

    def __init__(self, *args):
        this = _hklfile.new_Citation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def AddCitation(self, citation, link):
        return _hklfile.Citation_AddCitation(self, citation, link)

    def MakeLogCitation(self):
        return _hklfile.Citation_MakeLogCitation(self)
    __swig_destroy__ = _hklfile.delete_Citation
    __del__ = lambda self: None
Citation_swigregister = _hklfile.Citation_swigregister
Citation_swigregister(Citation)


def ClipperStringAsString(a):
    return _hklfile.ClipperStringAsString(a)
ClipperStringAsString = _hklfile.ClipperStringAsString
class ClipperStringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClipperStringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ClipperStringVector, name)
    __repr__ = _swig_repr

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

    def __nonzero__(self):
        return _hklfile.ClipperStringVector___nonzero__(self)

    def __bool__(self):
        return _hklfile.ClipperStringVector___bool__(self)

    def __len__(self):
        return _hklfile.ClipperStringVector___len__(self)

    def pop(self):
        return _hklfile.ClipperStringVector_pop(self)

    def __getslice__(self, i, j):
        return _hklfile.ClipperStringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _hklfile.ClipperStringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _hklfile.ClipperStringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _hklfile.ClipperStringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _hklfile.ClipperStringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _hklfile.ClipperStringVector___setitem__(self, *args)

    def append(self, x):
        return _hklfile.ClipperStringVector_append(self, x)

    def empty(self):
        return _hklfile.ClipperStringVector_empty(self)

    def size(self):
        return _hklfile.ClipperStringVector_size(self)

    def clear(self):
        return _hklfile.ClipperStringVector_clear(self)

    def swap(self, v):
        return _hklfile.ClipperStringVector_swap(self, v)

    def get_allocator(self):
        return _hklfile.ClipperStringVector_get_allocator(self)

    def begin(self):
        return _hklfile.ClipperStringVector_begin(self)

    def end(self):
        return _hklfile.ClipperStringVector_end(self)

    def rbegin(self):
        return _hklfile.ClipperStringVector_rbegin(self)

    def rend(self):
        return _hklfile.ClipperStringVector_rend(self)

    def pop_back(self):
        return _hklfile.ClipperStringVector_pop_back(self)

    def erase(self, *args):
        return _hklfile.ClipperStringVector_erase(self, *args)

    def __init__(self, *args):
        this = _hklfile.new_ClipperStringVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _hklfile.ClipperStringVector_push_back(self, x)

    def front(self):
        return _hklfile.ClipperStringVector_front(self)

    def back(self):
        return _hklfile.ClipperStringVector_back(self)

    def assign(self, n, x):
        return _hklfile.ClipperStringVector_assign(self, n, x)

    def resize(self, *args):
        return _hklfile.ClipperStringVector_resize(self, *args)

    def insert(self, *args):
        return _hklfile.ClipperStringVector_insert(self, *args)

    def reserve(self, n):
        return _hklfile.ClipperStringVector_reserve(self, n)

    def capacity(self):
        return _hklfile.ClipperStringVector_capacity(self)
    __swig_destroy__ = _hklfile.delete_ClipperStringVector
    __del__ = lambda self: None
ClipperStringVector_swigregister = _hklfile.ClipperStringVector_swigregister
ClipperStringVector_swigregister(ClipperStringVector)

class Spgr_descr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spgr_descr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Spgr_descr, name)
    __repr__ = _swig_repr
    Hall = _hklfile.Spgr_descr_Hall
    HM = _hklfile.Spgr_descr_HM
    XHM = _hklfile.Spgr_descr_XHM
    Symops = _hklfile.Spgr_descr_Symops
    Number = _hklfile.Spgr_descr_Number
    Unknown = _hklfile.Spgr_descr_Unknown

    def __init__(self, *args):
        this = _hklfile.new_Spgr_descr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def spacegroup_number(self):
        return _hklfile.Spgr_descr_spacegroup_number(self)

    def symbol_hall(self):
        return _hklfile.Spgr_descr_symbol_hall(self)

    def symbol_hm(self):
        return _hklfile.Spgr_descr_symbol_hm(self)

    def symbol_xhm(self):
        return _hklfile.Spgr_descr_symbol_xhm(self)

    def symbol_hm_ext(self):
        return _hklfile.Spgr_descr_symbol_hm_ext(self)
    __swig_getmethods__["set_preferred"] = lambda x: _hklfile.Spgr_descr_set_preferred
    if _newclass:
        set_preferred = staticmethod(_hklfile.Spgr_descr_set_preferred)

    def hash(self):
        return _hklfile.Spgr_descr_hash(self)
    __swig_destroy__ = _hklfile.delete_Spgr_descr
    __del__ = lambda self: None
Spgr_descr_swigregister = _hklfile.Spgr_descr_swigregister
Spgr_descr_swigregister(Spgr_descr)

def Spgr_descr_set_preferred(c):
    return _hklfile.Spgr_descr_set_preferred(c)
Spgr_descr_set_preferred = _hklfile.Spgr_descr_set_preferred

class Spacegroup(Spgr_descr):
    __swig_setmethods__ = {}
    for _s in [Spgr_descr]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spacegroup, name, value)
    __swig_getmethods__ = {}
    for _s in [Spgr_descr]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Spacegroup, name)
    __repr__ = _swig_repr
    Null = _hklfile.Spacegroup_Null
    P1 = _hklfile.Spacegroup_P1
    A = _hklfile.Spacegroup_A
    B = _hklfile.Spacegroup_B
    C = _hklfile.Spacegroup_C

    def __init__(self, *args):
        this = _hklfile.new_Spacegroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spgr_descr):
        return _hklfile.Spacegroup_init(self, spgr_descr)

    def is_null(self):
        return _hklfile.Spacegroup_is_null(self)

    def descr(self):
        return _hklfile.Spacegroup_descr(self)

    def num_symops(self):
        return _hklfile.Spacegroup_num_symops(self)

    def num_primops(self):
        return _hklfile.Spacegroup_num_primops(self)

    def num_primitive_symops(self):
        return _hklfile.Spacegroup_num_primitive_symops(self)

    def num_centering_symops(self):
        return _hklfile.Spacegroup_num_centering_symops(self)

    def num_inversion_symops(self):
        return _hklfile.Spacegroup_num_inversion_symops(self)

    def num_primitive_noninversion_symops(self):
        return _hklfile.Spacegroup_num_primitive_noninversion_symops(self)

    def symop(self, sym_no):
        return _hklfile.Spacegroup_symop(self, sym_no)

    def primitive_symop(self, sym_no):
        return _hklfile.Spacegroup_primitive_symop(self, sym_no)

    def inversion_symop(self, sym_no):
        return _hklfile.Spacegroup_inversion_symop(self, sym_no)

    def centering_symop(self, sym_no):
        return _hklfile.Spacegroup_centering_symop(self, sym_no)

    def order_of_symmetry_about_axis(self, axis):
        return _hklfile.Spacegroup_order_of_symmetry_about_axis(self, axis)

    def hkl_class(self, hkl):
        return _hklfile.Spacegroup_hkl_class(self, hkl)

    def recip_asu(self, hkl):
        return _hklfile.Spacegroup_recip_asu(self, hkl)

    def product_op(self, s1, s2):
        return _hklfile.Spacegroup_product_op(self, s1, s2)

    def inverse_op(self, s):
        return _hklfile.Spacegroup_inverse_op(self, s)

    def asu_max(self):
        return _hklfile.Spacegroup_asu_max(self)

    def asu_min(self):
        return _hklfile.Spacegroup_asu_min(self)

    def invariant_under_change_of_hand(self):
        return _hklfile.Spacegroup_invariant_under_change_of_hand(self)

    def symbol_laue(self):
        return _hklfile.Spacegroup_symbol_laue(self)
    __swig_getmethods__["p1"] = lambda x: _hklfile.Spacegroup_p1
    if _newclass:
        p1 = staticmethod(_hklfile.Spacegroup_p1)
    __swig_getmethods__["null"] = lambda x: _hklfile.Spacegroup_null
    if _newclass:
        null = staticmethod(_hklfile.Spacegroup_null)

    def debug(self):
        return _hklfile.Spacegroup_debug(self)
    __swig_destroy__ = _hklfile.delete_Spacegroup
    __del__ = lambda self: None
Spacegroup_swigregister = _hklfile.Spacegroup_swigregister
Spacegroup_swigregister(Spacegroup)

def Spacegroup_p1():
    return _hklfile.Spacegroup_p1()
Spacegroup_p1 = _hklfile.Spacegroup_p1

def Spacegroup_null():
    return _hklfile.Spacegroup_null()
Spacegroup_null = _hklfile.Spacegroup_null

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

    def __init__(self, *args):
        this = _hklfile.new_String(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def split(self, sep):
        return _hklfile.String_split(self, sep)

    def trim(self):
        return _hklfile.String_trim(self)

    def tail(self):
        return _hklfile.String_tail(self)

    def head(self):
        return _hklfile.String_head(self)

    def nohead(self):
        return _hklfile.String_nohead(self)

    def notail(self):
        return _hklfile.String_notail(self)

    def i(self):
        return _hklfile.String_i(self)

    def l(self):
        return _hklfile.String_l(self)

    def f32(self):
        return _hklfile.String_f32(self)

    def f64(self):
        return _hklfile.String_f64(self)

    def f(self):
        return _hklfile.String_f(self)

    def rational(self, *args):
        return _hklfile.String_rational(self, *args)
    __swig_destroy__ = _hklfile.delete_String
    __del__ = lambda self: None
String_swigregister = _hklfile.String_swigregister
String_swigregister(String)

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

    def __init__(self, *args):
        this = _hklfile.new_Metric_tensor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def lengthsq(self, *args):
        return _hklfile.Metric_tensor_lengthsq(self, *args)

    def format(self):
        return _hklfile.Metric_tensor_format(self)
    __swig_destroy__ = _hklfile.delete_Metric_tensor
    __del__ = lambda self: None
Metric_tensor_swigregister = _hklfile.Metric_tensor_swigregister
Metric_tensor_swigregister(Metric_tensor)

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

    def __init__(self, *args):
        this = _hklfile.new_Cell_descr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def a(self):
        return _hklfile.Cell_descr_a(self)

    def b(self):
        return _hklfile.Cell_descr_b(self)

    def c(self):
        return _hklfile.Cell_descr_c(self)

    def alpha(self):
        return _hklfile.Cell_descr_alpha(self)

    def beta(self):
        return _hklfile.Cell_descr_beta(self)

    def gamma(self):
        return _hklfile.Cell_descr_gamma(self)

    def alpha_deg(self):
        return _hklfile.Cell_descr_alpha_deg(self)

    def beta_deg(self):
        return _hklfile.Cell_descr_beta_deg(self)

    def gamma_deg(self):
        return _hklfile.Cell_descr_gamma_deg(self)

    def format(self):
        return _hklfile.Cell_descr_format(self)
    __swig_destroy__ = _hklfile.delete_Cell_descr
    __del__ = lambda self: None
Cell_descr_swigregister = _hklfile.Cell_descr_swigregister
Cell_descr_swigregister(Cell_descr)

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

    def __init__(self, *args):
        this = _hklfile.new_Cell(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, cell_):
        return _hklfile.Cell_init(self, cell_)

    def is_null(self):
        return _hklfile.Cell_is_null(self)

    def a_star(self):
        return _hklfile.Cell_a_star(self)

    def b_star(self):
        return _hklfile.Cell_b_star(self)

    def c_star(self):
        return _hklfile.Cell_c_star(self)

    def alpha_star(self):
        return _hklfile.Cell_alpha_star(self)

    def beta_star(self):
        return _hklfile.Cell_beta_star(self)

    def gamma_star(self):
        return _hklfile.Cell_gamma_star(self)

    def volume(self):
        return _hklfile.Cell_volume(self)

    def equals(self, other, tol=1.0):
        return _hklfile.Cell_equals(self, other, tol)

    def matrix_orth(self):
        return _hklfile.Cell_matrix_orth(self)

    def matrix_frac(self):
        return _hklfile.Cell_matrix_frac(self)

    def metric_real(self):
        return _hklfile.Cell_metric_real(self)

    def metric_reci(self):
        return _hklfile.Cell_metric_reci(self)

    def debug(self):
        return _hklfile.Cell_debug(self)
    __swig_destroy__ = _hklfile.delete_Cell
    __del__ = lambda self: None
Cell_swigregister = _hklfile.Cell_swigregister
Cell_swigregister(Cell)

class CCP4MTZfile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CCP4MTZfile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CCP4MTZfile, name)
    __repr__ = _swig_repr
    Default = _hklfile.CCP4MTZfile_Default
    Normal = _hklfile.CCP4MTZfile_Normal
    Legacy = _hklfile.CCP4MTZfile_Legacy

    def __init__(self):
        this = _hklfile.new_CCP4MTZfile()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _hklfile.delete_CCP4MTZfile
    __del__ = lambda self: None

    def open_read(self, filename_in):
        return _hklfile.CCP4MTZfile_open_read(self, filename_in)

    def close_read(self):
        return _hklfile.CCP4MTZfile_close_read(self)

    def open_append(self, filename_in, filename_out):
        return _hklfile.CCP4MTZfile_open_append(self, filename_in, filename_out)

    def close_append(self):
        return _hklfile.CCP4MTZfile_close_append(self)

    def open_write(self, filename_out):
        return _hklfile.CCP4MTZfile_open_write(self, filename_out)

    def close_write(self):
        return _hklfile.CCP4MTZfile_close_write(self)

    def spacegroup(self):
        return _hklfile.CCP4MTZfile_spacegroup(self)

    def cell(self):
        return _hklfile.CCP4MTZfile_cell(self)

    def resolution(self):
        return _hklfile.CCP4MTZfile_resolution(self)

    def hkl_sampling(self):
        return _hklfile.CCP4MTZfile_hkl_sampling(self)

    def import_hkl_list(self, target):
        return _hklfile.CCP4MTZfile_import_hkl_list(self, target)

    def import_hkl_info(self, target, generate=True):
        return _hklfile.CCP4MTZfile_import_hkl_info(self, target, generate)

    def import_crystal(self, cxtl, mtzpath):
        return _hklfile.CCP4MTZfile_import_crystal(self, cxtl, mtzpath)

    def import_dataset(self, cset, mtzpath):
        return _hklfile.CCP4MTZfile_import_dataset(self, cset, mtzpath)

    def export_hkl_info(self, target):
        return _hklfile.CCP4MTZfile_export_hkl_info(self, target)

    def export_crystal(self, cxtl, mtzpath):
        return _hklfile.CCP4MTZfile_export_crystal(self, cxtl, mtzpath)

    def export_dataset(self, cset, mtzpath):
        return _hklfile.CCP4MTZfile_export_dataset(self, cset, mtzpath)

    def import_chkl_data(self, *args):
        return _hklfile.CCP4MTZfile_import_chkl_data(self, *args)

    def export_chkl_data(self, target, mtzpath):
        return _hklfile.CCP4MTZfile_export_chkl_data(self, target, mtzpath)

    def column_paths(self):
        return _hklfile.CCP4MTZfile_column_paths(self)

    def title(self):
        return _hklfile.CCP4MTZfile_title(self)

    def set_title(self, title):
        return _hklfile.CCP4MTZfile_set_title(self, title)

    def history(self):
        return _hklfile.CCP4MTZfile_history(self)

    def set_history(self, history):
        return _hklfile.CCP4MTZfile_set_history(self, history)

    def num_reflections(self):
        return _hklfile.CCP4MTZfile_num_reflections(self)

    def sort_order(self):
        return _hklfile.CCP4MTZfile_sort_order(self)

    def low_res_limit(self):
        return _hklfile.CCP4MTZfile_low_res_limit(self)

    def high_res_limit(self):
        return _hklfile.CCP4MTZfile_high_res_limit(self)

    def ccp4_spacegroup_number(self):
        return _hklfile.CCP4MTZfile_ccp4_spacegroup_number(self)

    def spacegroup_confidence(self):
        return _hklfile.CCP4MTZfile_spacegroup_confidence(self)

    def set_column_label_mode(self, mode):
        return _hklfile.CCP4MTZfile_set_column_label_mode(self, mode)

    def set_verbose(self, verbose):
        return _hklfile.CCP4MTZfile_set_verbose(self, verbose)

    def column_labels(self):
        return _hklfile.CCP4MTZfile_column_labels(self)

    def import_hkl_data(self, *args):
        return _hklfile.CCP4MTZfile_import_hkl_data(self, *args)

    def export_hkl_data(self, *args):
        return _hklfile.CCP4MTZfile_export_hkl_data(self, *args)
CCP4MTZfile_swigregister = _hklfile.CCP4MTZfile_swigregister
CCP4MTZfile_swigregister(CCP4MTZfile)

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

    def __init__(self, *args):
        this = _hklfile.new_HKL_info(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spacegroup, cell, resolution, generate):
        return _hklfile.HKL_info_init(self, spacegroup, cell, resolution, generate)

    def is_null(self):
        return _hklfile.HKL_info_is_null(self)
    __swig_destroy__ = _hklfile.delete_HKL_info
    __del__ = lambda self: None
HKL_info_swigregister = _hklfile.HKL_info_swigregister
HKL_info_swigregister(HKL_info)

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