# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.11
#
# 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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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, *args): return _hklfile.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _hklfile.SwigPyIterator_equal(self, *args)
    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, *args): return _hklfile.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _hklfile.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _hklfile.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _hklfile.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _hklfile.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _hklfile.SwigPyIterator___add__(self, *args)
    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, *args): return _hklfile.UnsignedIntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.UnsignedIntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.UnsignedIntVector___delslice__(self, *args)
    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, *args): return _hklfile.UnsignedIntVector_append(self, *args)
    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, *args): return _hklfile.UnsignedIntVector_swap(self, *args)
    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, *args): return _hklfile.UnsignedIntVector_push_back(self, *args)
    def front(self): return _hklfile.UnsignedIntVector_front(self)
    def back(self): return _hklfile.UnsignedIntVector_back(self)
    def assign(self, *args): return _hklfile.UnsignedIntVector_assign(self, *args)
    def resize(self, *args): return _hklfile.UnsignedIntVector_resize(self, *args)
    def insert(self, *args): return _hklfile.UnsignedIntVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.UnsignedIntVector_reserve(self, *args)
    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, *args): return _hklfile.IntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.IntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.IntVector___delslice__(self, *args)
    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, *args): return _hklfile.IntVector_append(self, *args)
    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, *args): return _hklfile.IntVector_swap(self, *args)
    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, *args): return _hklfile.IntVector_push_back(self, *args)
    def front(self): return _hklfile.IntVector_front(self)
    def back(self): return _hklfile.IntVector_back(self)
    def assign(self, *args): return _hklfile.IntVector_assign(self, *args)
    def resize(self, *args): return _hklfile.IntVector_resize(self, *args)
    def insert(self, *args): return _hklfile.IntVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.IntVector_reserve(self, *args)
    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, *args): return _hklfile.IntIntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.IntIntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.IntIntVector___delslice__(self, *args)
    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, *args): return _hklfile.IntIntVector_append(self, *args)
    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, *args): return _hklfile.IntIntVector_swap(self, *args)
    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, *args): return _hklfile.IntIntVector_push_back(self, *args)
    def front(self): return _hklfile.IntIntVector_front(self)
    def back(self): return _hklfile.IntIntVector_back(self)
    def assign(self, *args): return _hklfile.IntIntVector_assign(self, *args)
    def resize(self, *args): return _hklfile.IntIntVector_resize(self, *args)
    def insert(self, *args): return _hklfile.IntIntVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.IntIntVector_reserve(self, *args)
    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, *args): return _hklfile.DoubleVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.DoubleVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.DoubleVector___delslice__(self, *args)
    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, *args): return _hklfile.DoubleVector_append(self, *args)
    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, *args): return _hklfile.DoubleVector_swap(self, *args)
    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, *args): return _hklfile.DoubleVector_push_back(self, *args)
    def front(self): return _hklfile.DoubleVector_front(self)
    def back(self): return _hklfile.DoubleVector_back(self)
    def assign(self, *args): return _hklfile.DoubleVector_assign(self, *args)
    def resize(self, *args): return _hklfile.DoubleVector_resize(self, *args)
    def insert(self, *args): return _hklfile.DoubleVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.DoubleVector_reserve(self, *args)
    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, *args): return _hklfile.DoubleDoubleVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.DoubleDoubleVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.DoubleDoubleVector___delslice__(self, *args)
    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, *args): return _hklfile.DoubleDoubleVector_append(self, *args)
    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, *args): return _hklfile.DoubleDoubleVector_swap(self, *args)
    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, *args): return _hklfile.DoubleDoubleVector_push_back(self, *args)
    def front(self): return _hklfile.DoubleDoubleVector_front(self)
    def back(self): return _hklfile.DoubleDoubleVector_back(self)
    def assign(self, *args): return _hklfile.DoubleDoubleVector_assign(self, *args)
    def resize(self, *args): return _hklfile.DoubleDoubleVector_resize(self, *args)
    def insert(self, *args): return _hklfile.DoubleDoubleVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.DoubleDoubleVector_reserve(self, *args)
    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, *args): return _hklfile.StringVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.StringVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.StringVector___delslice__(self, *args)
    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, *args): return _hklfile.StringVector_append(self, *args)
    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, *args): return _hklfile.StringVector_swap(self, *args)
    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, *args): return _hklfile.StringVector_push_back(self, *args)
    def front(self): return _hklfile.StringVector_front(self)
    def back(self): return _hklfile.StringVector_back(self)
    def assign(self, *args): return _hklfile.StringVector_assign(self, *args)
    def resize(self, *args): return _hklfile.StringVector_resize(self, *args)
    def insert(self, *args): return _hklfile.StringVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.StringVector_reserve(self, *args)
    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, *args): return _hklfile.XtalDatasetInfoVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.XtalDatasetInfoVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.XtalDatasetInfoVector___delslice__(self, *args)
    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, *args): return _hklfile.XtalDatasetInfoVector_append(self, *args)
    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, *args): return _hklfile.XtalDatasetInfoVector_swap(self, *args)
    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, *args): return _hklfile.XtalDatasetInfoVector_push_back(self, *args)
    def front(self): return _hklfile.XtalDatasetInfoVector_front(self)
    def back(self): return _hklfile.XtalDatasetInfoVector_back(self)
    def assign(self, *args): return _hklfile.XtalDatasetInfoVector_assign(self, *args)
    def resize(self, *args): return _hklfile.XtalDatasetInfoVector_resize(self, *args)
    def insert(self, *args): return _hklfile.XtalDatasetInfoVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.XtalDatasetInfoVector_reserve(self, *args)
    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, *args): return _hklfile.ColumnDataVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.ColumnDataVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.ColumnDataVector___delslice__(self, *args)
    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, *args): return _hklfile.ColumnDataVector_append(self, *args)
    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, *args): return _hklfile.ColumnDataVector_swap(self, *args)
    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, *args): return _hklfile.ColumnDataVector_push_back(self, *args)
    def front(self): return _hklfile.ColumnDataVector_front(self)
    def back(self): return _hklfile.ColumnDataVector_back(self)
    def assign(self, *args): return _hklfile.ColumnDataVector_assign(self, *args)
    def resize(self, *args): return _hklfile.ColumnDataVector_resize(self, *args)
    def insert(self, *args): return _hklfile.ColumnDataVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.ColumnDataVector_reserve(self, *args)
    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, *args): return _hklfile.ColumnStatisticsVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.ColumnStatisticsVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.ColumnStatisticsVector___delslice__(self, *args)
    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, *args): return _hklfile.ColumnStatisticsVector_append(self, *args)
    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, *args): return _hklfile.ColumnStatisticsVector_swap(self, *args)
    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, *args): return _hklfile.ColumnStatisticsVector_push_back(self, *args)
    def front(self): return _hklfile.ColumnStatisticsVector_front(self)
    def back(self): return _hklfile.ColumnStatisticsVector_back(self)
    def assign(self, *args): return _hklfile.ColumnStatisticsVector_assign(self, *args)
    def resize(self, *args): return _hklfile.ColumnStatisticsVector_resize(self, *args)
    def insert(self, *args): return _hklfile.ColumnStatisticsVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.ColumnStatisticsVector_reserve(self, *args)
    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, *args): return _hklfile.ColumnGroupBase_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.ColumnGroupBase_GetData(self, *args)
    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)
    def DataArray(self): return _hklfile.ColumnGroupBase_DataArray(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, *args): return _hklfile.IsigIColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.IsigIColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.IsigAnoColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.IsigAnoColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.FsigFColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.FsigFColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.DsigDColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.DsigDColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.FsigAnoColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.FsigAnoColumnGroup_GetData(self, *args)
    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 FphiColumnGroup(ColumnGroupBase):
    __swig_setmethods__ = {}
    for _s in [ColumnGroupBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FphiColumnGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [ColumnGroupBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FphiColumnGroup, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _hklfile.new_FphiColumnGroup(*args)
        try: self.this.append(this)
        except: self.this = this
    def ImportData(self, *args): return _hklfile.FphiColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.FphiColumnGroup_GetData(self, *args)
    def format(self): return _hklfile.FphiColumnGroup_format(self)
    __swig_destroy__ = _hklfile.delete_FphiColumnGroup
    __del__ = lambda self : None;
FphiColumnGroup_swigregister = _hklfile.FphiColumnGroup_swigregister
FphiColumnGroup_swigregister(FphiColumnGroup)

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, *args): return _hklfile.FlagColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.FlagColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.ABCDColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.ABCDColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.FloatColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.FloatColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.WeightColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.WeightColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.IsymColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.IsymColumnGroup_GetData(self, *args)
    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, *args): return _hklfile.BatchColumnGroup_ImportData(self, *args)
    def GetData(self, *args): return _hklfile.BatchColumnGroup_GetData(self, *args)
    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 ClipperLabelList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClipperLabelList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ClipperLabelList, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _hklfile.new_ClipperLabelList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["xname"] = _hklfile.ClipperLabelList_xname_set
    __swig_getmethods__["xname"] = _hklfile.ClipperLabelList_xname_get
    if _newclass:xname = _swig_property(_hklfile.ClipperLabelList_xname_get, _hklfile.ClipperLabelList_xname_set)
    __swig_setmethods__["dname"] = _hklfile.ClipperLabelList_dname_set
    __swig_getmethods__["dname"] = _hklfile.ClipperLabelList_dname_get
    if _newclass:dname = _swig_property(_hklfile.ClipperLabelList_dname_get, _hklfile.ClipperLabelList_dname_set)
    __swig_setmethods__["path"] = _hklfile.ClipperLabelList_path_set
    __swig_getmethods__["path"] = _hklfile.ClipperLabelList_path_get
    if _newclass:path = _swig_property(_hklfile.ClipperLabelList_path_get, _hklfile.ClipperLabelList_path_set)
    __swig_setmethods__["labels"] = _hklfile.ClipperLabelList_labels_set
    __swig_getmethods__["labels"] = _hklfile.ClipperLabelList_labels_get
    if _newclass:labels = _swig_property(_hklfile.ClipperLabelList_labels_get, _hklfile.ClipperLabelList_labels_set)
    __swig_destroy__ = _hklfile.delete_ClipperLabelList
    __del__ = lambda self : None;
