# 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('_ccp4srs', [dirname(__file__)])
        except ImportError:
            import _ccp4srs
            return _ccp4srs
        if fp is not None:
            try:
                _mod = imp.load_module('_ccp4srs', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ccp4srs = swig_import_helper()
    del swig_import_helper
else:
    import _ccp4srs
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__ = _ccp4srs.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _ccp4srs.SwigPyIterator_value(self)
    def incr(self, n=1): return _ccp4srs.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _ccp4srs.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _ccp4srs.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _ccp4srs.SwigPyIterator_equal(self, *args)
    def copy(self): return _ccp4srs.SwigPyIterator_copy(self)
    def next(self): return _ccp4srs.SwigPyIterator_next(self)
    def __next__(self): return _ccp4srs.SwigPyIterator___next__(self)
    def previous(self): return _ccp4srs.SwigPyIterator_previous(self)
    def advance(self, *args): return _ccp4srs.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _ccp4srs.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _ccp4srs.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _ccp4srs.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _ccp4srs.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _ccp4srs.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _ccp4srs.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _ccp4srs.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


def InitMatType():
  return _ccp4srs.InitMatType()
InitMatType = _ccp4srs.InitMatType

def mround(*args):
  return _ccp4srs.mround(*args)
mround = _ccp4srs.mround

def ifloor(*args):
  return _ccp4srs.ifloor(*args)
ifloor = _ccp4srs.ifloor

def Abs(*args):
  return _ccp4srs.Abs(*args)
Abs = _ccp4srs.Abs

def ISwap(*args):
  return _ccp4srs.ISwap(*args)
ISwap = _ccp4srs.ISwap

def WSwap(*args):
  return _ccp4srs.WSwap(*args)
WSwap = _ccp4srs.WSwap

def BSwap(*args):
  return _ccp4srs.BSwap(*args)
BSwap = _ccp4srs.BSwap

def OSwap(*args):
  return _ccp4srs.OSwap(*args)
OSwap = _ccp4srs.OSwap

def LSwap(*args):
  return _ccp4srs.LSwap(*args)
LSwap = _ccp4srs.LSwap

def RSwap(*args):
  return _ccp4srs.RSwap(*args)
RSwap = _ccp4srs.RSwap

def RMax(*args):
  return _ccp4srs.RMax(*args)
RMax = _ccp4srs.RMax

def LMax(*args):
  return _ccp4srs.LMax(*args)
LMax = _ccp4srs.LMax

def WMax(*args):
  return _ccp4srs.WMax(*args)
WMax = _ccp4srs.WMax

def IMax(*args):
  return _ccp4srs.IMax(*args)
IMax = _ccp4srs.IMax

def RMin(*args):
  return _ccp4srs.RMin(*args)
RMin = _ccp4srs.RMin

def LMin(*args):
  return _ccp4srs.LMin(*args)
LMin = _ccp4srs.LMin

def WMin(*args):
  return _ccp4srs.WMin(*args)
WMin = _ccp4srs.WMin

def IMin(*args):
  return _ccp4srs.IMin(*args)
IMin = _ccp4srs.IMin

def fsign(*args):
  return _ccp4srs.fsign(*args)
fsign = _ccp4srs.fsign

def GetVectorMemory(*args):
  return _ccp4srs.GetVectorMemory(*args)
GetVectorMemory = _ccp4srs.GetVectorMemory

def FreeVectorMemory(*args):
  return _ccp4srs.FreeVectorMemory(*args)
FreeVectorMemory = _ccp4srs.FreeVectorMemory

def GetMatrixMemory(*args):
  return _ccp4srs.GetMatrixMemory(*args)
GetMatrixMemory = _ccp4srs.GetMatrixMemory

def FreeMatrixMemory(*args):
  return _ccp4srs.FreeMatrixMemory(*args)
FreeMatrixMemory = _ccp4srs.FreeMatrixMemory

def GetMatrix3Memory(*args):
  return _ccp4srs.GetMatrix3Memory(*args)
GetMatrix3Memory = _ccp4srs.GetMatrix3Memory

def FreeMatrix3Memory(*args):
  return _ccp4srs.FreeMatrix3Memory(*args)
FreeMatrix3Memory = _ccp4srs.FreeMatrix3Memory

def MachinEps():
  return _ccp4srs.MachinEps()
MachinEps = _ccp4srs.MachinEps

def floatMachinEps():
  return _ccp4srs.floatMachinEps()
floatMachinEps = _ccp4srs.floatMachinEps

def frac(*args):
  return _ccp4srs.frac(*args)
frac = _ccp4srs.frac

def mod(*args):
  return _ccp4srs.mod(*args)
mod = _ccp4srs.mod

def Pow(*args):
  return _ccp4srs.Pow(*args)
Pow = _ccp4srs.Pow

def Pow1(*args):
  return _ccp4srs.Pow1(*args)
Pow1 = _ccp4srs.Pow1

def Exp(*args):
  return _ccp4srs.Exp(*args)
Exp = _ccp4srs.Exp

def Odd(*args):
  return _ccp4srs.Odd(*args)
Odd = _ccp4srs.Odd

def HexValL(*args):
  return _ccp4srs.HexValL(*args)
HexValL = _ccp4srs.HexValL

def OctValL(*args):
  return _ccp4srs.OctValL(*args)
OctValL = _ccp4srs.OctValL

def BinValL(*args):
  return _ccp4srs.BinValL(*args)
BinValL = _ccp4srs.BinValL

def BinValS(*args):
  return _ccp4srs.BinValS(*args)
BinValS = _ccp4srs.BinValS

def ParamStr(*args):
  return _ccp4srs.ParamStr(*args)
ParamStr = _ccp4srs.ParamStr

def CreateCopy(*args):
  return _ccp4srs.CreateCopy(*args)
CreateCopy = _ccp4srs.CreateCopy

def CreateCopy_n(*args):
  return _ccp4srs.CreateCopy_n(*args)
CreateCopy_n = _ccp4srs.CreateCopy_n

def CreateConcat(*args):
  return _ccp4srs.CreateConcat(*args)
CreateConcat = _ccp4srs.CreateConcat

def CreateCopCat(*args):
  return _ccp4srs.CreateCopCat(*args)
CreateCopCat = _ccp4srs.CreateCopCat

def LastOccurence(*args):
  return _ccp4srs.LastOccurence(*args)
LastOccurence = _ccp4srs.LastOccurence

def FirstOccurence(*args):
  return _ccp4srs.FirstOccurence(*args)
FirstOccurence = _ccp4srs.FirstOccurence

def indexOf(*args):
  return _ccp4srs.indexOf(*args)
indexOf = _ccp4srs.indexOf

def LowerCase(*args):
  return _ccp4srs.LowerCase(*args)
LowerCase = _ccp4srs.LowerCase

def UpperCase(*args):
  return _ccp4srs.UpperCase(*args)
UpperCase = _ccp4srs.UpperCase

def GetString(*args):
  return _ccp4srs.GetString(*args)
GetString = _ccp4srs.GetString

def GetStrTer(*args):
  return _ccp4srs.GetStrTer(*args)
GetStrTer = _ccp4srs.GetStrTer

def GetStrTerWin32File(*args):
  return _ccp4srs.GetStrTerWin32File(*args)
GetStrTerWin32File = _ccp4srs.GetStrTerWin32File

def strcpy_n(*args):
  return _ccp4srs.strcpy_n(*args)
strcpy_n = _ccp4srs.strcpy_n

def strcpy_n1(*args):
  return _ccp4srs.strcpy_n1(*args)
strcpy_n1 = _ccp4srs.strcpy_n1

def strcpy_nr(*args):
  return _ccp4srs.strcpy_nr(*args)
strcpy_nr = _ccp4srs.strcpy_nr

def strcpy_ns(*args):
  return _ccp4srs.strcpy_ns(*args)
strcpy_ns = _ccp4srs.strcpy_ns

def strcpy_cs(*args):
  return _ccp4srs.strcpy_cs(*args)
strcpy_cs = _ccp4srs.strcpy_cs

def strcpy_ncs(*args):
  return _ccp4srs.strcpy_ncs(*args)
strcpy_ncs = _ccp4srs.strcpy_ncs

def strcpy_css(*args):
  return _ccp4srs.strcpy_css(*args)
strcpy_css = _ccp4srs.strcpy_css

def strcpy_ncss(*args):
  return _ccp4srs.strcpy_ncss(*args)
strcpy_ncss = _ccp4srs.strcpy_ncss

def strcpy_n0(*args):
  return _ccp4srs.strcpy_n0(*args)
strcpy_n0 = _ccp4srs.strcpy_n0

def strlen_des(*args):
  return _ccp4srs.strlen_des(*args)
strlen_des = _ccp4srs.strlen_des

def strcpy_des(*args):
  return _ccp4srs.strcpy_des(*args)
strcpy_des = _ccp4srs.strcpy_des

def strcat_des(*args):
  return _ccp4srs.strcat_des(*args)
strcat_des = _ccp4srs.strcat_des

def PadSpaces(*args):
  return _ccp4srs.PadSpaces(*args)
PadSpaces = _ccp4srs.PadSpaces
SCUTKEY_BEGIN = _ccp4srs.SCUTKEY_BEGIN
SCUTKEY_END = _ccp4srs.SCUTKEY_END
SCUTKEY_BEGEND = _ccp4srs.SCUTKEY_BEGEND

def CutSpaces(*args):
  return _ccp4srs.CutSpaces(*args)
CutSpaces = _ccp4srs.CutSpaces

def DelSpaces(*args):
  return _ccp4srs.DelSpaces(*args)
DelSpaces = _ccp4srs.DelSpaces

def EnforceSpaces(*args):
  return _ccp4srs.EnforceSpaces(*args)
EnforceSpaces = _ccp4srs.EnforceSpaces

def set_new_float_unibin():
  return _ccp4srs.set_new_float_unibin()
set_new_float_unibin = _ccp4srs.set_new_float_unibin

def is_new_float_unibin():
  return _ccp4srs.is_new_float_unibin()
is_new_float_unibin = _ccp4srs.is_new_float_unibin

def set_old_float_unibin():
  return _ccp4srs.set_old_float_unibin()
set_old_float_unibin = _ccp4srs.set_old_float_unibin

def __modify4():
  return _ccp4srs.__modify4()
__modify4 = _ccp4srs.__modify4

def int2UniBin(*args):
  return _ccp4srs.int2UniBin(*args)
int2UniBin = _ccp4srs.int2UniBin

def short2UniBin(*args):
  return _ccp4srs.short2UniBin(*args)
short2UniBin = _ccp4srs.short2UniBin

def long2UniBin(*args):
  return _ccp4srs.long2UniBin(*args)
long2UniBin = _ccp4srs.long2UniBin

def word2UniBin(*args):
  return _ccp4srs.word2UniBin(*args)
word2UniBin = _ccp4srs.word2UniBin

def real2UniBin(*args):
  return _ccp4srs.real2UniBin(*args)
real2UniBin = _ccp4srs.real2UniBin

def float2UniBin(*args):
  return _ccp4srs.float2UniBin(*args)
float2UniBin = _ccp4srs.float2UniBin

def shortreal2UniBin(*args):
  return _ccp4srs.shortreal2UniBin(*args)
shortreal2UniBin = _ccp4srs.shortreal2UniBin

def UniBin2int(*args):
  return _ccp4srs.UniBin2int(*args)
UniBin2int = _ccp4srs.UniBin2int

def UniBin2short(*args):
  return _ccp4srs.UniBin2short(*args)
UniBin2short = _ccp4srs.UniBin2short

def UniBin2long(*args):
  return _ccp4srs.UniBin2long(*args)
UniBin2long = _ccp4srs.UniBin2long

def UniBin2word(*args):
  return _ccp4srs.UniBin2word(*args)
UniBin2word = _ccp4srs.UniBin2word

def UniBin2real(*args):
  return _ccp4srs.UniBin2real(*args)
UniBin2real = _ccp4srs.UniBin2real

def UniBin2shortreal(*args):
  return _ccp4srs.UniBin2shortreal(*args)
UniBin2shortreal = _ccp4srs.UniBin2shortreal

def UniBin2float(*args):
  return _ccp4srs.UniBin2float(*args)
UniBin2float = _ccp4srs.UniBin2float

def mem_write(*args):
  return _ccp4srs.mem_write(*args)
mem_write = _ccp4srs.mem_write

def mem_write_byte(*args):
  return _ccp4srs.mem_write_byte(*args)
mem_write_byte = _ccp4srs.mem_write_byte

def mem_read(*args):
  return _ccp4srs.mem_read(*args)
mem_read = _ccp4srs.mem_read

def mem_read_byte(*args):
  return _ccp4srs.mem_read_byte(*args)
mem_read_byte = _ccp4srs.mem_read_byte
class Base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Base, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Base()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Base
    __del__ = lambda self : None;
    def loadIndex(self, *args): return _ccp4srs.Base_loadIndex(self, *args)
    def loadStructure(self, *args): return _ccp4srs.Base_loadStructure(self, *args)
    def getIndex(self, *args): return _ccp4srs.Base_getIndex(self, *args)
    def unloadStructure(self, *args): return _ccp4srs.Base_unloadStructure(self, *args)
    def getPath(self, *args): return _ccp4srs.Base_getPath(self, *args)
    def getStructFile(self): return _ccp4srs.Base_getStructFile(self)
    def getGraphFile(self): return _ccp4srs.Base_getGraphFile(self)
    def n_entries(self): return _ccp4srs.Base_n_entries(self)
    def getEntryNo(self, *args): return _ccp4srs.Base_getEntryNo(self, *args)
    def getMonomer(self, *args): return _ccp4srs.Base_getMonomer(self, *args)
    def getNofAtoms(self, *args): return _ccp4srs.Base_getNofAtoms(self, *args)
    def getAtNames(self, *args): return _ccp4srs.Base_getAtNames(self, *args)
    def getAtoms(self, *args): return _ccp4srs.Base_getAtoms(self, *args)
    def getBonds(self, *args): return _ccp4srs.Base_getBonds(self, *args)
    def getHetInfo(self, *args): return _ccp4srs.Base_getHetInfo(self, *args)
Base_swigregister = _ccp4srs.Base_swigregister
Base_swigregister(Base)
cvar = _ccp4srs.cvar
MinReal = cvar.MinReal
MaxReal = cvar.MaxReal
fMinReal = cvar.fMinReal
fMaxReal = cvar.fMaxReal
MinShortReal = cvar.MinShortReal
MaxShortReal = cvar.MaxShortReal
MaxInt = cvar.MaxInt
MinInt = cvar.MinInt
MaxWord = cvar.MaxWord
MaxInt4 = cvar.MaxInt4
MinInt4 = cvar.MinInt4
MaxWord4 = cvar.MaxWord4
Pi = cvar.Pi
Eu = cvar.Eu
ln10 = cvar.ln10

class Chem(Base):
    __swig_setmethods__ = {}
    for _s in [Base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chem, name, value)
    __swig_getmethods__ = {}
    for _s in [Base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Chem, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Chem()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Chem
    __del__ = lambda self : None;
    def getEnergyTypes(self, *args): return _ccp4srs.Chem_getEnergyTypes(self, *args)
    def addHydrogens(self, *args): return _ccp4srs.Chem_addHydrogens(self, *args)
    def makeBonds(self, *args): return _ccp4srs.Chem_makeBonds(self, *args)
Chem_swigregister = _ccp4srs.Chem_swigregister
Chem_swigregister(Chem)

class Manager(Chem):
    __swig_setmethods__ = {}
    for _s in [Chem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Manager, name, value)
    __swig_getmethods__ = {}
    for _s in [Chem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Manager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Manager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Manager
    __del__ = lambda self : None;
Manager_swigregister = _ccp4srs.Manager_swigregister
Manager_swigregister(Manager)

class Monomer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Monomer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Monomer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Monomer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Monomer
    __del__ = lambda self : None;
    def type(self): return _ccp4srs.Monomer_type(self)
    def reset(self): return _ccp4srs.Monomer_reset(self)
    def ID(self): return _ccp4srs.Monomer_ID(self)
    def oldID(self): return _ccp4srs.Monomer_oldID(self)
    def setOldID(self, *args): return _ccp4srs.Monomer_setOldID(self, *args)
    def chem_name(self): return _ccp4srs.Monomer_chem_name(self)
    def chem_type(self): return _ccp4srs.Monomer_chem_type(self)
    def chem_formula(self): return _ccp4srs.Monomer_chem_formula(self)
    def n_atoms(self): return _ccp4srs.Monomer_n_atoms(self)
    def n_bonds(self): return _ccp4srs.Monomer_n_bonds(self)
    def n_angles(self): return _ccp4srs.Monomer_n_angles(self)
    def n_torsions(self): return _ccp4srs.Monomer_n_torsions(self)
    def n_chicenters(self): return _ccp4srs.Monomer_n_chicenters(self)
    def n_planes(self): return _ccp4srs.Monomer_n_planes(self)
    def atom(self, *args): return _ccp4srs.Monomer_atom(self, *args)
    def bond(self, *args): return _ccp4srs.Monomer_bond(self, *args)
    def angle(self, *args): return _ccp4srs.Monomer_angle(self, *args)
    def plane(self, *args): return _ccp4srs.Monomer_plane(self, *args)
    def tree(self): return _ccp4srs.Monomer_tree(self)
    def torsion(self, *args): return _ccp4srs.Monomer_torsion(self, *args)
    def chicenter(self, *args): return _ccp4srs.Monomer_chicenter(self, *args)
    def add(self, *args): return _ccp4srs.Monomer_add(self, *args)
    def get_atoms(self): return _ccp4srs.Monomer_get_atoms(self)
    def get_bonds(self): return _ccp4srs.Monomer_get_bonds(self)
    def get_angles(self): return _ccp4srs.Monomer_get_angles(self)
    def get_torsions(self): return _ccp4srs.Monomer_get_torsions(self)
    def get_chicenters(self): return _ccp4srs.Monomer_get_chicenters(self)
    def get_planes(self): return _ccp4srs.Monomer_get_planes(self)
    def get_tree(self): return _ccp4srs.Monomer_get_tree(self)
    def getACDLabs(self): return _ccp4srs.Monomer_getACDLabs(self)
    def getCACTVS(self): return _ccp4srs.Monomer_getCACTVS(self)
    def getOpenEye(self): return _ccp4srs.Monomer_getOpenEye(self)
    def getInChI(self): return _ccp4srs.Monomer_getInChI(self)
    def atom_no(self, *args): return _ccp4srs.Monomer_atom_no(self, *args)
    def get_bound(self, *args): return _ccp4srs.Monomer_get_bound(self, *args)
    def addHydrogens(self, *args): return _ccp4srs.Monomer_addHydrogens(self, *args)
    def getAtomNameMatch(self, *args): return _ccp4srs.Monomer_getAtomNameMatch(self, *args)
    def getGraph(self, *args): return _ccp4srs.Monomer_getGraph(self, *args)
    def getLeavingAtoms(self, *args): return _ccp4srs.Monomer_getLeavingAtoms(self, *args)
    def readFromCIF(self, *args): return _ccp4srs.Monomer_readFromCIF(self, *args)
    def makeCIF(self): return _ccp4srs.Monomer_makeCIF(self)
    def merge(self, *args): return _ccp4srs.Monomer_merge(self, *args)
Monomer_swigregister = _ccp4srs.Monomer_swigregister
Monomer_swigregister(Monomer)

class Bond(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bond, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Bond, name)
    __repr__ = _swig_repr
    noOrder = _ccp4srs.Bond_noOrder
    Single = _ccp4srs.Bond_Single
    Aromatic = _ccp4srs.Bond_Aromatic
    Double = _ccp4srs.Bond_Double
    Triple = _ccp4srs.Bond_Triple
    Deloc = _ccp4srs.Bond_Deloc
    Covalent = _ccp4srs.Bond_Covalent
    Metal = _ccp4srs.Bond_Metal
    def __init__(self): 
        this = _ccp4srs.new_Bond()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Bond
    __del__ = lambda self : None;
    def atom1(self): return _ccp4srs.Bond_atom1(self)
    def atom2(self): return _ccp4srs.Bond_atom2(self)
    def order(self): return _ccp4srs.Bond_order(self)
    def length(self): return _ccp4srs.Bond_length(self)
    def length_esd(self): return _ccp4srs.Bond_length_esd(self)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Bond_makeCIFTags
    if _newclass:makeCIFTags = staticmethod(_ccp4srs.Bond_makeCIFTags)
    def readFromCIF_ccp4(self, *args): return _ccp4srs.Bond_readFromCIF_ccp4(self, *args)
    def readFromCIF_rcsb(self, *args): return _ccp4srs.Bond_readFromCIF_rcsb(self, *args)
    def readFromCIF(self, *args): return _ccp4srs.Bond_readFromCIF(self, *args)
    def writeToCIF(self, *args): return _ccp4srs.Bond_writeToCIF(self, *args)
    def compare(self, *args): return _ccp4srs.Bond_compare(self, *args)
    def write_mem(self, *args): return _ccp4srs.Bond_write_mem(self, *args)
    def read_mem(self, *args): return _ccp4srs.Bond_read_mem(self, *args)
    def copy(self, *args): return _ccp4srs.Bond_copy(self, *args)
Bond_swigregister = _ccp4srs.Bond_swigregister
Bond_swigregister(Bond)

def Bond_makeCIFTags(*args):
  return _ccp4srs.Bond_makeCIFTags(*args)
Bond_makeCIFTags = _ccp4srs.Bond_makeCIFTags

class Angle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Angle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Angle, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Angle()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Angle
    __del__ = lambda self : None;
    def atom1(self): return _ccp4srs.Angle_atom1(self)
    def atom2(self): return _ccp4srs.Angle_atom2(self)
    def atom3(self): return _ccp4srs.Angle_atom3(self)
    def value(self): return _ccp4srs.Angle_value(self)
    def esd(self): return _ccp4srs.Angle_esd(self)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Angle_makeCIFTags
    if _newclass:makeCIFTags = staticmethod(_ccp4srs.Angle_makeCIFTags)
    def readFromCIF(self, *args): return _ccp4srs.Angle_readFromCIF(self, *args)
    def writeToCIF(self, *args): return _ccp4srs.Angle_writeToCIF(self, *args)
    def write_mem(self, *args): return _ccp4srs.Angle_write_mem(self, *args)
    def read_mem(self, *args): return _ccp4srs.Angle_read_mem(self, *args)
    def copy(self, *args): return _ccp4srs.Angle_copy(self, *args)
Angle_swigregister = _ccp4srs.Angle_swigregister
Angle_swigregister(Angle)

def Angle_makeCIFTags(*args):
  return _ccp4srs.Angle_makeCIFTags(*args)
Angle_makeCIFTags = _ccp4srs.Angle_makeCIFTags

class Plane(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plane, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Plane, name)
    __repr__ = _swig_repr
    Ok = _ccp4srs.Plane_Ok
    EmptyLoop = _ccp4srs.Plane_EmptyLoop
    NoMorePlanes = _ccp4srs.Plane_NoMorePlanes
    def __init__(self): 
        this = _ccp4srs.new_Plane()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Plane
    __del__ = lambda self : None;
    def id(self): return _ccp4srs.Plane_id(self)
    def size(self): return _ccp4srs.Plane_size(self)
    def atoms(self): return _ccp4srs.Plane_atoms(self)
    def esds(self): return _ccp4srs.Plane_esds(self)
    def atom(self, *args): return _ccp4srs.Plane_atom(self, *args)
    def esd(self, *args): return _ccp4srs.Plane_esd(self, *args)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Plane_makeCIFTags
    if _newclass:makeCIFTags = staticmethod(_ccp4srs.Plane_makeCIFTags)
    def readFromCIF(self, *args): return _ccp4srs.Plane_readFromCIF(self, *args)
    def writeToCIF(self, *args): return _ccp4srs.Plane_writeToCIF(self, *args)
    def write_mem(self, *args): return _ccp4srs.Plane_write_mem(self, *args)
    def read_mem(self, *args): return _ccp4srs.Plane_read_mem(self, *args)
    def copy(self, *args): return _ccp4srs.Plane_copy(self, *args)
Plane_swigregister = _ccp4srs.Plane_swigregister
Plane_swigregister(Plane)

def Plane_makeCIFTags(*args):
  return _ccp4srs.Plane_makeCIFTags(*args)
Plane_makeCIFTags = _ccp4srs.Plane_makeCIFTags

class Atom(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Atom, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Atom, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Atom()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Atom
    __del__ = lambda self : None;
    def id(self): return _ccp4srs.Atom_id(self)
    def name(self): return _ccp4srs.Atom_name(self)
    def rcsb_name(self): return _ccp4srs.Atom_rcsb_name(self)
    def old_name(self): return _ccp4srs.Atom_old_name(self)
    def element(self): return _ccp4srs.Atom_element(self)
    def energy_type(self): return _ccp4srs.Atom_energy_type(self)
    def x(self): return _ccp4srs.Atom_x(self)
    def y(self): return _ccp4srs.Atom_y(self)
    def z(self): return _ccp4srs.Atom_z(self)
    def x_pdbx(self): return _ccp4srs.Atom_x_pdbx(self)
    def y_pdbx(self): return _ccp4srs.Atom_y_pdbx(self)
    def z_pdbx(self): return _ccp4srs.Atom_z_pdbx(self)
    def x_mlib(self): return _ccp4srs.Atom_x_mlib(self)
    def y_mlib(self): return _ccp4srs.Atom_y_mlib(self)
    def z_mlib(self): return _ccp4srs.Atom_z_mlib(self)
    def charge(self): return _ccp4srs.Atom_charge(self)
    def weight(self): return _ccp4srs.Atom_weight(self)
    def vdw_radius(self): return _ccp4srs.Atom_vdw_radius(self)
    def vdwh_radius(self): return _ccp4srs.Atom_vdwh_radius(self)
    def ion_radius(self): return _ccp4srs.Atom_ion_radius(self)
    def valency(self): return _ccp4srs.Atom_valency(self)
    def sp(self): return _ccp4srs.Atom_sp(self)
    def rcsb_chirality(self): return _ccp4srs.Atom_rcsb_chirality(self)
    def ccp4_chirality(self): return _ccp4srs.Atom_ccp4_chirality(self)
    def chirality(self): return _ccp4srs.Atom_chirality(self)
    def leaving(self): return _ccp4srs.Atom_leaving(self)
    def isLeaving(self): return _ccp4srs.Atom_isLeaving(self)
    def hb_type(self): return _ccp4srs.Atom_hb_type(self)
    def name_pdb(self, *args): return _ccp4srs.Atom_name_pdb(self, *args)
    def rcsb_name_pdb(self, *args): return _ccp4srs.Atom_rcsb_name_pdb(self, *args)
    def old_name_pdb(self, *args): return _ccp4srs.Atom_old_name_pdb(self, *args)
    def element_pdb(self, *args): return _ccp4srs.Atom_element_pdb(self, *args)
    def set_energy_type(self, *args): return _ccp4srs.Atom_set_energy_type(self, *args)
    def set_old_name(self, *args): return _ccp4srs.Atom_set_old_name(self, *args)
    def set_rcsb_chirality(self, *args): return _ccp4srs.Atom_set_rcsb_chirality(self, *args)
    def set_chirality(self, *args): return _ccp4srs.Atom_set_chirality(self, *args)
    def set_hb_type(self, *args): return _ccp4srs.Atom_set_hb_type(self, *args)
    def set_vdw_radius(self, *args): return _ccp4srs.Atom_set_vdw_radius(self, *args)
    def set_vdwh_radius(self, *args): return _ccp4srs.Atom_set_vdwh_radius(self, *args)
    def set_ion_radius(self, *args): return _ccp4srs.Atom_set_ion_radius(self, *args)
    def set_valency(self, *args): return _ccp4srs.Atom_set_valency(self, *args)
    def set_sp(self, *args): return _ccp4srs.Atom_set_sp(self, *args)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Atom_makeCIFTags
    if _newclass:makeCIFTags = staticmethod(_ccp4srs.Atom_makeCIFTags)
    def readFromCIF_ccp4(self, *args): return _ccp4srs.Atom_readFromCIF_ccp4(self, *args)
    def readFromCIF_rcsb(self, *args): return _ccp4srs.Atom_readFromCIF_rcsb(self, *args)
    def readFromCIF(self, *args): return _ccp4srs.Atom_readFromCIF(self, *args)
    def writeToCIF(self, *args): return _ccp4srs.Atom_writeToCIF(self, *args)
    def copy(self, *args): return _ccp4srs.Atom_copy(self, *args)
    def merge(self, *args): return _ccp4srs.Atom_merge(self, *args)
    def write_mem(self, *args): return _ccp4srs.Atom_write_mem(self, *args)
    def read_mem(self, *args): return _ccp4srs.Atom_read_mem(self, *args)
Atom_swigregister = _ccp4srs.Atom_swigregister
Atom_swigregister(Atom)

def Atom_makeCIFTags(*args):
  return _ccp4srs.Atom_makeCIFTags(*args)
Atom_makeCIFTags = _ccp4srs.Atom_makeCIFTags


def get_atom_from_cif(*args):
  return _ccp4srs.get_atom_from_cif(*args)
get_atom_from_cif = _ccp4srs.get_atom_from_cif

def add_atom_to_cif(*args):
  return _ccp4srs.add_atom_to_cif(*args)
add_atom_to_cif = _ccp4srs.add_atom_to_cif
class Torsion(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Torsion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Torsion, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Torsion()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Torsion
    __del__ = lambda self : None;
    def id(self): return _ccp4srs.Torsion_id(self)
    def atom1(self): return _ccp4srs.Torsion_atom1(self)
    def atom2(self): return _ccp4srs.Torsion_atom2(self)
    def atom3(self): return _ccp4srs.Torsion_atom3(self)
    def atom4(self): return _ccp4srs.Torsion_atom4(self)
    def period(self): return _ccp4srs.Torsion_period(self)
    def value(self): return _ccp4srs.Torsion_value(self)
    def esd(self): return _ccp4srs.Torsion_esd(self)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Torsion_makeCIFTags
    if _newclass:makeCIFTags = staticmethod(_ccp4srs.Torsion_makeCIFTags)
    def readFromCIF(self, *args): return _ccp4srs.Torsion_readFromCIF(self, *args)
    def writeToCIF(self, *args): return _ccp4srs.Torsion_writeToCIF(self, *args)
    def write_mem(self, *args): return _ccp4srs.Torsion_write_mem(self, *args)
    def read_mem(self, *args): return _ccp4srs.Torsion_read_mem(self, *args)
    def copy(self, *args): return _ccp4srs.Torsion_copy(self, *args)
Torsion_swigregister = _ccp4srs.Torsion_swigregister
Torsion_swigregister(Torsion)

def Torsion_makeCIFTags(*args):
  return _ccp4srs.Torsion_makeCIFTags(*args)
Torsion_makeCIFTags = _ccp4srs.Torsion_makeCIFTags

class Tree(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tree, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Tree, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _ccp4srs.new_Tree()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ccp4srs.delete_Tree
    __del__ = lambda self : None;
    def empty(self): return _ccp4srs.Tree_empty(self)
    def size(self): return _ccp4srs.Tree_size(self)
    def atom(self, *args): return _ccp4srs.Tree_atom(self, *args)
    def backward(self, *args): return _ccp4srs.Tree_backward(self, *args)
    def forward(self, *args): return _ccp4srs.Tree_forward(self, *args)
    def connect(self, *args): return _ccp4srs.Tree_connect(self, *args)
    def readFromCIF(self, *args): return _ccp4srs.Tree_readFromCIF(self, *args)
    def writeToCIF(self, *args): return _ccp4srs.Tree_writeToCIF(self, *args)
    def write_mem(self, *args): return _ccp4srs.Tree_write_mem(self, *args)
    def read_mem(self, *args): return _ccp4srs.Tree_read_mem(self, *args)
    def copy(self, *args): return _ccp4srs.Tree_copy(self, *args)
Tree_swigregister = _ccp4srs.Tree_swigregister
Tree_swigregister(Tree)

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


