p4vasp 0.3.30+dfsg-3 / usr / lib / python2.7 / dist-packages / cp4vasp.py

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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_cp4vasp')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_cp4vasp')
    _cp4vasp = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_cp4vasp', [dirname(__file__)])
        except ImportError:
            import _cp4vasp
            return _cp4vasp
        try:
            _mod = imp.load_module('_cp4vasp', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _cp4vasp = swig_import_helper()
    del swig_import_helper
else:
    import _cp4vasp
del _swig_python_version_info

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

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

    def __init__(self):
        this = _cp4vasp.new_ClassInterface()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.ClassInterface_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_ClassInterface
    __del__ = lambda self: None
ClassInterface_swigregister = _cp4vasp.ClassInterface_swigregister
ClassInterface_swigregister(ClassInterface)


def getAtomtypesRecordHash(s):
    return _cp4vasp.getAtomtypesRecordHash(s)
getAtomtypesRecordHash = _cp4vasp.getAtomtypesRecordHash
class AtomtypesRecord(ClassInterface):
    __swig_setmethods__ = {}
    for _s in [ClassInterface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomtypesRecord, name, value)
    __swig_getmethods__ = {}
    for _s in [ClassInterface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AtomtypesRecord, name)
    __repr__ = _swig_repr

    def getClassName(self):
        return _cp4vasp.AtomtypesRecord_getClassName(self)

    def __init__(self):
        this = _cp4vasp.new_AtomtypesRecord()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_AtomtypesRecord
    __del__ = lambda self: None
    __swig_setmethods__["hash"] = _cp4vasp.AtomtypesRecord_hash_set
    __swig_getmethods__["hash"] = _cp4vasp.AtomtypesRecord_hash_get
    __swig_setmethods__["atomspertype"] = _cp4vasp.AtomtypesRecord_atomspertype_set
    __swig_getmethods__["atomspertype"] = _cp4vasp.AtomtypesRecord_atomspertype_get
    __swig_setmethods__["mass"] = _cp4vasp.AtomtypesRecord_mass_set
    __swig_getmethods__["mass"] = _cp4vasp.AtomtypesRecord_mass_get
    __swig_setmethods__["valence"] = _cp4vasp.AtomtypesRecord_valence_set
    __swig_getmethods__["valence"] = _cp4vasp.AtomtypesRecord_valence_get
    __swig_setmethods__["radius"] = _cp4vasp.AtomtypesRecord_radius_set
    __swig_getmethods__["radius"] = _cp4vasp.AtomtypesRecord_radius_get
    __swig_setmethods__["covalent"] = _cp4vasp.AtomtypesRecord_covalent_set
    __swig_getmethods__["covalent"] = _cp4vasp.AtomtypesRecord_covalent_get
    __swig_setmethods__["n"] = _cp4vasp.AtomtypesRecord_n_set
    __swig_getmethods__["n"] = _cp4vasp.AtomtypesRecord_n_get
    __swig_setmethods__["red"] = _cp4vasp.AtomtypesRecord_red_set
    __swig_getmethods__["red"] = _cp4vasp.AtomtypesRecord_red_get
    __swig_setmethods__["green"] = _cp4vasp.AtomtypesRecord_green_set
    __swig_getmethods__["green"] = _cp4vasp.AtomtypesRecord_green_get
    __swig_setmethods__["blue"] = _cp4vasp.AtomtypesRecord_blue_set
    __swig_getmethods__["blue"] = _cp4vasp.AtomtypesRecord_blue_get
    __swig_setmethods__["hidden"] = _cp4vasp.AtomtypesRecord_hidden_set
    __swig_getmethods__["hidden"] = _cp4vasp.AtomtypesRecord_hidden_get
    __swig_setmethods__["selected"] = _cp4vasp.AtomtypesRecord_selected_set
    __swig_getmethods__["selected"] = _cp4vasp.AtomtypesRecord_selected_get

    def getElement(self):
        return _cp4vasp.AtomtypesRecord_getElement(self)

    def setElement(self, s):
        return _cp4vasp.AtomtypesRecord_setElement(self, s)

    def getPPType(self):
        return _cp4vasp.AtomtypesRecord_getPPType(self)

    def getPPSpecie(self):
        return _cp4vasp.AtomtypesRecord_getPPSpecie(self)

    def getPPVersion(self):
        return _cp4vasp.AtomtypesRecord_getPPVersion(self)

    def getPseudopotential(self):
        return _cp4vasp.AtomtypesRecord_getPseudopotential(self)

    def setPPType(self, s):
        return _cp4vasp.AtomtypesRecord_setPPType(self, s)

    def setPPSpecie(self, s):
        return _cp4vasp.AtomtypesRecord_setPPSpecie(self, s)

    def setPPVersion(self, s):
        return _cp4vasp.AtomtypesRecord_setPPVersion(self, s)

    def setPseudopotential(self, s):
        return _cp4vasp.AtomtypesRecord_setPseudopotential(self, s)

    def clean(self):
        return _cp4vasp.AtomtypesRecord_clean(self)

    def setAtomtypesRecord(self, a):
        return _cp4vasp.AtomtypesRecord_setAtomtypesRecord(self, a)

    def clone(self):
        return _cp4vasp.AtomtypesRecord_clone(self)
AtomtypesRecord_swigregister = _cp4vasp.AtomtypesRecord_swigregister
AtomtypesRecord_swigregister(AtomtypesRecord)

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

    def getClassName(self):
        return _cp4vasp.AtomInfo_getClassName(self)
    __swig_getmethods__["types"] = _cp4vasp.AtomInfo_types_get
    __swig_getmethods__["allocation_step"] = _cp4vasp.AtomInfo_allocation_step_get

    def __init__(self, alloc=16):
        this = _cp4vasp.new_AtomInfo(alloc)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_AtomInfo
    __del__ = lambda self: None

    def append(self, r):
        return _cp4vasp.AtomInfo_append(self, r)

    def realloc(self, alloc):
        return _cp4vasp.AtomInfo_realloc(self, alloc)

    def allocate(self, n):
        return _cp4vasp.AtomInfo_allocate(self, n)

    def getRecord(self, i):
        return _cp4vasp.AtomInfo_getRecord(self, i)

    def setRecord(self, i, value):
        return _cp4vasp.AtomInfo_setRecord(self, i, value)

    def getRecordForAtom(self, i):
        return _cp4vasp.AtomInfo_getRecordForAtom(self, i)

    def getRecordForElement(self, x):
        return _cp4vasp.AtomInfo_getRecordForElement(self, x)

    def getRecordForElementSafe(self, x, i, m):
        return _cp4vasp.AtomInfo_getRecordForElementSafe(self, x, i, m)

    def speciesIndex(self, j):
        return _cp4vasp.AtomInfo_speciesIndex(self, j)

    def getNatoms(self):
        return _cp4vasp.AtomInfo_getNatoms(self)

    def setAtomInfo(self, a):
        return _cp4vasp.AtomInfo_setAtomInfo(self, a)

    def clean(self):
        return _cp4vasp.AtomInfo_clean(self)

    def clone(self):
        return _cp4vasp.AtomInfo_clone(self)

    def delitem(self, i):
        return _cp4vasp.AtomInfo_delitem(self, i)

    def len(self):
        return _cp4vasp.AtomInfo_len(self)

    def fillAttributesWithTable(self, table):
        return _cp4vasp.AtomInfo_fillAttributesWithTable(self, table)
AtomInfo_swigregister = _cp4vasp.AtomInfo_swigregister
AtomInfo_swigregister(AtomInfo)


def setvec3d(dest, x, y, z):
    return _cp4vasp.setvec3d(dest, x, y, z)
setvec3d = _cp4vasp.setvec3d

def deletevec3d(dest):
    return _cp4vasp.deletevec3d(dest)
deletevec3d = _cp4vasp.deletevec3d

def createmat3d(a11, a12, a13, a21, a22, a23, a31, a32, a33):
    return _cp4vasp.createmat3d(a11, a12, a13, a21, a22, a23, a31, a32, a33)
createmat3d = _cp4vasp.createmat3d

def setmat3d(dest, a11, a12, a13, a21, a22, a23, a31, a32, a33):
    return _cp4vasp.setmat3d(dest, a11, a12, a13, a21, a22, a23, a31, a32, a33)
setmat3d = _cp4vasp.setmat3d

def deletemat3d(dest):
    return _cp4vasp.deletemat3d(dest)
deletemat3d = _cp4vasp.deletemat3d

def getVecElement3d(dest, i):
    return _cp4vasp.getVecElement3d(dest, i)
getVecElement3d = _cp4vasp.getVecElement3d

def setVecElement3d(dest, i, value):
    return _cp4vasp.setVecElement3d(dest, i, value)
setVecElement3d = _cp4vasp.setVecElement3d

def getMatVecElement3d(dest, i):
    return _cp4vasp.getMatVecElement3d(dest, i)
getMatVecElement3d = _cp4vasp.getMatVecElement3d

def setMatVecElement3d(dest, i, value):
    return _cp4vasp.setMatVecElement3d(dest, i, value)
setMatVecElement3d = _cp4vasp.setMatVecElement3d

def getMatElement3d(dest, i, j):
    return _cp4vasp.getMatElement3d(dest, i, j)
getMatElement3d = _cp4vasp.getMatElement3d

def setMatElement3d(dest, i, j, value):
    return _cp4vasp.setMatElement3d(dest, i, j, value)
setMatElement3d = _cp4vasp.setMatElement3d

def add3d(dest, a):
    return _cp4vasp.add3d(dest, a)
add3d = _cp4vasp.add3d

def plus3d(dest, a, b):
    return _cp4vasp.plus3d(dest, a, b)
plus3d = _cp4vasp.plus3d

def createplus3d(a, b):
    return _cp4vasp.createplus3d(a, b)
createplus3d = _cp4vasp.createplus3d

def createplusmat3d(a, b):
    return _cp4vasp.createplusmat3d(a, b)
createplusmat3d = _cp4vasp.createplusmat3d

def sub3d(dest, a):
    return _cp4vasp.sub3d(dest, a)
sub3d = _cp4vasp.sub3d

def minus3d(dest, a, b):
    return _cp4vasp.minus3d(dest, a, b)
minus3d = _cp4vasp.minus3d

def createminus3d(a, b):
    return _cp4vasp.createminus3d(a, b)
createminus3d = _cp4vasp.createminus3d

def createminusmat3d(a, b):
    return _cp4vasp.createminusmat3d(a, b)
createminusmat3d = _cp4vasp.createminusmat3d

def neg3d(v):
    return _cp4vasp.neg3d(v)
neg3d = _cp4vasp.neg3d

def createneg3d(v):
    return _cp4vasp.createneg3d(v)
createneg3d = _cp4vasp.createneg3d

def createnegmat3d(v):
    return _cp4vasp.createnegmat3d(v)
createnegmat3d = _cp4vasp.createnegmat3d

def scalmul3d(dest, a):
    return _cp4vasp.scalmul3d(dest, a)
scalmul3d = _cp4vasp.scalmul3d

def createscalmultiply3d(v, a):
    return _cp4vasp.createscalmultiply3d(v, a)
createscalmultiply3d = _cp4vasp.createscalmultiply3d

def scaldiv3d(dest, a):
    return _cp4vasp.scaldiv3d(dest, a)
scaldiv3d = _cp4vasp.scaldiv3d

def createscaldivide3d(dest, a):
    return _cp4vasp.createscaldivide3d(dest, a)
createscaldivide3d = _cp4vasp.createscaldivide3d

def copy3d(dest, a):
    return _cp4vasp.copy3d(dest, a)
copy3d = _cp4vasp.copy3d

def clone3d(a):
    return _cp4vasp.clone3d(a)
clone3d = _cp4vasp.clone3d

def copymat3d(dest, a):
    return _cp4vasp.copymat3d(dest, a)
copymat3d = _cp4vasp.copymat3d

def clonemat3d(a):
    return _cp4vasp.clonemat3d(a)
clonemat3d = _cp4vasp.clonemat3d

def veclength3d(dest):
    return _cp4vasp.veclength3d(dest)
veclength3d = _cp4vasp.veclength3d

def normalize3d(dest):
    return _cp4vasp.normalize3d(dest)
normalize3d = _cp4vasp.normalize3d

def scalprod3d(a, b):
    return _cp4vasp.scalprod3d(a, b)
scalprod3d = _cp4vasp.scalprod3d

def crossprod3d(dest, a, b):
    return _cp4vasp.crossprod3d(dest, a, b)
crossprod3d = _cp4vasp.crossprod3d

def createcrossprod3d(a, b):
    return _cp4vasp.createcrossprod3d(a, b)
createcrossprod3d = _cp4vasp.createcrossprod3d

def createmultiplymatscal3d(a, v):
    return _cp4vasp.createmultiplymatscal3d(a, v)
createmultiplymatscal3d = _cp4vasp.createmultiplymatscal3d

def createmultiplymatvec3d(a, v):
    return _cp4vasp.createmultiplymatvec3d(a, v)
createmultiplymatvec3d = _cp4vasp.createmultiplymatvec3d

def multiplymatvec3d(dest, a, v):
    return _cp4vasp.multiplymatvec3d(dest, a, v)
multiplymatvec3d = _cp4vasp.multiplymatvec3d

def mulmatvec3d(a, v):
    return _cp4vasp.mulmatvec3d(a, v)
mulmatvec3d = _cp4vasp.mulmatvec3d

def multiplymatmat3d(dest, a, b):
    return _cp4vasp.multiplymatmat3d(dest, a, b)
multiplymatmat3d = _cp4vasp.multiplymatmat3d

def createmultiplymatmat3d(a, b):
    return _cp4vasp.createmultiplymatmat3d(a, b)
createmultiplymatmat3d = _cp4vasp.createmultiplymatmat3d

def mulmatmat3d(a, b):
    return _cp4vasp.mulmatmat3d(a, b)
mulmatmat3d = _cp4vasp.mulmatmat3d

def createrotmat3d(x, y, z):
    return _cp4vasp.createrotmat3d(x, y, z)
createrotmat3d = _cp4vasp.createrotmat3d

def createrotmat3da(x, y, z, a):
    return _cp4vasp.createrotmat3da(x, y, z, a)
createrotmat3da = _cp4vasp.createrotmat3da

def identitymat3d(dest):
    return _cp4vasp.identitymat3d(dest)
identitymat3d = _cp4vasp.identitymat3d

def createidentitymat3d():
    return _cp4vasp.createidentitymat3d()
createidentitymat3d = _cp4vasp.createidentitymat3d

def zeromat3d(dest):
    return _cp4vasp.zeromat3d(dest)
zeromat3d = _cp4vasp.zeromat3d

def createzeromat3d():
    return _cp4vasp.createzeromat3d()
createzeromat3d = _cp4vasp.createzeromat3d

def detmat3d(dest):
    return _cp4vasp.detmat3d(dest)
detmat3d = _cp4vasp.detmat3d

def transmat3d(dest):
    return _cp4vasp.transmat3d(dest)
transmat3d = _cp4vasp.transmat3d
class FArray1D(ClassInterface):
    __swig_setmethods__ = {}
    for _s in [ClassInterface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FArray1D, name, value)
    __swig_getmethods__ = {}
    for _s in [ClassInterface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FArray1D, name)
    __repr__ = _swig_repr

    def __init__(self, size=0):
        this = _cp4vasp.new_FArray1D(size)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clear(self):
        return _cp4vasp.FArray1D_clear(self)

    def size(self):
        return _cp4vasp.FArray1D_size(self)

    def get(self, i):
        return _cp4vasp.FArray1D_get(self, i)

    def set(self, i, x):
        return _cp4vasp.FArray1D_set(self, i, x)

    def printrepr(self):
        return _cp4vasp.FArray1D_printrepr(self)

    def parseString(self, s):
        return _cp4vasp.FArray1D_parseString(self, s)

    def cloneBuff(self):
        return _cp4vasp.FArray1D_cloneBuff(self)

    def clone(self):
        return _cp4vasp.FArray1D_clone(self)

    def getMinimum(self):
        return _cp4vasp.FArray1D_getMinimum(self)

    def getMaximum(self):
        return _cp4vasp.FArray1D_getMaximum(self)

    def getAverage(self):
        return _cp4vasp.FArray1D_getAverage(self)

    def getVariance(self):
        return _cp4vasp.FArray1D_getVariance(self)

    def getSigma(self):
        return _cp4vasp.FArray1D_getSigma(self)

    def getClassName(self):
        return _cp4vasp.FArray1D_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_FArray1D
    __del__ = lambda self: None
FArray1D_swigregister = _cp4vasp.FArray1D_swigregister
FArray1D_swigregister(FArray1D)

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

    def __init__(self, sizex=0, sizey=0):
        this = _cp4vasp.new_FArray2D(sizex, sizey)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getMinimum(self):
        return _cp4vasp.FArray2D_getMinimum(self)

    def getMaximum(self):
        return _cp4vasp.FArray2D_getMaximum(self)

    def getAverage(self):
        return _cp4vasp.FArray2D_getAverage(self)

    def getVariance(self):
        return _cp4vasp.FArray2D_getVariance(self)

    def getSigma(self):
        return _cp4vasp.FArray2D_getSigma(self)

    def sizeX(self):
        return _cp4vasp.FArray2D_sizeX(self)

    def sizeY(self):
        return _cp4vasp.FArray2D_sizeY(self)

    def clear(self):
        return _cp4vasp.FArray2D_clear(self)

    def get(self, i, j):
        return _cp4vasp.FArray2D_get(self, i, j)

    def set(self, i, j, x):
        return _cp4vasp.FArray2D_set(self, i, j, x)

    def printrepr(self):
        return _cp4vasp.FArray2D_printrepr(self)

    def parseString(self, i, s):
        return _cp4vasp.FArray2D_parseString(self, i, s)

    def getArray(self, i):
        return _cp4vasp.FArray2D_getArray(self, i)

    def cloneBuff(self):
        return _cp4vasp.FArray2D_cloneBuff(self)

    def clone(self):
        return _cp4vasp.FArray2D_clone(self)

    def cubicInterpolation(self, n, m):
        return _cp4vasp.FArray2D_cubicInterpolation(self, n, m)

    def smear(self, sigma, n, m, u, v):
        return _cp4vasp.FArray2D_smear(self, sigma, n, m, u, v)

    def cloneVector(self, i):
        return _cp4vasp.FArray2D_cloneVector(self, i)

    def getClassName(self):
        return _cp4vasp.FArray2D_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_FArray2D
    __del__ = lambda self: None
FArray2D_swigregister = _cp4vasp.FArray2D_swigregister
FArray2D_swigregister(FArray2D)


def createvec3d(*args):
    return _cp4vasp.createvec3d(*args)
createvec3d = _cp4vasp.createvec3d

def createFArray1Dsimple(node):
    return _cp4vasp.createFArray1Dsimple(node)
createFArray1Dsimple = _cp4vasp.createFArray1Dsimple

def createFArray2Dsimple(elem, tag, minx=0, miny=0):
    return _cp4vasp.createFArray2Dsimple(elem, tag, minx, miny)
createFArray2Dsimple = _cp4vasp.createFArray2Dsimple

def createFArray2DsimpleN(node, tag, minx=0, miny=0):
    return _cp4vasp.createFArray2DsimpleN(node, tag, minx, miny)
createFArray2DsimpleN = _cp4vasp.createFArray2DsimpleN

def createStructure(elem):
    return _cp4vasp.createStructure(elem)
createStructure = _cp4vasp.createStructure

def createStructureN(node):
    return _cp4vasp.createStructureN(node)
createStructureN = _cp4vasp.createStructureN
class Structure(ClassInterface):
    __swig_setmethods__ = {}
    for _s in [ClassInterface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Structure, name, value)
    __swig_getmethods__ = {}
    for _s in [ClassInterface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Structure, name)
    __repr__ = _swig_repr

    def getClassName(self):
        return _cp4vasp.Structure_getClassName(self)
    __swig_setmethods__["scaling_flag"] = _cp4vasp.Structure_scaling_flag_set
    __swig_getmethods__["scaling_flag"] = _cp4vasp.Structure_scaling_flag_get
    __swig_setmethods__["allocation_step"] = _cp4vasp.Structure_allocation_step_set
    __swig_getmethods__["allocation_step"] = _cp4vasp.Structure_allocation_step_get
    __swig_getmethods__["scaling"] = _cp4vasp.Structure_scaling_get
    __swig_getmethods__["basis"] = _cp4vasp.Structure_basis_get
    __swig_getmethods__["rbasis"] = _cp4vasp.Structure_rbasis_get
    __swig_getmethods__["total_number_of_atoms"] = _cp4vasp.Structure_total_number_of_atoms_get
    __swig_getmethods__["allocated"] = _cp4vasp.Structure_allocated_get
    __swig_getmethods__["info"] = _cp4vasp.Structure_info_get
    __swig_setmethods__["comment"] = _cp4vasp.Structure_comment_set
    __swig_getmethods__["comment"] = _cp4vasp.Structure_comment_get
    __swig_setmethods__["coordinates"] = _cp4vasp.Structure_coordinates_set
    __swig_getmethods__["coordinates"] = _cp4vasp.Structure_coordinates_get

    def __init__(self, *args):
        this = _cp4vasp.new_Structure(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_Structure
    __del__ = lambda self: None

    def correctScaling(self):
        return _cp4vasp.Structure_correctScaling(self)

    def parse(self, s):
        return _cp4vasp.Structure_parse(self, s)

    def read(self, path):
        return _cp4vasp.Structure_read(self, path)

    def write(self, path):
        return _cp4vasp.Structure_write(self, path)

    def toString(self):
        return _cp4vasp.Structure_toString(self)

    def isSelective(self):
        return _cp4vasp.Structure_isSelective(self)

    def isCarthesian(self):
        return _cp4vasp.Structure_isCarthesian(self)

    def isDirect(self):
        return _cp4vasp.Structure_isDirect(self)

    def getSelectiveDOF(self, i):
        return _cp4vasp.Structure_getSelectiveDOF(self, i)

    def setSelectiveDOF(self, i, value):
        return _cp4vasp.Structure_setSelectiveDOF(self, i, value)

    def setSelective(self, flag):
        return _cp4vasp.Structure_setSelective(self, flag)

    def updateRecipBasis(self):
        return _cp4vasp.Structure_updateRecipBasis(self)

    def getRecipBasis(self):
        return _cp4vasp.Structure_getRecipBasis(self)

    def forceConvertToCarthesian(self):
        return _cp4vasp.Structure_forceConvertToCarthesian(self)

    def forceConvertToDirect(self):
        return _cp4vasp.Structure_forceConvertToDirect(self)

    def setCarthesian(self, flag=1):
        return _cp4vasp.Structure_setCarthesian(self, flag)

    def setDirect(self, flag=1):
        return _cp4vasp.Structure_setDirect(self, flag)

    def dir2cart(self, dest, src):
        return _cp4vasp.Structure_dir2cart(self, dest, src)

    def cart2dir(self, dest, src):
        return _cp4vasp.Structure_cart2dir(self, dest, src)

    def dirVectorToUnitCell(self, dest, v):
        return _cp4vasp.Structure_dirVectorToUnitCell(self, dest, v)

    def dirVectorToCenteredUnitCell(self, dest, v):
        return _cp4vasp.Structure_dirVectorToCenteredUnitCell(self, dest, v)

    def cartVectorToUnitCell(self, dest, v):
        return _cp4vasp.Structure_cartVectorToUnitCell(self, dest, v)

    def cartVectorToCenteredUnitCell(self, dest, v):
        return _cp4vasp.Structure_cartVectorToCenteredUnitCell(self, dest, v)

    def vectorToUnitCell(self, dest, v):
        return _cp4vasp.Structure_vectorToUnitCell(self, dest, v)

    def vectorToCenteredUnitCell(self, dest, v):
        return _cp4vasp.Structure_vectorToCenteredUnitCell(self, dest, v)

    def toUnitCell(self):
        return _cp4vasp.Structure_toUnitCell(self)

    def toCenteredUnitCell(self):
        return _cp4vasp.Structure_toCenteredUnitCell(self)

    def mindistCartVectors(self, a, b):
        return _cp4vasp.Structure_mindistCartVectors(self, a, b)

    def mindistDirVectors(self, a, b):
        return _cp4vasp.Structure_mindistDirVectors(self, a, b)

    def createMindistMatrix(self):
        return _cp4vasp.Structure_createMindistMatrix(self)

    def deleteMindistMatrix(self):
        return _cp4vasp.Structure_deleteMindistMatrix(self)

    def getMindist(self, i, j):
        return _cp4vasp.Structure_getMindist(self, i, j)

    def clean(self):
        return _cp4vasp.Structure_clean(self)

    def setStructure(self, p):
        return _cp4vasp.Structure_setStructure(self, p)

    def clone(self):
        return _cp4vasp.Structure_clone(self)

    def len(self):
        return _cp4vasp.Structure_len(self)

    def getNumberOfSpecies(self):
        return _cp4vasp.Structure_getNumberOfSpecies(self)

    def getRecord(self, i):
        return _cp4vasp.Structure_getRecord(self, i)

    def get(self, i):
        return _cp4vasp.Structure_get(self, i)

    def set(self, i, x, y, z):
        return _cp4vasp.Structure_set(self, i, x, y, z)

    def allocate(self, n):
        return _cp4vasp.Structure_allocate(self, n)

    def realloc(self, alloc):
        return _cp4vasp.Structure_realloc(self, alloc)

    def append(self, x, y, z):
        return _cp4vasp.Structure_append(self, x, y, z)

    def delitem(self, i):
        return _cp4vasp.Structure_delitem(self, i)

    def setScaling(self, i, x):
        return _cp4vasp.Structure_setScaling(self, i, x)
Structure_swigregister = _cp4vasp.Structure_swigregister
Structure_swigregister(Structure)

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

    def total(self):
        return _cp4vasp.Process_total(self)

    def step(self):
        return _cp4vasp.Process_step(self)

    def status(self):
        return _cp4vasp.Process_status(self)

    def error(self):
        return _cp4vasp.Process_error(self)

    def next(self):
        return _cp4vasp.Process_next(self)
    __swig_destroy__ = _cp4vasp.delete_Process
    __del__ = lambda self: None

    def __init__(self):
        this = _cp4vasp.new_Process()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
Process_swigregister = _cp4vasp.Process_swigregister
Process_swigregister(Process)

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

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

    def next(self):
        return _cp4vasp.ReadChgcarProcess_next(self)
    __swig_destroy__ = _cp4vasp.delete_ReadChgcarProcess
    __del__ = lambda self: None
ReadChgcarProcess_swigregister = _cp4vasp.ReadChgcarProcess_swigregister
ReadChgcarProcess_swigregister(ReadChgcarProcess)

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

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

    def next(self):
        return _cp4vasp.ChgcarPlaneProcess_next(self)
    __swig_destroy__ = _cp4vasp.delete_ChgcarPlaneProcess
    __del__ = lambda self: None

    def getPlane(self):
        return _cp4vasp.ChgcarPlaneProcess_getPlane(self)
ChgcarPlaneProcess_swigregister = _cp4vasp.ChgcarPlaneProcess_swigregister
ChgcarPlaneProcess_swigregister(ChgcarPlaneProcess)

class Chgcar(ClassInterface):
    __swig_setmethods__ = {}
    for _s in [ClassInterface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chgcar, name, value)
    __swig_getmethods__ = {}
    for _s in [ClassInterface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Chgcar, name)
    __repr__ = _swig_repr
    __swig_setmethods__["plane_minimum"] = _cp4vasp.Chgcar_plane_minimum_set
    __swig_getmethods__["plane_minimum"] = _cp4vasp.Chgcar_plane_minimum_get
    __swig_setmethods__["plane_maximum"] = _cp4vasp.Chgcar_plane_maximum_set
    __swig_getmethods__["plane_maximum"] = _cp4vasp.Chgcar_plane_maximum_get
    __swig_setmethods__["plane_average"] = _cp4vasp.Chgcar_plane_average_set
    __swig_getmethods__["plane_average"] = _cp4vasp.Chgcar_plane_average_get
    __swig_setmethods__["plane_variance"] = _cp4vasp.Chgcar_plane_variance_set
    __swig_getmethods__["plane_variance"] = _cp4vasp.Chgcar_plane_variance_get

    def getClassName(self):
        return _cp4vasp.Chgcar_getClassName(self)
    __swig_setmethods__["structure"] = _cp4vasp.Chgcar_structure_set
    __swig_getmethods__["structure"] = _cp4vasp.Chgcar_structure_get
    __swig_setmethods__["nx"] = _cp4vasp.Chgcar_nx_set
    __swig_getmethods__["nx"] = _cp4vasp.Chgcar_nx_get
    __swig_setmethods__["ny"] = _cp4vasp.Chgcar_ny_set
    __swig_getmethods__["ny"] = _cp4vasp.Chgcar_ny_get
    __swig_setmethods__["nz"] = _cp4vasp.Chgcar_nz_set
    __swig_getmethods__["nz"] = _cp4vasp.Chgcar_nz_get
    __swig_setmethods__["data"] = _cp4vasp.Chgcar_data_set
    __swig_getmethods__["data"] = _cp4vasp.Chgcar_data_get

    def __init__(self):
        this = _cp4vasp.new_Chgcar()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_Chgcar
    __del__ = lambda self: None

    def subtractChgcar(self, c):
        return _cp4vasp.Chgcar_subtractChgcar(self, c)

    def calculateStatistics(self):
        return _cp4vasp.Chgcar_calculateStatistics(self)

    def getMinimum(self):
        return _cp4vasp.Chgcar_getMinimum(self)

    def getMaximum(self):
        return _cp4vasp.Chgcar_getMaximum(self)

    def getAverage(self):
        return _cp4vasp.Chgcar_getAverage(self)

    def getVariance(self):
        return _cp4vasp.Chgcar_getVariance(self)

    def getSigma(self):
        return _cp4vasp.Chgcar_getSigma(self)

    def clean(self):
        return _cp4vasp.Chgcar_clean(self)

    def read(self, path):
        return _cp4vasp.Chgcar_read(self, path)

    def createReadProcess(self, path):
        return _cp4vasp.Chgcar_createReadProcess(self, path)

    def write(self, path):
        return _cp4vasp.Chgcar_write(self, path)

    def get(self, i, j, k):
        return _cp4vasp.Chgcar_get(self, i, j, k)

    def getRaw(self, i, j, k):
        return _cp4vasp.Chgcar_getRaw(self, i, j, k)

    def set(self, i, j, k, val):
        return _cp4vasp.Chgcar_set(self, i, j, k, val)

    def setRaw(self, i, j, k, val):
        return _cp4vasp.Chgcar_setRaw(self, i, j, k, val)

    def getDirGrad(self, dest, i, j, k):
        return _cp4vasp.Chgcar_getDirGrad(self, dest, i, j, k)

    def getGrad(self, dest, i, j, k):
        return _cp4vasp.Chgcar_getGrad(self, dest, i, j, k)

    def downSampleByFactors(self, i, j, k):
        return _cp4vasp.Chgcar_downSampleByFactors(self, i, j, k)

    def sumElectrons(self):
        return _cp4vasp.Chgcar_sumElectrons(self)

    def gaussianSmearingX(self, sigma, limit=0.01):
        return _cp4vasp.Chgcar_gaussianSmearingX(self, sigma, limit)

    def gaussianSmearingY(self, sigma, limit=0.01):
        return _cp4vasp.Chgcar_gaussianSmearingY(self, sigma, limit)

    def gaussianSmearingZ(self, sigma, limit=0.01):
        return _cp4vasp.Chgcar_gaussianSmearingZ(self, sigma, limit)

    def clone(self):
        return _cp4vasp.Chgcar_clone(self)

    def setChgcar(self, c):
        return _cp4vasp.Chgcar_setChgcar(self, c)

    def calculatePlaneStatisticsX(self, n):
        return _cp4vasp.Chgcar_calculatePlaneStatisticsX(self, n)

    def calculatePlaneStatisticsY(self, n):
        return _cp4vasp.Chgcar_calculatePlaneStatisticsY(self, n)

    def calculatePlaneStatisticsZ(self, n):
        return _cp4vasp.Chgcar_calculatePlaneStatisticsZ(self, n)

    def searchMinPlaneX(self):
        return _cp4vasp.Chgcar_searchMinPlaneX(self)

    def searchMinPlaneY(self):
        return _cp4vasp.Chgcar_searchMinPlaneY(self)

    def searchMinPlaneZ(self):
        return _cp4vasp.Chgcar_searchMinPlaneZ(self)

    def getPlaneX(self, n):
        return _cp4vasp.Chgcar_getPlaneX(self, n)

    def getPlaneY(self, n):
        return _cp4vasp.Chgcar_getPlaneY(self, n)

    def getPlaneZ(self, n):
        return _cp4vasp.Chgcar_getPlaneZ(self, n)

    def createSmoothPlaneProcessX(self, n, sigmax, sigmay, sigmaz, limit=0.01):
        return _cp4vasp.Chgcar_createSmoothPlaneProcessX(self, n, sigmax, sigmay, sigmaz, limit)

    def createSmoothPlaneProcessY(self, n, sigmax, sigmay, sigmaz, limit=0.01):
        return _cp4vasp.Chgcar_createSmoothPlaneProcessY(self, n, sigmax, sigmay, sigmaz, limit)

    def createSmoothPlaneProcessZ(self, n, sigmax, sigmay, sigmaz, limit=0.01):
        return _cp4vasp.Chgcar_createSmoothPlaneProcessZ(self, n, sigmax, sigmay, sigmaz, limit)

    def createCCPlaneX(self, val, n=-1, delta=-1):
        return _cp4vasp.Chgcar_createCCPlaneX(self, val, n, delta)

    def createCCPlaneY(self, val, n=-1, delta=-1):
        return _cp4vasp.Chgcar_createCCPlaneY(self, val, n, delta)

    def createCCPlaneZ(self, val, n=-1, delta=-1):
        return _cp4vasp.Chgcar_createCCPlaneZ(self, val, n, delta)

    def createCCPlaneCubicX(self, val, n=-1, delta=-1):
        return _cp4vasp.Chgcar_createCCPlaneCubicX(self, val, n, delta)

    def createCCPlaneCubicY(self, val, n=-1, delta=-1):
        return _cp4vasp.Chgcar_createCCPlaneCubicY(self, val, n, delta)

    def createCCPlaneCubicZ(self, val, n=-1, delta=-1):
        return _cp4vasp.Chgcar_createCCPlaneCubicZ(self, val, n, delta)
Chgcar_swigregister = _cp4vasp.Chgcar_swigregister
Chgcar_swigregister(Chgcar)

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

    def __init__(self):
        this = _cp4vasp.new_ChgcarSmear()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.ChgcarSmear_getClassName(self)

    def setChgcar(self, c):
        return _cp4vasp.ChgcarSmear_setChgcar(self, c)

    def get(self, i, j, k):
        return _cp4vasp.ChgcarSmear_get(self, i, j, k)
    __swig_destroy__ = _cp4vasp.delete_ChgcarSmear
    __del__ = lambda self: None
ChgcarSmear_swigregister = _cp4vasp.ChgcarSmear_swigregister
ChgcarSmear_swigregister(ChgcarSmear)

class GaussianChgcarSmear(ChgcarSmear):
    __swig_setmethods__ = {}
    for _s in [ChgcarSmear]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GaussianChgcarSmear, name, value)
    __swig_getmethods__ = {}
    for _s in [ChgcarSmear]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GaussianChgcarSmear, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lx"] = _cp4vasp.GaussianChgcarSmear_lx_set
    __swig_getmethods__["lx"] = _cp4vasp.GaussianChgcarSmear_lx_get
    __swig_setmethods__["ly"] = _cp4vasp.GaussianChgcarSmear_ly_set
    __swig_getmethods__["ly"] = _cp4vasp.GaussianChgcarSmear_ly_get
    __swig_setmethods__["lz"] = _cp4vasp.GaussianChgcarSmear_lz_set
    __swig_getmethods__["lz"] = _cp4vasp.GaussianChgcarSmear_lz_get
    __swig_setmethods__["dir"] = _cp4vasp.GaussianChgcarSmear_dir_set
    __swig_getmethods__["dir"] = _cp4vasp.GaussianChgcarSmear_dir_get
    __swig_setmethods__["horizontal_sigma"] = _cp4vasp.GaussianChgcarSmear_horizontal_sigma_set
    __swig_getmethods__["horizontal_sigma"] = _cp4vasp.GaussianChgcarSmear_horizontal_sigma_get
    __swig_setmethods__["vertical_sigma"] = _cp4vasp.GaussianChgcarSmear_vertical_sigma_set
    __swig_getmethods__["vertical_sigma"] = _cp4vasp.GaussianChgcarSmear_vertical_sigma_get

    def __init__(self):
        this = _cp4vasp.new_GaussianChgcarSmear()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.GaussianChgcarSmear_getClassName(self)

    def setChgcar(self, c):
        return _cp4vasp.GaussianChgcarSmear_setChgcar(self, c)

    def get(self, i, j, k):
        return _cp4vasp.GaussianChgcarSmear_get(self, i, j, k)
    __swig_destroy__ = _cp4vasp.delete_GaussianChgcarSmear
    __del__ = lambda self: None
GaussianChgcarSmear_swigregister = _cp4vasp.GaussianChgcarSmear_swigregister
GaussianChgcarSmear_swigregister(GaussianChgcarSmear)

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

    def __init__(self, c, s, pstep=10):
        this = _cp4vasp.new_ChgcarSmearProcess(c, s, pstep)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def next(self):
        return _cp4vasp.ChgcarSmearProcess_next(self)

    def get(self):
        return _cp4vasp.ChgcarSmearProcess_get(self)

    def getClassName(self):
        return _cp4vasp.ChgcarSmearProcess_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_ChgcarSmearProcess
    __del__ = lambda self: None
ChgcarSmearProcess_swigregister = _cp4vasp.ChgcarSmearProcess_swigregister
ChgcarSmearProcess_swigregister(ChgcarSmearProcess)

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

    def __init__(self, c, s, nplane, dir, pstep=10):
        this = _cp4vasp.new_ChgcarSmearPlaneProcess(c, s, nplane, dir, pstep)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def planeName(self, *args):
        return _cp4vasp.ChgcarSmearPlaneProcess_planeName(self, *args)

    def next(self):
        return _cp4vasp.ChgcarSmearPlaneProcess_next(self)
    __swig_destroy__ = _cp4vasp.delete_ChgcarSmearPlaneProcess
    __del__ = lambda self: None

    def getClassName(self):
        return _cp4vasp.ChgcarSmearPlaneProcess_getClassName(self)

    def getPlane(self):
        return _cp4vasp.ChgcarSmearPlaneProcess_getPlane(self)
ChgcarSmearPlaneProcess_swigregister = _cp4vasp.ChgcarSmearPlaneProcess_swigregister
ChgcarSmearPlaneProcess_swigregister(ChgcarSmearPlaneProcess)

class STMSearchProcess(Process):
    __swig_setmethods__ = {}
    for _s in [Process]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, STMSearchProcess, name, value)
    __swig_getmethods__ = {}
    for _s in [Process]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, STMSearchProcess, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mode"] = _cp4vasp.STMSearchProcess_mode_set
    __swig_getmethods__["mode"] = _cp4vasp.STMSearchProcess_mode_get
    __swig_setmethods__["pstep"] = _cp4vasp.STMSearchProcess_pstep_set
    __swig_getmethods__["pstep"] = _cp4vasp.STMSearchProcess_pstep_get
    __swig_setmethods__["delta"] = _cp4vasp.STMSearchProcess_delta_set
    __swig_getmethods__["delta"] = _cp4vasp.STMSearchProcess_delta_get
    __swig_setmethods__["n0"] = _cp4vasp.STMSearchProcess_n0_set
    __swig_getmethods__["n0"] = _cp4vasp.STMSearchProcess_n0_get
    __swig_setmethods__["autoplane"] = _cp4vasp.STMSearchProcess_autoplane_set
    __swig_getmethods__["autoplane"] = _cp4vasp.STMSearchProcess_autoplane_get
    __swig_setmethods__["value"] = _cp4vasp.STMSearchProcess_value_set
    __swig_getmethods__["value"] = _cp4vasp.STMSearchProcess_value_get

    def __init__(self, c, val, s=None, n0=-1, dir=2, delta=-1, pstep=10, mode=0):
        this = _cp4vasp.new_STMSearchProcess(c, val, s, n0, dir, delta, pstep, mode)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def update(self):
        return _cp4vasp.STMSearchProcess_update(self)

    def getDir(self):
        return _cp4vasp.STMSearchProcess_getDir(self)

    def setDir(self, d):
        return _cp4vasp.STMSearchProcess_setDir(self, d)

    def setChgcar(self, c):
        return _cp4vasp.STMSearchProcess_setChgcar(self, c)

    def setSmear(self, s):
        return _cp4vasp.STMSearchProcess_setSmear(self, s)

    def searchFast(self, I, J):
        return _cp4vasp.STMSearchProcess_searchFast(self, I, J)

    def searchSlow(self, I, J):
        return _cp4vasp.STMSearchProcess_searchSlow(self, I, J)

    def getHeightFast(self, I, J):
        return _cp4vasp.STMSearchProcess_getHeightFast(self, I, J)

    def getHeightSlow(self, I, J):
        return _cp4vasp.STMSearchProcess_getHeightSlow(self, I, J)

    def getHeightFastCubic(self, I, J):
        return _cp4vasp.STMSearchProcess_getHeightFastCubic(self, I, J)

    def getHeightSlowCubic(self, I, J):
        return _cp4vasp.STMSearchProcess_getHeightSlowCubic(self, I, J)

    def getClassName(self):
        return _cp4vasp.STMSearchProcess_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_STMSearchProcess
    __del__ = lambda self: None

    def next(self):
        return _cp4vasp.STMSearchProcess_next(self)

    def processAll(self):
        return _cp4vasp.STMSearchProcess_processAll(self)

    def getPlane(self):
        return _cp4vasp.STMSearchProcess_getPlane(self)