ClipperLabelList_swigregister = _hklfile.ClipperLabelList_swigregister
ClipperLabelList_swigregister(ClipperLabelList)

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, *args): return _hklfile.ColumnStatistics_SetColumnNames(self, *args)
    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(*args):
  return _hklfile.formatClipperCell(*args)
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, *args): return _hklfile.Float_type_shift_phase(self, *args)
    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, *args): return _hklfile.Float_type_data_export(self, *args)
    def data_import(self, *args): return _hklfile.Float_type_data_import(self, *args)
    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, *args): return _hklfile.Weight_type_shift_phase(self, *args)
    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, *args): return _hklfile.Weight_type_data_export(self, *args)
    def data_import(self, *args): return _hklfile.Weight_type_data_import(self, *args)
    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, *args): return _hklfile.Isym_shift_phase(self, *args)
    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, *args): return _hklfile.Isym_data_export(self, *args)
    def data_import(self, *args): return _hklfile.Isym_data_import(self, *args)
    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, *args): return _hklfile.clipper_Batch_shift_phase(self, *args)
    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, *args): return _hklfile.clipper_Batch_data_export(self, *args)
    def data_import(self, *args): return _hklfile.clipper_Batch_data_import(self, *args)
    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 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, *args): return _hklfile.HklZone_SetResolutionLimit(self, *args)
    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, *args): return _hklfile.HklZone_GetResolutionCircle(self, *args)
    def ResolutionFromRadius(self, *args): return _hklfile.HklZone_ResolutionFromRadius(self, *args)
    def rewind(self): return _hklfile.HklZone_rewind(self)
    def NextReflection(self, *args): return _hklfile.HklZone_NextReflection(self, *args)
    def XYZtoHKL(self, *args): return _hklfile.HklZone_XYZtoHKL(self, *args)
    def NearestHKL(self, *args): return _hklfile.HklZone_NearestHKL(self, *args)
    def __init__(self, *args): 
        this = _hklfile.new_HklZone(*args)
        try: self.this.append(this)
        except: self.this = this
    def init(self, *args): return _hklfile.HklZone_init(self, *args)
    def SetStatus(self, *args): return _hklfile.HklZone_SetStatus(self, *args)
    def SetCellSpacegroup(self, *args): return _hklfile.HklZone_SetCellSpacegroup(self, *args)
    def IorFflag(self, *args): return _hklfile.HklZone_IorFflag(self, *args)
    def StoreGroupInfo(self, *args): return _hklfile.HklZone_StoreGroupInfo(self, *args)
    def AddReflection(self, *args): return _hklfile.HklZone_AddReflection(self, *args)
    def CloseReflectionList(self): return _hklfile.HklZone_CloseReflectionList(self)
    def IsInZone(self, *args): return _hklfile.HklZone_IsInZone(self, *args)
    def AreAnyInZone(self, *args): return _hklfile.HklZone_AreAnyInZone(self, *args)
    __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, *args): return _hklfile.MtzMerged_init(self, *args)
    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, *args): return _hklfile.MtzMerged_ColumnGroup(self, *args)
    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, *args): return _hklfile.CrystalDataset_init(self, *args)
    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, *args): return _hklfile.XtalDatasetInfo_init(self, *args)
    def GetCrystalDataset(self): return _hklfile.XtalDatasetInfo_GetCrystalDataset(self)
    def AddColumn(self, *args): return _hklfile.XtalDatasetInfo_AddColumn(self, *args)
    def AddColumnGroup(self, *args): return _hklfile.XtalDatasetInfo_AddColumnGroup(self, *args)
    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, *args): return _hklfile.ReflectionList_init(self, *args)
    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, *args): return _hklfile.ReflectionList_ColumnGroup(self, *args)
    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 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, *args): return _hklfile.ReflectionList_NextReflection(self, *args)
    def FormatReflection(self, *args): return _hklfile.ReflectionList_FormatReflection(self, *args)
    def Zone(self, *args): return _hklfile.ReflectionList_Zone(self, *args)
    def MaximumZoneLevel(self, *args): return _hklfile.ReflectionList_MaximumZoneLevel(self, *args)
    __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, *args): return _hklfile.ReflectionData_StoreOriginalHkl(self, *args)
    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, *args): return _hklfile.ReflectionInfo_init(self, *args)
    __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)

