# 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('_libMEDMEM_Swig', [dirname(__file__)])
        except ImportError:
            import _libMEDMEM_Swig
            return _libMEDMEM_Swig
        if fp is not None:
            try:
                _mod = imp.load_module('_libMEDMEM_Swig', fp, pathname, description)
            finally:
                fp.close()
                return _mod
    _libMEDMEM_Swig = swig_import_helper()
    del swig_import_helper
else:
    import _libMEDMEM_Swig
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 = _libMEDMEM_Swig.MED_CARTESIAN
MED_POLAR = _libMEDMEM_Swig.MED_POLAR
MED_BODY_FITTED = _libMEDMEM_Swig.MED_BODY_FITTED
MED_FULL_INTERLACE = _libMEDMEM_Swig.MED_FULL_INTERLACE
MED_NO_INTERLACE = _libMEDMEM_Swig.MED_NO_INTERLACE
RDONLY = _libMEDMEM_Swig.RDONLY
WRONLY = _libMEDMEM_Swig.WRONLY
RDWR = _libMEDMEM_Swig.RDWR
MED_LECT = _libMEDMEM_Swig.MED_LECT
MED_ECRI = _libMEDMEM_Swig.MED_ECRI
MED_REMP = _libMEDMEM_Swig.MED_REMP
ASCENDING = _libMEDMEM_Swig.ASCENDING
DESCENDING = _libMEDMEM_Swig.DESCENDING
MED_CELL = _libMEDMEM_Swig.MED_CELL
MED_FACE = _libMEDMEM_Swig.MED_FACE
MED_EDGE = _libMEDMEM_Swig.MED_EDGE
MED_NODE = _libMEDMEM_Swig.MED_NODE
MED_ALL_ENTITIES = _libMEDMEM_Swig.MED_ALL_ENTITIES
MED_NONE = _libMEDMEM_Swig.MED_NONE
MED_POINT1 = _libMEDMEM_Swig.MED_POINT1
MED_SEG2 = _libMEDMEM_Swig.MED_SEG2
MED_SEG3 = _libMEDMEM_Swig.MED_SEG3
MED_TRIA3 = _libMEDMEM_Swig.MED_TRIA3
MED_QUAD4 = _libMEDMEM_Swig.MED_QUAD4
MED_TRIA6 = _libMEDMEM_Swig.MED_TRIA6
MED_QUAD8 = _libMEDMEM_Swig.MED_QUAD8
MED_TETRA4 = _libMEDMEM_Swig.MED_TETRA4
MED_PYRA5 = _libMEDMEM_Swig.MED_PYRA5
MED_PENTA6 = _libMEDMEM_Swig.MED_PENTA6
MED_HEXA8 = _libMEDMEM_Swig.MED_HEXA8
MED_TETRA10 = _libMEDMEM_Swig.MED_TETRA10
MED_PYRA13 = _libMEDMEM_Swig.MED_PYRA13
MED_PENTA15 = _libMEDMEM_Swig.MED_PENTA15
MED_HEXA20 = _libMEDMEM_Swig.MED_HEXA20
MED_POLYGON = _libMEDMEM_Swig.MED_POLYGON
MED_POLYHEDRA = _libMEDMEM_Swig.MED_POLYHEDRA
MED_ALL_ELEMENTS = _libMEDMEM_Swig.MED_ALL_ELEMENTS
MED_NODAL = _libMEDMEM_Swig.MED_NODAL
MED_DESCENDING = _libMEDMEM_Swig.MED_DESCENDING
MED_DRIVER = _libMEDMEM_Swig.MED_DRIVER
GIBI_DRIVER = _libMEDMEM_Swig.GIBI_DRIVER
PORFLOW_DRIVER = _libMEDMEM_Swig.PORFLOW_DRIVER
VTK_DRIVER = _libMEDMEM_Swig.VTK_DRIVER
NO_DRIVER = _libMEDMEM_Swig.NO_DRIVER
ASCII_DRIVER = _libMEDMEM_Swig.ASCII_DRIVER
ENSIGHT_DRIVER = _libMEDMEM_Swig.ENSIGHT_DRIVER
MED_REEL64 = _libMEDMEM_Swig.MED_REEL64
MED_INT32 = _libMEDMEM_Swig.MED_INT32
MED_INT64 = _libMEDMEM_Swig.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"] = _libMEDMEM_Swig.DT_IT__dt_set
    __swig_getmethods__["dt"] = _libMEDMEM_Swig.DT_IT__dt_get
    if _newclass:dt = _swig_property(_libMEDMEM_Swig.DT_IT__dt_get, _libMEDMEM_Swig.DT_IT__dt_set)
    __swig_setmethods__["it"] = _libMEDMEM_Swig.DT_IT__it_set
    __swig_getmethods__["it"] = _libMEDMEM_Swig.DT_IT__it_get
    if _newclass:it = _swig_property(_libMEDMEM_Swig.DT_IT__it_get, _libMEDMEM_Swig.DT_IT__it_set)
    def getdt(self): return _libMEDMEM_Swig.DT_IT__getdt(self)
    def getit(self): return _libMEDMEM_Swig.DT_IT__getit(self)
    def __init__(self): 
        this = _libMEDMEM_Swig.new_DT_IT_()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDMEM_Swig.delete_DT_IT_
    __del__ = lambda self : None;
DT_IT__swigregister = _libMEDMEM_Swig.DT_IT__swigregister
DT_IT__swigregister(DT_IT_)

V21 = _libMEDMEM_Swig.V21
V22 = _libMEDMEM_Swig.V22

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

def setMedFileVersionForWriting(*args):
  return _libMEDMEM_Swig.setMedFileVersionForWriting(*args)