STMSearchProcess_swigregister = _cp4vasp.STMSearchProcess_swigregister
STMSearchProcess_swigregister(STMSearchProcess)


def VisInit():
    return _cp4vasp.VisInit()
VisInit = _cp4vasp.VisInit

def VisMainLoop():
    return _cp4vasp.VisMainLoop()
VisMainLoop = _cp4vasp.VisMainLoop

def VisMainLoopInThread():
    return _cp4vasp.VisMainLoopInThread()
VisMainLoopInThread = _cp4vasp.VisMainLoopInThread

def VisSync():
    return _cp4vasp.VisSync()
VisSync = _cp4vasp.VisSync

def VisCheck():
    return _cp4vasp.VisCheck()
VisCheck = _cp4vasp.VisCheck

def checkThreadsSupport():
    return _cp4vasp.checkThreadsSupport()
checkThreadsSupport = _cp4vasp.checkThreadsSupport
class VisBackEvent:
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisBackEvent, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VisBackEvent, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    create = _cp4vasp.VisBackEvent_create
    __swig_setmethods__["type"] = _cp4vasp.VisBackEvent_type_set
    __swig_getmethods__["type"] = _cp4vasp.VisBackEvent_type_get
    __swig_setmethods__["index"] = _cp4vasp.VisBackEvent_index_set
    __swig_getmethods__["index"] = _cp4vasp.VisBackEvent_index_get
    __swig_setmethods__["nx"] = _cp4vasp.VisBackEvent_nx_set
    __swig_getmethods__["nx"] = _cp4vasp.VisBackEvent_nx_get
    __swig_setmethods__["ny"] = _cp4vasp.VisBackEvent_ny_set
    __swig_getmethods__["ny"] = _cp4vasp.VisBackEvent_ny_get
    __swig_setmethods__["nz"] = _cp4vasp.VisBackEvent_nz_set
    __swig_getmethods__["nz"] = _cp4vasp.VisBackEvent_nz_get

    def getStructureDrawer(self):
        return _cp4vasp.VisBackEvent_getStructureDrawer(self)

    def getWindow(self):
        return _cp4vasp.VisBackEvent_getWindow(self)
    __swig_destroy__ = _cp4vasp.delete_VisBackEvent
    __del__ = lambda self: None