PROGRAM_VERSION = _hklfile.PROGRAM_VERSION
PROGRAM_DATE = _hklfile.PROGRAM_DATE
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_ASCII = _hklfile.ReflectionFileType_XDS_ASCII
    def __init__(self, *args): 
        this = _hklfile.new_ReflectionFileType(*args)
        try: self.this.append(this)
        except: self.this = this
    def SetTypeCode(self, *args): return _hklfile.ReflectionFileType_SetTypeCode(self, *args)
    def SetType(self, *args): return _hklfile.ReflectionFileType_SetType(self, *args)
    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 IsTypeSCA(self): return _hklfile.ReflectionFileType_IsTypeSCA(self)
    def IsTypeSHELX(self): return _hklfile.ReflectionFileType_IsTypeSHELX(self)
    def IsTypeSAINT(self): return _hklfile.ReflectionFileType_IsTypeSAINT(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(*args):
  return _hklfile.CheckCompatibleSymmetry(*args)
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, *args): return _hklfile.run_controls_SetStatus(self, *args)
    def Status(self): return _hklfile.run_controls_Status(self)
    def Set(self): return _hklfile.run_controls_Set(self)
    def Explicit(self): return _hklfile.run_controls_Explicit(self)
    def StoreRunBatchSelection(self, *args): return _hklfile.run_controls_StoreRunBatchSelection(self, *args)
    def RunNumber(self, *args): return _hklfile.run_controls_RunNumber(self, *args)
    def RunNumberList(self): return _hklfile.run_controls_RunNumberList(self)
    def BatchRanges(self, *args): return _hklfile.run_controls_BatchRanges(self, *args)
    def StoreUseRun(self, *args): return _hklfile.run_controls_StoreUseRun(self, *args)
    def UseRun(self): return _hklfile.run_controls_UseRun(self)
    def StoreResoByRun(self, *args): return _hklfile.run_controls_StoreResoByRun(self, *args)
    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)
    __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, *args): return _hklfile.col_controls_SetIcolFlag(self, *args)
    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 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, *args): return _hklfile.AnalysisControls_SetNbatchSmooth(self, *args)
    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_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, *args): return _hklfile.OutlierControl_SetNdatasets(self, *args)
    def SetReject(self, *args): return _hklfile.OutlierControl_SetReject(self, *args)
    def Reject(self, *args): return _hklfile.OutlierControl_Reject(self, *args)
    def SetEmax(self, *args): return _hklfile.OutlierControl_SetEmax(self, *args)
    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, *args): return _hklfile.RefineControl_SetNprocs(self, *args)
    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 PolarisationControl(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PolarisationControl, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PolarisationControl, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _hklfile.new_PolarisationControl()
        try: self.this.append(this)
        except: self.this = this
    def SetFactor(self, *args): return _hklfile.PolarisationControl_SetFactor(self, *args)
    def Factor(self): return _hklfile.PolarisationControl_Factor(self)
    def IsSet(self): return _hklfile.PolarisationControl_IsSet(self)
    __swig_getmethods__["Default"] = lambda x: _hklfile.PolarisationControl_Default
    if _newclass:Default = staticmethod(_hklfile.PolarisationControl_Default)
    __swig_destroy__ = _hklfile.delete_PolarisationControl
    __del__ = lambda self : None;
PolarisationControl_swigregister = _hklfile.PolarisationControl_swigregister
PolarisationControl_swigregister(PolarisationControl)

def PolarisationControl_Default():
  return _hklfile.PolarisationControl_Default()
PolarisationControl_Default = _hklfile.PolarisationControl_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__["polarisationcontrol"] = _hklfile.all_controls_polarisationcontrol_set
    __swig_getmethods__["polarisationcontrol"] = _hklfile.all_controls_polarisationcontrol_get
    if _newclass:polarisationcontrol = _swig_property(_hklfile.all_controls_polarisationcontrol_get, _hklfile.all_controls_polarisationcontrol_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, *args): return _hklfile.EProb_init(self, *args)
    def Clear(self): return _hklfile.EProb_Clear(self)
    def Null(self): return _hklfile.EProb_Null(self)
    def TooBig(self, *args): return _hklfile.EProb_TooBig(self, *args)
    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, *args): return _hklfile.hash_table_set_size(self, *args)
    def Size(self): return _hklfile.hash_table_Size(self)
    def add(self, *args): return _hklfile.hash_table_add(self, *args)
    def lookup(self, *args): return _hklfile.hash_table_lookup(self, *args)
    def number(self, *args): return _hklfile.hash_table_number(self, *args)
    __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(*args):
  return _hklfile.hash_table_prime(*args)
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, *args): return _hklfile.file_select_set_reslimits(self, *args)
    def reslimits(self): return _hklfile.file_select_reslimits(self)
    def in_reslimits(self, *args): return _hklfile.file_select_in_reslimits(self, *args)
    def accept_dataset(self, *args): return _hklfile.file_select_accept_dataset(self, *args)
    def accept_batch(self, *args): return _hklfile.file_select_accept_batch(self, *args)
    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)

