# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.39
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_libMEDClient', [dirname(__file__)])
        except ImportError:
            import _libMEDClient
            return _libMEDClient
        if fp is not None:
            try:
                _mod = imp.load_module('_libMEDClient', fp, pathname, description)
            finally:
                fp.close()
                return _mod
    _libMEDClient = swig_import_helper()
    del swig_import_helper
else:
    import _libMEDClient
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

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


MED_CARTESIAN = _libMEDClient.MED_CARTESIAN
MED_POLAR = _libMEDClient.MED_POLAR
MED_BODY_FITTED = _libMEDClient.MED_BODY_FITTED
MED_FULL_INTERLACE = _libMEDClient.MED_FULL_INTERLACE
MED_NO_INTERLACE = _libMEDClient.MED_NO_INTERLACE
RDONLY = _libMEDClient.RDONLY
WRONLY = _libMEDClient.WRONLY
RDWR = _libMEDClient.RDWR
MED_LECT = _libMEDClient.MED_LECT
MED_ECRI = _libMEDClient.MED_ECRI
MED_REMP = _libMEDClient.MED_REMP
ASCENDING = _libMEDClient.ASCENDING
DESCENDING = _libMEDClient.DESCENDING
MED_CELL = _libMEDClient.MED_CELL
MED_FACE = _libMEDClient.MED_FACE
MED_EDGE = _libMEDClient.MED_EDGE
MED_NODE = _libMEDClient.MED_NODE
MED_ALL_ENTITIES = _libMEDClient.MED_ALL_ENTITIES
MED_NONE = _libMEDClient.MED_NONE
MED_POINT1 = _libMEDClient.MED_POINT1
MED_SEG2 = _libMEDClient.MED_SEG2
MED_SEG3 = _libMEDClient.MED_SEG3
MED_TRIA3 = _libMEDClient.MED_TRIA3
MED_QUAD4 = _libMEDClient.MED_QUAD4
MED_TRIA6 = _libMEDClient.MED_TRIA6
MED_QUAD8 = _libMEDClient.MED_QUAD8
MED_TETRA4 = _libMEDClient.MED_TETRA4
MED_PYRA5 = _libMEDClient.MED_PYRA5
MED_PENTA6 = _libMEDClient.MED_PENTA6
MED_HEXA8 = _libMEDClient.MED_HEXA8
MED_TETRA10 = _libMEDClient.MED_TETRA10
MED_PYRA13 = _libMEDClient.MED_PYRA13
MED_PENTA15 = _libMEDClient.MED_PENTA15
MED_HEXA20 = _libMEDClient.MED_HEXA20
MED_POLYGON = _libMEDClient.MED_POLYGON
MED_POLYHEDRA = _libMEDClient.MED_POLYHEDRA
MED_ALL_ELEMENTS = _libMEDClient.MED_ALL_ELEMENTS
MED_NODAL = _libMEDClient.MED_NODAL
MED_DESCENDING = _libMEDClient.MED_DESCENDING
MED_DRIVER = _libMEDClient.MED_DRIVER
GIBI_DRIVER = _libMEDClient.GIBI_DRIVER
PORFLOW_DRIVER = _libMEDClient.PORFLOW_DRIVER
VTK_DRIVER = _libMEDClient.VTK_DRIVER
NO_DRIVER = _libMEDClient.NO_DRIVER
ASCII_DRIVER = _libMEDClient.ASCII_DRIVER
ENSIGHT_DRIVER = _libMEDClient.ENSIGHT_DRIVER
MED_REEL64 = _libMEDClient.MED_REEL64
MED_INT32 = _libMEDClient.MED_INT32
MED_INT64 = _libMEDClient.MED_INT64
class DT_IT_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DT_IT_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DT_IT_, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dt"] = _libMEDClient.DT_IT__dt_set
    __swig_getmethods__["dt"] = _libMEDClient.DT_IT__dt_get
    if _newclass:dt = _swig_property(_libMEDClient.DT_IT__dt_get, _libMEDClient.DT_IT__dt_set)
    __swig_setmethods__["it"] = _libMEDClient.DT_IT__it_set
    __swig_getmethods__["it"] = _libMEDClient.DT_IT__it_get
    if _newclass:it = _swig_property(_libMEDClient.DT_IT__it_get, _libMEDClient.DT_IT__it_set)
    def getdt(self): return _libMEDClient.DT_IT__getdt(self)
    def getit(self): return _libMEDClient.DT_IT__getit(self)
    def __init__(self): 
        this = _libMEDClient.new_DT_IT_()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDClient.delete_DT_IT_
    __del__ = lambda self : None;
DT_IT__swigregister = _libMEDClient.DT_IT__swigregister
DT_IT__swigregister(DT_IT_)

V21 = _libMEDClient.V21
V22 = _libMEDClient.V22

def getMedFileVersionForWriting():
  return _libMEDClient.getMedFileVersionForWriting()
getMedFileVersionForWriting = _libMEDClient.getMedFileVersionForWriting

def setMedFileVersionForWriting(*args):
  return _libMEDClient.setMedFileVersionForWriting(*args)