VisBackEvent_swigregister = _cp4vasp.VisBackEvent_swigregister
VisBackEvent_swigregister(VisBackEvent)
cvar = _cp4vasp.cvar
BE_NONE = cvar.BE_NONE
BE_SELECTED = cvar.BE_SELECTED
BE_DESELECTED = cvar.BE_DESELECTED
BE_WIN_ACTIVATE = cvar.BE_WIN_ACTIVATE
BE_WIN_DEACTIVATE = cvar.BE_WIN_DEACTIVATE
BE_WIN_SHOW = cvar.BE_WIN_SHOW
BE_WIN_HIDE = cvar.BE_WIN_HIDE
BE_WIN_CLOSE = cvar.BE_WIN_CLOSE

def VisBackEvent_create():
    return _cp4vasp.VisBackEvent_create()
VisBackEvent_create = _cp4vasp.VisBackEvent_create

class VisBackEventQueue:
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisBackEventQueue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VisBackEventQueue, name)
    __repr__ = _swig_repr
    get = _cp4vasp.VisBackEventQueue_get

    def __init__(self):
        this = _cp4vasp.new_VisBackEventQueue()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def current(self):
        return _cp4vasp.VisBackEventQueue_current(self)

    def last(self):
        return _cp4vasp.VisBackEventQueue_last(self)

    def pop(self):
        return _cp4vasp.VisBackEventQueue_pop(self)

    def append(self, e):
        return _cp4vasp.VisBackEventQueue_append(self, e)

    def prepend(self, e):
        return _cp4vasp.VisBackEventQueue_prepend(self, e)
    __swig_destroy__ = _cp4vasp.delete_VisBackEventQueue
    __del__ = lambda self: None