UNKNOWN = _hklfile.UNKNOWN
CHIRAL = _hklfile.CHIRAL
NONCHIRAL = _hklfile.NONCHIRAL
CENTROSYMMETRIC = _hklfile.CENTROSYMMETRIC

def Chiral_as_string(*args):
  return _hklfile.Chiral_as_string(*args)
Chiral_as_string = _hklfile.Chiral_as_string
ALL = _hklfile.ALL
BOTH = _hklfile.BOTH
IPLUS = _hklfile.IPLUS
IMINUS = _hklfile.IMINUS

def SpindleToPrincipleAxes(*args):
  return _hklfile.SpindleToPrincipleAxes(*args)
SpindleToPrincipleAxes = _hklfile.SpindleToPrincipleAxes

def SmallestComponent(*args):
  return _hklfile.SmallestComponent(*args)
SmallestComponent = _hklfile.SmallestComponent

def FormatSpindleToPrincipleAxes(*args):
  return _hklfile.FormatSpindleToPrincipleAxes(*args)
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)
    __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, *args): return _hklfile.ReindexOp_SetStrict(self, *args)
    def Strict(self): return _hklfile.ReindexOp_Strict(self)
    def SetDeviation(self, *args): return _hklfile.ReindexOp_SetDeviation(self, *args)
    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, *args): return _hklfile.ReindexOp_Symop(self, *args)
    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, *args): return _hklfile.ReindexOp_equals(self, *args)
    def FindSimplest(self, *args): return _hklfile.ReindexOp_FindSimplest(self, *args)
    __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, *args): return _hklfile.Scell_init(self, *args)
    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, *args): return _hklfile.Scell_change_basis(self, *args)
    def format(self, w=7, p=4): return _hklfile.Scell_format(self, w, p)
    def xml(self): return _hklfile.Scell_xml(self)
    def ClipperCell(self): return _hklfile.Scell_ClipperCell(self)
    def Volume(self): return _hklfile.Scell_Volume(self)
    def AngleTest(self, *args): return _hklfile.Scell_AngleTest(self, *args)
    def equals(self, *args): return _hklfile.Scell_equals(self, *args)
    def equalsTol(self, *args): return _hklfile.Scell_equalsTol(self, *args)
    def Difference(self, *args): return _hklfile.Scell_Difference(self, *args)
    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, *args): return _hklfile.UnitCellSet_init(self, *args)
    def clear(self): return _hklfile.UnitCellSet_clear(self)
    def AddCell(self, *args): return _hklfile.UnitCellSet_AddCell(self, *args)
    def AddCellSet(self, *args): return _hklfile.UnitCellSet_AddCellSet(self, *args)
    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, *args): return _hklfile.UnitCellSet_Average(self, *args)
    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, *args): return _hklfile.Hkl_invresolsq(self, *args)
    def change_basis(self, *args): return _hklfile.Hkl_change_basis(self, *args)
    def orth(self, *args): return _hklfile.Hkl_orth(self, *args)
    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(*args):
  return _hklfile.HklDecode(*args)
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, *args): return _hklfile.PxdName_update(self, *args)
    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, *args): return _hklfile.Xdataset_add_batch(self, *args)
    def ClearBatchList(self): return _hklfile.Xdataset_ClearBatchList(self)
    def num_batches(self): return _hklfile.Xdataset_num_batches(self)
    def change_basis(self, *args): return _hklfile.Xdataset_change_basis(self, *args)
    def AddRunIndex(self, *args): return _hklfile.Xdataset_AddRunIndex(self, *args)
    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, *args): return _hklfile.Xdataset_SetCellWavelength(self, *args)
    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, *args): return _hklfile.Xdataset_AddCellWavelength(self, *args)
    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, *args): return _hklfile.Batch_change_basis(self, *args)
    def SetCellConstraint(self, *args): return _hklfile.Batch_SetCellConstraint(self, *args)
    def SetCell(self, *args): return _hklfile.Batch_SetCell(self, *args)
    def FileNumber(self, *args): return _hklfile.Batch_FileNumber(self, *args)
    def OffsetPhi(self, *args): return _hklfile.Batch_OffsetPhi(self, *args)
    def PhiOffset(self): return _hklfile.Batch_PhiOffset(self)
    def SetRunIndex(self, *args): return _hklfile.Batch_SetRunIndex(self, *args)
    def RunIndex(self): return _hklfile.Batch_RunIndex(self)
    def num(self, *args): return _hklfile.Batch_num(self, *args)
    def OffsetNum(self, *args): return _hklfile.Batch_OffsetNum(self, *args)
    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 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, *args): return _hklfile.Batch_OffsetTime(self, *args)
    def StoreTimeRange(self, *args): return _hklfile.Batch_StoreTimeRange(self, *args)
    def Accepted(self): return _hklfile.Batch_Accepted(self)
    def SetAccept(self, *args): return _hklfile.Batch_SetAccept(self, *args)
    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 ValidOrientation(self): return _hklfile.Batch_ValidOrientation(self)
    def HtoSr(self, *args): return _hklfile.Batch_HtoSr(self, *args)
    def HtoSr0(self, *args): return _hklfile.Batch_HtoSr0(self, *args)
    def SrtoSr0(self, *args): return _hklfile.Batch_SrtoSr0(self, *args)
    def Sr0toP(self, *args): return _hklfile.Batch_Sr0toP(self, *args)
    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, *args): return _hklfile.Batch_SetPole(self, *args)
    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)
    __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, *args): return _hklfile.BatchSelection_AddBatch(self, *args)
    def AddRange(self, *args): return _hklfile.BatchSelection_AddRange(self, *args)
    def FindInSelection(self, *args): return _hklfile.BatchSelection_FindInSelection(self, *args)
    def InSelection(self, *args): return _hklfile.BatchSelection_InSelection(self, *args)
    def FlagNumber(self, *args): return _hklfile.BatchSelection_FlagNumber(self, *args)
    def UniqueFlags(self): return _hklfile.BatchSelection_UniqueFlags(self)
    def BatchRanges(self, *args): return _hklfile.BatchSelection_BatchRanges(self, *args)
    def CheckSeries(self, *args): return _hklfile.BatchSelection_CheckSeries(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, *args): return _hklfile.SpaceGroup_Symop(self, *args)
    def RotSymop(self, *args): return _hklfile.SpaceGroup_RotSymop(self, *args)
    def InvRotSymop(self, *args): return _hklfile.SpaceGroup_InvRotSymop(self, *args)
    def SymopFromIsym(self, *args): return _hklfile.SpaceGroup_SymopFromIsym(self, *args)
    def RotSymopCode(self, *args): return _hklfile.SpaceGroup_RotSymopCode(self, *args)
    def InvRotSymopCode(self, *args): return _hklfile.SpaceGroup_InvRotSymopCode(self, *args)
    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, *args): return _hklfile.SpaceGroup_NewLatticePointGroup(self, *args)
    def SymopCodes(self): return _hklfile.SpaceGroup_SymopCodes(self)
    def IsSymopIdentity(self, *args): return _hklfile.SpaceGroup_IsSymopIdentity(self, *args)
    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 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, *args): return _hklfile.SpaceGroup_put_in_asu(self, *args)
    def get_from_asu(self, *args): return _hklfile.SpaceGroup_get_from_asu(self, *args)
    def ChangeBasis(self, *args): return _hklfile.SpaceGroup_ChangeBasis(self, *args)
    __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(*args):
  return _hklfile.SpaceGroup_isNameCentredTriclinic(*args)
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, *args): return _hklfile.hkl_symmetry_set_reindex(self, *args)
    def GetSpaceGroup(self): return _hklfile.hkl_symmetry_GetSpaceGroup(self)
    def ClipperGroup(self): return _hklfile.hkl_symmetry_ClipperGroup(self)
    def get_from_asu(self, *args): return _hklfile.hkl_symmetry_get_from_asu(self, *args)
    def is_centric(self, *args): return _hklfile.hkl_symmetry_is_centric(self, *args)
    def epsilon(self, *args): return _hklfile.hkl_symmetry_epsilon(self, *args)
    def IsCentro(self): return _hklfile.hkl_symmetry_IsCentro(self)
    def IsChiral(self): return _hklfile.hkl_symmetry_IsChiral(self)
    def LatticePresent(self, *args): return _hklfile.hkl_symmetry_LatticePresent(self, *args)
    def ChangeBasis(self, *args): return _hklfile.hkl_symmetry_ChangeBasis(self, *args)
    def Nelement(self): return _hklfile.hkl_symmetry_Nelement(self)
    def IsElementIdent(self, *args): return _hklfile.hkl_symmetry_IsElementIdent(self, *args)
    __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, *args): return _hklfile.hkl_symmetry_format_element(self, *args)
    def XML_element(self, *args): return _hklfile.hkl_symmetry_XML_element(self, *args)
    def print_element(self, *args): return _hklfile.hkl_symmetry_print_element(self, *args)
    def print_elements(self): return _hklfile.hkl_symmetry_print_elements(self)
    def NopInElement(self, *args): return _hklfile.hkl_symmetry_NopInElement(self, *args)
    def SymopInElement(self, *args): return _hklfile.hkl_symmetry_SymopInElement(self, *args)
    def ClipperSymopInElement(self, *args): return _hklfile.hkl_symmetry_ClipperSymopInElement(self, *args)
    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, HorR=' '): return _hklfile.hkl_symmetry_symbol_xHM(self, HorR)
    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, *args): return _hklfile.hkl_symmetry_RotSymopsInElement(self, *args)
    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, *args): return _hklfile.hkl_symmetry_equals_rt(self, *args)
    def equals_r(self, *args): return _hklfile.hkl_symmetry_equals_r(self, *args)
    def equals_r_order(self, *args): return _hklfile.hkl_symmetry_equals_r_order(self, *args)
    def __eq__(self, *args): return _hklfile.hkl_symmetry___eq__(self, *args)
    def __ne__(self, *args): return _hklfile.hkl_symmetry___ne__(self, *args)
    def equalElement(self, *args): return _hklfile.hkl_symmetry_equalElement(self, *args)
    __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, *args): 
        this = _hklfile.new_IceRing(*args)
        try: self.this.append(this)
        except: self.this = this
    def Dstar(self): return _hklfile.IceRing_Dstar(self)
    def InRing(self, *args): return _hklfile.IceRing_InRing(self, *args)
    def ClearSums(self): return _hklfile.IceRing_ClearSums(self)
    def AddObs(self, *args): return _hklfile.IceRing_AddObs(self, *args)
    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, *args): return _hklfile.Rings_AddRing(self, *args)
    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, *args): return _hklfile.Rings_Dstar(self, *args)
    def CopyRejRings(self, *args): return _hklfile.Rings_CopyRejRings(self, *args)
    def InRing(self, *args): return _hklfile.Rings_InRing(self, *args)
    def ClearSums(self): return _hklfile.Rings_ClearSums(self)
    def AddObs(self, *args): return _hklfile.Rings_AddObs(self, *args)
    def SetReject(self, *args): return _hklfile.Rings_SetReject(self, *args)
    def MeanI(self, *args): return _hklfile.Rings_MeanI(self, *args)
    def MeanSigI(self, *args): return _hklfile.Rings_MeanSigI(self, *args)
    def MeanSSqr(self, *args): return _hklfile.Rings_MeanSSqr(self, *args)
    def Reject(self, *args): return _hklfile.Rings_Reject(self, *args)
    def N(self, *args): return _hklfile.Rings_N(self, *args)
    __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(*args):
  return _hklfile.SetDiagCMat33(*args)
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(*args):
  return _hklfile.is_rtop_ident(*args)
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(*args):
  return _hklfile.IntVec(*args)