setMedFileVersionForWriting = _libMEDClient.setMedFileVersionForWriting
class CELLMODEL(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CELLMODEL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CELLMODEL, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_CELLMODEL(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfVertexes(self): return _libMEDClient.CELLMODEL_getNumberOfVertexes(self)
    def getNumberOfNodes(self): return _libMEDClient.CELLMODEL_getNumberOfNodes(self)
    def getDimension(self): return _libMEDClient.CELLMODEL_getDimension(self)
    def getType(self): return _libMEDClient.CELLMODEL_getType(self)
    def getNumberOfConstituents(self, *args): return _libMEDClient.CELLMODEL_getNumberOfConstituents(self, *args)
    def getNodeConstituent(self, *args): return _libMEDClient.CELLMODEL_getNodeConstituent(self, *args)
    def getConstituentType(self, *args): return _libMEDClient.CELLMODEL_getConstituentType(self, *args)
    def getNumberOfConstituentsType(self): return _libMEDClient.CELLMODEL_getNumberOfConstituentsType(self)
    def getName(self): return _libMEDClient.CELLMODEL_getName(self)
    __swig_destroy__ = _libMEDClient.delete_CELLMODEL
    __del__ = lambda self : None;
    def __str__(self): return _libMEDClient.CELLMODEL___str__(self)
CELLMODEL_swigregister = _libMEDClient.CELLMODEL_swigregister
CELLMODEL_swigregister(CELLMODEL)

class SUPPORT(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SUPPORT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SUPPORT, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_SUPPORT
    __del__ = lambda self : None;
    def update(self): return _libMEDClient.SUPPORT_update(self)
    def getMesh(self): return _libMEDClient.SUPPORT_getMesh(self)
    def getMeshName(self): return _libMEDClient.SUPPORT_getMeshName(self)
    def setMesh(self, *args): return _libMEDClient.SUPPORT_setMesh(self, *args)
    def getEntity(self): return _libMEDClient.SUPPORT_getEntity(self)
    def setEntity(self, *args): return _libMEDClient.SUPPORT_setEntity(self, *args)
    def isOnAllElements(self): return _libMEDClient.SUPPORT_isOnAllElements(self)
    def setAll(self, *args): return _libMEDClient.SUPPORT_setAll(self, *args)
    def getNumberOfTypes(self): return _libMEDClient.SUPPORT_getNumberOfTypes(self)
    def setNumberOfGeometricType(self, *args): return _libMEDClient.SUPPORT_setNumberOfGeometricType(self, *args)
    def getNumberOfElements(self, *args): return _libMEDClient.SUPPORT_getNumberOfElements(self, *args)
    def setGeometricType(self, *args): return _libMEDClient.SUPPORT_setGeometricType(self, *args)
    def setNumberOfElements(self, *args): return _libMEDClient.SUPPORT_setNumberOfElements(self, *args)
    def setNumber(self, *args): return _libMEDClient.SUPPORT_setNumber(self, *args)
    def deepCompare(self, *args): return _libMEDClient.SUPPORT_deepCompare(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_SUPPORT(*args)
        try: self.this.append(this)
        except: self.this = this
    def setpartial(self, *args): return _libMEDClient.SUPPORT_setpartial(self, *args)
    def getName(self): return _libMEDClient.SUPPORT_getName(self)
    def setName(self, *args): return _libMEDClient.SUPPORT_setName(self, *args)
    def getDescription(self): return _libMEDClient.SUPPORT_getDescription(self)
    def setDescription(self, *args): return _libMEDClient.SUPPORT_setDescription(self, *args)
    def makeMesh(self): return _libMEDClient.SUPPORT_makeMesh(self)
    def __str__(self): return _libMEDClient.SUPPORT___str__(self)
    def getTypes(self): return _libMEDClient.SUPPORT_getTypes(self)
    def getNumber(self, *args): return _libMEDClient.SUPPORT_getNumber(self, *args)
    def getNumberIndex(self): return _libMEDClient.SUPPORT_getNumberIndex(self)
    def getComplement(self): return _libMEDClient.SUPPORT_getComplement(self)
    def substract(self, *args): return _libMEDClient.SUPPORT_substract(self, *args)
    def getBoundaryElements(self, *args): return _libMEDClient.SUPPORT_getBoundaryElements(self, *args)
SUPPORT_swigregister = _libMEDClient.SUPPORT_swigregister
SUPPORT_swigregister(SUPPORT)

class FAMILY(SUPPORT):
    __swig_setmethods__ = {}
    for _s in [SUPPORT]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FAMILY, name, value)
    __swig_getmethods__ = {}
    for _s in [SUPPORT]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FAMILY, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FAMILY
    __del__ = lambda self : None;
    def assign(self, *args): return _libMEDClient.FAMILY_assign(self, *args)
    def setIdentifier(self, *args): return _libMEDClient.FAMILY_setIdentifier(self, *args)
    def setNumberOfAttributes(self, *args): return _libMEDClient.FAMILY_setNumberOfAttributes(self, *args)
    def setAttributesIdentifiers(self, *args): return _libMEDClient.FAMILY_setAttributesIdentifiers(self, *args)
    def setAttributesValues(self, *args): return _libMEDClient.FAMILY_setAttributesValues(self, *args)
    def setAttributesDescriptions(self, *args): return _libMEDClient.FAMILY_setAttributesDescriptions(self, *args)
    def setNumberOfGroups(self, *args): return _libMEDClient.FAMILY_setNumberOfGroups(self, *args)
    def setGroupsNames(self, *args): return _libMEDClient.FAMILY_setGroupsNames(self, *args)
    def getIdentifier(self): return _libMEDClient.FAMILY_getIdentifier(self)
    def getNumberOfAttributes(self): return _libMEDClient.FAMILY_getNumberOfAttributes(self)
    def getNumberOfGroups(self): return _libMEDClient.FAMILY_getNumberOfGroups(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_FAMILY(*args)
        try: self.this.append(this)
        except: self.this = this
    def getAttributeDescription(self, *args): return _libMEDClient.FAMILY_getAttributeDescription(self, *args)
    def getGroupName(self, *args): return _libMEDClient.FAMILY_getGroupName(self, *args)
    def __str__(self): return _libMEDClient.FAMILY___str__(self)
    def getAttributesIdentifiers(self): return _libMEDClient.FAMILY_getAttributesIdentifiers(self)
    def getAttributesValues(self): return _libMEDClient.FAMILY_getAttributesValues(self)
FAMILY_swigregister = _libMEDClient.FAMILY_swigregister
FAMILY_swigregister(FAMILY)

class FIELD_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELD_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FIELD_, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELD_(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDClient.delete_FIELD_
    __del__ = lambda self : None;
    def rmDriver(self, index = 0): return _libMEDClient.FIELD__rmDriver(self, index)
    def setIterationNumber(self, *args): return _libMEDClient.FIELD__setIterationNumber(self, *args)
    def getIterationNumber(self): return _libMEDClient.FIELD__getIterationNumber(self)
    def setTime(self, *args): return _libMEDClient.FIELD__setTime(self, *args)
    def getTime(self): return _libMEDClient.FIELD__getTime(self)
    def setOrderNumber(self, *args): return _libMEDClient.FIELD__setOrderNumber(self, *args)
    def getOrderNumber(self): return _libMEDClient.FIELD__getOrderNumber(self)
    def getValueType(self): return _libMEDClient.FIELD__getValueType(self)
    def getInterlacingType(self): return _libMEDClient.FIELD__getInterlacingType(self)
    def getSupport(self): return _libMEDClient.FIELD__getSupport(self)
    def setSupport(self, *args): return _libMEDClient.FIELD__setSupport(self, *args)
    def setNumberOfComponents(self, *args): return _libMEDClient.FIELD__setNumberOfComponents(self, *args)
    def getNumberOfComponents(self): return _libMEDClient.FIELD__getNumberOfComponents(self)
    def setNumberOfValues(self, *args): return _libMEDClient.FIELD__setNumberOfValues(self, *args)
    def getNumberOfValues(self): return _libMEDClient.FIELD__getNumberOfValues(self)
    def getName(self): return _libMEDClient.FIELD__getName(self)
    def getDescription(self): return _libMEDClient.FIELD__getDescription(self)
    def getComponentName(self, *args): return _libMEDClient.FIELD__getComponentName(self, *args)
    def getComponentDescription(self, *args): return _libMEDClient.FIELD__getComponentDescription(self, *args)
    def getMEDComponentUnit(self, *args): return _libMEDClient.FIELD__getMEDComponentUnit(self, *args)
    def setName(self, *args): return _libMEDClient.FIELD__setName(self, *args)
    def setComponentName(self, *args): return _libMEDClient.FIELD__setComponentName(self, *args)
    def setMEDComponentUnit(self, *args): return _libMEDClient.FIELD__setMEDComponentUnit(self, *args)
    def setDescription(self, *args): return _libMEDClient.FIELD__setDescription(self, *args)
    def setComponentDescription(self, *args): return _libMEDClient.FIELD__setComponentDescription(self, *args)
    def addDriver(self, *args): return _libMEDClient.FIELD__addDriver(self, *args)
    def getSupportAndOwner(self): return _libMEDClient.FIELD__getSupportAndOwner(self)
FIELD__swigregister = _libMEDClient.FIELD__swigregister
FIELD__swigregister(FIELD_)

class FIELDDOUBLE(FIELD_):
    __swig_setmethods__ = {}
    for _s in [FIELD_]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDDOUBLE, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELD_]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDDOUBLE, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDDOUBLE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDClient.FIELDDOUBLE_read(self, index)
    def getValueIJ(self, *args): return _libMEDClient.FIELDDOUBLE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDClient.FIELDDOUBLE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDClient.FIELDDOUBLE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDClient.FIELDDOUBLE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDClient.FIELDDOUBLE_setValue(self, *args)
    def setRow(self, *args): return _libMEDClient.FIELDDOUBLE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDClient.FIELDDOUBLE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDClient.FIELDDOUBLE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDClient.FIELDDOUBLE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDClient.FIELDDOUBLE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDClient.FIELDDOUBLE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDClient.FIELDDOUBLE_allocValue(self, *args)
    def deallocValue(self): return _libMEDClient.FIELDDOUBLE_deallocValue(self)
    def applyLin(self, *args): return _libMEDClient.FIELDDOUBLE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDClient.FIELDDOUBLE_applyPow(self, *args)
    def normMax(self): return _libMEDClient.FIELDDOUBLE_normMax(self)
    def norm2(self): return _libMEDClient.FIELDDOUBLE_norm2(self)
    def normL2(self, *args): return _libMEDClient.FIELDDOUBLE_normL2(self, *args)
    def normL1(self, *args): return _libMEDClient.FIELDDOUBLE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDClient.FIELDDOUBLE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDClient.FIELDDOUBLE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDClient.FIELDDOUBLE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDClient.FIELDDOUBLE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDClient.FIELDDOUBLE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDDOUBLE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDClient.FIELDDOUBLE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDClient.FIELDDOUBLE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDClient.FIELDDOUBLE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDClient.FIELDDOUBLE___add__(self, *args)
    def __sub__(self, *args): return _libMEDClient.FIELDDOUBLE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDClient.FIELDDOUBLE___mul__(self, *args)
    def __div__(self, *args): return _libMEDClient.FIELDDOUBLE___div__(self, *args)
    def addDeep(self, *args): return _libMEDClient.FIELDDOUBLE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDClient.FIELDDOUBLE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDClient.FIELDDOUBLE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDClient.FIELDDOUBLE_divDeep(self, *args)
    def getValue(self): return _libMEDClient.FIELDDOUBLE_getValue(self)
    def getValueByType(self, *args): return _libMEDClient.FIELDDOUBLE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDClient.FIELDDOUBLE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDClient.FIELDDOUBLE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDClient.FIELDDOUBLE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDClient.FIELDDOUBLE_extract(self, *args)
FIELDDOUBLE_swigregister = _libMEDClient.FIELDDOUBLE_swigregister
FIELDDOUBLE_swigregister(FIELDDOUBLE)

class FIELDDOUBLENOINTERLACE(FIELD_):
    __swig_setmethods__ = {}
    for _s in [FIELD_]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDDOUBLENOINTERLACE, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELD_]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDDOUBLENOINTERLACE, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDDOUBLENOINTERLACE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDClient.FIELDDOUBLENOINTERLACE_read(self, index)
    def getValueIJ(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_setValue(self, *args)
    def setRow(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_allocValue(self, *args)
    def deallocValue(self): return _libMEDClient.FIELDDOUBLENOINTERLACE_deallocValue(self)
    def applyLin(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_applyPow(self, *args)
    def normMax(self): return _libMEDClient.FIELDDOUBLENOINTERLACE_normMax(self)
    def norm2(self): return _libMEDClient.FIELDDOUBLENOINTERLACE_norm2(self)
    def normL2(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_normL2(self, *args)
    def normL1(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDClient.FIELDDOUBLENOINTERLACE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDClient.FIELDDOUBLENOINTERLACE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDClient.FIELDDOUBLENOINTERLACE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDDOUBLENOINTERLACE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDClient.FIELDDOUBLENOINTERLACE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE___add__(self, *args)
    def __sub__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE___mul__(self, *args)
    def __div__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE___div__(self, *args)
    def addDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_divDeep(self, *args)
    def getValue(self): return _libMEDClient.FIELDDOUBLENOINTERLACE_getValue(self)
    def getValueByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACE_extract(self, *args)
FIELDDOUBLENOINTERLACE_swigregister = _libMEDClient.FIELDDOUBLENOINTERLACE_swigregister
FIELDDOUBLENOINTERLACE_swigregister(FIELDDOUBLENOINTERLACE)

class FIELDDOUBLENOINTERLACEBYTYPE(FIELD_):
    __swig_setmethods__ = {}
    for _s in [FIELD_]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDDOUBLENOINTERLACEBYTYPE, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELD_]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDDOUBLENOINTERLACEBYTYPE, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDDOUBLENOINTERLACEBYTYPE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_read(self, index)
    def getValueIJ(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_setValue(self, *args)
    def setRow(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_allocValue(self, *args)
    def deallocValue(self): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_deallocValue(self)
    def applyLin(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_applyPow(self, *args)
    def normMax(self): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_normMax(self)
    def norm2(self): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_norm2(self)
    def normL2(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_normL2(self, *args)
    def normL1(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDDOUBLENOINTERLACEBYTYPE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE___add__(self, *args)
    def __sub__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE___mul__(self, *args)
    def __div__(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE___div__(self, *args)
    def addDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_divDeep(self, *args)
    def getValue(self): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getValue(self)
    def getValueByType(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_extract(self, *args)
FIELDDOUBLENOINTERLACEBYTYPE_swigregister = _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPE_swigregister
FIELDDOUBLENOINTERLACEBYTYPE_swigregister(FIELDDOUBLENOINTERLACEBYTYPE)

class FIELDINT(FIELD_):
    __swig_setmethods__ = {}
    for _s in [FIELD_]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDINT, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELD_]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDINT, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDINT
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDClient.FIELDINT_read(self, index)
    def getValueIJ(self, *args): return _libMEDClient.FIELDINT_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDClient.FIELDINT_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDClient.FIELDINT_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDClient.FIELDINT_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDClient.FIELDINT_setValue(self, *args)
    def setRow(self, *args): return _libMEDClient.FIELDINT_setRow(self, *args)
    def setColumn(self, *args): return _libMEDClient.FIELDINT_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDClient.FIELDINT_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDClient.FIELDINT_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDClient.FIELDINT_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDClient.FIELDINT_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDClient.FIELDINT_allocValue(self, *args)
    def deallocValue(self): return _libMEDClient.FIELDINT_deallocValue(self)
    def applyLin(self, *args): return _libMEDClient.FIELDINT_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDClient.FIELDINT_applyPow(self, *args)
    def normMax(self): return _libMEDClient.FIELDINT_normMax(self)
    def norm2(self): return _libMEDClient.FIELDINT_norm2(self)
    def normL2(self, *args): return _libMEDClient.FIELDINT_normL2(self, *args)
    def normL1(self, *args): return _libMEDClient.FIELDINT_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDClient.FIELDINT_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDClient.FIELDINT_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDClient.FIELDINT_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDClient.FIELDINT_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDClient.FIELDINT_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDINT(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDClient.FIELDINT_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDClient.FIELDINT_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDClient.FIELDINT_execFunc(self, *args)
    def __add__(self, *args): return _libMEDClient.FIELDINT___add__(self, *args)
    def __sub__(self, *args): return _libMEDClient.FIELDINT___sub__(self, *args)
    def __mul__(self, *args): return _libMEDClient.FIELDINT___mul__(self, *args)
    def __div__(self, *args): return _libMEDClient.FIELDINT___div__(self, *args)
    def addDeep(self, *args): return _libMEDClient.FIELDINT_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDClient.FIELDINT_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDClient.FIELDINT_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDClient.FIELDINT_divDeep(self, *args)
    def getValue(self): return _libMEDClient.FIELDINT_getValue(self)
    def getValueByType(self, *args): return _libMEDClient.FIELDINT_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDClient.FIELDINT_getRow(self, *args)
    def getColumn(self, *args): return _libMEDClient.FIELDINT_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDClient.FIELDINT_allocValue2(self, *args)
    def extract(self, *args): return _libMEDClient.FIELDINT_extract(self, *args)
FIELDINT_swigregister = _libMEDClient.FIELDINT_swigregister
FIELDINT_swigregister(FIELDINT)

class FIELDINTNOINTERLACE(FIELD_):
    __swig_setmethods__ = {}
    for _s in [FIELD_]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDINTNOINTERLACE, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELD_]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDINTNOINTERLACE, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDINTNOINTERLACE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDClient.FIELDINTNOINTERLACE_read(self, index)
    def getValueIJ(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_setValue(self, *args)
    def setRow(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_allocValue(self, *args)
    def deallocValue(self): return _libMEDClient.FIELDINTNOINTERLACE_deallocValue(self)
    def applyLin(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_applyPow(self, *args)
    def normMax(self): return _libMEDClient.FIELDINTNOINTERLACE_normMax(self)
    def norm2(self): return _libMEDClient.FIELDINTNOINTERLACE_norm2(self)
    def normL2(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_normL2(self, *args)
    def normL1(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDClient.FIELDINTNOINTERLACE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDClient.FIELDINTNOINTERLACE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDClient.FIELDINTNOINTERLACE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDINTNOINTERLACE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDClient.FIELDINTNOINTERLACE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDClient.FIELDINTNOINTERLACE___add__(self, *args)
    def __sub__(self, *args): return _libMEDClient.FIELDINTNOINTERLACE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDClient.FIELDINTNOINTERLACE___mul__(self, *args)
    def __div__(self, *args): return _libMEDClient.FIELDINTNOINTERLACE___div__(self, *args)
    def addDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_divDeep(self, *args)
    def getValue(self): return _libMEDClient.FIELDINTNOINTERLACE_getValue(self)
    def getValueByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDClient.FIELDINTNOINTERLACE_extract(self, *args)
FIELDINTNOINTERLACE_swigregister = _libMEDClient.FIELDINTNOINTERLACE_swigregister
FIELDINTNOINTERLACE_swigregister(FIELDINTNOINTERLACE)

class FIELDINTNOINTERLACEBYTYPE(FIELD_):
    __swig_setmethods__ = {}
    for _s in [FIELD_]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDINTNOINTERLACEBYTYPE, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELD_]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDINTNOINTERLACEBYTYPE, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDINTNOINTERLACEBYTYPE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_read(self, index)
    def getValueIJ(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_setValue(self, *args)
    def setRow(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_allocValue(self, *args)
    def deallocValue(self): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_deallocValue(self)
    def applyLin(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_applyPow(self, *args)
    def normMax(self): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_normMax(self)
    def norm2(self): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_norm2(self)
    def normL2(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_normL2(self, *args)
    def normL1(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDINTNOINTERLACEBYTYPE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE___add__(self, *args)
    def __sub__(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE___mul__(self, *args)
    def __div__(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE___div__(self, *args)
    def addDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_divDeep(self, *args)
    def getValue(self): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getValue(self)
    def getValueByType(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDClient.FIELDINTNOINTERLACEBYTYPE_extract(self, *args)
FIELDINTNOINTERLACEBYTYPE_swigregister = _libMEDClient.FIELDINTNOINTERLACEBYTYPE_swigregister
FIELDINTNOINTERLACEBYTYPE_swigregister(FIELDINTNOINTERLACEBYTYPE)

class GROUP(SUPPORT):
    __swig_setmethods__ = {}
    for _s in [SUPPORT]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GROUP, name, value)
    __swig_getmethods__ = {}
    for _s in [SUPPORT]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GROUP, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _libMEDClient.new_GROUP()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDClient.delete_GROUP
    __del__ = lambda self : None;
    def setNumberOfFamilies(self, *args): return _libMEDClient.GROUP_setNumberOfFamilies(self, *args)
    def setFamilies(self, *args): return _libMEDClient.GROUP_setFamilies(self, *args)
    def getNumberOfFamilies(self): return _libMEDClient.GROUP_getNumberOfFamilies(self)
    def getFamilies(self): return _libMEDClient.GROUP_getFamilies(self)
    def getFamily(self, *args): return _libMEDClient.GROUP_getFamily(self, *args)
GROUP_swigregister = _libMEDClient.GROUP_swigregister
GROUP_swigregister(GROUP)

class MESH(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MESH, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MESH, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MESH
    __del__ = lambda self : None;
    def rmDriver(self, index = 0): return _libMEDClient.MESH_rmDriver(self, index)
    def read(self, index = 0): return _libMEDClient.MESH_read(self, index)
    def getSpaceDimension(self): return _libMEDClient.MESH_getSpaceDimension(self)
    def getMeshDimension(self): return _libMEDClient.MESH_getMeshDimension(self)
    def getNumberOfNodes(self): return _libMEDClient.MESH_getNumberOfNodes(self)
    def convertToPoly(self): return _libMEDClient.MESH_convertToPoly(self)
    def getIsAGrid(self): return _libMEDClient.MESH_getIsAGrid(self)
    def getCoordinate(self, *args): return _libMEDClient.MESH_getCoordinate(self, *args)
    def getNumberOfTypes(self, *args): return _libMEDClient.MESH_getNumberOfTypes(self, *args)
    def calculateConnectivity(self, *args): return _libMEDClient.MESH_calculateConnectivity(self, *args)
    def getNumberOfElements(self, *args): return _libMEDClient.MESH_getNumberOfElements(self, *args)
    def getNumberOfFamilies(self, *args): return _libMEDClient.MESH_getNumberOfFamilies(self, *args)
    def getElementNumber(self, *args): return _libMEDClient.MESH_getElementNumber(self, *args)
    def getCellsTypes(self, *args): return _libMEDClient.MESH_getCellsTypes(self, *args)
    def getFamily(self, *args): return _libMEDClient.MESH_getFamily(self, *args)
    def getNumberOfGroups(self, *args): return _libMEDClient.MESH_getNumberOfGroups(self, *args)
    def getGroup(self, *args): return _libMEDClient.MESH_getGroup(self, *args)
    def getElementType(self, *args): return _libMEDClient.MESH_getElementType(self, *args)
    def getElementContainingPoint(self, *args): return _libMEDClient.MESH_getElementContainingPoint(self, *args)
    def getNumberOfTypesWithPoly(self, *args): return _libMEDClient.MESH_getNumberOfTypesWithPoly(self, *args)
    def getNumberOfPolygons(self, *args): return _libMEDClient.MESH_getNumberOfPolygons(self, *args)
    def getNumberOfPolyhedronFaces(self): return _libMEDClient.MESH_getNumberOfPolyhedronFaces(self)
    def getNumberOfPolyhedron(self): return _libMEDClient.MESH_getNumberOfPolyhedron(self)
    def getNumberOfElementsWithPoly(self, *args): return _libMEDClient.MESH_getNumberOfElementsWithPoly(self, *args)
    def existPolygonsConnectivity(self, *args): return _libMEDClient.MESH_existPolygonsConnectivity(self, *args)
    def existPolyhedronConnectivity(self, *args): return _libMEDClient.MESH_existPolyhedronConnectivity(self, *args)
    def getElementTypeWithPoly(self, *args): return _libMEDClient.MESH_getElementTypeWithPoly(self, *args)
    def getSupportOnAll(self, *args): return _libMEDClient.MESH_getSupportOnAll(self, *args)
    def getName(self): return _libMEDClient.MESH_getName(self)
    def getBoundaryElements(self, *args): return _libMEDClient.MESH_getBoundaryElements(self, *args)
    def getSkin(self, *args): return _libMEDClient.MESH_getSkin(self, *args)
    def mergeSupports(self, *args): return _libMEDClient.MESH_mergeSupports(self, *args)
    def intersectSupports(self, *args): return _libMEDClient.MESH_intersectSupports(self, *args)
    def mergeFieldsDouble(self, *args): return _libMEDClient.MESH_mergeFieldsDouble(self, *args)
    def mergeFieldsInt(self, *args): return _libMEDClient.MESH_mergeFieldsInt(self, *args)
    def getCellType(self, *args): return _libMEDClient.MESH_getCellType(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_MESH(*args)
        try: self.this.append(this)
        except: self.this = this
    def addDriver(self, *args): return _libMEDClient.MESH_addDriver(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDClient.MESH_write(self, index, driverName)
    def setName(self, *args): return _libMEDClient.MESH_setName(self, *args)
    def getCoordinatesSystem(self): return _libMEDClient.MESH_getCoordinatesSystem(self)
    def __str__(self): return _libMEDClient.MESH___str__(self)
    def getCoordinateName(self, *args): return _libMEDClient.MESH_getCoordinateName(self, *args)
    def getCoordinateUnit(self, *args): return _libMEDClient.MESH_getCoordinateUnit(self, *args)
    def getCoordinatesNames(self): return _libMEDClient.MESH_getCoordinatesNames(self)
    def getCoordinatesUnits(self): return _libMEDClient.MESH_getCoordinatesUnits(self)
    def getCoordinates(self, *args): return _libMEDClient.MESH_getCoordinates(self, *args)
    def getTypes(self, *args): return _libMEDClient.MESH_getTypes(self, *args)
    def getConnectivity(self, *args): return _libMEDClient.MESH_getConnectivity(self, *args)
    def getConnectivityIndex(self, *args): return _libMEDClient.MESH_getConnectivityIndex(self, *args)
    def getReverseConnectivity(self, *args): return _libMEDClient.MESH_getReverseConnectivity(self, *args)
    def getReverseConnectivityIndex(self, *args): return _libMEDClient.MESH_getReverseConnectivityIndex(self, *args)
    def getGlobalNumberingIndex(self, *args): return _libMEDClient.MESH_getGlobalNumberingIndex(self, *args)
    def getPolygonsConnectivity(self, *args): return _libMEDClient.MESH_getPolygonsConnectivity(self, *args)
    def getPolygonsConnectivityIndex(self, *args): return _libMEDClient.MESH_getPolygonsConnectivityIndex(self, *args)
    def getPolyhedronConnectivity(self, *args): return _libMEDClient.MESH_getPolyhedronConnectivity(self, *args)
    def getPolyhedronIndex(self, *args): return _libMEDClient.MESH_getPolyhedronIndex(self, *args)
    def getPolyhedronFacesIndex(self): return _libMEDClient.MESH_getPolyhedronFacesIndex(self)
    def getTypesWithPoly(self, *args): return _libMEDClient.MESH_getTypesWithPoly(self, *args)
    def getVolume(self, *args): return _libMEDClient.MESH_getVolume(self, *args)
    def getArea(self, *args): return _libMEDClient.MESH_getArea(self, *args)
    def getLength(self, *args): return _libMEDClient.MESH_getLength(self, *args)
    def getNormal(self, *args): return _libMEDClient.MESH_getNormal(self, *args)
    def getBarycenter(self, *args): return _libMEDClient.MESH_getBarycenter(self, *args)
MESH_swigregister = _libMEDClient.MESH_swigregister
MESH_swigregister(MESH)

class MESHING(MESH):
    __swig_setmethods__ = {}
    for _s in [MESH]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MESHING, name, value)
    __swig_getmethods__ = {}
    for _s in [MESH]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MESHING, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _libMEDClient.new_MESHING()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDClient.delete_MESHING
    __del__ = lambda self : None;
    def setSpaceDimension(self, *args): return _libMEDClient.MESHING_setSpaceDimension(self, *args)
    def setMeshDimension(self, *args): return _libMEDClient.MESHING_setMeshDimension(self, *args)
    def setNumberOfNodes(self, *args): return _libMEDClient.MESHING_setNumberOfNodes(self, *args)
    def setNumberOfTypes(self, *args): return _libMEDClient.MESHING_setNumberOfTypes(self, *args)
    def setTypes(self, *args): return _libMEDClient.MESHING_setTypes(self, *args)
    def setNumberOfElements(self, *args): return _libMEDClient.MESHING_setNumberOfElements(self, *args)
    def setConnectivity(self, *args): return _libMEDClient.MESHING_setConnectivity(self, *args)
    def setConnectivities(self, *args): return _libMEDClient.MESHING_setConnectivities(self, *args)
    def addGroup(self, *args): return _libMEDClient.MESHING_addGroup(self, *args)
    def setPolygonsConnectivity(self, *args): return _libMEDClient.MESHING_setPolygonsConnectivity(self, *args)
    def setPolyhedraConnectivity(self, *args): return _libMEDClient.MESHING_setPolyhedraConnectivity(self, *args)
    def setCoordinates(self, *args): return _libMEDClient.MESHING_setCoordinates(self, *args)
    def setCoordinatesSystem(self, *args): return _libMEDClient.MESHING_setCoordinatesSystem(self, *args)
    def setCoordinateName(self, *args): return _libMEDClient.MESHING_setCoordinateName(self, *args)
    def setCoordinateUnit(self, *args): return _libMEDClient.MESHING_setCoordinateUnit(self, *args)
MESHING_swigregister = _libMEDClient.MESHING_swigregister
MESHING_swigregister(MESHING)

class GRID(MESH):
    __swig_setmethods__ = {}
    for _s in [MESH]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GRID, name, value)
    __swig_getmethods__ = {}
    for _s in [MESH]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GRID, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GRID
    __del__ = lambda self : None;
    def getNodeNumber(self, *args): return _libMEDClient.GRID_getNodeNumber(self, *args)
    def getCellNumber(self, *args): return _libMEDClient.GRID_getCellNumber(self, *args)
    def getEdgeNumber(self, *args): return _libMEDClient.GRID_getEdgeNumber(self, *args)
    def getFaceNumber(self, *args): return _libMEDClient.GRID_getFaceNumber(self, *args)
    def getGridType(self): return _libMEDClient.GRID_getGridType(self)
    def getArrayLength(self, *args): return _libMEDClient.GRID_getArrayLength(self, *args)
    def getArrayValue(self, *args): return _libMEDClient.GRID_getArrayValue(self, *args)
    def setGridType(self, *args): return _libMEDClient.GRID_setGridType(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_GRID(*args)
        try: self.this.append(this)
        except: self.this = this
    def getEntityPosition(self, *args): return _libMEDClient.GRID_getEntityPosition(self, *args)
GRID_swigregister = _libMEDClient.GRID_swigregister
GRID_swigregister(GRID)

class PointLocator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointLocator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PointLocator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_PointLocator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDClient.delete_PointLocator
    __del__ = lambda self : None;
    def locate(self, *args): return _libMEDClient.PointLocator_locate(self, *args)
PointLocator_swigregister = _libMEDClient.PointLocator_swigregister
PointLocator_swigregister(PointLocator)

class MED(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED
    __del__ = lambda self : None;
    def rmDriver(self, index = 0): return _libMEDClient.MED_rmDriver(self, index)
    def getNumberOfMeshes(self): return _libMEDClient.MED_getNumberOfMeshes(self)
    def getNumberOfFields(self): return _libMEDClient.MED_getNumberOfFields(self)
    def updateSupport(self): return _libMEDClient.MED_updateSupport(self)
    def write(self, index = 0): return _libMEDClient.MED_write(self, index)
    def read(self, index = 0): return _libMEDClient.MED_read(self, index)
    def readFileStruct(self, index = 0): return _libMEDClient.MED_readFileStruct(self, index)
    def addField(self, *args): return _libMEDClient.MED_addField(self, *args)
    def addMesh(self, *args): return _libMEDClient.MED_addMesh(self, *args)
    def updateNamesInMaps(self): return _libMEDClient.MED_updateNamesInMaps(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED(*args)
        try: self.this.append(this)
        except: self.this = this
    def addDriver(self, *args): return _libMEDClient.MED_addDriver(self, *args)
    def getMeshNames(self): return _libMEDClient.MED_getMeshNames(self)
    def getMeshName(self, *args): return _libMEDClient.MED_getMeshName(self, *args)
    def getFieldNames(self): return _libMEDClient.MED_getFieldNames(self)
    def getFieldName(self, *args): return _libMEDClient.MED_getFieldName(self, *args)
    def getMesh(self, *args): return _libMEDClient.MED_getMesh(self, *args)
    def getFieldNumberOfIteration(self, *args): return _libMEDClient.MED_getFieldNumberOfIteration(self, *args)
    def getFieldIteration(self, *args): return _libMEDClient.MED_getFieldIteration(self, *args)
    def getField(self, *args): return _libMEDClient.MED_getField(self, *args)
    def getFieldT(self, *args): return _libMEDClient.MED_getFieldT(self, *args)
    def getField2(self, *args): return _libMEDClient.MED_getField2(self, *args)
    def getSupport(self, *args): return _libMEDClient.MED_getSupport(self, *args)
MED_swigregister = _libMEDClient.MED_swigregister
MED_swigregister(MED)

class MED_MED_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_MED_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_MED_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    def open(self): return _libMEDClient.MED_MED_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_MED_RDONLY_DRIVER_close(self)
    def read(self): return _libMEDClient.MED_MED_RDONLY_DRIVER_read(self)
    def readFileStruct(self): return _libMEDClient.MED_MED_RDONLY_DRIVER_readFileStruct(self)
    __swig_destroy__ = _libMEDClient.delete_MED_MED_RDONLY_DRIVER
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_MED_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_MED_RDONLY_DRIVER___str__(self)
MED_MED_RDONLY_DRIVER_swigregister = _libMEDClient.MED_MED_RDONLY_DRIVER_swigregister
MED_MED_RDONLY_DRIVER_swigregister(MED_MED_RDONLY_DRIVER)

class MED_MED_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_MED_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_MED_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    def open(self): return _libMEDClient.MED_MED_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_MED_WRONLY_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_MED_WRONLY_DRIVER_write(self)
    def writeFrom(self): return _libMEDClient.MED_MED_WRONLY_DRIVER_writeFrom(self)
    __swig_destroy__ = _libMEDClient.delete_MED_MED_WRONLY_DRIVER
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_MED_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_MED_WRONLY_DRIVER___str__(self)
MED_MED_WRONLY_DRIVER_swigregister = _libMEDClient.MED_MED_WRONLY_DRIVER_swigregister
MED_MED_WRONLY_DRIVER_swigregister(MED_MED_WRONLY_DRIVER)

class MED_MED_RDWR_DRIVER(MED_MED_RDONLY_DRIVER,MED_MED_WRONLY_DRIVER):
    __swig_setmethods__ = {}
    for _s in [MED_MED_RDONLY_DRIVER,MED_MED_WRONLY_DRIVER]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_MED_RDWR_DRIVER, name, value)
    __swig_getmethods__ = {}
    for _s in [MED_MED_RDONLY_DRIVER,MED_MED_WRONLY_DRIVER]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MED_MED_RDWR_DRIVER, name)
    __repr__ = _swig_repr
    def open(self): return _libMEDClient.MED_MED_RDWR_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_MED_RDWR_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_MED_RDWR_DRIVER_write(self)
    def writeFrom(self): return _libMEDClient.MED_MED_RDWR_DRIVER_writeFrom(self)
    def read(self): return _libMEDClient.MED_MED_RDWR_DRIVER_read(self)
    def readFileStruct(self): return _libMEDClient.MED_MED_RDWR_DRIVER_readFileStruct(self)
    __swig_destroy__ = _libMEDClient.delete_MED_MED_RDWR_DRIVER
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_MED_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_MED_RDWR_DRIVER___str__(self)
MED_MED_RDWR_DRIVER_swigregister = _libMEDClient.MED_MED_RDWR_DRIVER_swigregister
MED_MED_RDWR_DRIVER_swigregister(MED_MED_RDWR_DRIVER)

class GIBI_MESH_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GIBI_MESH_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GIBI_MESH_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GIBI_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.GIBI_MESH_RDONLY_DRIVER_open(self)
    def write(self): return _libMEDClient.GIBI_MESH_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.GIBI_MESH_RDONLY_DRIVER_read(self)
    def close(self): return _libMEDClient.GIBI_MESH_RDONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_GIBI_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.GIBI_MESH_RDONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.GIBI_MESH_RDONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.GIBI_MESH_RDONLY_DRIVER_getMeshName(self)
GIBI_MESH_RDONLY_DRIVER_swigregister = _libMEDClient.GIBI_MESH_RDONLY_DRIVER_swigregister
GIBI_MESH_RDONLY_DRIVER_swigregister(GIBI_MESH_RDONLY_DRIVER)

class GIBI_MESH_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GIBI_MESH_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GIBI_MESH_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GIBI_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.GIBI_MESH_WRONLY_DRIVER_open(self)
    def write(self): return _libMEDClient.GIBI_MESH_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.GIBI_MESH_WRONLY_DRIVER_read(self)
    def close(self): return _libMEDClient.GIBI_MESH_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_GIBI_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.GIBI_MESH_WRONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.GIBI_MESH_WRONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.GIBI_MESH_WRONLY_DRIVER_getMeshName(self)
GIBI_MESH_WRONLY_DRIVER_swigregister = _libMEDClient.GIBI_MESH_WRONLY_DRIVER_swigregister
GIBI_MESH_WRONLY_DRIVER_swigregister(GIBI_MESH_WRONLY_DRIVER)

class GIBI_MESH_RDWR_DRIVER(GIBI_MESH_RDONLY_DRIVER,GIBI_MESH_WRONLY_DRIVER):
    __swig_setmethods__ = {}
    for _s in [GIBI_MESH_RDONLY_DRIVER,GIBI_MESH_WRONLY_DRIVER]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GIBI_MESH_RDWR_DRIVER, name, value)
    __swig_getmethods__ = {}
    for _s in [GIBI_MESH_RDONLY_DRIVER,GIBI_MESH_WRONLY_DRIVER]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GIBI_MESH_RDWR_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GIBI_MESH_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.GIBI_MESH_RDWR_DRIVER_open(self)
    def write(self): return _libMEDClient.GIBI_MESH_RDWR_DRIVER_write(self)
    def read(self): return _libMEDClient.GIBI_MESH_RDWR_DRIVER_read(self)
    def close(self): return _libMEDClient.GIBI_MESH_RDWR_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_GIBI_MESH_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.GIBI_MESH_RDWR_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.GIBI_MESH_RDWR_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.GIBI_MESH_RDWR_DRIVER_getMeshName(self)
GIBI_MESH_RDWR_DRIVER_swigregister = _libMEDClient.GIBI_MESH_RDWR_DRIVER_swigregister
GIBI_MESH_RDWR_DRIVER_swigregister(GIBI_MESH_RDWR_DRIVER)

class GIBI_MED_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GIBI_MED_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GIBI_MED_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GIBI_MED_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.GIBI_MED_RDONLY_DRIVER_open(self)
    def write(self): return _libMEDClient.GIBI_MED_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.GIBI_MED_RDONLY_DRIVER_read(self)
    def close(self): return _libMEDClient.GIBI_MED_RDONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_GIBI_MED_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.GIBI_MED_RDONLY_DRIVER___str__(self)
GIBI_MED_RDONLY_DRIVER_swigregister = _libMEDClient.GIBI_MED_RDONLY_DRIVER_swigregister
GIBI_MED_RDONLY_DRIVER_swigregister(GIBI_MED_RDONLY_DRIVER)

class GIBI_MED_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GIBI_MED_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GIBI_MED_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GIBI_MED_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.GIBI_MED_WRONLY_DRIVER_open(self)
    def write(self): return _libMEDClient.GIBI_MED_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.GIBI_MED_WRONLY_DRIVER_read(self)
    def close(self): return _libMEDClient.GIBI_MED_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_GIBI_MED_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.GIBI_MED_WRONLY_DRIVER___str__(self)
GIBI_MED_WRONLY_DRIVER_swigregister = _libMEDClient.GIBI_MED_WRONLY_DRIVER_swigregister
GIBI_MED_WRONLY_DRIVER_swigregister(GIBI_MED_WRONLY_DRIVER)

class PORFLOW_MESH_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PORFLOW_MESH_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PORFLOW_MESH_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_PORFLOW_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER_open(self)
    def write(self): return _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER_read(self)
    def close(self): return _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_PORFLOW_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER_getMeshName(self)
PORFLOW_MESH_RDONLY_DRIVER_swigregister = _libMEDClient.PORFLOW_MESH_RDONLY_DRIVER_swigregister
PORFLOW_MESH_RDONLY_DRIVER_swigregister(PORFLOW_MESH_RDONLY_DRIVER)

class PORFLOW_MESH_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PORFLOW_MESH_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PORFLOW_MESH_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_PORFLOW_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER_open(self)
    def write(self): return _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER_read(self)
    def close(self): return _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_PORFLOW_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER_getMeshName(self)
PORFLOW_MESH_WRONLY_DRIVER_swigregister = _libMEDClient.PORFLOW_MESH_WRONLY_DRIVER_swigregister
PORFLOW_MESH_WRONLY_DRIVER_swigregister(PORFLOW_MESH_WRONLY_DRIVER)

class PORFLOW_MESH_RDWR_DRIVER(PORFLOW_MESH_RDONLY_DRIVER,PORFLOW_MESH_WRONLY_DRIVER):
    __swig_setmethods__ = {}
    for _s in [PORFLOW_MESH_RDONLY_DRIVER,PORFLOW_MESH_WRONLY_DRIVER]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PORFLOW_MESH_RDWR_DRIVER, name, value)
    __swig_getmethods__ = {}
    for _s in [PORFLOW_MESH_RDONLY_DRIVER,PORFLOW_MESH_WRONLY_DRIVER]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PORFLOW_MESH_RDWR_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_PORFLOW_MESH_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.PORFLOW_MESH_RDWR_DRIVER_open(self)
    def write(self): return _libMEDClient.PORFLOW_MESH_RDWR_DRIVER_write(self)
    def read(self): return _libMEDClient.PORFLOW_MESH_RDWR_DRIVER_read(self)
    def close(self): return _libMEDClient.PORFLOW_MESH_RDWR_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_PORFLOW_MESH_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.PORFLOW_MESH_RDWR_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.PORFLOW_MESH_RDWR_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.PORFLOW_MESH_RDWR_DRIVER_getMeshName(self)
PORFLOW_MESH_RDWR_DRIVER_swigregister = _libMEDClient.PORFLOW_MESH_RDWR_DRIVER_swigregister
PORFLOW_MESH_RDWR_DRIVER_swigregister(PORFLOW_MESH_RDWR_DRIVER)

class MED_MESH_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_MESH_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_MESH_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER_read(self)
    def desactivateFacesComputation(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER_desactivateFacesComputation(self)
    def activateFacesComputation(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER_activateFacesComputation(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.MED_MESH_RDONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.MED_MESH_RDONLY_DRIVER_getMeshName(self)
MED_MESH_RDONLY_DRIVER_swigregister = _libMEDClient.MED_MESH_RDONLY_DRIVER_swigregister
MED_MESH_RDONLY_DRIVER_swigregister(MED_MESH_RDONLY_DRIVER)

class MED_MESH_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_MESH_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_MESH_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
    def write(self): return _libMEDClient.MED_MESH_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_MESH_WRONLY_DRIVER_read(self)
    def open(self): return _libMEDClient.MED_MESH_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_MESH_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_MESH_WRONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.MED_MESH_WRONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.MED_MESH_WRONLY_DRIVER_getMeshName(self)
MED_MESH_WRONLY_DRIVER_swigregister = _libMEDClient.MED_MESH_WRONLY_DRIVER_swigregister
MED_MESH_WRONLY_DRIVER_swigregister(MED_MESH_WRONLY_DRIVER)

class MED_MESH_RDWR_DRIVER(MED_MESH_RDONLY_DRIVER,MED_MESH_WRONLY_DRIVER):
    __swig_setmethods__ = {}
    for _s in [MED_MESH_RDONLY_DRIVER,MED_MESH_WRONLY_DRIVER]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_MESH_RDWR_DRIVER, name, value)
    __swig_getmethods__ = {}
    for _s in [MED_MESH_RDONLY_DRIVER,MED_MESH_WRONLY_DRIVER]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MED_MESH_RDWR_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_MESH_RDWR_DRIVER
    __del__ = lambda self : None;
    def write(self): return _libMEDClient.MED_MESH_RDWR_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_MESH_RDWR_DRIVER_read(self)
    def open(self): return _libMEDClient.MED_MESH_RDWR_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_MESH_RDWR_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_MESH_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_MESH_RDWR_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDClient.MED_MESH_RDWR_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDClient.MED_MESH_RDWR_DRIVER_getMeshName(self)
MED_MESH_RDWR_DRIVER_swigregister = _libMEDClient.MED_MESH_RDWR_DRIVER_swigregister
MED_MESH_RDWR_DRIVER_swigregister(MED_MESH_RDWR_DRIVER)

class MED_FIELDDOUBLE_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_FIELDDOUBLE_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_FIELDDOUBLE_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_FIELDDOUBLE_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_FIELDDOUBLE_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER_getFieldName(self)
MED_FIELDDOUBLE_RDONLY_DRIVER_swigregister = _libMEDClient.MED_FIELDDOUBLE_RDONLY_DRIVER_swigregister
MED_FIELDDOUBLE_RDONLY_DRIVER_swigregister(MED_FIELDDOUBLE_RDONLY_DRIVER)

class MED_FIELDINT_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_FIELDINT_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_FIELDINT_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_FIELDINT_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.MED_FIELDINT_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_FIELDINT_RDONLY_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_FIELDINT_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_FIELDINT_RDONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_FIELDINT_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_FIELDINT_RDONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDClient.MED_FIELDINT_RDONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDClient.MED_FIELDINT_RDONLY_DRIVER_getFieldName(self)
MED_FIELDINT_RDONLY_DRIVER_swigregister = _libMEDClient.MED_FIELDINT_RDONLY_DRIVER_swigregister
MED_FIELDINT_RDONLY_DRIVER_swigregister(MED_FIELDINT_RDONLY_DRIVER)

class MED_FIELDDOUBLE_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_FIELDDOUBLE_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_FIELDDOUBLE_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_FIELDDOUBLE_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_FIELDDOUBLE_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER_getFieldName(self)
MED_FIELDDOUBLE_WRONLY_DRIVER_swigregister = _libMEDClient.MED_FIELDDOUBLE_WRONLY_DRIVER_swigregister
MED_FIELDDOUBLE_WRONLY_DRIVER_swigregister(MED_FIELDDOUBLE_WRONLY_DRIVER)

class MED_FIELDINT_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_FIELDINT_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MED_FIELDINT_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_FIELDINT_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.MED_FIELDINT_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_FIELDINT_WRONLY_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_FIELDINT_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_FIELDINT_WRONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_FIELDINT_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_FIELDINT_WRONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDClient.MED_FIELDINT_WRONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDClient.MED_FIELDINT_WRONLY_DRIVER_getFieldName(self)
MED_FIELDINT_WRONLY_DRIVER_swigregister = _libMEDClient.MED_FIELDINT_WRONLY_DRIVER_swigregister
MED_FIELDINT_WRONLY_DRIVER_swigregister(MED_FIELDINT_WRONLY_DRIVER)

class MED_FIELDDOUBLE_RDWR_DRIVER(MED_FIELDDOUBLE_RDONLY_DRIVER,MED_FIELDDOUBLE_WRONLY_DRIVER):
    __swig_setmethods__ = {}
    for _s in [MED_FIELDDOUBLE_RDONLY_DRIVER,MED_FIELDDOUBLE_WRONLY_DRIVER]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_FIELDDOUBLE_RDWR_DRIVER, name, value)
    __swig_getmethods__ = {}
    for _s in [MED_FIELDDOUBLE_RDONLY_DRIVER,MED_FIELDDOUBLE_WRONLY_DRIVER]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MED_FIELDDOUBLE_RDWR_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_FIELDDOUBLE_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_FIELDDOUBLE_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER_getFieldName(self)
MED_FIELDDOUBLE_RDWR_DRIVER_swigregister = _libMEDClient.MED_FIELDDOUBLE_RDWR_DRIVER_swigregister
MED_FIELDDOUBLE_RDWR_DRIVER_swigregister(MED_FIELDDOUBLE_RDWR_DRIVER)

class MED_FIELDINT_RDWR_DRIVER(MED_FIELDINT_RDONLY_DRIVER,MED_FIELDINT_WRONLY_DRIVER):
    __swig_setmethods__ = {}
    for _s in [MED_FIELDINT_RDONLY_DRIVER,MED_FIELDINT_WRONLY_DRIVER]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MED_FIELDINT_RDWR_DRIVER, name, value)
    __swig_getmethods__ = {}
    for _s in [MED_FIELDINT_RDONLY_DRIVER,MED_FIELDINT_WRONLY_DRIVER]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MED_FIELDINT_RDWR_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_MED_FIELDINT_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.MED_FIELDINT_RDWR_DRIVER_open(self)
    def close(self): return _libMEDClient.MED_FIELDINT_RDWR_DRIVER_close(self)
    def write(self): return _libMEDClient.MED_FIELDINT_RDWR_DRIVER_write(self)
    def read(self): return _libMEDClient.MED_FIELDINT_RDWR_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_MED_FIELDINT_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.MED_FIELDINT_RDWR_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDClient.MED_FIELDINT_RDWR_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDClient.MED_FIELDINT_RDWR_DRIVER_getFieldName(self)
MED_FIELDINT_RDWR_DRIVER_swigregister = _libMEDClient.MED_FIELDINT_RDWR_DRIVER_swigregister
MED_FIELDINT_RDWR_DRIVER_swigregister(MED_FIELDINT_RDWR_DRIVER)

class ASCII_FIELDDOUBLE_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ASCII_FIELDDOUBLE_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ASCII_FIELDDOUBLE_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_ASCII_FIELDDOUBLE_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.ASCII_FIELDDOUBLE_DRIVER_open(self)
    def close(self): return _libMEDClient.ASCII_FIELDDOUBLE_DRIVER_close(self)
    def write(self): return _libMEDClient.ASCII_FIELDDOUBLE_DRIVER_write(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_ASCII_FIELDDOUBLE_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
ASCII_FIELDDOUBLE_DRIVER_swigregister = _libMEDClient.ASCII_FIELDDOUBLE_DRIVER_swigregister
ASCII_FIELDDOUBLE_DRIVER_swigregister(ASCII_FIELDDOUBLE_DRIVER)

class ASCII_FIELDINT_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ASCII_FIELDINT_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ASCII_FIELDINT_DRIVER, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_ASCII_FIELDINT_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDClient.ASCII_FIELDINT_DRIVER_open(self)
    def close(self): return _libMEDClient.ASCII_FIELDINT_DRIVER_close(self)
    def write(self): return _libMEDClient.ASCII_FIELDINT_DRIVER_write(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_ASCII_FIELDINT_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
ASCII_FIELDINT_DRIVER_swigregister = _libMEDClient.ASCII_FIELDINT_DRIVER_swigregister
ASCII_FIELDINT_DRIVER_swigregister(ASCII_FIELDINT_DRIVER)

ENSIGHT_6 = _libMEDClient.ENSIGHT_6
ENSIGHT_GOLD = _libMEDClient.ENSIGHT_GOLD

def setEnSightFormatForWriting(*args):
  return _libMEDClient.setEnSightFormatForWriting(*args)
setEnSightFormatForWriting = _libMEDClient.setEnSightFormatForWriting
class ENSIGHT_MED_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ENSIGHT_MED_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ENSIGHT_MED_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_ENSIGHT_MED_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def read(self): return _libMEDClient.ENSIGHT_MED_RDONLY_DRIVER_read(self)
    def readFileStruct(self): return _libMEDClient.ENSIGHT_MED_RDONLY_DRIVER_readFileStruct(self)
    __swig_destroy__ = _libMEDClient.delete_ENSIGHT_MED_RDONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MED_RDONLY_DRIVER_swigregister = _libMEDClient.ENSIGHT_MED_RDONLY_DRIVER_swigregister
ENSIGHT_MED_RDONLY_DRIVER_swigregister(ENSIGHT_MED_RDONLY_DRIVER)

def setIgnoreIncompatibility(toIgnore = True):
  return _libMEDClient.setIgnoreIncompatibility(toIgnore)
setIgnoreIncompatibility = _libMEDClient.setIgnoreIncompatibility

class ENSIGHT_MED_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ENSIGHT_MED_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ENSIGHT_MED_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_ENSIGHT_MED_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def write(self): return _libMEDClient.ENSIGHT_MED_WRONLY_DRIVER_write(self)
    __swig_destroy__ = _libMEDClient.delete_ENSIGHT_MED_WRONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MED_WRONLY_DRIVER_swigregister = _libMEDClient.ENSIGHT_MED_WRONLY_DRIVER_swigregister
ENSIGHT_MED_WRONLY_DRIVER_swigregister(ENSIGHT_MED_WRONLY_DRIVER)

class ENSIGHT_MESH_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ENSIGHT_MESH_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ENSIGHT_MESH_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_ENSIGHT_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def read(self): return _libMEDClient.ENSIGHT_MESH_RDONLY_DRIVER_read(self)
    __swig_destroy__ = _libMEDClient.delete_ENSIGHT_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MESH_RDONLY_DRIVER_swigregister = _libMEDClient.ENSIGHT_MESH_RDONLY_DRIVER_swigregister
ENSIGHT_MESH_RDONLY_DRIVER_swigregister(ENSIGHT_MESH_RDONLY_DRIVER)

class ENSIGHT_MESH_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ENSIGHT_MESH_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ENSIGHT_MESH_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_ENSIGHT_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def write(self): return _libMEDClient.ENSIGHT_MESH_WRONLY_DRIVER_write(self)
    __swig_destroy__ = _libMEDClient.delete_ENSIGHT_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MESH_WRONLY_DRIVER_swigregister = _libMEDClient.ENSIGHT_MESH_WRONLY_DRIVER_swigregister
ENSIGHT_MESH_WRONLY_DRIVER_swigregister(ENSIGHT_MESH_WRONLY_DRIVER)

class ENSIGHT_FIELD_RDONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ENSIGHT_FIELD_RDONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ENSIGHT_FIELD_RDONLY_DRIVER, name)
    __repr__ = _swig_repr
    def setFieldName(self, *args): return _libMEDClient.ENSIGHT_FIELD_RDONLY_DRIVER_setFieldName(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_ENSIGHT_FIELD_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def read(self): return _libMEDClient.ENSIGHT_FIELD_RDONLY_DRIVER_read(self)
    __swig_destroy__ = _libMEDClient.delete_ENSIGHT_FIELD_RDONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_FIELD_RDONLY_DRIVER_swigregister = _libMEDClient.ENSIGHT_FIELD_RDONLY_DRIVER_swigregister
ENSIGHT_FIELD_RDONLY_DRIVER_swigregister(ENSIGHT_FIELD_RDONLY_DRIVER)

class ENSIGHT_FIELD_WRONLY_DRIVER(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ENSIGHT_FIELD_WRONLY_DRIVER, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ENSIGHT_FIELD_WRONLY_DRIVER, name)
    __repr__ = _swig_repr
    def setFieldName(self, *args): return _libMEDClient.ENSIGHT_FIELD_WRONLY_DRIVER_setFieldName(self, *args)
    def __init__(self, *args): 
        this = _libMEDClient.new_ENSIGHT_FIELD_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def write(self): return _libMEDClient.ENSIGHT_FIELD_WRONLY_DRIVER_write(self)
    __swig_destroy__ = _libMEDClient.delete_ENSIGHT_FIELD_WRONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_FIELD_WRONLY_DRIVER_swigregister = _libMEDClient.ENSIGHT_FIELD_WRONLY_DRIVER_swigregister
ENSIGHT_FIELD_WRONLY_DRIVER_swigregister(ENSIGHT_FIELD_WRONLY_DRIVER)

class GAUSS_LOCALIZATION_FULL(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAUSS_LOCALIZATION_FULL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GAUSS_LOCALIZATION_FULL, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GAUSS_LOCALIZATION_FULL
    __del__ = lambda self : None;
    def getName(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL_getName(self)
    def getType(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL_getType(self)
    def getNbGauss(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL_getNbGauss(self)
    def getInterlacingType(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL_getInterlacingType(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_GAUSS_LOCALIZATION_FULL(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL___str__(self)
    def getRefCoo(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL_getRefCoo(self)
    def getGsCoo(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL_getGsCoo(self)
    def getWeight(self): return _libMEDClient.GAUSS_LOCALIZATION_FULL_getWeight(self)
GAUSS_LOCALIZATION_FULL_swigregister = _libMEDClient.GAUSS_LOCALIZATION_FULL_swigregister
GAUSS_LOCALIZATION_FULL_swigregister(GAUSS_LOCALIZATION_FULL)

class GAUSS_LOCALIZATION_NO(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAUSS_LOCALIZATION_NO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GAUSS_LOCALIZATION_NO, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_GAUSS_LOCALIZATION_NO
    __del__ = lambda self : None;
    def getName(self): return _libMEDClient.GAUSS_LOCALIZATION_NO_getName(self)
    def getType(self): return _libMEDClient.GAUSS_LOCALIZATION_NO_getType(self)
    def getNbGauss(self): return _libMEDClient.GAUSS_LOCALIZATION_NO_getNbGauss(self)
    def getInterlacingType(self): return _libMEDClient.GAUSS_LOCALIZATION_NO_getInterlacingType(self)
    def __init__(self, *args): 
        this = _libMEDClient.new_GAUSS_LOCALIZATION_NO(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDClient.GAUSS_LOCALIZATION_NO___str__(self)
    def getRefCoo(self): return _libMEDClient.GAUSS_LOCALIZATION_NO_getRefCoo(self)
    def getGsCoo(self): return _libMEDClient.GAUSS_LOCALIZATION_NO_getGsCoo(self)
    def getWeight(self): return _libMEDClient.GAUSS_LOCALIZATION_NO_getWeight(self)
GAUSS_LOCALIZATION_NO_swigregister = _libMEDClient.GAUSS_LOCALIZATION_NO_swigregister
GAUSS_LOCALIZATION_NO_swigregister(GAUSS_LOCALIZATION_NO)


def createFieldDoubleFromField(*args):
  return _libMEDClient.createFieldDoubleFromField(*args)
createFieldDoubleFromField = _libMEDClient.createFieldDoubleFromField

def createFieldIntFromField(*args):
  return _libMEDClient.createFieldIntFromField(*args)
createFieldIntFromField = _libMEDClient.createFieldIntFromField

def createFieldDoubleNoInterlaceFromField(*args):
  return _libMEDClient.createFieldDoubleNoInterlaceFromField(*args)
createFieldDoubleNoInterlaceFromField = _libMEDClient.createFieldDoubleNoInterlaceFromField

def createFieldIntNoInterlaceFromField(*args):
  return _libMEDClient.createFieldIntNoInterlaceFromField(*args)
createFieldIntNoInterlaceFromField = _libMEDClient.createFieldIntNoInterlaceFromField

def createFieldDoubleNoInterlaceByTypeFromField(*args):
  return _libMEDClient.createFieldDoubleNoInterlaceByTypeFromField(*args)
createFieldDoubleNoInterlaceByTypeFromField = _libMEDClient.createFieldDoubleNoInterlaceByTypeFromField

def createFieldIntNoInterlaceByTypeFromField(*args):
  return _libMEDClient.createFieldIntNoInterlaceByTypeFromField(*args)
createFieldIntNoInterlaceByTypeFromField = _libMEDClient.createFieldIntNoInterlaceByTypeFromField

def createFieldDoubleScalarProduct(*args):
  return _libMEDClient.createFieldDoubleScalarProduct(*args)
createFieldDoubleScalarProduct = _libMEDClient.createFieldDoubleScalarProduct

def createFieldIntScalarProduct(*args):
  return _libMEDClient.createFieldIntScalarProduct(*args)
createFieldIntScalarProduct = _libMEDClient.createFieldIntScalarProduct

def createFieldDoubleNoInterlaceScalarProduct(*args):
  return _libMEDClient.createFieldDoubleNoInterlaceScalarProduct(*args)
createFieldDoubleNoInterlaceScalarProduct = _libMEDClient.createFieldDoubleNoInterlaceScalarProduct

def createFieldIntNoInterlaceScalarProduct(*args):
  return _libMEDClient.createFieldIntNoInterlaceScalarProduct(*args)
createFieldIntNoInterlaceScalarProduct = _libMEDClient.createFieldIntNoInterlaceScalarProduct

def createFieldDoubleNoInterlaceByTypeScalarProduct(*args):
  return _libMEDClient.createFieldDoubleNoInterlaceByTypeScalarProduct(*args)
createFieldDoubleNoInterlaceByTypeScalarProduct = _libMEDClient.createFieldDoubleNoInterlaceByTypeScalarProduct

def createFieldIntNoInterlaceByTypeScalarProduct(*args):
  return _libMEDClient.createFieldIntNoInterlaceByTypeScalarProduct(*args)
createFieldIntNoInterlaceByTypeScalarProduct = _libMEDClient.createFieldIntNoInterlaceByTypeScalarProduct

def createFieldDoubleScalarProductDeep(*args):
  return _libMEDClient.createFieldDoubleScalarProductDeep(*args)
createFieldDoubleScalarProductDeep = _libMEDClient.createFieldDoubleScalarProductDeep

def createFieldIntScalarProductDeep(*args):
  return _libMEDClient.createFieldIntScalarProductDeep(*args)
createFieldIntScalarProductDeep = _libMEDClient.createFieldIntScalarProductDeep

def createFieldDoubleNoInterlaceScalarProductDeep(*args):
  return _libMEDClient.createFieldDoubleNoInterlaceScalarProductDeep(*args)
createFieldDoubleNoInterlaceScalarProductDeep = _libMEDClient.createFieldDoubleNoInterlaceScalarProductDeep

def createFieldIntNoInterlaceScalarProductDeep(*args):
  return _libMEDClient.createFieldIntNoInterlaceScalarProductDeep(*args)
createFieldIntNoInterlaceScalarProductDeep = _libMEDClient.createFieldIntNoInterlaceScalarProductDeep

def createFieldDoubleNoInterlaceByTypeScalarProductDeep(*args):
  return _libMEDClient.createFieldDoubleNoInterlaceByTypeScalarProductDeep(*args)
createFieldDoubleNoInterlaceByTypeScalarProductDeep = _libMEDClient.createFieldDoubleNoInterlaceByTypeScalarProductDeep

def createFieldIntNoInterlaceByTypeScalarProductDeep(*args):
  return _libMEDClient.createFieldIntNoInterlaceByTypeScalarProductDeep(*args)
createFieldIntNoInterlaceByTypeScalarProductDeep = _libMEDClient.createFieldIntNoInterlaceByTypeScalarProductDeep

def createFieldDoubleConvertFullInterlace(*args):
  return _libMEDClient.createFieldDoubleConvertFullInterlace(*args)
createFieldDoubleConvertFullInterlace = _libMEDClient.createFieldDoubleConvertFullInterlace

def createFieldIntConvertFullInterlace(*args):
  return _libMEDClient.createFieldIntConvertFullInterlace(*args)
createFieldIntConvertFullInterlace = _libMEDClient.createFieldIntConvertFullInterlace

def createFieldDoubleConvertNoInterlace(*args):
  return _libMEDClient.createFieldDoubleConvertNoInterlace(*args)
createFieldDoubleConvertNoInterlace = _libMEDClient.createFieldDoubleConvertNoInterlace

def createFieldIntConvertNoInterlace(*args):
  return _libMEDClient.createFieldIntConvertNoInterlace(*args)
createFieldIntConvertNoInterlace = _libMEDClient.createFieldIntConvertNoInterlace

def createGridFromMesh(*args):
  return _libMEDClient.createGridFromMesh(*args)
createGridFromMesh = _libMEDClient.createGridFromMesh

def createFieldDoubleFromAnalytic(*args):
  return _libMEDClient.createFieldDoubleFromAnalytic(*args)
createFieldDoubleFromAnalytic = _libMEDClient.createFieldDoubleFromAnalytic

def createFieldIntFromAnalytic(*args):
  return _libMEDClient.createFieldIntFromAnalytic(*args)
createFieldIntFromAnalytic = _libMEDClient.createFieldIntFromAnalytic

def createFieldDoubleNoInterlaceFromAnalytic(*args):
  return _libMEDClient.createFieldDoubleNoInterlaceFromAnalytic(*args)
createFieldDoubleNoInterlaceFromAnalytic = _libMEDClient.createFieldDoubleNoInterlaceFromAnalytic

def createFieldIntNoInterlaceFromAnalytic(*args):
  return _libMEDClient.createFieldIntNoInterlaceFromAnalytic(*args)
createFieldIntNoInterlaceFromAnalytic = _libMEDClient.createFieldIntNoInterlaceFromAnalytic

def createCorbaSupport(*args):
  return _libMEDClient.createCorbaSupport(*args)
createCorbaSupport = _libMEDClient.createCorbaSupport

def createLocalFieldDouble(*args):
  return _libMEDClient.createLocalFieldDouble(*args)
createLocalFieldDouble = _libMEDClient.createLocalFieldDouble

def createLocalFieldInt(*args):
  return _libMEDClient.createLocalFieldInt(*args)
createLocalFieldInt = _libMEDClient.createLocalFieldInt

def createCorbaMesh(*args):
  return _libMEDClient.createCorbaMesh(*args)
createCorbaMesh = _libMEDClient.createCorbaMesh
class MESHClient(MESH):
    __swig_setmethods__ = {}
    for _s in [MESH]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MESHClient, name, value)
    __swig_getmethods__ = {}
    for _s in [MESH]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MESHClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_MESHClient(*args)
        try: self.this.append(this)
        except: self.this = this
    def blankCopy(self): return _libMEDClient.MESHClient_blankCopy(self)
    def fillCopy(self): return _libMEDClient.MESHClient_fillCopy(self)
    __swig_destroy__ = _libMEDClient.delete_MESHClient
    __del__ = lambda self : None;
MESHClient_swigregister = _libMEDClient.MESHClient_swigregister
MESHClient_swigregister(MESHClient)

def createCorbaFieldDouble(*args):
  return _libMEDClient.createCorbaFieldDouble(*args)
createCorbaFieldDouble = _libMEDClient.createCorbaFieldDouble

def createCorbaFieldInt(*args):
  return _libMEDClient.createCorbaFieldInt(*args)
createCorbaFieldInt = _libMEDClient.createCorbaFieldInt


def getMeshPointer(*args):
  return _libMEDClient.getMeshPointer(*args)
getMeshPointer = _libMEDClient.getMeshPointer
class SUPPORTClient(SUPPORT):
    __swig_setmethods__ = {}
    for _s in [SUPPORT]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SUPPORTClient, name, value)
    __swig_getmethods__ = {}
    for _s in [SUPPORT]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SUPPORTClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _libMEDClient.new_SUPPORTClient(*args)
        try: self.this.append(this)
        except: self.this = this
    def blankCopy(self): return _libMEDClient.SUPPORTClient_blankCopy(self)
    def fillCopy(self): return _libMEDClient.SUPPORTClient_fillCopy(self)
    __swig_destroy__ = _libMEDClient.delete_SUPPORTClient
    __del__ = lambda self : None;
SUPPORTClient_swigregister = _libMEDClient.SUPPORTClient_swigregister
SUPPORTClient_swigregister(SUPPORTClient)

class FIELDDOUBLEClient(FIELDDOUBLE):
    __swig_setmethods__ = {}
    for _s in [FIELDDOUBLE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDDOUBLEClient, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELDDOUBLE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDDOUBLEClient, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDDOUBLEClient
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDDOUBLEClient(*args)
        try: self.this.append(this)
        except: self.this = this
FIELDDOUBLEClient_swigregister = _libMEDClient.FIELDDOUBLEClient_swigregister
FIELDDOUBLEClient_swigregister(FIELDDOUBLEClient)

class FIELDDOUBLENOINTERLACEClient(FIELDDOUBLENOINTERLACE):
    __swig_setmethods__ = {}
    for _s in [FIELDDOUBLENOINTERLACE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDDOUBLENOINTERLACEClient, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELDDOUBLENOINTERLACE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDDOUBLENOINTERLACEClient, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDDOUBLENOINTERLACEClient
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDDOUBLENOINTERLACEClient(*args)
        try: self.this.append(this)
        except: self.this = this
FIELDDOUBLENOINTERLACEClient_swigregister = _libMEDClient.FIELDDOUBLENOINTERLACEClient_swigregister
FIELDDOUBLENOINTERLACEClient_swigregister(FIELDDOUBLENOINTERLACEClient)

class FIELDDOUBLENOINTERLACEBYTYPEClient(FIELDDOUBLENOINTERLACEBYTYPE):
    __swig_setmethods__ = {}
    for _s in [FIELDDOUBLENOINTERLACEBYTYPE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDDOUBLENOINTERLACEBYTYPEClient, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELDDOUBLENOINTERLACEBYTYPE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDDOUBLENOINTERLACEBYTYPEClient, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDDOUBLENOINTERLACEBYTYPEClient
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDDOUBLENOINTERLACEBYTYPEClient(*args)
        try: self.this.append(this)
        except: self.this = this
FIELDDOUBLENOINTERLACEBYTYPEClient_swigregister = _libMEDClient.FIELDDOUBLENOINTERLACEBYTYPEClient_swigregister
FIELDDOUBLENOINTERLACEBYTYPEClient_swigregister(FIELDDOUBLENOINTERLACEBYTYPEClient)

class FIELDINTClient(FIELDINT):
    __swig_setmethods__ = {}
    for _s in [FIELDINT]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDINTClient, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELDINT]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDINTClient, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDINTClient
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDINTClient(*args)
        try: self.this.append(this)
        except: self.this = this
FIELDINTClient_swigregister = _libMEDClient.FIELDINTClient_swigregister
FIELDINTClient_swigregister(FIELDINTClient)

class FIELDINTNOINTERLACEClient(FIELDINTNOINTERLACE):
    __swig_setmethods__ = {}
    for _s in [FIELDINTNOINTERLACE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDINTNOINTERLACEClient, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELDINTNOINTERLACE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDINTNOINTERLACEClient, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDINTNOINTERLACEClient
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDINTNOINTERLACEClient(*args)
        try: self.this.append(this)
        except: self.this = this
FIELDINTNOINTERLACEClient_swigregister = _libMEDClient.FIELDINTNOINTERLACEClient_swigregister
FIELDINTNOINTERLACEClient_swigregister(FIELDINTNOINTERLACEClient)

class FIELDINTNOINTERLACEBYTYPEClient(FIELDINTNOINTERLACEBYTYPE):
    __swig_setmethods__ = {}
    for _s in [FIELDINTNOINTERLACEBYTYPE]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FIELDINTNOINTERLACEBYTYPEClient, name, value)
    __swig_getmethods__ = {}
    for _s in [FIELDINTNOINTERLACEBYTYPE]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FIELDINTNOINTERLACEBYTYPEClient, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libMEDClient.delete_FIELDINTNOINTERLACEBYTYPEClient
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDClient.new_FIELDINTNOINTERLACEBYTYPEClient(*args)
        try: self.this.append(this)
        except: self.this = this
FIELDINTNOINTERLACEBYTYPEClient_swigregister = _libMEDClient.FIELDINTNOINTERLACEBYTYPEClient_swigregister
FIELDINTNOINTERLACEBYTYPEClient_swigregister(FIELDINTNOINTERLACEBYTYPEClient)


def getDoublePointer(*args):
  return _libMEDClient.getDoublePointer(*args)
getDoublePointer = _libMEDClient.getDoublePointer

def getDoubleNoInterlacePointer(*args):
  return _libMEDClient.getDoubleNoInterlacePointer(*args)
getDoubleNoInterlacePointer = _libMEDClient.getDoubleNoInterlacePointer

def getDoubleNoInterlaceByTypePointer(*args):
  return _libMEDClient.getDoubleNoInterlaceByTypePointer(*args)
getDoubleNoInterlaceByTypePointer = _libMEDClient.getDoubleNoInterlaceByTypePointer

def getIntPointer(*args):
  return _libMEDClient.getIntPointer(*args)
getIntPointer = _libMEDClient.getIntPointer

def getIntNoInterlacePointer(*args):
  return _libMEDClient.getIntNoInterlacePointer(*args)
getIntNoInterlacePointer = _libMEDClient.getIntNoInterlacePointer

def getIntNoInterlaceByTypePointer(*args):
  return _libMEDClient.getIntNoInterlaceByTypePointer(*args)
getIntNoInterlaceByTypePointer = _libMEDClient.getIntNoInterlaceByTypePointer