VisBackEventQueue_swigregister = _cp4vasp.VisBackEventQueue_swigregister
VisBackEventQueue_swigregister(VisBackEventQueue)

def VisBackEventQueue_get():
    return _cp4vasp.VisBackEventQueue_get()
VisBackEventQueue_get = _cp4vasp.VisBackEventQueue_get

class VisWindow(ClassInterface):
    __swig_setmethods__ = {}
    for _s in [ClassInterface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisWindow, name, value)
    __swig_getmethods__ = {}
    for _s in [ClassInterface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisWindow, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mouse_x"] = _cp4vasp.VisWindow_mouse_x_set
    __swig_getmethods__["mouse_x"] = _cp4vasp.VisWindow_mouse_x_get
    __swig_setmethods__["mouse_y"] = _cp4vasp.VisWindow_mouse_y_set
    __swig_getmethods__["mouse_y"] = _cp4vasp.VisWindow_mouse_y_get
    __swig_setmethods__["mouse_button1"] = _cp4vasp.VisWindow_mouse_button1_set
    __swig_getmethods__["mouse_button1"] = _cp4vasp.VisWindow_mouse_button1_get
    __swig_setmethods__["mouse_button2"] = _cp4vasp.VisWindow_mouse_button2_set
    __swig_getmethods__["mouse_button2"] = _cp4vasp.VisWindow_mouse_button2_get
    __swig_setmethods__["mouse_button3"] = _cp4vasp.VisWindow_mouse_button3_set
    __swig_getmethods__["mouse_button3"] = _cp4vasp.VisWindow_mouse_button3_get
    __swig_setmethods__["mouse_button"] = _cp4vasp.VisWindow_mouse_button_set
    __swig_getmethods__["mouse_button"] = _cp4vasp.VisWindow_mouse_button_get
    __swig_setmethods__["key"] = _cp4vasp.VisWindow_key_set
    __swig_getmethods__["key"] = _cp4vasp.VisWindow_key_get

    def getClassName(self):
        return _cp4vasp.VisWindow_getClassName(self)
    __swig_getmethods__["x"] = _cp4vasp.VisWindow_x_get
    __swig_getmethods__["y"] = _cp4vasp.VisWindow_y_get
    __swig_getmethods__["w"] = _cp4vasp.VisWindow_w_get
    __swig_getmethods__["h"] = _cp4vasp.VisWindow_h_get

    def __init__(self, x, y, w, h, title):
        this = _cp4vasp.new_VisWindow(x, y, w, h, title)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_VisWindow
    __del__ = lambda self: None
    getFirstWindow = _cp4vasp.VisWindow_getFirstWindow
    getLastWindow = _cp4vasp.VisWindow_getLastWindow
    getWindow = _cp4vasp.VisWindow_getWindow
    getWindowByOutput = _cp4vasp.VisWindow_getWindowByOutput
    windowsCount = _cp4vasp.VisWindow_windowsCount
    getWindowIndex = _cp4vasp.VisWindow_getWindowIndex
    deleteAllWindows = _cp4vasp.VisWindow_deleteAllWindows

    def getNextWindow(self):
        return _cp4vasp.VisWindow_getNextWindow(self)

    def getPreviousWindow(self):
        return _cp4vasp.VisWindow_getPreviousWindow(self)
    deleteWindow = _cp4vasp.VisWindow_deleteWindow

    def getTitle(self):
        return _cp4vasp.VisWindow_getTitle(self)

    def setTitle(self, title):
        return _cp4vasp.VisWindow_setTitle(self, title)

    def position(self, x, y):
        return _cp4vasp.VisWindow_position(self, x, y)

    def size(self, x, y):
        return _cp4vasp.VisWindow_size(self, x, y)

    def resize(self, x, y, w, h):
        return _cp4vasp.VisWindow_resize(self, x, y, w, h)

    def show(self):
        return _cp4vasp.VisWindow_show(self)

    def hide(self):
        return _cp4vasp.VisWindow_hide(self)

    def redraw(self):
        return _cp4vasp.VisWindow_redraw(self)

    def setDrawer(self, d):
        return _cp4vasp.VisWindow_setDrawer(self, d)

    def getDrawer(self):
        return _cp4vasp.VisWindow_getDrawer(self)

    def saveScreenshot(self, path):
        return _cp4vasp.VisWindow_saveScreenshot(self, path)
VisWindow_swigregister = _cp4vasp.VisWindow_swigregister
VisWindow_swigregister(VisWindow)

def VisWindow_getFirstWindow():
    return _cp4vasp.VisWindow_getFirstWindow()
VisWindow_getFirstWindow = _cp4vasp.VisWindow_getFirstWindow

def VisWindow_getLastWindow():
    return _cp4vasp.VisWindow_getLastWindow()
VisWindow_getLastWindow = _cp4vasp.VisWindow_getLastWindow

def VisWindow_getWindow(n):
    return _cp4vasp.VisWindow_getWindow(n)
VisWindow_getWindow = _cp4vasp.VisWindow_getWindow

def VisWindow_getWindowByOutput(w):
    return _cp4vasp.VisWindow_getWindowByOutput(w)
VisWindow_getWindowByOutput = _cp4vasp.VisWindow_getWindowByOutput

def VisWindow_windowsCount():
    return _cp4vasp.VisWindow_windowsCount()
VisWindow_windowsCount = _cp4vasp.VisWindow_windowsCount

def VisWindow_getWindowIndex(w):
    return _cp4vasp.VisWindow_getWindowIndex(w)
VisWindow_getWindowIndex = _cp4vasp.VisWindow_getWindowIndex

def VisWindow_deleteAllWindows():
    return _cp4vasp.VisWindow_deleteAllWindows()
VisWindow_deleteAllWindows = _cp4vasp.VisWindow_deleteAllWindows

def VisWindow_deleteWindow(n):
    return _cp4vasp.VisWindow_deleteWindow(n)
VisWindow_deleteWindow = _cp4vasp.VisWindow_deleteWindow

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

    def __init__(self):
        this = _cp4vasp.new_VisDrawer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.VisDrawer_getClassName(self)

    def getWindow(self):
        return _cp4vasp.VisDrawer_getWindow(self)

    def getPrevious(self):
        return _cp4vasp.VisDrawer_getPrevious(self)

    def getNext(self):
        return _cp4vasp.VisDrawer_getNext(self)

    def getFirst(self):
        return _cp4vasp.VisDrawer_getFirst(self)

    def getLast(self):
        return _cp4vasp.VisDrawer_getLast(self)

    def countBefore(self):
        return _cp4vasp.VisDrawer_countBefore(self)

    def countAfter(self):
        return _cp4vasp.VisDrawer_countAfter(self)

    def count(self):
        return _cp4vasp.VisDrawer_count(self)

    def insertAfter(self, d):
        return _cp4vasp.VisDrawer_insertAfter(self, d)

    def insertBefore(self, d):
        return _cp4vasp.VisDrawer_insertBefore(self, d)

    def insertSequenceAfter(self, d):
        return _cp4vasp.VisDrawer_insertSequenceAfter(self, d)

    def insertSequenceBefore(self, d):
        return _cp4vasp.VisDrawer_insertSequenceBefore(self, d)

    def append(self, d):
        return _cp4vasp.VisDrawer_append(self, d)

    def appendSequence(self, d):
        return _cp4vasp.VisDrawer_appendSequence(self, d)
    __swig_destroy__ = _cp4vasp.delete_VisDrawer
    __del__ = lambda self: None

    def getMouseX(self):
        return _cp4vasp.VisDrawer_getMouseX(self)

    def getMouseY(self):
        return _cp4vasp.VisDrawer_getMouseY(self)

    def getMouseButton(self):
        return _cp4vasp.VisDrawer_getMouseButton(self)

    def getMouseButton1(self):
        return _cp4vasp.VisDrawer_getMouseButton1(self)

    def getMouseButton2(self):
        return _cp4vasp.VisDrawer_getMouseButton2(self)

    def getMouseButton3(self):
        return _cp4vasp.VisDrawer_getMouseButton3(self)

    def getKey(self):
        return _cp4vasp.VisDrawer_getKey(self)

    def getWidth(self):
        return _cp4vasp.VisDrawer_getWidth(self)

    def getHeight(self):
        return _cp4vasp.VisDrawer_getHeight(self)

    def redraw(self):
        return _cp4vasp.VisDrawer_redraw(self)
VisDrawer_swigregister = _cp4vasp.VisDrawer_swigregister
VisDrawer_swigregister(VisDrawer)

class VisNavDrawer(VisDrawer):
    __swig_setmethods__ = {}
    for _s in [VisDrawer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisNavDrawer, name, value)
    __swig_getmethods__ = {}
    for _s in [VisDrawer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisNavDrawer, name)
    __repr__ = _swig_repr
    __swig_getmethods__["bg_red"] = _cp4vasp.VisNavDrawer_bg_red_get
    __swig_getmethods__["bg_green"] = _cp4vasp.VisNavDrawer_bg_green_get
    __swig_getmethods__["bg_blue"] = _cp4vasp.VisNavDrawer_bg_blue_get

    def __init__(self):
        this = _cp4vasp.new_VisNavDrawer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getRotMatElement(self, i, j):
        return _cp4vasp.VisNavDrawer_getRotMatElement(self, i, j)

    def setBackground(self, red, green, blue):
        return _cp4vasp.VisNavDrawer_setBackground(self, red, green, blue)

    def setAntialiasing(self, a):
        return _cp4vasp.VisNavDrawer_setAntialiasing(self, a)

    def getAntialiasing(self):
        return _cp4vasp.VisNavDrawer_getAntialiasing(self)

    def getClassName(self):
        return _cp4vasp.VisNavDrawer_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_VisNavDrawer
    __del__ = lambda self: None

    def setHome(self):
        return _cp4vasp.VisNavDrawer_setHome(self)

    def setFrontView(self):
        return _cp4vasp.VisNavDrawer_setFrontView(self)

    def setBackView(self):
        return _cp4vasp.VisNavDrawer_setBackView(self)

    def setLeftView(self):
        return _cp4vasp.VisNavDrawer_setLeftView(self)

    def setRightView(self):
        return _cp4vasp.VisNavDrawer_setRightView(self)

    def setTopView(self):
        return _cp4vasp.VisNavDrawer_setTopView(self)

    def setBottomView(self):
        return _cp4vasp.VisNavDrawer_setBottomView(self)

    def getPerspective(self):
        return _cp4vasp.VisNavDrawer_getPerspective(self)

    def setPerspective(self, flag):
        return _cp4vasp.VisNavDrawer_setPerspective(self, flag)

    def getZoom(self):
        return _cp4vasp.VisNavDrawer_getZoom(self)

    def setZoom(self, z):
        return _cp4vasp.VisNavDrawer_setZoom(self, z)

    def mulZoom(self, z):
        return _cp4vasp.VisNavDrawer_mulZoom(self, z)
VisNavDrawer_swigregister = _cp4vasp.VisNavDrawer_swigregister
VisNavDrawer_swigregister(VisNavDrawer)


def getDefaultPrimitivesResolution():
    return _cp4vasp.getDefaultPrimitivesResolution()
getDefaultPrimitivesResolution = _cp4vasp.getDefaultPrimitivesResolution

def setDefaultPrimitivesResolution(r):
    return _cp4vasp.setDefaultPrimitivesResolution(r)
setDefaultPrimitivesResolution = _cp4vasp.setDefaultPrimitivesResolution
class VisPrimitiveDrawer(VisDrawer):
    __swig_setmethods__ = {}
    for _s in [VisDrawer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisPrimitiveDrawer, name, value)
    __swig_getmethods__ = {}
    for _s in [VisDrawer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisPrimitiveDrawer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["arrow_radius"] = _cp4vasp.VisPrimitiveDrawer_arrow_radius_set
    __swig_getmethods__["arrow_radius"] = _cp4vasp.VisPrimitiveDrawer_arrow_radius_get
    __swig_setmethods__["arrowhead_radius"] = _cp4vasp.VisPrimitiveDrawer_arrowhead_radius_set
    __swig_getmethods__["arrowhead_radius"] = _cp4vasp.VisPrimitiveDrawer_arrowhead_radius_get
    __swig_setmethods__["arrowhead_length"] = _cp4vasp.VisPrimitiveDrawer_arrowhead_length_set
    __swig_getmethods__["arrowhead_length"] = _cp4vasp.VisPrimitiveDrawer_arrowhead_length_get

    def __init__(self):
        this = _cp4vasp.new_VisPrimitiveDrawer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.VisPrimitiveDrawer_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_VisPrimitiveDrawer
    __del__ = lambda self: None

    def setPrimitivesResolution(self, r):
        return _cp4vasp.VisPrimitiveDrawer_setPrimitivesResolution(self, r)

    def color(self, red, green, blue):
        return _cp4vasp.VisPrimitiveDrawer_color(self, red, green, blue)

    def sphere(self, x, y, z, radius):
        return _cp4vasp.VisPrimitiveDrawer_sphere(self, x, y, z, radius)

    def cylinder(self, x1, y1, z1, x2, y2, z2, radius):
        return _cp4vasp.VisPrimitiveDrawer_cylinder(self, x1, y1, z1, x2, y2, z2, radius)

    def cone(self, x1, y1, z1, x2, y2, z2, radius):
        return _cp4vasp.VisPrimitiveDrawer_cone(self, x1, y1, z1, x2, y2, z2, radius)

    def line(self, x1, y1, z1, x2, y2, z2):
        return _cp4vasp.VisPrimitiveDrawer_line(self, x1, y1, z1, x2, y2, z2)

    def arrow(self, x, y, z, dx, dy, dz, scale=1.0, normalize=0):
        return _cp4vasp.VisPrimitiveDrawer_arrow(self, x, y, z, dx, dy, dz, scale, normalize)
VisPrimitiveDrawer_swigregister = _cp4vasp.VisPrimitiveDrawer_swigregister
VisPrimitiveDrawer_swigregister(VisPrimitiveDrawer)

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

    def __init__(self):
        this = _cp4vasp.new_AtomId()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["atom"] = _cp4vasp.AtomId_atom_set
    __swig_getmethods__["atom"] = _cp4vasp.AtomId_atom_get
    __swig_setmethods__["nx"] = _cp4vasp.AtomId_nx_set
    __swig_getmethods__["nx"] = _cp4vasp.AtomId_nx_get
    __swig_setmethods__["ny"] = _cp4vasp.AtomId_ny_set
    __swig_getmethods__["ny"] = _cp4vasp.AtomId_ny_get
    __swig_setmethods__["nz"] = _cp4vasp.AtomId_nz_set
    __swig_getmethods__["nz"] = _cp4vasp.AtomId_nz_get
    __swig_destroy__ = _cp4vasp.delete_AtomId
    __del__ = lambda self: None
AtomId_swigregister = _cp4vasp.AtomId_swigregister
AtomId_swigregister(AtomId)

class VisStructureDrawer(VisPrimitiveDrawer):
    __swig_setmethods__ = {}
    for _s in [VisPrimitiveDrawer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisStructureDrawer, name, value)
    __swig_getmethods__ = {}
    for _s in [VisPrimitiveDrawer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisStructureDrawer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["cell_red"] = _cp4vasp.VisStructureDrawer_cell_red_set
    __swig_getmethods__["cell_red"] = _cp4vasp.VisStructureDrawer_cell_red_get
    __swig_setmethods__["cell_green"] = _cp4vasp.VisStructureDrawer_cell_green_set
    __swig_getmethods__["cell_green"] = _cp4vasp.VisStructureDrawer_cell_green_get
    __swig_setmethods__["cell_blue"] = _cp4vasp.VisStructureDrawer_cell_blue_set
    __swig_getmethods__["cell_blue"] = _cp4vasp.VisStructureDrawer_cell_blue_get
    __swig_setmethods__["bond_red"] = _cp4vasp.VisStructureDrawer_bond_red_set
    __swig_getmethods__["bond_red"] = _cp4vasp.VisStructureDrawer_bond_red_get
    __swig_setmethods__["bond_green"] = _cp4vasp.VisStructureDrawer_bond_green_set
    __swig_getmethods__["bond_green"] = _cp4vasp.VisStructureDrawer_bond_green_get
    __swig_setmethods__["bond_blue"] = _cp4vasp.VisStructureDrawer_bond_blue_set
    __swig_getmethods__["bond_blue"] = _cp4vasp.VisStructureDrawer_bond_blue_get
    __swig_getmethods__["info"] = _cp4vasp.VisStructureDrawer_info_get
    __swig_getmethods__["cell_line_width"] = _cp4vasp.VisStructureDrawer_cell_line_width_get
    __swig_getmethods__["showcellflag"] = _cp4vasp.VisStructureDrawer_showcellflag_get

    def updateStructure(self):
        return _cp4vasp.VisStructureDrawer_updateStructure(self)

    def setMultiple(self, a, b, c):
        return _cp4vasp.VisStructureDrawer_setMultiple(self, a, b, c)

    def setMultiple1(self, a):
        return _cp4vasp.VisStructureDrawer_setMultiple1(self, a)

    def setMultiple2(self, a):
        return _cp4vasp.VisStructureDrawer_setMultiple2(self, a)

    def setMultiple3(self, a):
        return _cp4vasp.VisStructureDrawer_setMultiple3(self, a)

    def getMultiple1(self):
        return _cp4vasp.VisStructureDrawer_getMultiple1(self)

    def getMultiple2(self):
        return _cp4vasp.VisStructureDrawer_getMultiple2(self)

    def getMultiple3(self):
        return _cp4vasp.VisStructureDrawer_getMultiple3(self)

    def __init__(self):
        this = _cp4vasp.new_VisStructureDrawer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.VisStructureDrawer_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_VisStructureDrawer
    __del__ = lambda self: None

    def switchSelectionByPick(self, x, y):
        return _cp4vasp.VisStructureDrawer_switchSelectionByPick(self, x, y)

    def setPrimitivesResolution(self, r):
        return _cp4vasp.VisStructureDrawer_setPrimitivesResolution(self, r)

    def selectObject(self, x, y, z, radius, phase=0.0):
        return _cp4vasp.VisStructureDrawer_selectObject(self, x, y, z, radius, phase)

    def fillInfo(self):
        return _cp4vasp.VisStructureDrawer_fillInfo(self)

    def setStructure(self, s):
        return _cp4vasp.VisStructureDrawer_setStructure(self, s)

    def getStructure(self):
        return _cp4vasp.VisStructureDrawer_getStructure(self)

    def getRadiusFactor(self):
        return _cp4vasp.VisStructureDrawer_getRadiusFactor(self)

    def setRadiusFactor(self, r):
        return _cp4vasp.VisStructureDrawer_setRadiusFactor(self, r)

    def getBondRadius(self):
        return _cp4vasp.VisStructureDrawer_getBondRadius(self)

    def setBondRadius(self, r):
        return _cp4vasp.VisStructureDrawer_setBondRadius(self, r)

    def getBondFactor(self):
        return _cp4vasp.VisStructureDrawer_getBondFactor(self)

    def setBondFactor(self, r):
        return _cp4vasp.VisStructureDrawer_setBondFactor(self, r)

    def showCell(self, f=1):
        return _cp4vasp.VisStructureDrawer_showCell(self, f)

    def getCellLineWidth(self):
        return _cp4vasp.VisStructureDrawer_getCellLineWidth(self)

    def setCellLineWidth(self, w):
        return _cp4vasp.VisStructureDrawer_setCellLineWidth(self, w)

    def setCellColor(self, r, g, b):
        return _cp4vasp.VisStructureDrawer_setCellColor(self, r, g, b)

    def setBondColor(self, r, g, b):
        return _cp4vasp.VisStructureDrawer_setBondColor(self, r, g, b)

    def getSelected(self, i):
        return _cp4vasp.VisStructureDrawer_getSelected(self, i)

    def getSelectedCount(self):
        return _cp4vasp.VisStructureDrawer_getSelectedCount(self)

    def appendSelected(self, atom, nx=0, ny=0, nz=0):
        return _cp4vasp.VisStructureDrawer_appendSelected(self, atom, nx, ny, nz)

    def notifySelected(self, atom, nx=0, ny=0, nz=0):
        return _cp4vasp.VisStructureDrawer_notifySelected(self, atom, nx, ny, nz)

    def notifyDeselected(self, atom, nx=0, ny=0, nz=0):
        return _cp4vasp.VisStructureDrawer_notifyDeselected(self, atom, nx, ny, nz)

    def removeSelectedAll(self):
        return _cp4vasp.VisStructureDrawer_removeSelectedAll(self)

    def removeSelectedItem(self, i):
        return _cp4vasp.VisStructureDrawer_removeSelectedItem(self, i)

    def findSelectedAtom(self, atom, nx=0, ny=0, nz=0):
        return _cp4vasp.VisStructureDrawer_findSelectedAtom(self, atom, nx, ny, nz)

    def selectAtom(self, atom, nx, ny, nz):
        return _cp4vasp.VisStructureDrawer_selectAtom(self, atom, nx, ny, nz)

    def deselectAtom(self, atom, nx, ny, nz):
        return _cp4vasp.VisStructureDrawer_deselectAtom(self, atom, nx, ny, nz)

    def switchAtomSelection(self, atom, nx, ny, nz):
        return _cp4vasp.VisStructureDrawer_switchAtomSelection(self, atom, nx, ny, nz)
VisStructureDrawer_swigregister = _cp4vasp.VisStructureDrawer_swigregister
VisStructureDrawer_swigregister(VisStructureDrawer)

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

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

    def getClassName(self):
        return _cp4vasp.Clamp_getClassName(self)

    def f(self, x):
        return _cp4vasp.Clamp_f(self, x)
    __swig_destroy__ = _cp4vasp.delete_Clamp
    __del__ = lambda self: None
Clamp_swigregister = _cp4vasp.Clamp_swigregister
Clamp_swigregister(Clamp)

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

    def __init__(self):
        this = _cp4vasp.new_ThresholdClamp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ThresholdClamp
    __del__ = lambda self: None
ThresholdClamp_swigregister = _cp4vasp.ThresholdClamp_swigregister
ThresholdClamp_swigregister(ThresholdClamp)

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

    def __init__(self):
        this = _cp4vasp.new_SawtoothClamp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_SawtoothClamp
    __del__ = lambda self: None
SawtoothClamp_swigregister = _cp4vasp.SawtoothClamp_swigregister
SawtoothClamp_swigregister(SawtoothClamp)

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

    def __init__(self):
        this = _cp4vasp.new_CosClamp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_CosClamp
    __del__ = lambda self: None
CosClamp_swigregister = _cp4vasp.CosClamp_swigregister
CosClamp_swigregister(CosClamp)

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

    def __init__(self):
        this = _cp4vasp.new_WaveClamp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_WaveClamp
    __del__ = lambda self: None
WaveClamp_swigregister = _cp4vasp.WaveClamp_swigregister
WaveClamp_swigregister(WaveClamp)

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

    def __init__(self):
        this = _cp4vasp.new_AtanClamp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_AtanClamp
    __del__ = lambda self: None
AtanClamp_swigregister = _cp4vasp.AtanClamp_swigregister
AtanClamp_swigregister(AtanClamp)

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

    def __init__(self):
        this = _cp4vasp.new_FermiClamp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_FermiClamp
    __del__ = lambda self: None
FermiClamp_swigregister = _cp4vasp.FermiClamp_swigregister
FermiClamp_swigregister(FermiClamp)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["color"] = _cp4vasp.ColorGradient_color_set
    __swig_getmethods__["color"] = _cp4vasp.ColorGradient_color_get

    def getClassName(self):
        return _cp4vasp.ColorGradient_getClassName(self)

    def f(self, x):
        return _cp4vasp.ColorGradient_f(self, x)

    def glcolor(self, x):
        return _cp4vasp.ColorGradient_glcolor(self, x)
    __swig_destroy__ = _cp4vasp.delete_ColorGradient
    __del__ = lambda self: None
ColorGradient_swigregister = _cp4vasp.ColorGradient_swigregister
ColorGradient_swigregister(ColorGradient)

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

    def getClassName(self):
        return _cp4vasp.GrayColorGradient_getClassName(self)

    def f(self, x):
        return _cp4vasp.GrayColorGradient_f(self, x)

    def __init__(self):
        this = _cp4vasp.new_GrayColorGradient()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_GrayColorGradient
    __del__ = lambda self: None
GrayColorGradient_swigregister = _cp4vasp.GrayColorGradient_swigregister
GrayColorGradient_swigregister(GrayColorGradient)

class RainbowColorGradient(ColorGradient):
    __swig_setmethods__ = {}
    for _s in [ColorGradient]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RainbowColorGradient, name, value)
    __swig_getmethods__ = {}
    for _s in [ColorGradient]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RainbowColorGradient, name)
    __repr__ = _swig_repr
    __swig_setmethods__["saturation"] = _cp4vasp.RainbowColorGradient_saturation_set
    __swig_getmethods__["saturation"] = _cp4vasp.RainbowColorGradient_saturation_get
    __swig_setmethods__["value"] = _cp4vasp.RainbowColorGradient_value_set
    __swig_getmethods__["value"] = _cp4vasp.RainbowColorGradient_value_get

    def __init__(self, saturation=1.0, value=1.0):
        this = _cp4vasp.new_RainbowColorGradient(saturation, value)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.RainbowColorGradient_getClassName(self)

    def f(self, x):
        return _cp4vasp.RainbowColorGradient_f(self, x)
    __swig_destroy__ = _cp4vasp.delete_RainbowColorGradient
    __del__ = lambda self: None
RainbowColorGradient_swigregister = _cp4vasp.RainbowColorGradient_swigregister
RainbowColorGradient_swigregister(RainbowColorGradient)

class VisSlideDrawer(VisDrawer):
    __swig_setmethods__ = {}
    for _s in [VisDrawer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisSlideDrawer, name, value)
    __swig_getmethods__ = {}
    for _s in [VisDrawer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisSlideDrawer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["n1"] = _cp4vasp.VisSlideDrawer_n1_set
    __swig_getmethods__["n1"] = _cp4vasp.VisSlideDrawer_n1_get
    __swig_setmethods__["n2"] = _cp4vasp.VisSlideDrawer_n2_set
    __swig_getmethods__["n2"] = _cp4vasp.VisSlideDrawer_n2_get
    __swig_setmethods__["lo"] = _cp4vasp.VisSlideDrawer_lo_set
    __swig_getmethods__["lo"] = _cp4vasp.VisSlideDrawer_lo_get
    __swig_setmethods__["hi"] = _cp4vasp.VisSlideDrawer_hi_set
    __swig_getmethods__["hi"] = _cp4vasp.VisSlideDrawer_hi_get
    __swig_setmethods__["scale"] = _cp4vasp.VisSlideDrawer_scale_set
    __swig_getmethods__["scale"] = _cp4vasp.VisSlideDrawer_scale_get

    def __init__(self):
        this = _cp4vasp.new_VisSlideDrawer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setShadow(self, f):
        return _cp4vasp.VisSlideDrawer_setShadow(self, f)

    def getShadow(self):
        return _cp4vasp.VisSlideDrawer_getShadow(self)

    def setB1(self, b):
        return _cp4vasp.VisSlideDrawer_setB1(self, b)

    def setB2(self, b):
        return _cp4vasp.VisSlideDrawer_setB2(self, b)

    def setOrigin(self, b):
        return _cp4vasp.VisSlideDrawer_setOrigin(self, b)

    def setFArray(self, fa):
        return _cp4vasp.VisSlideDrawer_setFArray(self, fa)

    def setGradient(self, g):
        return _cp4vasp.VisSlideDrawer_setGradient(self, g)

    def setClamp(self, c):
        return _cp4vasp.VisSlideDrawer_setClamp(self, c)

    def assureClampAndGradient(self):
        return _cp4vasp.VisSlideDrawer_assureClampAndGradient(self)
    __swig_destroy__ = _cp4vasp.delete_VisSlideDrawer
    __del__ = lambda self: None
VisSlideDrawer_swigregister = _cp4vasp.VisSlideDrawer_swigregister
VisSlideDrawer_swigregister(VisSlideDrawer)

class VisStructureArrowsDrawer(VisDrawer):
    __swig_setmethods__ = {}
    for _s in [VisDrawer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisStructureArrowsDrawer, name, value)
    __swig_getmethods__ = {}
    for _s in [VisDrawer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisStructureArrowsDrawer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["arrow_radius"] = _cp4vasp.VisStructureArrowsDrawer_arrow_radius_set
    __swig_getmethods__["arrow_radius"] = _cp4vasp.VisStructureArrowsDrawer_arrow_radius_get
    __swig_setmethods__["arrowhead_radius"] = _cp4vasp.VisStructureArrowsDrawer_arrowhead_radius_set
    __swig_getmethods__["arrowhead_radius"] = _cp4vasp.VisStructureArrowsDrawer_arrowhead_radius_get
    __swig_setmethods__["arrowhead_length"] = _cp4vasp.VisStructureArrowsDrawer_arrowhead_length_set
    __swig_getmethods__["arrowhead_length"] = _cp4vasp.VisStructureArrowsDrawer_arrowhead_length_get
    __swig_setmethods__["red"] = _cp4vasp.VisStructureArrowsDrawer_red_set
    __swig_getmethods__["red"] = _cp4vasp.VisStructureArrowsDrawer_red_get
    __swig_setmethods__["green"] = _cp4vasp.VisStructureArrowsDrawer_green_set
    __swig_getmethods__["green"] = _cp4vasp.VisStructureArrowsDrawer_green_get
    __swig_setmethods__["blue"] = _cp4vasp.VisStructureArrowsDrawer_blue_set
    __swig_getmethods__["blue"] = _cp4vasp.VisStructureArrowsDrawer_blue_get
    __swig_setmethods__["arrows_scale"] = _cp4vasp.VisStructureArrowsDrawer_arrows_scale_set
    __swig_getmethods__["arrows_scale"] = _cp4vasp.VisStructureArrowsDrawer_arrows_scale_get

    def __init__(self, sd):
        this = _cp4vasp.new_VisStructureArrowsDrawer(sd)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.VisStructureArrowsDrawer_getClassName(self)
    __swig_destroy__ = _cp4vasp.delete_VisStructureArrowsDrawer
    __del__ = lambda self: None

    def updateStructure(self):
        return _cp4vasp.VisStructureArrowsDrawer_updateStructure(self)

    def len(self):
        return _cp4vasp.VisStructureArrowsDrawer_len(self)

    def getArrow(self, i):
        return _cp4vasp.VisStructureArrowsDrawer_getArrow(self, i)

    def setArrow(self, i, x, y, z):
        return _cp4vasp.VisStructureArrowsDrawer_setArrow(self, i, x, y, z)

    def setScale(self, s):
        return _cp4vasp.VisStructureArrowsDrawer_setScale(self, s)

    def getScale(self):
        return _cp4vasp.VisStructureArrowsDrawer_getScale(self)
VisStructureArrowsDrawer_swigregister = _cp4vasp.VisStructureArrowsDrawer_swigregister
VisStructureArrowsDrawer_swigregister(VisStructureArrowsDrawer)

class VisIsosurfaceDrawer(VisDrawer):
    __swig_setmethods__ = {}
    for _s in [VisDrawer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisIsosurfaceDrawer, name, value)
    __swig_getmethods__ = {}
    for _s in [VisDrawer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisIsosurfaceDrawer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["list"] = _cp4vasp.VisIsosurfaceDrawer_list_set
    __swig_getmethods__["list"] = _cp4vasp.VisIsosurfaceDrawer_list_get
    __swig_setmethods__["list_update_required"] = _cp4vasp.VisIsosurfaceDrawer_list_update_required_set
    __swig_getmethods__["list_update_required"] = _cp4vasp.VisIsosurfaceDrawer_list_update_required_get
    __swig_setmethods__["level"] = _cp4vasp.VisIsosurfaceDrawer_level_set
    __swig_getmethods__["level"] = _cp4vasp.VisIsosurfaceDrawer_level_get
    __swig_setmethods__["draw_as_points"] = _cp4vasp.VisIsosurfaceDrawer_draw_as_points_set
    __swig_getmethods__["draw_as_points"] = _cp4vasp.VisIsosurfaceDrawer_draw_as_points_get
    __swig_setmethods__["mx"] = _cp4vasp.VisIsosurfaceDrawer_mx_set
    __swig_getmethods__["mx"] = _cp4vasp.VisIsosurfaceDrawer_mx_get
    __swig_setmethods__["my"] = _cp4vasp.VisIsosurfaceDrawer_my_set
    __swig_getmethods__["my"] = _cp4vasp.VisIsosurfaceDrawer_my_get
    __swig_setmethods__["mz"] = _cp4vasp.VisIsosurfaceDrawer_mz_set
    __swig_getmethods__["mz"] = _cp4vasp.VisIsosurfaceDrawer_mz_get
    __swig_setmethods__["chgcar"] = _cp4vasp.VisIsosurfaceDrawer_chgcar_set
    __swig_getmethods__["chgcar"] = _cp4vasp.VisIsosurfaceDrawer_chgcar_get

    def paint_isosurface(self, c, level):
        return _cp4vasp.VisIsosurfaceDrawer_paint_isosurface(self, c, level)

    def handle_tetrahedron(self, c, a1, a2, a3, b1, b2, b3, c1, c2, c3, d1, d2, d3, level):
        return _cp4vasp.VisIsosurfaceDrawer_handle_tetrahedron(self, c, a1, a2, a3, b1, b2, b3, c1, c2, c3, d1, d2, d3, level)

    def handle_type1(self, va, vb, vc, vd, nA, nB, nC, nD, A, B, C, D):
        return _cp4vasp.VisIsosurfaceDrawer_handle_type1(self, va, vb, vc, vd, nA, nB, nC, nD, A, B, C, D)

    def handle_type2(self, va, vb, vc, vd, nA, nB, nC, nD, A, B, C, D):
        return _cp4vasp.VisIsosurfaceDrawer_handle_type2(self, va, vb, vc, vd, nA, nB, nC, nD, A, B, C, D)
    __swig_setmethods__["red"] = _cp4vasp.VisIsosurfaceDrawer_red_set
    __swig_getmethods__["red"] = _cp4vasp.VisIsosurfaceDrawer_red_get
    __swig_setmethods__["green"] = _cp4vasp.VisIsosurfaceDrawer_green_set
    __swig_getmethods__["green"] = _cp4vasp.VisIsosurfaceDrawer_green_get
    __swig_setmethods__["blue"] = _cp4vasp.VisIsosurfaceDrawer_blue_set
    __swig_getmethods__["blue"] = _cp4vasp.VisIsosurfaceDrawer_blue_get

    def __init__(self):
        this = _cp4vasp.new_VisIsosurfaceDrawer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getClassName(self):
        return _cp4vasp.VisIsosurfaceDrawer_getClassName(self)

    def setMultiple(self, a, b, c):
        return _cp4vasp.VisIsosurfaceDrawer_setMultiple(self, a, b, c)

    def setMultiple1(self, a):
        return _cp4vasp.VisIsosurfaceDrawer_setMultiple1(self, a)

    def setMultiple2(self, a):
        return _cp4vasp.VisIsosurfaceDrawer_setMultiple2(self, a)

    def setMultiple3(self, a):
        return _cp4vasp.VisIsosurfaceDrawer_setMultiple3(self, a)

    def getMultiple1(self):
        return _cp4vasp.VisIsosurfaceDrawer_getMultiple1(self)

    def getMultiple2(self):
        return _cp4vasp.VisIsosurfaceDrawer_getMultiple2(self)

    def getMultiple3(self):
        return _cp4vasp.VisIsosurfaceDrawer_getMultiple3(self)

    def updateIsosurface(self):
        return _cp4vasp.VisIsosurfaceDrawer_updateIsosurface(self)

    def setLevel(self, l):
        return _cp4vasp.VisIsosurfaceDrawer_setLevel(self, l)

    def setChgcar(self, c):
        return _cp4vasp.VisIsosurfaceDrawer_setChgcar(self, c)

    def getLevel(self):
        return _cp4vasp.VisIsosurfaceDrawer_getLevel(self)

    def getDrawAsPoints(self):
        return _cp4vasp.VisIsosurfaceDrawer_getDrawAsPoints(self)

    def setDrawAsPoints(self, b):
        return _cp4vasp.VisIsosurfaceDrawer_setDrawAsPoints(self, b)
    __swig_destroy__ = _cp4vasp.delete_VisIsosurfaceDrawer
    __del__ = lambda self: None
VisIsosurfaceDrawer_swigregister = _cp4vasp.VisIsosurfaceDrawer_swigregister
VisIsosurfaceDrawer_swigregister(VisIsosurfaceDrawer)


def ODP_parseString(src):
    return _cp4vasp.ODP_parseString(src)
ODP_parseString = _cp4vasp.ODP_parseString

def ODP_parseFile(path):
    return _cp4vasp.ODP_parseFile(path)
ODP_parseFile = _cp4vasp.ODP_parseFile
class ODPNode:
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ODPNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ODPNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["doc"] = _cp4vasp.ODPNode_doc_set
    __swig_getmethods__["doc"] = _cp4vasp.ODPNode_doc_get
    __swig_setmethods__["pos"] = _cp4vasp.ODPNode_pos_set
    __swig_getmethods__["pos"] = _cp4vasp.ODPNode_pos_get

    def __init__(self, node):
        this = _cp4vasp.new_ODPNode(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    ELEMENT_NODE = _cp4vasp.ODPNode_ELEMENT_NODE
    ATTRIBUTE_NODE = _cp4vasp.ODPNode_ATTRIBUTE_NODE
    TEXT_NODE = _cp4vasp.ODPNode_TEXT_NODE
    CDATA_SECTION_NODE = _cp4vasp.ODPNode_CDATA_SECTION_NODE
    ENTITY_REFERENCE_NODE = _cp4vasp.ODPNode_ENTITY_REFERENCE_NODE
    ENTITY_NODE = _cp4vasp.ODPNode_ENTITY_NODE
    PROCESSING_INSTRUCTION_NODE = _cp4vasp.ODPNode_PROCESSING_INSTRUCTION_NODE
    COMMENT_NODE = _cp4vasp.ODPNode_COMMENT_NODE
    DOCUMENT_NODE = _cp4vasp.ODPNode_DOCUMENT_NODE
    DOCUMENT_TYPE_NODE = _cp4vasp.ODPNode_DOCUMENT_TYPE_NODE
    DOCUMENT_FRAGMENT_NODE = _cp4vasp.ODPNode_DOCUMENT_FRAGMENT_NODE
    NOTATION_NODE = _cp4vasp.ODPNode_NOTATION_NODE

    def getNodeName(self):
        return _cp4vasp.ODPNode_getNodeName(self)

    def getNodeValue(self):
        return _cp4vasp.ODPNode_getNodeValue(self)

    def setNodeValue(self, v):
        return _cp4vasp.ODPNode_setNodeValue(self, v)

    def getNodeType(self):
        return _cp4vasp.ODPNode_getNodeType(self)

    def getParentNode(self):
        return _cp4vasp.ODPNode_getParentNode(self)

    def getChildNodes(self):
        return _cp4vasp.ODPNode_getChildNodes(self)

    def getFirstChild(self):
        return _cp4vasp.ODPNode_getFirstChild(self)

    def getLastChild(self):
        return _cp4vasp.ODPNode_getLastChild(self)

    def getPreviousSibling(self):
        return _cp4vasp.ODPNode_getPreviousSibling(self)

    def getNextSibling(self):
        return _cp4vasp.ODPNode_getNextSibling(self)

    def getAttributes(self):
        return _cp4vasp.ODPNode_getAttributes(self)

    def getOwnerDocument(self):
        return _cp4vasp.ODPNode_getOwnerDocument(self)

    def hasChildNodes(self):
        return _cp4vasp.ODPNode_hasChildNodes(self)

    def up(self):
        return _cp4vasp.ODPNode_up(self)

    def down(self):
        return _cp4vasp.ODPNode_down(self)

    def next(self):
        return _cp4vasp.ODPNode_next(self)

    def previous(self):
        return _cp4vasp.ODPNode_previous(self)

    def poschar(self):
        return _cp4vasp.ODPNode_poschar(self)
    __swig_destroy__ = _cp4vasp.delete_ODPNode
    __del__ = lambda self: None
ODPNode_swigregister = _cp4vasp.ODPNode_swigregister
ODPNode_swigregister(ODPNode)

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

    def hasFeature(self, feature, version):
        return _cp4vasp.ODPDOMImplementation_hasFeature(self, feature, version)

    def __init__(self):
        this = _cp4vasp.new_ODPDOMImplementation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ODPDOMImplementation
    __del__ = lambda self: None
ODPDOMImplementation_swigregister = _cp4vasp.ODPDOMImplementation_swigregister
ODPDOMImplementation_swigregister(ODPDOMImplementation)

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

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

    def getDoctype(self):
        return _cp4vasp.ODPDocument_getDoctype(self)

    def getImplementation(self):
        return _cp4vasp.ODPDocument_getImplementation(self)

    def getDocumentElement(self):
        return _cp4vasp.ODPDocument_getDocumentElement(self)

    def createElement(self, tagName):
        return _cp4vasp.ODPDocument_createElement(self, tagName)

    def createDocumentFragment(self):
        return _cp4vasp.ODPDocument_createDocumentFragment(self)

    def createTextNode(self, data):
        return _cp4vasp.ODPDocument_createTextNode(self, data)

    def createComment(self, data):
        return _cp4vasp.ODPDocument_createComment(self, data)

    def createCDATASection(self, data):
        return _cp4vasp.ODPDocument_createCDATASection(self, data)

    def createProcessingInstruction(self, target, data):
        return _cp4vasp.ODPDocument_createProcessingInstruction(self, target, data)

    def createAttribute(self, name):
        return _cp4vasp.ODPDocument_createAttribute(self, name)

    def createEntityReference(self, name):
        return _cp4vasp.ODPDocument_createEntityReference(self, name)

    def getElementsByTagName(self, tagname):
        return _cp4vasp.ODPDocument_getElementsByTagName(self, tagname)
    __swig_destroy__ = _cp4vasp.delete_ODPDocument
    __del__ = lambda self: None
ODPDocument_swigregister = _cp4vasp.ODPDocument_swigregister
ODPDocument_swigregister(ODPDocument)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _cp4vasp.delete_ODPDocumentParent
    __del__ = lambda self: None
ODPDocumentParent_swigregister = _cp4vasp.ODPDocumentParent_swigregister
ODPDocumentParent_swigregister(ODPDocumentParent)

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

    def __init__(self, node):
        this = _cp4vasp.new_ODPElement(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getTagName(self):
        return _cp4vasp.ODPElement_getTagName(self)

    def getAttribute(self, name):
        return _cp4vasp.ODPElement_getAttribute(self, name)

    def setAttribute(self, name, value):
        return _cp4vasp.ODPElement_setAttribute(self, name, value)

    def removeAttribute(self, name):
        return _cp4vasp.ODPElement_removeAttribute(self, name)

    def getAttributeNode(self, name):
        return _cp4vasp.ODPElement_getAttributeNode(self, name)

    def setAttributeNode(self, newAttr):
        return _cp4vasp.ODPElement_setAttributeNode(self, newAttr)

    def removeAttributeNode(self, oldAttr):
        return _cp4vasp.ODPElement_removeAttributeNode(self, oldAttr)

    def getElementsByTagName(self, name):
        return _cp4vasp.ODPElement_getElementsByTagName(self, name)

    def normalize(self):
        return _cp4vasp.ODPElement_normalize(self)

    def refreshAttr(self):
        return _cp4vasp.ODPElement_refreshAttr(self)
    __swig_destroy__ = _cp4vasp.delete_ODPElement
    __del__ = lambda self: None
ODPElement_swigregister = _cp4vasp.ODPElement_swigregister
ODPElement_swigregister(ODPElement)

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

    def getData(self):
        return _cp4vasp.ODPCharacterData_getData(self)

    def setData(self, s):
        return _cp4vasp.ODPCharacterData_setData(self, s)

    def __init__(self, node):
        this = _cp4vasp.new_ODPCharacterData(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getLength(self):
        return _cp4vasp.ODPCharacterData_getLength(self)

    def substringData(self, offset, count):
        return _cp4vasp.ODPCharacterData_substringData(self, offset, count)

    def appendData(self, arg):
        return _cp4vasp.ODPCharacterData_appendData(self, arg)

    def insertData(self, offset, arg):
        return _cp4vasp.ODPCharacterData_insertData(self, offset, arg)

    def deleteData(self, offset, count):
        return _cp4vasp.ODPCharacterData_deleteData(self, offset, count)

    def replaceData(self, offset, count, arg):
        return _cp4vasp.ODPCharacterData_replaceData(self, offset, count, arg)
    __swig_destroy__ = _cp4vasp.delete_ODPCharacterData
    __del__ = lambda self: None
ODPCharacterData_swigregister = _cp4vasp.ODPCharacterData_swigregister
ODPCharacterData_swigregister(ODPCharacterData)

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

    def __init__(self, node):
        this = _cp4vasp.new_ODPText(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def splitText(self, offset):
        return _cp4vasp.ODPText_splitText(self, offset)
    __swig_destroy__ = _cp4vasp.delete_ODPText
    __del__ = lambda self: None
ODPText_swigregister = _cp4vasp.ODPText_swigregister
ODPText_swigregister(ODPText)

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

    def __init__(self, node):
        this = _cp4vasp.new_ODPComment(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ODPComment
    __del__ = lambda self: None
ODPComment_swigregister = _cp4vasp.ODPComment_swigregister
ODPComment_swigregister(ODPComment)

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

    def __init__(self, node):
        this = _cp4vasp.new_ODPCDATASection(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ODPCDATASection
    __del__ = lambda self: None
ODPCDATASection_swigregister = _cp4vasp.ODPCDATASection_swigregister
ODPCDATASection_swigregister(ODPCDATASection)

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

    def item(self, index):
        return _cp4vasp.ODPNodeList_item(self, index)

    def getLength(self):
        return _cp4vasp.ODPNodeList_getLength(self)

    def __init__(self):
        this = _cp4vasp.new_ODPNodeList()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ODPNodeList
    __del__ = lambda self: None
ODPNodeList_swigregister = _cp4vasp.ODPNodeList_swigregister
ODPNodeList_swigregister(ODPNodeList)

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

    def __init__(self, node):
        this = _cp4vasp.new_ODPChildList(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def item(self, index):
        return _cp4vasp.ODPChildList_item(self, index)

    def getLength(self):
        return _cp4vasp.ODPChildList_getLength(self)
    __swig_destroy__ = _cp4vasp.delete_ODPChildList
    __del__ = lambda self: None
ODPChildList_swigregister = _cp4vasp.ODPChildList_swigregister
ODPChildList_swigregister(ODPChildList)

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

    def __init__(self, node, tag):
        this = _cp4vasp.new_ODPElementsByTagNameList(node, tag)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ODPElementsByTagNameList
    __del__ = lambda self: None

    def item(self, index):
        return _cp4vasp.ODPElementsByTagNameList_item(self, index)

    def getLength(self):
        return _cp4vasp.ODPElementsByTagNameList_getLength(self)
ODPElementsByTagNameList_swigregister = _cp4vasp.ODPElementsByTagNameList_swigregister
ODPElementsByTagNameList_swigregister(ODPElementsByTagNameList)

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

    def __init__(self, node, tag):
        this = _cp4vasp.new_ODPChildrenByTagNameList(node, tag)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ODPChildrenByTagNameList
    __del__ = lambda self: None

    def item(self, index):
        return _cp4vasp.ODPChildrenByTagNameList_item(self, index)

    def getLength(self):
        return _cp4vasp.ODPChildrenByTagNameList_getLength(self)
ODPChildrenByTagNameList_swigregister = _cp4vasp.ODPChildrenByTagNameList_swigregister
ODPChildrenByTagNameList_swigregister(ODPChildrenByTagNameList)

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

    def getNamedItem(self, name):
        return _cp4vasp.ODPNamedNodeMap_getNamedItem(self, name)

    def setNamedItem(self, arg):
        return _cp4vasp.ODPNamedNodeMap_setNamedItem(self, arg)

    def removeNamedItem(self, name):
        return _cp4vasp.ODPNamedNodeMap_removeNamedItem(self, name)

    def item(self, index):
        return _cp4vasp.ODPNamedNodeMap_item(self, index)

    def getLength(self):
        return _cp4vasp.ODPNamedNodeMap_getLength(self)

    def __init__(self):
        this = _cp4vasp.new_ODPNamedNodeMap()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cp4vasp.delete_ODPNamedNodeMap
    __del__ = lambda self: None
ODPNamedNodeMap_swigregister = _cp4vasp.ODPNamedNodeMap_swigregister
ODPNamedNodeMap_swigregister(ODPNamedNodeMap)

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

    def __init__(self, node):
        this = _cp4vasp.new_ODPAttributeMap(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setNode(self, node):
        return _cp4vasp.ODPAttributeMap_setNode(self, node)

    def getAttribute(self, name):
        return _cp4vasp.ODPAttributeMap_getAttribute(self, name)

    def getNamedItem(self, name):
        return _cp4vasp.ODPAttributeMap_getNamedItem(self, name)

    def item(self, index):
        return _cp4vasp.ODPAttributeMap_item(self, index)

    def getLength(self):
        return _cp4vasp.ODPAttributeMap_getLength(self)
    __swig_destroy__ = _cp4vasp.delete_ODPAttributeMap
    __del__ = lambda self: None
ODPAttributeMap_swigregister = _cp4vasp.ODPAttributeMap_swigregister
ODPAttributeMap_swigregister(ODPAttributeMap)

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

    def __init__(self, node):
        this = _cp4vasp.new_ODPAttr(node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getName(self):
        return _cp4vasp.ODPAttr_getName(self)

    def getSpecified(self):
        return _cp4vasp.ODPAttr_getSpecified(self)

    def getValue(self):
        return _cp4vasp.ODPAttr_getValue(self)

    def setValue(self, s):
        return _cp4vasp.ODPAttr_setValue(self, s)
    __swig_destroy__ = _cp4vasp.delete_ODPAttr
    __del__ = lambda self: None
ODPAttr_swigregister = _cp4vasp.ODPAttr_swigregister
ODPAttr_swigregister(ODPAttr)