IntVec = _hklfile.IntVec

def LsqTransform(*args):
  return _hklfile.LsqTransform(*args)
LsqTransform = _hklfile.LsqTransform

def AxisDirection(*args):
  return _hklfile.AxisDirection(*args)
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, *args): return _hklfile.MtzUnmrgFile_open_read(self, *args)
    def close_read(self): return _hklfile.MtzUnmrgFile_close_read(self)
    def FillHklList(self, *args): return _hklfile.MtzUnmrgFile_FillHklList(self, *args)
    def AddHklList(self, *args): return _hklfile.MtzUnmrgFile_AddHklList(self, *args)
    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, *args): return _hklfile.MtzUnmrgFile_Rrefl(self, *args)
    def get_dataset(self, *args): return _hklfile.MtzUnmrgFile_get_dataset(self, *args)
    def get_batch(self, *args): return _hklfile.MtzUnmrgFile_get_batch(self, *args)
    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 Nlattices(self): return _hklfile.MtzUnmrgFile_Nlattices(self)
    def NumberinLattice(self): return _hklfile.MtzUnmrgFile_NumberinLattice(self)
    def LatticeNumber(self): return _hklfile.MtzUnmrgFile_LatticeNumber(self)
MtzUnmrgFile_swigregister = _hklfile.MtzUnmrgFile_swigregister
MtzUnmrgFile_swigregister(MtzUnmrgFile)


