text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 4.0.2
  #
  # Do not make changes to this file unless you know what you are doing--modify
  # the SWIG interface file instead.
  
  from sys import version_info as _swig_python_version_info
  if _swig_python_version_info < (2, 7, 0):
      raise RuntimeError("Python 2.7 or later required")
  
  # Import the low-level C/C++ module
  if __package__ or "." in __name__:
      from . import _fespace
  else:
      import _fespace
  
  try:
      import builtins as __builtin__
  except ImportError:
      import __builtin__
  
  _swig_new_instance_method = _fespace.SWIG_PyInstanceMethod_New
  _swig_new_static_method = _fespace.SWIG_PyStaticMethod_New
  
  def _swig_repr(self):
      try:
          strthis = "proxy of " + self.this.__repr__()
      except __builtin__.Exception:
          strthis = ""
      return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
  
  
  def _swig_setattr_nondynamic_instance_variable(set):
      def set_instance_attr(self, name, value):
          if name == "thisown":
              self.this.own(value)
          elif name == "this":
              set(self, name, value)
          elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
              set(self, name, value)
          else:
              raise AttributeError("You cannot add instance attributes to %s" % self)
      return set_instance_attr
  
  
  def _swig_setattr_nondynamic_class_variable(set):
      def set_class_attr(cls, name, value):
          if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
              set(cls, name, value)
          else:
              raise AttributeError("You cannot add class attributes to %s" % cls)
      return set_class_attr
  
  
  def _swig_add_metaclass(metaclass):
      """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
      def wrapper(cls):
          return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
      return wrapper
  
  
  class _SwigNonDynamicMeta(type):
      """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
      __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
  
  
  import weakref
  
  import mfem._par.array
  import mfem._par.mem_manager
  import mfem._par.vector
  import mfem._par.coefficient
  import mfem._par.globals
  import mfem._par.matrix
  import mfem._par.operators
  import mfem._par.symmat
  import mfem._par.intrules
  import mfem._par.sparsemat
  import mfem._par.densemat
  import mfem._par.eltrans
  import mfem._par.fe
  import mfem._par.geom
  import mfem._par.fe_base
  import mfem._par.fe_fixed_order
  import mfem._par.element
  import mfem._par.table
  import mfem._par.hash
  import mfem._par.fe_h1
  import mfem._par.fe_nd
  import mfem._par.fe_rt
  import mfem._par.fe_l2
  import mfem._par.fe_nurbs
  import mfem._par.fe_pos
  import mfem._par.fe_ser
  import mfem._par.mesh
  import mfem._par.sort_pairs
  import mfem._par.ncmesh
  import mfem._par.vtk
  import mfem._par.vertex
  import mfem._par.gridfunc
  import mfem._par.bilininteg
  import mfem._par.fe_coll
  import mfem._par.lininteg
  import mfem._par.linearform
  import mfem._par.nonlininteg
  import mfem._par.doftrans
  import mfem._par.handle
  import mfem._par.hypre
  import mfem._par.restriction
  class FiniteElementSpacePtrArray(object):
      r"""Proxy of C++ mfem::Array< mfem::FiniteElementSpace * > class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
      __swig_destroy__ = _fespace.delete_FiniteElementSpacePtrArray
  
      def GetData(self, *args):
          r"""
          GetData(FiniteElementSpacePtrArray self) -> FiniteElementSpace
          GetData(FiniteElementSpacePtrArray self) -> mfem::FiniteElementSpace *const *
          """
          return _fespace.FiniteElementSpacePtrArray_GetData(self, *args)
      GetData = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_GetData)
  
      def GetMemory(self, *args):
          r"""
          GetMemory(FiniteElementSpacePtrArray self) -> mfem::Memory< mfem::FiniteElementSpace * >
          GetMemory(FiniteElementSpacePtrArray self) -> mfem::Memory< mfem::FiniteElementSpace * > const &
          """
          return _fespace.FiniteElementSpacePtrArray_GetMemory(self, *args)
      GetMemory = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_GetMemory)
  
      def UseDevice(self):
          r"""UseDevice(FiniteElementSpacePtrArray self) -> bool"""
          return _fespace.FiniteElementSpacePtrArray_UseDevice(self)
      UseDevice = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_UseDevice)
  
      def OwnsData(self):
          r"""OwnsData(FiniteElementSpacePtrArray self) -> bool"""
          return _fespace.FiniteElementSpacePtrArray_OwnsData(self)
      OwnsData = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_OwnsData)
  
      def StealData(self, p):
          r"""StealData(FiniteElementSpacePtrArray self, mfem::FiniteElementSpace *** p)"""
          return _fespace.FiniteElementSpacePtrArray_StealData(self, p)
      StealData = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_StealData)
  
      def LoseData(self):
          r"""LoseData(FiniteElementSpacePtrArray self)"""
          return _fespace.FiniteElementSpacePtrArray_LoseData(self)
      LoseData = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_LoseData)
  
      def MakeDataOwner(self):
          r"""MakeDataOwner(FiniteElementSpacePtrArray self)"""
          return _fespace.FiniteElementSpacePtrArray_MakeDataOwner(self)
      MakeDataOwner = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_MakeDataOwner)
  
      def Size(self):
          r"""Size(FiniteElementSpacePtrArray self) -> int"""
          return _fespace.FiniteElementSpacePtrArray_Size(self)
      Size = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Size)
  
      def SetSize(self, *args):
          r"""
          SetSize(FiniteElementSpacePtrArray self, int nsize)
          SetSize(FiniteElementSpacePtrArray self, int nsize, FiniteElementSpace initval)
          SetSize(FiniteElementSpacePtrArray self, int nsize, mfem::MemoryType mt)
          """
          return _fespace.FiniteElementSpacePtrArray_SetSize(self, *args)
      SetSize = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_SetSize)
  
      def Capacity(self):
          r"""Capacity(FiniteElementSpacePtrArray self) -> int"""
          return _fespace.FiniteElementSpacePtrArray_Capacity(self)
      Capacity = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Capacity)
  
      def Reserve(self, capacity):
          r"""Reserve(FiniteElementSpacePtrArray self, int capacity)"""
          return _fespace.FiniteElementSpacePtrArray_Reserve(self, capacity)
      Reserve = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Reserve)
  
      def Append(self, *args):
          r"""
          Append(FiniteElementSpacePtrArray self, FiniteElementSpace el) -> int
          Append(FiniteElementSpacePtrArray self, mfem::FiniteElementSpace *const * els, int nels) -> int
          Append(FiniteElementSpacePtrArray self, FiniteElementSpacePtrArray els) -> int
          """
          return _fespace.FiniteElementSpacePtrArray_Append(self, *args)
      Append = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Append)
  
      def Prepend(self, el):
          r"""Prepend(FiniteElementSpacePtrArray self, FiniteElementSpace el) -> int"""
          return _fespace.FiniteElementSpacePtrArray_Prepend(self, el)
      Prepend = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Prepend)
  
      def Last(self, *args):
          r"""
          Last(FiniteElementSpacePtrArray self) -> FiniteElementSpace
          Last(FiniteElementSpacePtrArray self) -> FiniteElementSpace
          """
          return _fespace.FiniteElementSpacePtrArray_Last(self, *args)
      Last = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Last)
  
      def DeleteLast(self):
          r"""DeleteLast(FiniteElementSpacePtrArray self)"""
          return _fespace.FiniteElementSpacePtrArray_DeleteLast(self)
      DeleteLast = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_DeleteLast)
  
      def DeleteAll(self):
          r"""DeleteAll(FiniteElementSpacePtrArray self)"""
          return _fespace.FiniteElementSpacePtrArray_DeleteAll(self)
      DeleteAll = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_DeleteAll)
  
      def Copy(self, copy):
          r"""Copy(FiniteElementSpacePtrArray self, FiniteElementSpacePtrArray copy)"""
          return _fespace.FiniteElementSpacePtrArray_Copy(self, copy)
      Copy = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Copy)
  
      def MakeRef(self, *args):
          r"""
          MakeRef(FiniteElementSpacePtrArray self, mfem::FiniteElementSpace ** arg2, int arg3)
          MakeRef(FiniteElementSpacePtrArray self, FiniteElementSpacePtrArray master)
          """
          return _fespace.FiniteElementSpacePtrArray_MakeRef(self, *args)
      MakeRef = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_MakeRef)
  
      def GetSubArray(self, offset, sa_size, sa):
          r"""GetSubArray(FiniteElementSpacePtrArray self, int offset, int sa_size, FiniteElementSpacePtrArray sa)"""
          return _fespace.FiniteElementSpacePtrArray_GetSubArray(self, offset, sa_size, sa)
      GetSubArray = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_GetSubArray)
  
      def begin(self, *args):
          r"""
          begin(FiniteElementSpacePtrArray self) -> FiniteElementSpace
          begin(FiniteElementSpacePtrArray self) -> mfem::FiniteElementSpace *const *
          """
          return _fespace.FiniteElementSpacePtrArray_begin(self, *args)
      begin = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_begin)
  
      def end(self, *args):
          r"""
          end(FiniteElementSpacePtrArray self) -> FiniteElementSpace
          end(FiniteElementSpacePtrArray self) -> mfem::FiniteElementSpace *const *
          """
          return _fespace.FiniteElementSpacePtrArray_end(self, *args)
      end = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_end)
  
      def MemoryUsage(self):
          r"""MemoryUsage(FiniteElementSpacePtrArray self) -> long"""
          return _fespace.FiniteElementSpacePtrArray_MemoryUsage(self)
      MemoryUsage = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_MemoryUsage)
  
      def Read(self, on_dev=True):
          r"""Read(FiniteElementSpacePtrArray self, bool on_dev=True) -> mfem::FiniteElementSpace *const *"""
          return _fespace.FiniteElementSpacePtrArray_Read(self, on_dev)
      Read = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Read)
  
      def HostRead(self):
          r"""HostRead(FiniteElementSpacePtrArray self) -> mfem::FiniteElementSpace *const *"""
          return _fespace.FiniteElementSpacePtrArray_HostRead(self)
      HostRead = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_HostRead)
  
      def Write(self, on_dev=True):
          r"""Write(FiniteElementSpacePtrArray self, bool on_dev=True) -> mfem::FiniteElementSpace **"""
          return _fespace.FiniteElementSpacePtrArray_Write(self, on_dev)
      Write = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Write)
  
      def HostWrite(self):
          r"""HostWrite(FiniteElementSpacePtrArray self) -> mfem::FiniteElementSpace **"""
          return _fespace.FiniteElementSpacePtrArray_HostWrite(self)
      HostWrite = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_HostWrite)
  
      def ReadWrite(self, on_dev=True):
          r"""ReadWrite(FiniteElementSpacePtrArray self, bool on_dev=True) -> mfem::FiniteElementSpace **"""
          return _fespace.FiniteElementSpacePtrArray_ReadWrite(self, on_dev)
      ReadWrite = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_ReadWrite)
  
      def HostReadWrite(self):
          r"""HostReadWrite(FiniteElementSpacePtrArray self) -> mfem::FiniteElementSpace **"""
          return _fespace.FiniteElementSpacePtrArray_HostReadWrite(self)
      HostReadWrite = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_HostReadWrite)
  
      def __init__(self, *args):
          r"""
          __init__(FiniteElementSpacePtrArray self) -> FiniteElementSpacePtrArray
          __init__(FiniteElementSpacePtrArray self, mfem::MemoryType mt) -> FiniteElementSpacePtrArray
          __init__(FiniteElementSpacePtrArray self, int asize) -> FiniteElementSpacePtrArray
          __init__(FiniteElementSpacePtrArray self, int asize, mfem::MemoryType mt) -> FiniteElementSpacePtrArray
          __init__(FiniteElementSpacePtrArray self, mfem::FiniteElementSpace ** data_) -> FiniteElementSpacePtrArray
          __init__(FiniteElementSpacePtrArray self, FiniteElementSpacePtrArray src) -> FiniteElementSpacePtrArray
          __init__(FiniteElementSpacePtrArray self, void * List_or_Tuple) -> FiniteElementSpacePtrArray
          """
          _fespace.FiniteElementSpacePtrArray_swiginit(self, _fespace.new_FiniteElementSpacePtrArray(*args))
  
      def __setitem__(self, i, v):
          r"""__setitem__(FiniteElementSpacePtrArray self, int i, FiniteElementSpace v)"""
  
          i = int(i)
  
  
          return _fespace.FiniteElementSpacePtrArray___setitem__(self, i, v)
  
  
      def Assign(self, *args):
          r"""
          Assign(FiniteElementSpacePtrArray self, mfem::FiniteElementSpace *const * arg2)
          Assign(FiniteElementSpacePtrArray self, FiniteElementSpace a)
          """
          return _fespace.FiniteElementSpacePtrArray_Assign(self, *args)
      Assign = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray_Assign)
  
      def ToList(self):
          return [self[i] for i in range(self.Size())]
  
  
  
      def __iter__(self):
          class iter_array:
              def __init__(self, obj):
                  self.obj = obj
                  self.idx = 0
                  self.size = obj.Size()
              def __iter__(self):
                  self.idx = 0
              def __next__(self):
                  if self.idx < self.size:
                      res = self.obj[self.idx]
                      self.idx += 1
                      return res
                  else:
                      raise StopIteration
          return iter_array(self)
  
  
  
      def __getitem__(self, param):
          r"""__getitem__(FiniteElementSpacePtrArray self, PyObject * param) -> PyObject *"""
          return _fespace.FiniteElementSpacePtrArray___getitem__(self, param)
      __getitem__ = _swig_new_instance_method(_fespace.FiniteElementSpacePtrArray___getitem__)
  
  # Register FiniteElementSpacePtrArray in _fespace:
  _fespace.FiniteElementSpacePtrArray_swigregister(FiniteElementSpacePtrArray)
  
  class Ordering(object):
      r"""Proxy of C++ mfem::Ordering class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
      byNODES = _fespace.Ordering_byNODES
      
      byVDIM = _fespace.Ordering_byVDIM
      
  
      def __init__(self):
          r"""__init__(Ordering self) -> Ordering"""
          _fespace.Ordering_swiginit(self, _fespace.new_Ordering())
      __swig_destroy__ = _fespace.delete_Ordering
  
  # Register Ordering in _fespace:
  _fespace.Ordering_swigregister(Ordering)
  
  ElementDofOrdering_NATIVE = _fespace.ElementDofOrdering_NATIVE
  
  ElementDofOrdering_LEXICOGRAPHIC = _fespace.ElementDofOrdering_LEXICOGRAPHIC
  
  class FiniteElementSpace(object):
      r"""Proxy of C++ mfem::FiniteElementSpace class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          r"""
          __init__(FiniteElementSpace self) -> FiniteElementSpace
          __init__(FiniteElementSpace self, FiniteElementSpace orig, Mesh mesh=None, FiniteElementCollection fec=None) -> FiniteElementSpace
          __init__(FiniteElementSpace self, Mesh mesh, FiniteElementCollection fec, int vdim=1, int ordering=byNODES) -> FiniteElementSpace
          __init__(FiniteElementSpace self, Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES) -> FiniteElementSpace
          """
          _fespace.FiniteElementSpace_swiginit(self, _fespace.new_FiniteElementSpace(*args))
  
  
          '''
              FiniteElementSpace(Mesh *m, const FiniteElementCollection *f,
                            int vdim = 1, int ordering = Ordering::byNODES);
              keep reference to mesh and fec to prevent it from
              freeed from pytho garbage collector
          '''
          if hasattr(self, 'this'):
              self.mesh = args[0]
              self.fec = args[1]
  
  
  
  
  
      def GetMesh(self):
          r"""GetMesh(FiniteElementSpace self) -> Mesh"""
          return _fespace.FiniteElementSpace_GetMesh(self)
      GetMesh = _swig_new_instance_method(_fespace.FiniteElementSpace_GetMesh)
  
      def GetNURBSext(self, *args):
          r"""
          GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension const
          GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *
          """
          return _fespace.FiniteElementSpace_GetNURBSext(self, *args)
      GetNURBSext = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNURBSext)
  
      def StealNURBSext(self):
          r"""StealNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *"""
          return _fespace.FiniteElementSpace_StealNURBSext(self)
      StealNURBSext = _swig_new_instance_method(_fespace.FiniteElementSpace_StealNURBSext)
  
      def Conforming(self):
          r"""Conforming(FiniteElementSpace self) -> bool"""
          return _fespace.FiniteElementSpace_Conforming(self)
      Conforming = _swig_new_instance_method(_fespace.FiniteElementSpace_Conforming)
  
      def Nonconforming(self):
          r"""Nonconforming(FiniteElementSpace self) -> bool"""
          return _fespace.FiniteElementSpace_Nonconforming(self)
      Nonconforming = _swig_new_instance_method(_fespace.FiniteElementSpace_Nonconforming)
  
      def SetElementOrder(self, i, p):
          r"""SetElementOrder(FiniteElementSpace self, int i, int p)"""
          return _fespace.FiniteElementSpace_SetElementOrder(self, i, p)
      SetElementOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_SetElementOrder)
  
      def GetElementOrder(self, i):
          r"""GetElementOrder(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetElementOrder(self, i)
      GetElementOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementOrder)
  
      def GetMaxElementOrder(self):
          r"""GetMaxElementOrder(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetMaxElementOrder(self)
      GetMaxElementOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetMaxElementOrder)
  
      def IsVariableOrder(self):
          r"""IsVariableOrder(FiniteElementSpace self) -> bool"""
          return _fespace.FiniteElementSpace_IsVariableOrder(self)
      IsVariableOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_IsVariableOrder)
  
      def GetConformingProlongation(self):
          r"""GetConformingProlongation(FiniteElementSpace self) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_GetConformingProlongation(self)
      GetConformingProlongation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingProlongation)
  
      def GetConformingRestriction(self):
          r"""GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_GetConformingRestriction(self)
      GetConformingRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingRestriction)
  
      def GetHpConformingRestriction(self):
          r"""GetHpConformingRestriction(FiniteElementSpace self) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_GetHpConformingRestriction(self)
      GetHpConformingRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetHpConformingRestriction)
  
      def GetProlongationMatrix(self):
          r"""GetProlongationMatrix(FiniteElementSpace self) -> Operator"""
          return _fespace.FiniteElementSpace_GetProlongationMatrix(self)
      GetProlongationMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_GetProlongationMatrix)
  
      def GetRestrictionTransposeOperator(self):
          r"""GetRestrictionTransposeOperator(FiniteElementSpace self) -> Operator"""
          return _fespace.FiniteElementSpace_GetRestrictionTransposeOperator(self)
      GetRestrictionTransposeOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetRestrictionTransposeOperator)
  
      def GetRestrictionOperator(self):
          r"""GetRestrictionOperator(FiniteElementSpace self) -> Operator"""
          return _fespace.FiniteElementSpace_GetRestrictionOperator(self)
      GetRestrictionOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetRestrictionOperator)
  
      def GetRestrictionMatrix(self):
          r"""GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_GetRestrictionMatrix(self)
      GetRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_GetRestrictionMatrix)
  
      def GetHpRestrictionMatrix(self):
          r"""GetHpRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_GetHpRestrictionMatrix(self)
      GetHpRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_GetHpRestrictionMatrix)
  
      def GetElementRestriction(self, e_ordering):
          r"""GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"""
          return _fespace.FiniteElementSpace_GetElementRestriction(self, e_ordering)
      GetElementRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementRestriction)
  
      def GetFaceRestriction(self, *args, **kwargs):
          r"""GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> FaceRestriction"""
          return _fespace.FiniteElementSpace_GetFaceRestriction(self, *args, **kwargs)
      GetFaceRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceRestriction)
  
      def GetQuadratureInterpolator(self, *args):
          r"""
          GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const
          GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *
          """
          return _fespace.FiniteElementSpace_GetQuadratureInterpolator(self, *args)
      GetQuadratureInterpolator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetQuadratureInterpolator)
  
      def GetFaceQuadratureInterpolator(self, ir, type):
          r"""GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"""
          return _fespace.FiniteElementSpace_GetFaceQuadratureInterpolator(self, ir, type)
      GetFaceQuadratureInterpolator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceQuadratureInterpolator)
  
      def GetOrder(self, i):
          r"""GetOrder(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetOrder(self, i)
      GetOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetOrder)
  
      def GetEdgeOrder(self, edge, variant=0):
          r"""GetEdgeOrder(FiniteElementSpace self, int edge, int variant=0) -> int"""
          return _fespace.FiniteElementSpace_GetEdgeOrder(self, edge, variant)
      GetEdgeOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEdgeOrder)
  
      def GetFaceOrder(self, face, variant=0):
          r"""GetFaceOrder(FiniteElementSpace self, int face, int variant=0) -> int"""
          return _fespace.FiniteElementSpace_GetFaceOrder(self, face, variant)
      GetFaceOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceOrder)
  
      def GetVDim(self):
          r"""GetVDim(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetVDim(self)
      GetVDim = _swig_new_instance_method(_fespace.FiniteElementSpace_GetVDim)
  
      def GetNDofs(self):
          r"""GetNDofs(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNDofs(self)
      GetNDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNDofs)
  
      def GetVSize(self):
          r"""GetVSize(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetVSize(self)
      GetVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetVSize)
  
      def GetTrueVSize(self):
          r"""GetTrueVSize(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetTrueVSize(self)
      GetTrueVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTrueVSize)
  
      def GetNConformingDofs(self):
          r"""GetNConformingDofs(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNConformingDofs(self)
      GetNConformingDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNConformingDofs)
  
      def GetConformingVSize(self):
          r"""GetConformingVSize(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetConformingVSize(self)
      GetConformingVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingVSize)
  
      def GetOrdering(self):
          r"""GetOrdering(FiniteElementSpace self) -> mfem::Ordering::Type"""
          return _fespace.FiniteElementSpace_GetOrdering(self)
      GetOrdering = _swig_new_instance_method(_fespace.FiniteElementSpace_GetOrdering)
  
      def FEColl(self):
          r"""FEColl(FiniteElementSpace self) -> FiniteElementCollection"""
          return _fespace.FiniteElementSpace_FEColl(self)
      FEColl = _swig_new_instance_method(_fespace.FiniteElementSpace_FEColl)
  
      def GetNVDofs(self):
          r"""GetNVDofs(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNVDofs(self)
      GetNVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNVDofs)
  
      def GetNEDofs(self):
          r"""GetNEDofs(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNEDofs(self)
      GetNEDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNEDofs)
  
      def GetNFDofs(self):
          r"""GetNFDofs(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNFDofs(self)
      GetNFDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNFDofs)
  
      def GetNV(self):
          r"""GetNV(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNV(self)
      GetNV = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNV)
  
      def GetNE(self):
          r"""GetNE(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNE(self)
      GetNE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNE)
  
      def GetNF(self):
          r"""GetNF(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNF(self)
      GetNF = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNF)
  
      def GetNBE(self):
          r"""GetNBE(FiniteElementSpace self) -> int"""
          return _fespace.FiniteElementSpace_GetNBE(self)
      GetNBE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNBE)
  
      def GetNFbyType(self, type):
          r"""GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"""
          return _fespace.FiniteElementSpace_GetNFbyType(self, type)
      GetNFbyType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNFbyType)
  
      def GetElementType(self, i):
          r"""GetElementType(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetElementType(self, i)
      GetElementType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementType)
  
      def GetElementVertices(self, i, vertices):
          r"""GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"""
          return _fespace.FiniteElementSpace_GetElementVertices(self, i, vertices)
      GetElementVertices = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementVertices)
  
      def GetBdrElementType(self, i):
          r"""GetBdrElementType(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetBdrElementType(self, i)
      GetBdrElementType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementType)
  
      def GetElementTransformation(self, *args):
          r"""
          GetElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation
          GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr)
          """
          return _fespace.FiniteElementSpace_GetElementTransformation(self, *args)
      GetElementTransformation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementTransformation)
  
      def GetBdrElementTransformation(self, i):
          r"""GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"""
          return _fespace.FiniteElementSpace_GetBdrElementTransformation(self, i)
      GetBdrElementTransformation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementTransformation)
  
      def GetAttribute(self, i):
          r"""GetAttribute(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetAttribute(self, i)
      GetAttribute = _swig_new_instance_method(_fespace.FiniteElementSpace_GetAttribute)
  
      def GetBdrAttribute(self, i):
          r"""GetBdrAttribute(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetBdrAttribute(self, i)
      GetBdrAttribute = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrAttribute)
  
      def GetElementDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetElementDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetBdrElementDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetBdrElementDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetFaceDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetFaceDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetEdgeDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetEdgeDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetVertexDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetVertexDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetElementInteriorDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetElementInteriorDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetFaceInteriorDofs(self, i, dofs):
          r"""GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"""
          return _fespace.FiniteElementSpace_GetFaceInteriorDofs(self, i, dofs)
      GetFaceInteriorDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceInteriorDofs)
  
      def GetNumElementInteriorDofs(self, i):
          r"""GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetNumElementInteriorDofs(self, i)
      GetNumElementInteriorDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNumElementInteriorDofs)
  
      def GetEdgeInteriorDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetEdgeInteriorDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetVDofs(self, vd, dofs, ndofs=-1):
          r"""GetVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)"""
          return _fespace.FiniteElementSpace_GetVDofs(self, vd, dofs, ndofs)
      GetVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetVDofs)
  
      def DofsToVDofs(self, *args):
          r"""
          DofsToVDofs(FiniteElementSpace self, intArray dofs, int ndofs=-1)
          DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)
          """
          return _fespace.FiniteElementSpace_DofsToVDofs(self, *args)
      DofsToVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_DofsToVDofs)
  
      def DofToVDof(self, dof, vd, ndofs=-1):
          r"""DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"""
          return _fespace.FiniteElementSpace_DofToVDof(self, dof, vd, ndofs)
      DofToVDof = _swig_new_instance_method(_fespace.FiniteElementSpace_DofToVDof)
  
      def VDofToDof(self, vdof):
          r"""VDofToDof(FiniteElementSpace self, int vdof) -> int"""
          return _fespace.FiniteElementSpace_VDofToDof(self, vdof)
      VDofToDof = _swig_new_instance_method(_fespace.FiniteElementSpace_VDofToDof)
  
      @staticmethod
      def AdjustVDofs(vdofs):
          r"""AdjustVDofs(intArray vdofs)"""
          return _fespace.FiniteElementSpace_AdjustVDofs(vdofs)
      AdjustVDofs = _swig_new_static_method(_fespace.FiniteElementSpace_AdjustVDofs)
  
      def GetElementVDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetElementVDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetBdrElementVDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetBdrElementVDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetFaceVDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetFaceVDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetEdgeVDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetEdgeVDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetVertexVDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetVertexVDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetElementInteriorVDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetElementInteriorVDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def GetEdgeInteriorVDofs(self, i):
          from  .array import intArray
          vdofs = intArray()
          _fespace.FiniteElementSpace_GetEdgeInteriorVDofs(self, i, vdofs)
          return vdofs.ToList()
  
  
  
      def RebuildElementToDofTable(self):
          r"""RebuildElementToDofTable(FiniteElementSpace self)"""
          return _fespace.FiniteElementSpace_RebuildElementToDofTable(self)
      RebuildElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_RebuildElementToDofTable)
  
      def ReorderElementToDofTable(self):
          r"""ReorderElementToDofTable(FiniteElementSpace self)"""
          return _fespace.FiniteElementSpace_ReorderElementToDofTable(self)
      ReorderElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_ReorderElementToDofTable)
  
      def GetElementToFaceOrientationTable(self):
          r"""GetElementToFaceOrientationTable(FiniteElementSpace self) -> Table"""
          return _fespace.FiniteElementSpace_GetElementToFaceOrientationTable(self)
      GetElementToFaceOrientationTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementToFaceOrientationTable)
  
      def GetElementToDofTable(self):
          r"""GetElementToDofTable(FiniteElementSpace self) -> Table"""
          return _fespace.FiniteElementSpace_GetElementToDofTable(self)
      GetElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementToDofTable)
  
      def GetBdrElementToDofTable(self):
          r"""GetBdrElementToDofTable(FiniteElementSpace self) -> Table"""
          return _fespace.FiniteElementSpace_GetBdrElementToDofTable(self)
      GetBdrElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementToDofTable)
  
      def GetFaceToDofTable(self):
          r"""GetFaceToDofTable(FiniteElementSpace self) -> Table"""
          return _fespace.FiniteElementSpace_GetFaceToDofTable(self)
      GetFaceToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceToDofTable)
  
      def BuildDofToArrays(self):
          r"""BuildDofToArrays(FiniteElementSpace self)"""
          return _fespace.FiniteElementSpace_BuildDofToArrays(self)
      BuildDofToArrays = _swig_new_instance_method(_fespace.FiniteElementSpace_BuildDofToArrays)
  
      def GetElementForDof(self, i):
          r"""GetElementForDof(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetElementForDof(self, i)
      GetElementForDof = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementForDof)
  
      def GetLocalDofForDof(self, i):
          r"""GetLocalDofForDof(FiniteElementSpace self, int i) -> int"""
          return _fespace.FiniteElementSpace_GetLocalDofForDof(self, i)
      GetLocalDofForDof = _swig_new_instance_method(_fespace.FiniteElementSpace_GetLocalDofForDof)
  
      def GetFE(self, i):
          r"""GetFE(FiniteElementSpace self, int i) -> FiniteElement"""
          return _fespace.FiniteElementSpace_GetFE(self, i)
      GetFE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFE)
  
      def GetBE(self, i):
          r"""GetBE(FiniteElementSpace self, int i) -> FiniteElement"""
          return _fespace.FiniteElementSpace_GetBE(self, i)
      GetBE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBE)
  
      def GetFaceElement(self, i):
          r"""GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"""
          return _fespace.FiniteElementSpace_GetFaceElement(self, i)
      GetFaceElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceElement)
  
      def GetEdgeElement(self, i, variant=0):
          r"""GetEdgeElement(FiniteElementSpace self, int i, int variant=0) -> FiniteElement"""
          return _fespace.FiniteElementSpace_GetEdgeElement(self, i, variant)
      GetEdgeElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEdgeElement)
  
      def GetTraceElement(self, i, geom_type):
          r"""GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"""
          return _fespace.FiniteElementSpace_GetTraceElement(self, i, geom_type)
      GetTraceElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTraceElement)
  
      def GetEssentialVDofs(self, bdr_attr_is_ess, ess_vdofs, component=-1):
          r"""GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"""
          return _fespace.FiniteElementSpace_GetEssentialVDofs(self, bdr_attr_is_ess, ess_vdofs, component)
      GetEssentialVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEssentialVDofs)
  
      def GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component=-1):
          r"""GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"""
          return _fespace.FiniteElementSpace_GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component)
      GetEssentialTrueDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEssentialTrueDofs)
  
      def GetBoundaryTrueDofs(self, boundary_dofs, component=-1):
          r"""GetBoundaryTrueDofs(FiniteElementSpace self, intArray boundary_dofs, int component=-1)"""
          return _fespace.FiniteElementSpace_GetBoundaryTrueDofs(self, boundary_dofs, component)
      GetBoundaryTrueDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBoundaryTrueDofs)
  
      @staticmethod
      def MarkerToList(marker, list):
          r"""MarkerToList(intArray marker, intArray list)"""
          return _fespace.FiniteElementSpace_MarkerToList(marker, list)
      MarkerToList = _swig_new_static_method(_fespace.FiniteElementSpace_MarkerToList)
  
      @staticmethod
      def ListToMarker(list, marker_size, marker, mark_val=-1):
          r"""ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"""
          return _fespace.FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val)
      ListToMarker = _swig_new_static_method(_fespace.FiniteElementSpace_ListToMarker)
  
      def ConvertToConformingVDofs(self, dofs, cdofs):
          r"""ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"""
          return _fespace.FiniteElementSpace_ConvertToConformingVDofs(self, dofs, cdofs)
      ConvertToConformingVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_ConvertToConformingVDofs)
  
      def ConvertFromConformingVDofs(self, cdofs, dofs):
          r"""ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"""
          return _fespace.FiniteElementSpace_ConvertFromConformingVDofs(self, cdofs, dofs)
      ConvertFromConformingVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_ConvertFromConformingVDofs)
  
      def D2C_GlobalRestrictionMatrix(self, cfes):
          r"""D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_D2C_GlobalRestrictionMatrix(self, cfes)
      D2C_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_D2C_GlobalRestrictionMatrix)
  
      def D2Const_GlobalRestrictionMatrix(self, cfes):
          r"""D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_D2Const_GlobalRestrictionMatrix(self, cfes)
      D2Const_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_D2Const_GlobalRestrictionMatrix)
  
      def H2L_GlobalRestrictionMatrix(self, lfes):
          r"""H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"""
          return _fespace.FiniteElementSpace_H2L_GlobalRestrictionMatrix(self, lfes)
      H2L_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_H2L_GlobalRestrictionMatrix)
  
      def GetTransferOperator(self, coarse_fes, T):
          r"""GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"""
          return _fespace.FiniteElementSpace_GetTransferOperator(self, coarse_fes, T)
      GetTransferOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTransferOperator)
  
      def GetTrueTransferOperator(self, coarse_fes, T):
          r"""GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"""
          return _fespace.FiniteElementSpace_GetTrueTransferOperator(self, coarse_fes, T)
      GetTrueTransferOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTrueTransferOperator)
  
      def Update(self, want_transform=True):
          r"""Update(FiniteElementSpace self, bool want_transform=True)"""
          return _fespace.FiniteElementSpace_Update(self, want_transform)
      Update = _swig_new_instance_method(_fespace.FiniteElementSpace_Update)
  
      def GetUpdateOperator(self, *args):
          r"""
          GetUpdateOperator(FiniteElementSpace self) -> Operator
          GetUpdateOperator(FiniteElementSpace self, OperatorHandle T)
          """
          return _fespace.FiniteElementSpace_GetUpdateOperator(self, *args)
      GetUpdateOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetUpdateOperator)
  
      def SetUpdateOperatorOwner(self, own):
          r"""SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"""
          return _fespace.FiniteElementSpace_SetUpdateOperatorOwner(self, own)
      SetUpdateOperatorOwner = _swig_new_instance_method(_fespace.FiniteElementSpace_SetUpdateOperatorOwner)
  
      def SetUpdateOperatorType(self, tid):
          r"""SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"""
          return _fespace.FiniteElementSpace_SetUpdateOperatorType(self, tid)
      SetUpdateOperatorType = _swig_new_instance_method(_fespace.FiniteElementSpace_SetUpdateOperatorType)
  
      def UpdatesFinished(self):
          r"""UpdatesFinished(FiniteElementSpace self)"""
          return _fespace.FiniteElementSpace_UpdatesFinished(self)
      UpdatesFinished = _swig_new_instance_method(_fespace.FiniteElementSpace_UpdatesFinished)
  
      def GetSequence(self):
          r"""GetSequence(FiniteElementSpace self) -> long"""
          return _fespace.FiniteElementSpace_GetSequence(self)
      GetSequence = _swig_new_instance_method(_fespace.FiniteElementSpace_GetSequence)
  
      def IsDGSpace(self):
          r"""IsDGSpace(FiniteElementSpace self) -> bool"""
          return _fespace.FiniteElementSpace_IsDGSpace(self)
      IsDGSpace = _swig_new_instance_method(_fespace.FiniteElementSpace_IsDGSpace)
  
      def SetRelaxedHpConformity(self, relaxed=True):
          r"""SetRelaxedHpConformity(FiniteElementSpace self, bool relaxed=True)"""
          return _fespace.FiniteElementSpace_SetRelaxedHpConformity(self, relaxed)
      SetRelaxedHpConformity = _swig_new_instance_method(_fespace.FiniteElementSpace_SetRelaxedHpConformity)
  
      def Load(self, m, input):
          r"""Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"""
          return _fespace.FiniteElementSpace_Load(self, m, input)
      Load = _swig_new_instance_method(_fespace.FiniteElementSpace_Load)
      __swig_destroy__ = _fespace.delete_FiniteElementSpace
  
      def SaveGZ(self, file, precision=16):
          r"""SaveGZ(FiniteElementSpace self, char const * file, int precision=16)"""
          return _fespace.FiniteElementSpace_SaveGZ(self, file, precision)
      SaveGZ = _swig_new_instance_method(_fespace.FiniteElementSpace_SaveGZ)
  
      def Save(self, *args):
          r"""
          Save(FiniteElementSpace self, std::ostream & out)
          Save(FiniteElementSpace self, char const * file, int precision=16)
          Save(FiniteElementSpace self)
          """
          return _fespace.FiniteElementSpace_Save(self, *args)
      Save = _swig_new_instance_method(_fespace.FiniteElementSpace_Save)
  
  # Register FiniteElementSpace in _fespace:
  _fespace.FiniteElementSpace_swigregister(FiniteElementSpace)
  
  def FiniteElementSpace_AdjustVDofs(vdofs):
      r"""FiniteElementSpace_AdjustVDofs(intArray vdofs)"""
      return _fespace.FiniteElementSpace_AdjustVDofs(vdofs)
  FiniteElementSpace_AdjustVDofs = _fespace.FiniteElementSpace_AdjustVDofs
  
  def FiniteElementSpace_MarkerToList(marker, list):
      r"""FiniteElementSpace_MarkerToList(intArray marker, intArray list)"""
      return _fespace.FiniteElementSpace_MarkerToList(marker, list)
  FiniteElementSpace_MarkerToList = _fespace.FiniteElementSpace_MarkerToList
  
  def FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val=-1):
      r"""FiniteElementSpace_ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"""
      return _fespace.FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val)
  FiniteElementSpace_ListToMarker = _fespace.FiniteElementSpace_ListToMarker
  
  class QuadratureSpace(object):
      r"""Proxy of C++ mfem::QuadratureSpace class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          r"""
          __init__(QuadratureSpace self, Mesh mesh_, int order_) -> QuadratureSpace
          __init__(QuadratureSpace self, Mesh mesh_, std::istream & _in) -> QuadratureSpace
          """
          _fespace.QuadratureSpace_swiginit(self, _fespace.new_QuadratureSpace(*args))
      __swig_destroy__ = _fespace.delete_QuadratureSpace
  
      def GetSize(self):
          r"""GetSize(QuadratureSpace self) -> int"""
          return _fespace.QuadratureSpace_GetSize(self)
      GetSize = _swig_new_instance_method(_fespace.QuadratureSpace_GetSize)
  
      def GetOrder(self):
          r"""GetOrder(QuadratureSpace self) -> int"""
          return _fespace.QuadratureSpace_GetOrder(self)
      GetOrder = _swig_new_instance_method(_fespace.QuadratureSpace_GetOrder)
  
      def GetMesh(self):
          r"""GetMesh(QuadratureSpace self) -> Mesh"""
          return _fespace.QuadratureSpace_GetMesh(self)
      GetMesh = _swig_new_instance_method(_fespace.QuadratureSpace_GetMesh)
  
      def GetNE(self):
          r"""GetNE(QuadratureSpace self) -> int"""
          return _fespace.QuadratureSpace_GetNE(self)
      GetNE = _swig_new_instance_method(_fespace.QuadratureSpace_GetNE)
  
      def GetElementIntRule(self, idx):
          r"""GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"""
          return _fespace.QuadratureSpace_GetElementIntRule(self, idx)
      GetElementIntRule = _swig_new_instance_method(_fespace.QuadratureSpace_GetElementIntRule)
  
      def SaveGZ(self, file, precision=16):
          r"""SaveGZ(QuadratureSpace self, char const * file, int precision=16)"""
          return _fespace.QuadratureSpace_SaveGZ(self, file, precision)
      SaveGZ = _swig_new_instance_method(_fespace.QuadratureSpace_SaveGZ)
  
      def Save(self, *args):
          r"""
          Save(QuadratureSpace self, std::ostream & out)
          Save(QuadratureSpace self, char const * file, int precision=16)
          Save(QuadratureSpace self)
          """
          return _fespace.QuadratureSpace_Save(self, *args)
      Save = _swig_new_instance_method(_fespace.QuadratureSpace_Save)
  
  # Register QuadratureSpace in _fespace:
  _fespace.QuadratureSpace_swigregister(QuadratureSpace)
  
  
  def UsesTensorBasis(fes):
      r"""UsesTensorBasis(FiniteElementSpace fes) -> bool"""
      return _fespace.UsesTensorBasis(fes)
  UsesTensorBasis = _fespace.UsesTensorBasis
  
  
  