setMedFileVersionForWriting = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_CELLMODEL(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfVertexes(self): return _libMEDMEM_Swig.CELLMODEL_getNumberOfVertexes(self)
    def getNumberOfNodes(self): return _libMEDMEM_Swig.CELLMODEL_getNumberOfNodes(self)
    def getDimension(self): return _libMEDMEM_Swig.CELLMODEL_getDimension(self)
    def getType(self): return _libMEDMEM_Swig.CELLMODEL_getType(self)
    def getNumberOfConstituents(self, *args): return _libMEDMEM_Swig.CELLMODEL_getNumberOfConstituents(self, *args)
    def getNodeConstituent(self, *args): return _libMEDMEM_Swig.CELLMODEL_getNodeConstituent(self, *args)
    def getConstituentType(self, *args): return _libMEDMEM_Swig.CELLMODEL_getConstituentType(self, *args)
    def getNumberOfConstituentsType(self): return _libMEDMEM_Swig.CELLMODEL_getNumberOfConstituentsType(self)
    def getName(self): return _libMEDMEM_Swig.CELLMODEL_getName(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_CELLMODEL
    __del__ = lambda self : None;
    def __str__(self): return _libMEDMEM_Swig.CELLMODEL___str__(self)
CELLMODEL_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_SUPPORT
    __del__ = lambda self : None;
    def update(self): return _libMEDMEM_Swig.SUPPORT_update(self)
    def getMesh(self): return _libMEDMEM_Swig.SUPPORT_getMesh(self)
    def getMeshName(self): return _libMEDMEM_Swig.SUPPORT_getMeshName(self)
    def setMesh(self, *args): return _libMEDMEM_Swig.SUPPORT_setMesh(self, *args)
    def getEntity(self): return _libMEDMEM_Swig.SUPPORT_getEntity(self)
    def setEntity(self, *args): return _libMEDMEM_Swig.SUPPORT_setEntity(self, *args)
    def isOnAllElements(self): return _libMEDMEM_Swig.SUPPORT_isOnAllElements(self)
    def setAll(self, *args): return _libMEDMEM_Swig.SUPPORT_setAll(self, *args)
    def getNumberOfTypes(self): return _libMEDMEM_Swig.SUPPORT_getNumberOfTypes(self)
    def setNumberOfGeometricType(self, *args): return _libMEDMEM_Swig.SUPPORT_setNumberOfGeometricType(self, *args)
    def getNumberOfElements(self, *args): return _libMEDMEM_Swig.SUPPORT_getNumberOfElements(self, *args)
    def setGeometricType(self, *args): return _libMEDMEM_Swig.SUPPORT_setGeometricType(self, *args)
    def setNumberOfElements(self, *args): return _libMEDMEM_Swig.SUPPORT_setNumberOfElements(self, *args)
    def setNumber(self, *args): return _libMEDMEM_Swig.SUPPORT_setNumber(self, *args)
    def deepCompare(self, *args): return _libMEDMEM_Swig.SUPPORT_deepCompare(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_SUPPORT(*args)
        try: self.this.append(this)
        except: self.this = this
    def setpartial(self, *args): return _libMEDMEM_Swig.SUPPORT_setpartial(self, *args)
    def getName(self): return _libMEDMEM_Swig.SUPPORT_getName(self)
    def setName(self, *args): return _libMEDMEM_Swig.SUPPORT_setName(self, *args)
    def getDescription(self): return _libMEDMEM_Swig.SUPPORT_getDescription(self)
    def setDescription(self, *args): return _libMEDMEM_Swig.SUPPORT_setDescription(self, *args)
    def makeMesh(self): return _libMEDMEM_Swig.SUPPORT_makeMesh(self)
    def __str__(self): return _libMEDMEM_Swig.SUPPORT___str__(self)
    def getTypes(self): return _libMEDMEM_Swig.SUPPORT_getTypes(self)
    def getNumber(self, *args): return _libMEDMEM_Swig.SUPPORT_getNumber(self, *args)
    def getNumberIndex(self): return _libMEDMEM_Swig.SUPPORT_getNumberIndex(self)
    def getComplement(self): return _libMEDMEM_Swig.SUPPORT_getComplement(self)
    def substract(self, *args): return _libMEDMEM_Swig.SUPPORT_substract(self, *args)
    def getBoundaryElements(self, *args): return _libMEDMEM_Swig.SUPPORT_getBoundaryElements(self, *args)
SUPPORT_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_FAMILY
    __del__ = lambda self : None;
    def assign(self, *args): return _libMEDMEM_Swig.FAMILY_assign(self, *args)
    def setIdentifier(self, *args): return _libMEDMEM_Swig.FAMILY_setIdentifier(self, *args)
    def setNumberOfAttributes(self, *args): return _libMEDMEM_Swig.FAMILY_setNumberOfAttributes(self, *args)
    def setAttributesIdentifiers(self, *args): return _libMEDMEM_Swig.FAMILY_setAttributesIdentifiers(self, *args)
    def setAttributesValues(self, *args): return _libMEDMEM_Swig.FAMILY_setAttributesValues(self, *args)
    def setAttributesDescriptions(self, *args): return _libMEDMEM_Swig.FAMILY_setAttributesDescriptions(self, *args)
    def setNumberOfGroups(self, *args): return _libMEDMEM_Swig.FAMILY_setNumberOfGroups(self, *args)
    def setGroupsNames(self, *args): return _libMEDMEM_Swig.FAMILY_setGroupsNames(self, *args)
    def getIdentifier(self): return _libMEDMEM_Swig.FAMILY_getIdentifier(self)
    def getNumberOfAttributes(self): return _libMEDMEM_Swig.FAMILY_getNumberOfAttributes(self)
    def getNumberOfGroups(self): return _libMEDMEM_Swig.FAMILY_getNumberOfGroups(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_FAMILY(*args)
        try: self.this.append(this)
        except: self.this = this
    def getAttributeDescription(self, *args): return _libMEDMEM_Swig.FAMILY_getAttributeDescription(self, *args)
    def getGroupName(self, *args): return _libMEDMEM_Swig.FAMILY_getGroupName(self, *args)
    def __str__(self): return _libMEDMEM_Swig.FAMILY___str__(self)
    def getAttributesIdentifiers(self): return _libMEDMEM_Swig.FAMILY_getAttributesIdentifiers(self)
    def getAttributesValues(self): return _libMEDMEM_Swig.FAMILY_getAttributesValues(self)
FAMILY_swigregister = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_FIELD_(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDMEM_Swig.delete_FIELD_
    __del__ = lambda self : None;
    def rmDriver(self, index = 0): return _libMEDMEM_Swig.FIELD__rmDriver(self, index)
    def setIterationNumber(self, *args): return _libMEDMEM_Swig.FIELD__setIterationNumber(self, *args)
    def getIterationNumber(self): return _libMEDMEM_Swig.FIELD__getIterationNumber(self)
    def setTime(self, *args): return _libMEDMEM_Swig.FIELD__setTime(self, *args)
    def getTime(self): return _libMEDMEM_Swig.FIELD__getTime(self)
    def setOrderNumber(self, *args): return _libMEDMEM_Swig.FIELD__setOrderNumber(self, *args)
    def getOrderNumber(self): return _libMEDMEM_Swig.FIELD__getOrderNumber(self)
    def getValueType(self): return _libMEDMEM_Swig.FIELD__getValueType(self)
    def getInterlacingType(self): return _libMEDMEM_Swig.FIELD__getInterlacingType(self)
    def getSupport(self): return _libMEDMEM_Swig.FIELD__getSupport(self)
    def setSupport(self, *args): return _libMEDMEM_Swig.FIELD__setSupport(self, *args)
    def setNumberOfComponents(self, *args): return _libMEDMEM_Swig.FIELD__setNumberOfComponents(self, *args)
    def getNumberOfComponents(self): return _libMEDMEM_Swig.FIELD__getNumberOfComponents(self)
    def setNumberOfValues(self, *args): return _libMEDMEM_Swig.FIELD__setNumberOfValues(self, *args)
    def getNumberOfValues(self): return _libMEDMEM_Swig.FIELD__getNumberOfValues(self)
    def getName(self): return _libMEDMEM_Swig.FIELD__getName(self)
    def getDescription(self): return _libMEDMEM_Swig.FIELD__getDescription(self)
    def getComponentName(self, *args): return _libMEDMEM_Swig.FIELD__getComponentName(self, *args)
    def getComponentDescription(self, *args): return _libMEDMEM_Swig.FIELD__getComponentDescription(self, *args)
    def getMEDComponentUnit(self, *args): return _libMEDMEM_Swig.FIELD__getMEDComponentUnit(self, *args)
    def setName(self, *args): return _libMEDMEM_Swig.FIELD__setName(self, *args)
    def setComponentName(self, *args): return _libMEDMEM_Swig.FIELD__setComponentName(self, *args)
    def setMEDComponentUnit(self, *args): return _libMEDMEM_Swig.FIELD__setMEDComponentUnit(self, *args)
    def setDescription(self, *args): return _libMEDMEM_Swig.FIELD__setDescription(self, *args)
    def setComponentDescription(self, *args): return _libMEDMEM_Swig.FIELD__setComponentDescription(self, *args)
    def addDriver(self, *args): return _libMEDMEM_Swig.FIELD__addDriver(self, *args)
    def getSupportAndOwner(self): return _libMEDMEM_Swig.FIELD__getSupportAndOwner(self)
FIELD__swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_FIELDDOUBLE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDMEM_Swig.FIELDDOUBLE_read(self, index)
    def getValueIJ(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_setValue(self, *args)
    def setRow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_allocValue(self, *args)
    def deallocValue(self): return _libMEDMEM_Swig.FIELDDOUBLE_deallocValue(self)
    def applyLin(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_applyPow(self, *args)
    def normMax(self): return _libMEDMEM_Swig.FIELDDOUBLE_normMax(self)
    def norm2(self): return _libMEDMEM_Swig.FIELDDOUBLE_norm2(self)
    def normL2(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_normL2(self, *args)
    def normL1(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDDOUBLE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDDOUBLE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDMEM_Swig.FIELDDOUBLE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_FIELDDOUBLE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDMEM_Swig.FIELDDOUBLE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE___add__(self, *args)
    def __sub__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE___mul__(self, *args)
    def __div__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE___div__(self, *args)
    def addDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_divDeep(self, *args)
    def getValue(self): return _libMEDMEM_Swig.FIELDDOUBLE_getValue(self)
    def getValueByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDMEM_Swig.FIELDDOUBLE_extract(self, *args)
FIELDDOUBLE_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_FIELDDOUBLENOINTERLACE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_read(self, index)
    def getValueIJ(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_setValue(self, *args)
    def setRow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_allocValue(self, *args)
    def deallocValue(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_deallocValue(self)
    def applyLin(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_applyPow(self, *args)
    def normMax(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_normMax(self)
    def norm2(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_norm2(self)
    def normL2(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_normL2(self, *args)
    def normL1(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_FIELDDOUBLENOINTERLACE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE___add__(self, *args)
    def __sub__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE___mul__(self, *args)
    def __div__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE___div__(self, *args)
    def addDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_divDeep(self, *args)
    def getValue(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getValue(self)
    def getValueByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACE_extract(self, *args)
FIELDDOUBLENOINTERLACE_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_FIELDDOUBLENOINTERLACEBYTYPE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_read(self, index)
    def getValueIJ(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_setValue(self, *args)
    def setRow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_allocValue(self, *args)
    def deallocValue(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_deallocValue(self)
    def applyLin(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_applyPow(self, *args)
    def normMax(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_normMax(self)
    def norm2(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_norm2(self)
    def normL2(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_normL2(self, *args)
    def normL1(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_FIELDDOUBLENOINTERLACEBYTYPE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE___add__(self, *args)
    def __sub__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE___mul__(self, *args)
    def __div__(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE___div__(self, *args)
    def addDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_divDeep(self, *args)
    def getValue(self): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getValue(self)
    def getValueByType(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDMEM_Swig.FIELDDOUBLENOINTERLACEBYTYPE_extract(self, *args)
FIELDDOUBLENOINTERLACEBYTYPE_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_FIELDINT
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDMEM_Swig.FIELDINT_read(self, index)
    def getValueIJ(self, *args): return _libMEDMEM_Swig.FIELDINT_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDMEM_Swig.FIELDINT_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDINT_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDINT_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDMEM_Swig.FIELDINT_setValue(self, *args)
    def setRow(self, *args): return _libMEDMEM_Swig.FIELDINT_setRow(self, *args)
    def setColumn(self, *args): return _libMEDMEM_Swig.FIELDINT_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDMEM_Swig.FIELDINT_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDMEM_Swig.FIELDINT_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDINT_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDINT_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDMEM_Swig.FIELDINT_allocValue(self, *args)
    def deallocValue(self): return _libMEDMEM_Swig.FIELDINT_deallocValue(self)
    def applyLin(self, *args): return _libMEDMEM_Swig.FIELDINT_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDMEM_Swig.FIELDINT_applyPow(self, *args)
    def normMax(self): return _libMEDMEM_Swig.FIELDINT_normMax(self)
    def norm2(self): return _libMEDMEM_Swig.FIELDINT_norm2(self)
    def normL2(self, *args): return _libMEDMEM_Swig.FIELDINT_normL2(self, *args)
    def normL1(self, *args): return _libMEDMEM_Swig.FIELDINT_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDINT_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDINT_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDMEM_Swig.FIELDINT_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDMEM_Swig.FIELDINT_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDMEM_Swig.FIELDINT_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_FIELDINT(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDMEM_Swig.FIELDINT_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDMEM_Swig.FIELDINT_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDMEM_Swig.FIELDINT_execFunc(self, *args)
    def __add__(self, *args): return _libMEDMEM_Swig.FIELDINT___add__(self, *args)
    def __sub__(self, *args): return _libMEDMEM_Swig.FIELDINT___sub__(self, *args)
    def __mul__(self, *args): return _libMEDMEM_Swig.FIELDINT___mul__(self, *args)
    def __div__(self, *args): return _libMEDMEM_Swig.FIELDINT___div__(self, *args)
    def addDeep(self, *args): return _libMEDMEM_Swig.FIELDINT_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDMEM_Swig.FIELDINT_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDMEM_Swig.FIELDINT_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDMEM_Swig.FIELDINT_divDeep(self, *args)
    def getValue(self): return _libMEDMEM_Swig.FIELDINT_getValue(self)
    def getValueByType(self, *args): return _libMEDMEM_Swig.FIELDINT_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDMEM_Swig.FIELDINT_getRow(self, *args)
    def getColumn(self, *args): return _libMEDMEM_Swig.FIELDINT_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDMEM_Swig.FIELDINT_allocValue2(self, *args)
    def extract(self, *args): return _libMEDMEM_Swig.FIELDINT_extract(self, *args)
FIELDINT_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_FIELDINTNOINTERLACE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_read(self, index)
    def getValueIJ(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_setValue(self, *args)
    def setRow(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_allocValue(self, *args)
    def deallocValue(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_deallocValue(self)
    def applyLin(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_applyPow(self, *args)
    def normMax(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_normMax(self)
    def norm2(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_norm2(self)
    def normL2(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_normL2(self, *args)
    def normL1(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_FIELDINTNOINTERLACE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE___add__(self, *args)
    def __sub__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE___mul__(self, *args)
    def __div__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE___div__(self, *args)
    def addDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_divDeep(self, *args)
    def getValue(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getValue(self)
    def getValueByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACE_extract(self, *args)
FIELDINTNOINTERLACE_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_FIELDINTNOINTERLACEBYTYPE
    __del__ = lambda self : None;
    def read(self, index = 0): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_read(self, index)
    def getValueIJ(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getValueIJ(self, *args)
    def getValueIJK(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getValueIJK(self, *args)
    def getValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getValueIJByType(self, *args)
    def getValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getValueIJKByType(self, *args)
    def setValue(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_setValue(self, *args)
    def setRow(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_setRow(self, *args)
    def setColumn(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_setColumn(self, *args)
    def setValueIJ(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_setValueIJ(self, *args)
    def setValueIJK(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_setValueIJK(self, *args)
    def setValueIJByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_setValueIJByType(self, *args)
    def setValueIJKByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_setValueIJKByType(self, *args)
    def allocValue(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_allocValue(self, *args)
    def deallocValue(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_deallocValue(self)
    def applyLin(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_applyLin(self, *args)
    def applyPow(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_applyPow(self, *args)
    def normMax(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_normMax(self)
    def norm2(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_norm2(self)
    def normL2(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_normL2(self, *args)
    def normL1(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_normL1(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_write(self, index, driverName)
    def writeAppend(self, index = 0, driverName = ""): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_writeAppend(self, index, driverName)
    def getGaussPresence(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getGaussPresence(self)
    def getGaussLocalizationPtr(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getGaussLocalizationPtr(self, *args)
    def getNbGaussI(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getNbGaussI(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_FIELDINTNOINTERLACEBYTYPE(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNumberOfGaussPoints(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getNumberOfGaussPoints(self)
    def applyPyFunc(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_applyPyFunc(self, *args)
    def execFunc(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_execFunc(self, *args)
    def __add__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE___add__(self, *args)
    def __sub__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE___sub__(self, *args)
    def __mul__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE___mul__(self, *args)
    def __div__(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE___div__(self, *args)
    def addDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_addDeep(self, *args)
    def subDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_subDeep(self, *args)
    def mulDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_mulDeep(self, *args)
    def divDeep(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_divDeep(self, *args)
    def getValue(self): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getValue(self)
    def getValueByType(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getValueByType(self, *args)
    def getRow(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getRow(self, *args)
    def getColumn(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_getColumn(self, *args)
    def allocValue2(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_allocValue2(self, *args)
    def extract(self, *args): return _libMEDMEM_Swig.FIELDINTNOINTERLACEBYTYPE_extract(self, *args)
FIELDINTNOINTERLACEBYTYPE_swigregister = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_GROUP()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDMEM_Swig.delete_GROUP
    __del__ = lambda self : None;
    def setNumberOfFamilies(self, *args): return _libMEDMEM_Swig.GROUP_setNumberOfFamilies(self, *args)
    def setFamilies(self, *args): return _libMEDMEM_Swig.GROUP_setFamilies(self, *args)
    def getNumberOfFamilies(self): return _libMEDMEM_Swig.GROUP_getNumberOfFamilies(self)
    def getFamilies(self): return _libMEDMEM_Swig.GROUP_getFamilies(self)
    def getFamily(self, *args): return _libMEDMEM_Swig.GROUP_getFamily(self, *args)
GROUP_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MESH
    __del__ = lambda self : None;
    def rmDriver(self, index = 0): return _libMEDMEM_Swig.MESH_rmDriver(self, index)
    def read(self, index = 0): return _libMEDMEM_Swig.MESH_read(self, index)
    def getSpaceDimension(self): return _libMEDMEM_Swig.MESH_getSpaceDimension(self)
    def getMeshDimension(self): return _libMEDMEM_Swig.MESH_getMeshDimension(self)
    def getNumberOfNodes(self): return _libMEDMEM_Swig.MESH_getNumberOfNodes(self)
    def convertToPoly(self): return _libMEDMEM_Swig.MESH_convertToPoly(self)
    def getIsAGrid(self): return _libMEDMEM_Swig.MESH_getIsAGrid(self)
    def getCoordinate(self, *args): return _libMEDMEM_Swig.MESH_getCoordinate(self, *args)
    def getNumberOfTypes(self, *args): return _libMEDMEM_Swig.MESH_getNumberOfTypes(self, *args)
    def calculateConnectivity(self, *args): return _libMEDMEM_Swig.MESH_calculateConnectivity(self, *args)
    def getNumberOfElements(self, *args): return _libMEDMEM_Swig.MESH_getNumberOfElements(self, *args)
    def getNumberOfFamilies(self, *args): return _libMEDMEM_Swig.MESH_getNumberOfFamilies(self, *args)
    def getElementNumber(self, *args): return _libMEDMEM_Swig.MESH_getElementNumber(self, *args)
    def getCellsTypes(self, *args): return _libMEDMEM_Swig.MESH_getCellsTypes(self, *args)
    def getFamily(self, *args): return _libMEDMEM_Swig.MESH_getFamily(self, *args)
    def getNumberOfGroups(self, *args): return _libMEDMEM_Swig.MESH_getNumberOfGroups(self, *args)
    def getGroup(self, *args): return _libMEDMEM_Swig.MESH_getGroup(self, *args)
    def getElementType(self, *args): return _libMEDMEM_Swig.MESH_getElementType(self, *args)
    def getElementContainingPoint(self, *args): return _libMEDMEM_Swig.MESH_getElementContainingPoint(self, *args)
    def getNumberOfTypesWithPoly(self, *args): return _libMEDMEM_Swig.MESH_getNumberOfTypesWithPoly(self, *args)
    def getNumberOfPolygons(self, *args): return _libMEDMEM_Swig.MESH_getNumberOfPolygons(self, *args)
    def getNumberOfPolyhedronFaces(self): return _libMEDMEM_Swig.MESH_getNumberOfPolyhedronFaces(self)
    def getNumberOfPolyhedron(self): return _libMEDMEM_Swig.MESH_getNumberOfPolyhedron(self)
    def getNumberOfElementsWithPoly(self, *args): return _libMEDMEM_Swig.MESH_getNumberOfElementsWithPoly(self, *args)
    def existPolygonsConnectivity(self, *args): return _libMEDMEM_Swig.MESH_existPolygonsConnectivity(self, *args)
    def existPolyhedronConnectivity(self, *args): return _libMEDMEM_Swig.MESH_existPolyhedronConnectivity(self, *args)
    def getElementTypeWithPoly(self, *args): return _libMEDMEM_Swig.MESH_getElementTypeWithPoly(self, *args)
    def getSupportOnAll(self, *args): return _libMEDMEM_Swig.MESH_getSupportOnAll(self, *args)
    def getName(self): return _libMEDMEM_Swig.MESH_getName(self)
    def getBoundaryElements(self, *args): return _libMEDMEM_Swig.MESH_getBoundaryElements(self, *args)
    def getSkin(self, *args): return _libMEDMEM_Swig.MESH_getSkin(self, *args)
    def mergeSupports(self, *args): return _libMEDMEM_Swig.MESH_mergeSupports(self, *args)
    def intersectSupports(self, *args): return _libMEDMEM_Swig.MESH_intersectSupports(self, *args)
    def mergeFieldsDouble(self, *args): return _libMEDMEM_Swig.MESH_mergeFieldsDouble(self, *args)
    def mergeFieldsInt(self, *args): return _libMEDMEM_Swig.MESH_mergeFieldsInt(self, *args)
    def getCellType(self, *args): return _libMEDMEM_Swig.MESH_getCellType(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MESH(*args)
        try: self.this.append(this)
        except: self.this = this
    def addDriver(self, *args): return _libMEDMEM_Swig.MESH_addDriver(self, *args)
    def write(self, index = 0, driverName = ""): return _libMEDMEM_Swig.MESH_write(self, index, driverName)
    def setName(self, *args): return _libMEDMEM_Swig.MESH_setName(self, *args)
    def getCoordinatesSystem(self): return _libMEDMEM_Swig.MESH_getCoordinatesSystem(self)
    def __str__(self): return _libMEDMEM_Swig.MESH___str__(self)
    def getCoordinateName(self, *args): return _libMEDMEM_Swig.MESH_getCoordinateName(self, *args)
    def getCoordinateUnit(self, *args): return _libMEDMEM_Swig.MESH_getCoordinateUnit(self, *args)
    def getCoordinatesNames(self): return _libMEDMEM_Swig.MESH_getCoordinatesNames(self)
    def getCoordinatesUnits(self): return _libMEDMEM_Swig.MESH_getCoordinatesUnits(self)
    def getCoordinates(self, *args): return _libMEDMEM_Swig.MESH_getCoordinates(self, *args)
    def getTypes(self, *args): return _libMEDMEM_Swig.MESH_getTypes(self, *args)
    def getConnectivity(self, *args): return _libMEDMEM_Swig.MESH_getConnectivity(self, *args)
    def getConnectivityIndex(self, *args): return _libMEDMEM_Swig.MESH_getConnectivityIndex(self, *args)
    def getReverseConnectivity(self, *args): return _libMEDMEM_Swig.MESH_getReverseConnectivity(self, *args)
    def getReverseConnectivityIndex(self, *args): return _libMEDMEM_Swig.MESH_getReverseConnectivityIndex(self, *args)
    def getGlobalNumberingIndex(self, *args): return _libMEDMEM_Swig.MESH_getGlobalNumberingIndex(self, *args)
    def getPolygonsConnectivity(self, *args): return _libMEDMEM_Swig.MESH_getPolygonsConnectivity(self, *args)
    def getPolygonsConnectivityIndex(self, *args): return _libMEDMEM_Swig.MESH_getPolygonsConnectivityIndex(self, *args)
    def getPolyhedronConnectivity(self, *args): return _libMEDMEM_Swig.MESH_getPolyhedronConnectivity(self, *args)
    def getPolyhedronIndex(self, *args): return _libMEDMEM_Swig.MESH_getPolyhedronIndex(self, *args)
    def getPolyhedronFacesIndex(self): return _libMEDMEM_Swig.MESH_getPolyhedronFacesIndex(self)
    def getTypesWithPoly(self, *args): return _libMEDMEM_Swig.MESH_getTypesWithPoly(self, *args)
    def getVolume(self, *args): return _libMEDMEM_Swig.MESH_getVolume(self, *args)
    def getArea(self, *args): return _libMEDMEM_Swig.MESH_getArea(self, *args)
    def getLength(self, *args): return _libMEDMEM_Swig.MESH_getLength(self, *args)
    def getNormal(self, *args): return _libMEDMEM_Swig.MESH_getNormal(self, *args)
    def getBarycenter(self, *args): return _libMEDMEM_Swig.MESH_getBarycenter(self, *args)
MESH_swigregister = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_MESHING()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDMEM_Swig.delete_MESHING
    __del__ = lambda self : None;
    def setSpaceDimension(self, *args): return _libMEDMEM_Swig.MESHING_setSpaceDimension(self, *args)
    def setMeshDimension(self, *args): return _libMEDMEM_Swig.MESHING_setMeshDimension(self, *args)
    def setNumberOfNodes(self, *args): return _libMEDMEM_Swig.MESHING_setNumberOfNodes(self, *args)
    def setNumberOfTypes(self, *args): return _libMEDMEM_Swig.MESHING_setNumberOfTypes(self, *args)
    def setTypes(self, *args): return _libMEDMEM_Swig.MESHING_setTypes(self, *args)
    def setNumberOfElements(self, *args): return _libMEDMEM_Swig.MESHING_setNumberOfElements(self, *args)
    def setConnectivity(self, *args): return _libMEDMEM_Swig.MESHING_setConnectivity(self, *args)
    def setConnectivities(self, *args): return _libMEDMEM_Swig.MESHING_setConnectivities(self, *args)
    def addGroup(self, *args): return _libMEDMEM_Swig.MESHING_addGroup(self, *args)
    def setPolygonsConnectivity(self, *args): return _libMEDMEM_Swig.MESHING_setPolygonsConnectivity(self, *args)
    def setPolyhedraConnectivity(self, *args): return _libMEDMEM_Swig.MESHING_setPolyhedraConnectivity(self, *args)
    def setCoordinates(self, *args): return _libMEDMEM_Swig.MESHING_setCoordinates(self, *args)
    def setCoordinatesSystem(self, *args): return _libMEDMEM_Swig.MESHING_setCoordinatesSystem(self, *args)
    def setCoordinateName(self, *args): return _libMEDMEM_Swig.MESHING_setCoordinateName(self, *args)
    def setCoordinateUnit(self, *args): return _libMEDMEM_Swig.MESHING_setCoordinateUnit(self, *args)
MESHING_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GRID
    __del__ = lambda self : None;
    def getNodeNumber(self, *args): return _libMEDMEM_Swig.GRID_getNodeNumber(self, *args)
    def getCellNumber(self, *args): return _libMEDMEM_Swig.GRID_getCellNumber(self, *args)
    def getEdgeNumber(self, *args): return _libMEDMEM_Swig.GRID_getEdgeNumber(self, *args)
    def getFaceNumber(self, *args): return _libMEDMEM_Swig.GRID_getFaceNumber(self, *args)
    def getGridType(self): return _libMEDMEM_Swig.GRID_getGridType(self)
    def getArrayLength(self, *args): return _libMEDMEM_Swig.GRID_getArrayLength(self, *args)
    def getArrayValue(self, *args): return _libMEDMEM_Swig.GRID_getArrayValue(self, *args)
    def setGridType(self, *args): return _libMEDMEM_Swig.GRID_setGridType(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GRID(*args)
        try: self.this.append(this)
        except: self.this = this
    def getEntityPosition(self, *args): return _libMEDMEM_Swig.GRID_getEntityPosition(self, *args)
GRID_swigregister = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_PointLocator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libMEDMEM_Swig.delete_PointLocator
    __del__ = lambda self : None;
    def locate(self, *args): return _libMEDMEM_Swig.PointLocator_locate(self, *args)
PointLocator_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED
    __del__ = lambda self : None;
    def rmDriver(self, index = 0): return _libMEDMEM_Swig.MED_rmDriver(self, index)
    def getNumberOfMeshes(self): return _libMEDMEM_Swig.MED_getNumberOfMeshes(self)
    def getNumberOfFields(self): return _libMEDMEM_Swig.MED_getNumberOfFields(self)
    def updateSupport(self): return _libMEDMEM_Swig.MED_updateSupport(self)
    def write(self, index = 0): return _libMEDMEM_Swig.MED_write(self, index)
    def read(self, index = 0): return _libMEDMEM_Swig.MED_read(self, index)
    def readFileStruct(self, index = 0): return _libMEDMEM_Swig.MED_readFileStruct(self, index)
    def addField(self, *args): return _libMEDMEM_Swig.MED_addField(self, *args)
    def addMesh(self, *args): return _libMEDMEM_Swig.MED_addMesh(self, *args)
    def updateNamesInMaps(self): return _libMEDMEM_Swig.MED_updateNamesInMaps(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED(*args)
        try: self.this.append(this)
        except: self.this = this
    def addDriver(self, *args): return _libMEDMEM_Swig.MED_addDriver(self, *args)
    def getMeshNames(self): return _libMEDMEM_Swig.MED_getMeshNames(self)
    def getMeshName(self, *args): return _libMEDMEM_Swig.MED_getMeshName(self, *args)
    def getFieldNames(self): return _libMEDMEM_Swig.MED_getFieldNames(self)
    def getFieldName(self, *args): return _libMEDMEM_Swig.MED_getFieldName(self, *args)
    def getMesh(self, *args): return _libMEDMEM_Swig.MED_getMesh(self, *args)
    def getFieldNumberOfIteration(self, *args): return _libMEDMEM_Swig.MED_getFieldNumberOfIteration(self, *args)
    def getFieldIteration(self, *args): return _libMEDMEM_Swig.MED_getFieldIteration(self, *args)
    def getField(self, *args): return _libMEDMEM_Swig.MED_getField(self, *args)
    def getFieldT(self, *args): return _libMEDMEM_Swig.MED_getFieldT(self, *args)
    def getField2(self, *args): return _libMEDMEM_Swig.MED_getField2(self, *args)
    def getSupport(self, *args): return _libMEDMEM_Swig.MED_getSupport(self, *args)
MED_swigregister = _libMEDMEM_Swig.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 _libMEDMEM_Swig.MED_MED_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_MED_RDONLY_DRIVER_close(self)
    def read(self): return _libMEDMEM_Swig.MED_MED_RDONLY_DRIVER_read(self)
    def readFileStruct(self): return _libMEDMEM_Swig.MED_MED_RDONLY_DRIVER_readFileStruct(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_MED_MED_RDONLY_DRIVER
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_MED_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_MED_RDONLY_DRIVER___str__(self)
MED_MED_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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 _libMEDMEM_Swig.MED_MED_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_MED_WRONLY_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_MED_WRONLY_DRIVER_write(self)
    def writeFrom(self): return _libMEDMEM_Swig.MED_MED_WRONLY_DRIVER_writeFrom(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_MED_MED_WRONLY_DRIVER
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_MED_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_MED_WRONLY_DRIVER___str__(self)
MED_MED_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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 _libMEDMEM_Swig.MED_MED_RDWR_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_MED_RDWR_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_MED_RDWR_DRIVER_write(self)
    def writeFrom(self): return _libMEDMEM_Swig.MED_MED_RDWR_DRIVER_writeFrom(self)
    def read(self): return _libMEDMEM_Swig.MED_MED_RDWR_DRIVER_read(self)
    def readFileStruct(self): return _libMEDMEM_Swig.MED_MED_RDWR_DRIVER_readFileStruct(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_MED_MED_RDWR_DRIVER
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_MED_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_MED_RDWR_DRIVER___str__(self)
MED_MED_RDWR_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GIBI_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.GIBI_MESH_RDONLY_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.GIBI_MESH_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.GIBI_MESH_RDONLY_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.GIBI_MESH_RDONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GIBI_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.GIBI_MESH_RDONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.GIBI_MESH_RDONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.GIBI_MESH_RDONLY_DRIVER_getMeshName(self)
GIBI_MESH_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GIBI_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.GIBI_MESH_WRONLY_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.GIBI_MESH_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.GIBI_MESH_WRONLY_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.GIBI_MESH_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GIBI_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.GIBI_MESH_WRONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.GIBI_MESH_WRONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.GIBI_MESH_WRONLY_DRIVER_getMeshName(self)
GIBI_MESH_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GIBI_MESH_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.GIBI_MESH_RDWR_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.GIBI_MESH_RDWR_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.GIBI_MESH_RDWR_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.GIBI_MESH_RDWR_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GIBI_MESH_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.GIBI_MESH_RDWR_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.GIBI_MESH_RDWR_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.GIBI_MESH_RDWR_DRIVER_getMeshName(self)
GIBI_MESH_RDWR_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GIBI_MED_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.GIBI_MED_RDONLY_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.GIBI_MED_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.GIBI_MED_RDONLY_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.GIBI_MED_RDONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GIBI_MED_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.GIBI_MED_RDONLY_DRIVER___str__(self)
GIBI_MED_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GIBI_MED_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.GIBI_MED_WRONLY_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.GIBI_MED_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.GIBI_MED_WRONLY_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.GIBI_MED_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GIBI_MED_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.GIBI_MED_WRONLY_DRIVER___str__(self)
GIBI_MED_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_PORFLOW_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDONLY_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDONLY_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_PORFLOW_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.PORFLOW_MESH_RDONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDONLY_DRIVER_getMeshName(self)
PORFLOW_MESH_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_PORFLOW_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.PORFLOW_MESH_WRONLY_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.PORFLOW_MESH_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.PORFLOW_MESH_WRONLY_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.PORFLOW_MESH_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_PORFLOW_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.PORFLOW_MESH_WRONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.PORFLOW_MESH_WRONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.PORFLOW_MESH_WRONLY_DRIVER_getMeshName(self)
PORFLOW_MESH_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_PORFLOW_MESH_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDWR_DRIVER_open(self)
    def write(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDWR_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDWR_DRIVER_read(self)
    def close(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDWR_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_PORFLOW_MESH_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDWR_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.PORFLOW_MESH_RDWR_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.PORFLOW_MESH_RDWR_DRIVER_getMeshName(self)
PORFLOW_MESH_RDWR_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_read(self)
    def desactivateFacesComputation(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_desactivateFacesComputation(self)
    def activateFacesComputation(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_activateFacesComputation(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.MED_MESH_RDONLY_DRIVER_getMeshName(self)
MED_MESH_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
    def write(self): return _libMEDMEM_Swig.MED_MESH_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_MESH_WRONLY_DRIVER_read(self)
    def open(self): return _libMEDMEM_Swig.MED_MESH_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_MESH_WRONLY_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_MESH_WRONLY_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.MED_MESH_WRONLY_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.MED_MESH_WRONLY_DRIVER_getMeshName(self)
MED_MESH_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_MESH_RDWR_DRIVER
    __del__ = lambda self : None;
    def write(self): return _libMEDMEM_Swig.MED_MESH_RDWR_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_MESH_RDWR_DRIVER_read(self)
    def open(self): return _libMEDMEM_Swig.MED_MESH_RDWR_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_MESH_RDWR_DRIVER_close(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_MESH_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_MESH_RDWR_DRIVER___str__(self)
    def setMeshName(self, *args): return _libMEDMEM_Swig.MED_MESH_RDWR_DRIVER_setMeshName(self, *args)
    def getMeshName(self): return _libMEDMEM_Swig.MED_MESH_RDWR_DRIVER_getMeshName(self)
MED_MESH_RDWR_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_FIELDDOUBLE_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDONLY_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_FIELDDOUBLE_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDONLY_DRIVER_getFieldName(self)
MED_FIELDDOUBLE_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_FIELDINT_RDONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.MED_FIELDINT_RDONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_FIELDINT_RDONLY_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_FIELDINT_RDONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_FIELDINT_RDONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_FIELDINT_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_FIELDINT_RDONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDMEM_Swig.MED_FIELDINT_RDONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDMEM_Swig.MED_FIELDINT_RDONLY_DRIVER_getFieldName(self)
MED_FIELDINT_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_FIELDDOUBLE_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_WRONLY_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_WRONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_FIELDDOUBLE_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_WRONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDMEM_Swig.MED_FIELDDOUBLE_WRONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_WRONLY_DRIVER_getFieldName(self)
MED_FIELDDOUBLE_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_FIELDINT_WRONLY_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.MED_FIELDINT_WRONLY_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_FIELDINT_WRONLY_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_FIELDINT_WRONLY_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_FIELDINT_WRONLY_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_FIELDINT_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_FIELDINT_WRONLY_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDMEM_Swig.MED_FIELDINT_WRONLY_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDMEM_Swig.MED_FIELDINT_WRONLY_DRIVER_getFieldName(self)
MED_FIELDINT_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_FIELDDOUBLE_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDWR_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDWR_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDWR_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDWR_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_FIELDDOUBLE_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDWR_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDWR_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDMEM_Swig.MED_FIELDDOUBLE_RDWR_DRIVER_getFieldName(self)
MED_FIELDDOUBLE_RDWR_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_MED_FIELDINT_RDWR_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.MED_FIELDINT_RDWR_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.MED_FIELDINT_RDWR_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.MED_FIELDINT_RDWR_DRIVER_write(self)
    def read(self): return _libMEDMEM_Swig.MED_FIELDINT_RDWR_DRIVER_read(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_MED_FIELDINT_RDWR_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.MED_FIELDINT_RDWR_DRIVER___str__(self)
    def setFieldName(self, *args): return _libMEDMEM_Swig.MED_FIELDINT_RDWR_DRIVER_setFieldName(self, *args)
    def getFieldName(self): return _libMEDMEM_Swig.MED_FIELDINT_RDWR_DRIVER_getFieldName(self)
MED_FIELDINT_RDWR_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_ASCII_FIELDDOUBLE_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.ASCII_FIELDDOUBLE_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.ASCII_FIELDDOUBLE_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.ASCII_FIELDDOUBLE_DRIVER_write(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_ASCII_FIELDDOUBLE_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
ASCII_FIELDDOUBLE_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_ASCII_FIELDINT_DRIVER
    __del__ = lambda self : None;
    def open(self): return _libMEDMEM_Swig.ASCII_FIELDINT_DRIVER_open(self)
    def close(self): return _libMEDMEM_Swig.ASCII_FIELDINT_DRIVER_close(self)
    def write(self): return _libMEDMEM_Swig.ASCII_FIELDINT_DRIVER_write(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_ASCII_FIELDINT_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
ASCII_FIELDINT_DRIVER_swigregister = _libMEDMEM_Swig.ASCII_FIELDINT_DRIVER_swigregister
ASCII_FIELDINT_DRIVER_swigregister(ASCII_FIELDINT_DRIVER)

ENSIGHT_6 = _libMEDMEM_Swig.ENSIGHT_6
ENSIGHT_GOLD = _libMEDMEM_Swig.ENSIGHT_GOLD

def setEnSightFormatForWriting(*args):
  return _libMEDMEM_Swig.setEnSightFormatForWriting(*args)
setEnSightFormatForWriting = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_ENSIGHT_MED_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def read(self): return _libMEDMEM_Swig.ENSIGHT_MED_RDONLY_DRIVER_read(self)
    def readFileStruct(self): return _libMEDMEM_Swig.ENSIGHT_MED_RDONLY_DRIVER_readFileStruct(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_ENSIGHT_MED_RDONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MED_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.ENSIGHT_MED_RDONLY_DRIVER_swigregister
ENSIGHT_MED_RDONLY_DRIVER_swigregister(ENSIGHT_MED_RDONLY_DRIVER)

def setIgnoreIncompatibility(toIgnore = True):
  return _libMEDMEM_Swig.setIgnoreIncompatibility(toIgnore)
setIgnoreIncompatibility = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_ENSIGHT_MED_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def write(self): return _libMEDMEM_Swig.ENSIGHT_MED_WRONLY_DRIVER_write(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_ENSIGHT_MED_WRONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MED_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_ENSIGHT_MESH_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def read(self): return _libMEDMEM_Swig.ENSIGHT_MESH_RDONLY_DRIVER_read(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_ENSIGHT_MESH_RDONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MESH_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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 = _libMEDMEM_Swig.new_ENSIGHT_MESH_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def write(self): return _libMEDMEM_Swig.ENSIGHT_MESH_WRONLY_DRIVER_write(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_ENSIGHT_MESH_WRONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_MESH_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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 _libMEDMEM_Swig.ENSIGHT_FIELD_RDONLY_DRIVER_setFieldName(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_ENSIGHT_FIELD_RDONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def read(self): return _libMEDMEM_Swig.ENSIGHT_FIELD_RDONLY_DRIVER_read(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_ENSIGHT_FIELD_RDONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_FIELD_RDONLY_DRIVER_swigregister = _libMEDMEM_Swig.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 _libMEDMEM_Swig.ENSIGHT_FIELD_WRONLY_DRIVER_setFieldName(self, *args)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_ENSIGHT_FIELD_WRONLY_DRIVER(*args)
        try: self.this.append(this)
        except: self.this = this
    def write(self): return _libMEDMEM_Swig.ENSIGHT_FIELD_WRONLY_DRIVER_write(self)
    __swig_destroy__ = _libMEDMEM_Swig.delete_ENSIGHT_FIELD_WRONLY_DRIVER
    __del__ = lambda self : None;
ENSIGHT_FIELD_WRONLY_DRIVER_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GAUSS_LOCALIZATION_FULL
    __del__ = lambda self : None;
    def getName(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL_getName(self)
    def getType(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL_getType(self)
    def getNbGauss(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL_getNbGauss(self)
    def getInterlacingType(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL_getInterlacingType(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GAUSS_LOCALIZATION_FULL(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL___str__(self)
    def getRefCoo(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL_getRefCoo(self)
    def getGsCoo(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL_getGsCoo(self)
    def getWeight(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_FULL_getWeight(self)
GAUSS_LOCALIZATION_FULL_swigregister = _libMEDMEM_Swig.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__ = _libMEDMEM_Swig.delete_GAUSS_LOCALIZATION_NO
    __del__ = lambda self : None;
    def getName(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_getName(self)
    def getType(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_getType(self)
    def getNbGauss(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_getNbGauss(self)
    def getInterlacingType(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_getInterlacingType(self)
    def __init__(self, *args): 
        this = _libMEDMEM_Swig.new_GAUSS_LOCALIZATION_NO(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO___str__(self)
    def getRefCoo(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_getRefCoo(self)
    def getGsCoo(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_getGsCoo(self)
    def getWeight(self): return _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_getWeight(self)
GAUSS_LOCALIZATION_NO_swigregister = _libMEDMEM_Swig.GAUSS_LOCALIZATION_NO_swigregister
GAUSS_LOCALIZATION_NO_swigregister(GAUSS_LOCALIZATION_NO)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