def ClipperSymopsFromMtzSYMGRP(*args):
  return _hklfile.ClipperSymopsFromMtzSYMGRP(*args)
ClipperSymopsFromMtzSYMGRP = _hklfile.ClipperSymopsFromMtzSYMGRP

def spg_to_mtz(*args):
  return _hklfile.spg_to_mtz(*args)
spg_to_mtz = _hklfile.spg_to_mtz

def CmtzSymgrpEqual(*args):
  return _hklfile.CmtzSymgrpEqual(*args)
CmtzSymgrpEqual = _hklfile.CmtzSymgrpEqual

def ccp4_write_spacegroup(*args):
  return _hklfile.ccp4_write_spacegroup(*args)
ccp4_write_spacegroup = _hklfile.ccp4_write_spacegroup

def addToHistory(*args):
  return _hklfile.addToHistory(*args)
addToHistory = _hklfile.addToHistory

def MTZaddHistory(*args):
  return _hklfile.MTZaddHistory(*args)
MTZaddHistory = _hklfile.MTZaddHistory

def PackFlagValues(*args):
  return _hklfile.PackFlagValues(*args)
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, *args): return _hklfile.ObservationFlag_AddFlag(self, *args)
    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, *args): return _hklfile.ObservationFlag_BgPkValues(self, *args)
    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 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

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, *args): return _hklfile.ObservationFlagControl_SetBGRlimit(self, *args)
    def SetPKRlimit(self, *args): return _hklfile.ObservationFlagControl_SetPKRlimit(self, *args)
    def SetGradlimit(self, *args): return _hklfile.ObservationFlagControl_SetGradlimit(self, *args)
    def SetAcceptOverload(self): return _hklfile.ObservationFlagControl_SetAcceptOverload(self)
    def SetAcceptEdge(self): return _hklfile.ObservationFlagControl_SetAcceptEdge(self)
    def IsAccepted(self, *args): return _hklfile.ObservationFlagControl_IsAccepted(self, *args)
    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
    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 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 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, *args): return _hklfile.Range_SetRange(self, *args)
    def SetNbin(self, *args): return _hklfile.Range_SetNbin(self, *args)
    def clear(self): return _hklfile.Range_clear(self)
    def update(self, *args): return _hklfile.Range_update(self, *args)
    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, *args): return _hklfile.Range_bin(self, *args)
    def tbin(self, *args): return _hklfile.Range_tbin(self, *args)
    def Nbins(self): return _hklfile.Range_Nbins(self)
    def bounds(self, *args): return _hklfile.Range_bounds(self, *args)
    def middle(self, *args): return _hklfile.Range_middle(self, *args)
    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, *args): return _hklfile.ResoRange_init_range(self, *args)
    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, *args): return _hklfile.ResoRange_SetNbins(self, *args)
    def Nbins(self): return _hklfile.ResoRange_Nbins(self)
    def SetWidth(self, *args): return _hklfile.ResoRange_SetWidth(self, *args)
    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, *args): return _hklfile.ResoRange_middleA(self, *args)
    def boundsA(self, *args): return _hklfile.ResoRange_boundsA(self, *args)
    def boundsS(self, *args): return _hklfile.ResoRange_boundsS(self, *args)
    def BinRange(self, *args): return _hklfile.ResoRange_BinRange(self, *args)
    def MaxRange(self, *args): return _hklfile.ResoRange_MaxRange(self, *args)
    def MinRange(self, *args): return _hklfile.ResoRange_MinRange(self, *args)
    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, *args): return _hklfile.IntRange_SetRange(self, *args)
    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, *args): return _hklfile.IntRange_InRange(self, *args)
    def MaxRange(self, *args): return _hklfile.IntRange_MaxRange(self, *args)
    def midrange(self): return _hklfile.IntRange_midrange(self)
    def __eq__(self, *args): return _hklfile.IntRange___eq__(self, *args)
    def __ne__(self, *args): return _hklfile.IntRange___ne__(self, *args)
    def Overlap(self, *args): return _hklfile.IntRange_Overlap(self, *args)
    __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, *args): return _hklfile.Euler_explicit_SetAngles(self, *args)
    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, *args): return _hklfile.Rotation_euler_explicit(self, *args)
    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 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, *args): return _hklfile.Run_AddBatch(self, *args)
    def SortList(self): return _hklfile.Run_SortList(self)
    def IsInList(self, *args): return _hklfile.Run_IsInList(self, *args)
    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 BatchRange(self): return _hklfile.Run_BatchRange(self)
    def Batch0(self): return _hklfile.Run_Batch0(self)
    def SetBatchSerial0(self, *args): return _hklfile.Run_SetBatchSerial0(self, *args)
    def BatchSerial0(self): return _hklfile.Run_BatchSerial0(self)
    def Nbatches(self): return _hklfile.Run_Nbatches(self)
    def OffsetBatchNumbers(self, *args): return _hklfile.Run_OffsetBatchNumbers(self, *args)
    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, *args): return _hklfile.Run_SetValidOrientation(self, *args)
    def ValidOrientation(self): return _hklfile.Run_ValidOrientation(self)
    def StoreSpindleToPrincipleAxis(self, *args): return _hklfile.Run_StoreSpindleToPrincipleAxis(self, *args)
    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, *args): return _hklfile.Run_formatPrint(self, *args)
    def formatPrintBrief(self, *args): return _hklfile.Run_formatPrintBrief(self, *args)
    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, *args): return _hklfile.Run_StoreResoRange(self, *args)
    def GetResoRange(self): return _hklfile.Run_GetResoRange(self)
    def IsResoRange(self): return _hklfile.Run_IsResoRange(self)
    def InResoRange(self, *args): return _hklfile.Run_InResoRange(self, *args)
    def SetLatticeNumber(self, *args): return _hklfile.Run_SetLatticeNumber(self, *args)
    def LatticeNumber(self): return _hklfile.Run_LatticeNumber(self)
    def StoreUse(self, *args): return _hklfile.Run_StoreUse(self, *args)
    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 IncrementOffset(self, *args): return _hklfile.RunRange_IncrementOffset(self, *args)
    __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(*args):
  return _hklfile.CompareRunRanges(*args)
CompareRunRanges = _hklfile.CompareRunRanges

def FindRunIndex(*args):
  return _hklfile.FindRunIndex(*args)
FindRunIndex = _hklfile.FindRunIndex

def BaseFileName(*args):
  return _hklfile.BaseFileName(*args)
BaseFileName = _hklfile.BaseFileName

def FileNameNoExtension(*args):
  return _hklfile.FileNameNoExtension(*args)
FileNameNoExtension = _hklfile.FileNameNoExtension

def FileNameExtension(*args):
  return _hklfile.FileNameExtension(*args)
FileNameExtension = _hklfile.FileNameExtension

def AddFileExtension(*args):
  return _hklfile.AddFileExtension(*args)
AddFileExtension = _hklfile.AddFileExtension

def Directory(*args):
  return _hklfile.Directory(*args)
Directory = _hklfile.Directory

def FormatCell(*args):
  return _hklfile.FormatCell(*args)
FormatCell = _hklfile.FormatCell

def MnSd(*args):
  return _hklfile.MnSd(*args)
MnSd = _hklfile.MnSd

def IRandom(*args):
  return _hklfile.IRandom(*args)
IRandom = _hklfile.IRandom

def FRandom(*args):
  return _hklfile.FRandom(*args)
FRandom = _hklfile.FRandom

def SafeSqrt(*args):
  return _hklfile.SafeSqrt(*args)
SafeSqrt = _hklfile.SafeSqrt

def AverageDsetCell(*args):
  return _hklfile.AverageDsetCell(*args)
AverageDsetCell = _hklfile.AverageDsetCell

def AverageBatchCell(*args):
  return _hklfile.AverageBatchCell(*args)
AverageBatchCell = _hklfile.AverageBatchCell

def AverageDsetWavelength(*args):
  return _hklfile.AverageDsetWavelength(*args)
AverageDsetWavelength = _hklfile.AverageDsetWavelength

def AverageWavelength(*args):
  return _hklfile.AverageWavelength(*args)
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, *args): return _hklfile.MeanSD___iadd__(self, *args)
    __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(*args):
  return _hklfile.MeanSD_MeanSDsmallerSD(*args)
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, *args): return _hklfile.MeanValue___iadd__(self, *args)
    __swig_destroy__ = _hklfile.delete_MeanValue
    __del__ = lambda self : None;
MeanValue_swigregister = _hklfile.MeanValue_swigregister
MeanValue_swigregister(MeanValue)


def Median(*args):
  return _hklfile.Median(*args)
Median = _hklfile.Median
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__["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__["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)
    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(*args):
  return _hklfile.StringUtil_StripNull(*args)
StringUtil_StripNull = _hklfile.StringUtil_StripNull

def StringUtil_Trim(*args):
  return _hklfile.StringUtil_Trim(*args)
StringUtil_Trim = _hklfile.StringUtil_Trim

def StringUtil_CentreString(*args):
  return _hklfile.StringUtil_CentreString(*args)
StringUtil_CentreString = _hklfile.StringUtil_CentreString

def StringUtil_PadString(*args):
  return _hklfile.StringUtil_PadString(*args)
StringUtil_PadString = _hklfile.StringUtil_PadString

def StringUtil_RightString(*args):
  return _hklfile.StringUtil_RightString(*args)
StringUtil_RightString = _hklfile.StringUtil_RightString

def StringUtil_LeftString(*args):
  return _hklfile.StringUtil_LeftString(*args)
StringUtil_LeftString = _hklfile.StringUtil_LeftString

def StringUtil_split(*args):
  return _hklfile.StringUtil_split(*args)
StringUtil_split = _hklfile.StringUtil_split

def StringUtil_MakeXMLtag(*args):
  return _hklfile.StringUtil_MakeXMLtag(*args)
StringUtil_MakeXMLtag = _hklfile.StringUtil_MakeXMLtag

def StringUtil_XMLstring(*args):
  return _hklfile.StringUtil_XMLstring(*args)
StringUtil_XMLstring = _hklfile.StringUtil_XMLstring

def StringUtil_FormatXMLcrossTable(*args):
  return _hklfile.StringUtil_FormatXMLcrossTable(*args)
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(*args):
  return _hklfile.StringUtil_formatFraction(*args)
StringUtil_formatFraction = _hklfile.StringUtil_formatFraction

def StringUtil_ToUpper(*args):
  return _hklfile.StringUtil_ToUpper(*args)
StringUtil_ToUpper = _hklfile.StringUtil_ToUpper

def StringUtil_BuftoLine(*args):
  return _hklfile.StringUtil_BuftoLine(*args)
StringUtil_BuftoLine = _hklfile.StringUtil_BuftoLine

def StringUtil_FormatSaveVector(*args):
  return _hklfile.StringUtil_FormatSaveVector(*args)
StringUtil_FormatSaveVector = _hklfile.StringUtil_FormatSaveVector

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(*args):
  return _hklfile.FormatOutput_logTab(*args)
FormatOutput_logTab = _hklfile.FormatOutput_logTab

def FormatOutput_logTabPrintf(*args):
  return _hklfile.FormatOutput_logTabPrintf(*args)
FormatOutput_logTabPrintf = _hklfile.FormatOutput_logTabPrintf

def FormatOutput_logWarning(*args):
  return _hklfile.FormatOutput_logWarning(*args)
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, *args): return _hklfile.Citation_AddCitation(self, *args)
    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(*args):
  return _hklfile.ClipperStringAsString(*args)
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, *args): return _hklfile.ClipperStringVector___getslice__(self, *args)
    def __setslice__(self, *args): return _hklfile.ClipperStringVector___setslice__(self, *args)
    def __delslice__(self, *args): return _hklfile.ClipperStringVector___delslice__(self, *args)
    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, *args): return _hklfile.ClipperStringVector_append(self, *args)
    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, *args): return _hklfile.ClipperStringVector_swap(self, *args)
    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, *args): return _hklfile.ClipperStringVector_push_back(self, *args)
    def front(self): return _hklfile.ClipperStringVector_front(self)
    def back(self): return _hklfile.ClipperStringVector_back(self)
    def assign(self, *args): return _hklfile.ClipperStringVector_assign(self, *args)
    def resize(self, *args): return _hklfile.ClipperStringVector_resize(self, *args)
    def insert(self, *args): return _hklfile.ClipperStringVector_insert(self, *args)
    def reserve(self, *args): return _hklfile.ClipperStringVector_reserve(self, *args)
    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(*args):
  return _hklfile.Spgr_descr_set_preferred(*args)
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, *args): return _hklfile.Spacegroup_init(self, *args)
    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, *args): return _hklfile.Spacegroup_symop(self, *args)
    def primitive_symop(self, *args): return _hklfile.Spacegroup_primitive_symop(self, *args)
    def inversion_symop(self, *args): return _hklfile.Spacegroup_inversion_symop(self, *args)
    def centering_symop(self, *args): return _hklfile.Spacegroup_centering_symop(self, *args)
    def order_of_symmetry_about_axis(self, *args): return _hklfile.Spacegroup_order_of_symmetry_about_axis(self, *args)
    def hkl_class(self, *args): return _hklfile.Spacegroup_hkl_class(self, *args)
    def recip_asu(self, *args): return _hklfile.Spacegroup_recip_asu(self, *args)
    def product_op(self, *args): return _hklfile.Spacegroup_product_op(self, *args)
    def inverse_op(self, *args): return _hklfile.Spacegroup_inverse_op(self, *args)
    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, *args): return _hklfile.String_split(self, *args)
    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, *args): return _hklfile.Cell_init(self, *args)
    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, *args): return _hklfile.Cell_equals(self, *args)
    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, *args): return _hklfile.CCP4MTZfile_open_read(self, *args)
    def close_read(self): return _hklfile.CCP4MTZfile_close_read(self)
    def open_append(self, *args): return _hklfile.CCP4MTZfile_open_append(self, *args)
    def close_append(self): return _hklfile.CCP4MTZfile_close_append(self)
    def open_write(self, *args): return _hklfile.CCP4MTZfile_open_write(self, *args)
    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, *args): return _hklfile.CCP4MTZfile_import_hkl_list(self, *args)
    def import_hkl_info(self, *args): return _hklfile.CCP4MTZfile_import_hkl_info(self, *args)
    def import_crystal(self, *args): return _hklfile.CCP4MTZfile_import_crystal(self, *args)
    def import_dataset(self, *args): return _hklfile.CCP4MTZfile_import_dataset(self, *args)
    def export_hkl_info(self, *args): return _hklfile.CCP4MTZfile_export_hkl_info(self, *args)
    def export_crystal(self, *args): return _hklfile.CCP4MTZfile_export_crystal(self, *args)
    def export_dataset(self, *args): return _hklfile.CCP4MTZfile_export_dataset(self, *args)
    def import_chkl_data(self, *args): return _hklfile.CCP4MTZfile_import_chkl_data(self, *args)
    def export_chkl_data(self, *args): return _hklfile.CCP4MTZfile_export_chkl_data(self, *args)
    def column_paths(self): return _hklfile.CCP4MTZfile_column_paths(self)
    def title(self): return _hklfile.CCP4MTZfile_title(self)
    def set_title(self, *args): return _hklfile.CCP4MTZfile_set_title(self, *args)
    def history(self): return _hklfile.CCP4MTZfile_history(self)
    def set_history(self, *args): return _hklfile.CCP4MTZfile_set_history(self, *args)
    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, *args): return _hklfile.CCP4MTZfile_set_column_label_mode(self, *args)
    def set_verbose(self, *args): return _hklfile.CCP4MTZfile_set_verbose(self, *args)
    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, *args): return _hklfile.HKL_info_init(self, *args)
    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.