# 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 _fe
else:
    import _fe

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _fe.SWIG_PyInstanceMethod_New
_swig_new_static_method = _fe.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._ser.array
import mfem._ser.mem_manager
import mfem._ser.vector
import mfem._ser.geom
import mfem._ser.intrules
import mfem._ser.densemat
import mfem._ser.operators
import mfem._ser.matrix
import mfem._ser.sparsemat
class BasisType(object):
    r"""Proxy of C++ mfem::BasisType class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Invalid = _fe.BasisType_Invalid
    
    GaussLegendre = _fe.BasisType_GaussLegendre
    
    GaussLobatto = _fe.BasisType_GaussLobatto
    
    Positive = _fe.BasisType_Positive
    
    OpenUniform = _fe.BasisType_OpenUniform
    
    ClosedUniform = _fe.BasisType_ClosedUniform
    
    OpenHalfUniform = _fe.BasisType_OpenHalfUniform
    
    Serendipity = _fe.BasisType_Serendipity
    
    ClosedGL = _fe.BasisType_ClosedGL
    
    NumBasisTypes = _fe.BasisType_NumBasisTypes
    

    @staticmethod
    def Check(b_type):
        r"""Check(int b_type) -> int"""
        return _fe.BasisType_Check(b_type)
    Check = _swig_new_static_method(_fe.BasisType_Check)

    @staticmethod
    def CheckNodal(b_type):
        r"""CheckNodal(int b_type) -> int"""
        return _fe.BasisType_CheckNodal(b_type)
    CheckNodal = _swig_new_static_method(_fe.BasisType_CheckNodal)

    @staticmethod
    def GetQuadrature1D(b_type):
        r"""GetQuadrature1D(int b_type) -> int"""
        return _fe.BasisType_GetQuadrature1D(b_type)
    GetQuadrature1D = _swig_new_static_method(_fe.BasisType_GetQuadrature1D)

    @staticmethod
    def GetNodalBasis(qpt_type):
        r"""GetNodalBasis(int qpt_type) -> int"""
        return _fe.BasisType_GetNodalBasis(qpt_type)
    GetNodalBasis = _swig_new_static_method(_fe.BasisType_GetNodalBasis)

    @staticmethod
    def Name(b_type):
        r"""Name(int b_type) -> char const *"""
        return _fe.BasisType_Name(b_type)
    Name = _swig_new_static_method(_fe.BasisType_Name)

    @staticmethod
    def GetChar(b_type):
        r"""GetChar(int b_type) -> char"""
        return _fe.BasisType_GetChar(b_type)
    GetChar = _swig_new_static_method(_fe.BasisType_GetChar)

    @staticmethod
    def GetType(b_ident):
        r"""GetType(char b_ident) -> int"""
        return _fe.BasisType_GetType(b_ident)
    GetType = _swig_new_static_method(_fe.BasisType_GetType)

    def __init__(self):
        r"""__init__(BasisType self) -> BasisType"""
        _fe.BasisType_swiginit(self, _fe.new_BasisType())
    __swig_destroy__ = _fe.delete_BasisType

# Register BasisType in _fe:
_fe.BasisType_swigregister(BasisType)

def BasisType_Check(b_type):
    r"""BasisType_Check(int b_type) -> int"""
    return _fe.BasisType_Check(b_type)
BasisType_Check = _fe.BasisType_Check

def BasisType_CheckNodal(b_type):
    r"""BasisType_CheckNodal(int b_type) -> int"""
    return _fe.BasisType_CheckNodal(b_type)
BasisType_CheckNodal = _fe.BasisType_CheckNodal

def BasisType_GetQuadrature1D(b_type):
    r"""BasisType_GetQuadrature1D(int b_type) -> int"""
    return _fe.BasisType_GetQuadrature1D(b_type)
BasisType_GetQuadrature1D = _fe.BasisType_GetQuadrature1D

def BasisType_GetNodalBasis(qpt_type):
    r"""BasisType_GetNodalBasis(int qpt_type) -> int"""
    return _fe.BasisType_GetNodalBasis(qpt_type)
BasisType_GetNodalBasis = _fe.BasisType_GetNodalBasis

def BasisType_Name(b_type):
    r"""BasisType_Name(int b_type) -> char const *"""
    return _fe.BasisType_Name(b_type)
BasisType_Name = _fe.BasisType_Name

def BasisType_GetChar(b_type):
    r"""BasisType_GetChar(int b_type) -> char"""
    return _fe.BasisType_GetChar(b_type)
BasisType_GetChar = _fe.BasisType_GetChar

def BasisType_GetType(b_ident):
    r"""BasisType_GetType(char b_ident) -> int"""
    return _fe.BasisType_GetType(b_ident)
BasisType_GetType = _fe.BasisType_GetType

class DofToQuad(object):
    r"""Proxy of C++ mfem::DofToQuad class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IntRule = property(_fe.DofToQuad_IntRule_get, _fe.DofToQuad_IntRule_set, doc=r"""IntRule : p.q(const).mfem::IntegrationRule""")
    FULL = _fe.DofToQuad_FULL
    
    TENSOR = _fe.DofToQuad_TENSOR
    
    mode = property(_fe.DofToQuad_mode_get, _fe.DofToQuad_mode_set, doc=r"""mode : mfem::DofToQuad::Mode""")
    ndof = property(_fe.DofToQuad_ndof_get, _fe.DofToQuad_ndof_set, doc=r"""ndof : int""")
    nqpt = property(_fe.DofToQuad_nqpt_get, _fe.DofToQuad_nqpt_set, doc=r"""nqpt : int""")
    B = property(_fe.DofToQuad_B_get, _fe.DofToQuad_B_set, doc=r"""B : mfem::Array<(double)>""")
    Bt = property(_fe.DofToQuad_Bt_get, _fe.DofToQuad_Bt_set, doc=r"""Bt : mfem::Array<(double)>""")
    G = property(_fe.DofToQuad_G_get, _fe.DofToQuad_G_set, doc=r"""G : mfem::Array<(double)>""")
    Gt = property(_fe.DofToQuad_Gt_get, _fe.DofToQuad_Gt_set, doc=r"""Gt : mfem::Array<(double)>""")

    def __init__(self):
        r"""__init__(DofToQuad self) -> DofToQuad"""
        _fe.DofToQuad_swiginit(self, _fe.new_DofToQuad())
    __swig_destroy__ = _fe.delete_DofToQuad

# Register DofToQuad in _fe:
_fe.DofToQuad_swigregister(DofToQuad)

class FunctionSpace(object):
    r"""Proxy of C++ mfem::FunctionSpace class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Pk = _fe.FunctionSpace_Pk
    
    Qk = _fe.FunctionSpace_Qk
    
    rQk = _fe.FunctionSpace_rQk
    

    def __init__(self):
        r"""__init__(FunctionSpace self) -> FunctionSpace"""
        _fe.FunctionSpace_swiginit(self, _fe.new_FunctionSpace())
    __swig_destroy__ = _fe.delete_FunctionSpace

# Register FunctionSpace in _fe:
_fe.FunctionSpace_swigregister(FunctionSpace)

class FiniteElement(object):
    r"""Proxy of C++ mfem::FiniteElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    SCALAR = _fe.FiniteElement_SCALAR
    
    VECTOR = _fe.FiniteElement_VECTOR
    
    VALUE = _fe.FiniteElement_VALUE
    
    INTEGRAL = _fe.FiniteElement_INTEGRAL
    
    H_DIV = _fe.FiniteElement_H_DIV
    
    H_CURL = _fe.FiniteElement_H_CURL
    
    NONE = _fe.FiniteElement_NONE
    
    GRAD = _fe.FiniteElement_GRAD
    
    DIV = _fe.FiniteElement_DIV
    
    CURL = _fe.FiniteElement_CURL
    

    def GetDim(self):
        r"""GetDim(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetDim(self)
    GetDim = _swig_new_instance_method(_fe.FiniteElement_GetDim)

    def GetGeomType(self):
        r"""GetGeomType(FiniteElement self) -> mfem::Geometry::Type"""
        return _fe.FiniteElement_GetGeomType(self)
    GetGeomType = _swig_new_instance_method(_fe.FiniteElement_GetGeomType)

    def GetDof(self):
        r"""GetDof(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetDof(self)
    GetDof = _swig_new_instance_method(_fe.FiniteElement_GetDof)

    def GetOrder(self):
        r"""GetOrder(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetOrder(self)
    GetOrder = _swig_new_instance_method(_fe.FiniteElement_GetOrder)

    def HasAnisotropicOrders(self):
        r"""HasAnisotropicOrders(FiniteElement self) -> bool"""
        return _fe.FiniteElement_HasAnisotropicOrders(self)
    HasAnisotropicOrders = _swig_new_instance_method(_fe.FiniteElement_HasAnisotropicOrders)

    def GetAnisotropicOrders(self):
        r"""GetAnisotropicOrders(FiniteElement self) -> int const *"""
        return _fe.FiniteElement_GetAnisotropicOrders(self)
    GetAnisotropicOrders = _swig_new_instance_method(_fe.FiniteElement_GetAnisotropicOrders)

    def Space(self):
        r"""Space(FiniteElement self) -> int"""
        return _fe.FiniteElement_Space(self)
    Space = _swig_new_instance_method(_fe.FiniteElement_Space)

    def GetRangeType(self):
        r"""GetRangeType(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetRangeType(self)
    GetRangeType = _swig_new_instance_method(_fe.FiniteElement_GetRangeType)

    def GetDerivRangeType(self):
        r"""GetDerivRangeType(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetDerivRangeType(self)
    GetDerivRangeType = _swig_new_instance_method(_fe.FiniteElement_GetDerivRangeType)

    def GetMapType(self):
        r"""GetMapType(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetMapType(self)
    GetMapType = _swig_new_instance_method(_fe.FiniteElement_GetMapType)

    def GetDerivType(self):
        r"""GetDerivType(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetDerivType(self)
    GetDerivType = _swig_new_instance_method(_fe.FiniteElement_GetDerivType)

    def GetDerivMapType(self):
        r"""GetDerivMapType(FiniteElement self) -> int"""
        return _fe.FiniteElement_GetDerivMapType(self)
    GetDerivMapType = _swig_new_instance_method(_fe.FiniteElement_GetDerivMapType)

    def CalcShape(self, ip, shape):
        r"""CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.FiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.FiniteElement_CalcShape)

    def CalcPhysShape(self, Trans, shape):
        r"""CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"""
        return _fe.FiniteElement_CalcPhysShape(self, Trans, shape)
    CalcPhysShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.FiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.FiniteElement_CalcDShape)

    def CalcPhysDShape(self, Trans, dshape):
        r"""CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"""
        return _fe.FiniteElement_CalcPhysDShape(self, Trans, dshape)
    CalcPhysDShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysDShape)

    def GetNodes(self):
        r"""GetNodes(FiniteElement self) -> IntegrationRule"""
        return _fe.FiniteElement_GetNodes(self)
    GetNodes = _swig_new_instance_method(_fe.FiniteElement_GetNodes)

    def CalcVShape(self, *args):
        r"""
        CalcVShape(FiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.FiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.FiniteElement_CalcVShape)

    def CalcPhysVShape(self, Trans, shape):
        r"""CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"""
        return _fe.FiniteElement_CalcPhysVShape(self, Trans, shape)
    CalcPhysVShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.FiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.FiniteElement_CalcDivShape)

    def CalcPhysDivShape(self, Trans, divshape):
        r"""CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"""
        return _fe.FiniteElement_CalcPhysDivShape(self, Trans, divshape)
    CalcPhysDivShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysDivShape)

    def CalcCurlShape(self, ip, curl_shape):
        r"""CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"""
        return _fe.FiniteElement_CalcCurlShape(self, ip, curl_shape)
    CalcCurlShape = _swig_new_instance_method(_fe.FiniteElement_CalcCurlShape)

    def CalcPhysCurlShape(self, Trans, curl_shape):
        r"""CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"""
        return _fe.FiniteElement_CalcPhysCurlShape(self, Trans, curl_shape)
    CalcPhysCurlShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysCurlShape)

    def GetFaceDofs(self, face, dofs, ndofs):
        r"""GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"""
        return _fe.FiniteElement_GetFaceDofs(self, face, dofs, ndofs)
    GetFaceDofs = _swig_new_instance_method(_fe.FiniteElement_GetFaceDofs)

    def CalcHessian(self, ip, Hessian):
        r"""CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"""
        return _fe.FiniteElement_CalcHessian(self, ip, Hessian)
    CalcHessian = _swig_new_instance_method(_fe.FiniteElement_CalcHessian)

    def CalcPhysHessian(self, Trans, Hessian):
        r"""CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"""
        return _fe.FiniteElement_CalcPhysHessian(self, Trans, Hessian)
    CalcPhysHessian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysHessian)

    def CalcPhysLaplacian(self, Trans, Laplacian):
        r"""CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"""
        return _fe.FiniteElement_CalcPhysLaplacian(self, Trans, Laplacian)
    CalcPhysLaplacian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysLaplacian)

    def CalcPhysLinLaplacian(self, Trans, Laplacian):
        r"""CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"""
        return _fe.FiniteElement_CalcPhysLinLaplacian(self, Trans, Laplacian)
    CalcPhysLinLaplacian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysLinLaplacian)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.FiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.FiniteElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.FiniteElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.FiniteElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.FiniteElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.FiniteElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(FiniteElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.FiniteElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.FiniteElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.FiniteElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.FiniteElement_ProjectMatrixCoefficient)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(FiniteElement self, int vertex, Vector dofs)"""
        return _fe.FiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.FiniteElement_ProjectDelta)

    def Project(self, *args):
        r"""
        Project(FiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(FiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.FiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.FiniteElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.FiniteElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.FiniteElement_ProjectGrad)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.FiniteElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.FiniteElement_ProjectCurl)

    def ProjectDiv(self, fe, Trans, div):
        r"""ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"""
        return _fe.FiniteElement_ProjectDiv(self, fe, Trans, div)
    ProjectDiv = _swig_new_instance_method(_fe.FiniteElement_ProjectDiv)

    def GetDofToQuad(self, ir, mode):
        r"""GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"""
        return _fe.FiniteElement_GetDofToQuad(self, ir, mode)
    GetDofToQuad = _swig_new_instance_method(_fe.FiniteElement_GetDofToQuad)
    __swig_destroy__ = _fe.delete_FiniteElement

    @staticmethod
    def IsClosedType(b_type):
        r"""IsClosedType(int b_type) -> bool"""
        return _fe.FiniteElement_IsClosedType(b_type)
    IsClosedType = _swig_new_static_method(_fe.FiniteElement_IsClosedType)

    @staticmethod
    def IsOpenType(b_type):
        r"""IsOpenType(int b_type) -> bool"""
        return _fe.FiniteElement_IsOpenType(b_type)
    IsOpenType = _swig_new_static_method(_fe.FiniteElement_IsOpenType)

    @staticmethod
    def VerifyClosed(b_type):
        r"""VerifyClosed(int b_type) -> int"""
        return _fe.FiniteElement_VerifyClosed(b_type)
    VerifyClosed = _swig_new_static_method(_fe.FiniteElement_VerifyClosed)

    @staticmethod
    def VerifyOpen(b_type):
        r"""VerifyOpen(int b_type) -> int"""
        return _fe.FiniteElement_VerifyOpen(b_type)
    VerifyOpen = _swig_new_static_method(_fe.FiniteElement_VerifyOpen)

    @staticmethod
    def VerifyNodal(b_type):
        r"""VerifyNodal(int b_type) -> int"""
        return _fe.FiniteElement_VerifyNodal(b_type)
    VerifyNodal = _swig_new_static_method(_fe.FiniteElement_VerifyNodal)

# Register FiniteElement in _fe:
_fe.FiniteElement_swigregister(FiniteElement)

def FiniteElement_IsClosedType(b_type):
    r"""FiniteElement_IsClosedType(int b_type) -> bool"""
    return _fe.FiniteElement_IsClosedType(b_type)
FiniteElement_IsClosedType = _fe.FiniteElement_IsClosedType

def FiniteElement_IsOpenType(b_type):
    r"""FiniteElement_IsOpenType(int b_type) -> bool"""
    return _fe.FiniteElement_IsOpenType(b_type)
FiniteElement_IsOpenType = _fe.FiniteElement_IsOpenType

def FiniteElement_VerifyClosed(b_type):
    r"""FiniteElement_VerifyClosed(int b_type) -> int"""
    return _fe.FiniteElement_VerifyClosed(b_type)
FiniteElement_VerifyClosed = _fe.FiniteElement_VerifyClosed

def FiniteElement_VerifyOpen(b_type):
    r"""FiniteElement_VerifyOpen(int b_type) -> int"""
    return _fe.FiniteElement_VerifyOpen(b_type)
FiniteElement_VerifyOpen = _fe.FiniteElement_VerifyOpen

def FiniteElement_VerifyNodal(b_type):
    r"""FiniteElement_VerifyNodal(int b_type) -> int"""
    return _fe.FiniteElement_VerifyNodal(b_type)
FiniteElement_VerifyNodal = _fe.FiniteElement_VerifyNodal

class ScalarFiniteElement(FiniteElement):
    r"""Proxy of C++ mfem::ScalarFiniteElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def SetMapType(self, M):
        r"""SetMapType(ScalarFiniteElement self, int M)"""
        return _fe.ScalarFiniteElement_SetMapType(self, M)
    SetMapType = _swig_new_instance_method(_fe.ScalarFiniteElement_SetMapType)

    def NodalLocalInterpolation(self, Trans, I, fine_fe):
        r"""NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"""
        return _fe.ScalarFiniteElement_NodalLocalInterpolation(self, Trans, I, fine_fe)
    NodalLocalInterpolation = _swig_new_instance_method(_fe.ScalarFiniteElement_NodalLocalInterpolation)

    def ScalarLocalInterpolation(self, Trans, I, fine_fe):
        r"""ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"""
        return _fe.ScalarFiniteElement_ScalarLocalInterpolation(self, Trans, I, fine_fe)
    ScalarLocalInterpolation = _swig_new_instance_method(_fe.ScalarFiniteElement_ScalarLocalInterpolation)

    def GetDofToQuad(self, ir, mode):
        r"""GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"""
        return _fe.ScalarFiniteElement_GetDofToQuad(self, ir, mode)
    GetDofToQuad = _swig_new_instance_method(_fe.ScalarFiniteElement_GetDofToQuad)
    __swig_destroy__ = _fe.delete_ScalarFiniteElement

# Register ScalarFiniteElement in _fe:
_fe.ScalarFiniteElement_swigregister(ScalarFiniteElement)

class NodalFiniteElement(ScalarFiniteElement):
    r"""Proxy of C++ mfem::NodalFiniteElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.NodalFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.NodalFiniteElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.NodalFiniteElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.NodalFiniteElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.NodalFiniteElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.NodalFiniteElement_GetTransferMatrix)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.NodalFiniteElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(NodalFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(NodalFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.NodalFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.NodalFiniteElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.NodalFiniteElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectGrad)

    def ProjectDiv(self, fe, Trans, div):
        r"""ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"""
        return _fe.NodalFiniteElement_ProjectDiv(self, fe, Trans, div)
    ProjectDiv = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectDiv)
    __swig_destroy__ = _fe.delete_NodalFiniteElement

# Register NodalFiniteElement in _fe:
_fe.NodalFiniteElement_swigregister(NodalFiniteElement)

class PositiveFiniteElement(ScalarFiniteElement):
    r"""Proxy of C++ mfem::PositiveFiniteElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.PositiveFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.PositiveFiniteElement_GetLocalInterpolation)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.PositiveFiniteElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.PositiveFiniteElement_GetTransferMatrix)

    def Project(self, *args):
        r"""
        Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.PositiveFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.PositiveFiniteElement_Project)
    __swig_destroy__ = _fe.delete_PositiveFiniteElement

# Register PositiveFiniteElement in _fe:
_fe.PositiveFiniteElement_swigregister(PositiveFiniteElement)

class VectorFiniteElement(FiniteElement):
    r"""Proxy of C++ mfem::VectorFiniteElement 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, **kwargs):
        r"""__init__(VectorFiniteElement self, int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk) -> VectorFiniteElement"""
        _fe.VectorFiniteElement_swiginit(self, _fe.new_VectorFiniteElement(*args, **kwargs))
    __swig_destroy__ = _fe.delete_VectorFiniteElement

# Register VectorFiniteElement in _fe:
_fe.VectorFiniteElement_swigregister(VectorFiniteElement)

class PointFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::PointFiniteElement 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):
        r"""__init__(PointFiniteElement self) -> PointFiniteElement"""
        _fe.PointFiniteElement_swiginit(self, _fe.new_PointFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.PointFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.PointFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.PointFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.PointFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_PointFiniteElement

# Register PointFiniteElement in _fe:
_fe.PointFiniteElement_swigregister(PointFiniteElement)

class Linear1DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Linear1DFiniteElement 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):
        r"""__init__(Linear1DFiniteElement self) -> Linear1DFiniteElement"""
        _fe.Linear1DFiniteElement_swiginit(self, _fe.new_Linear1DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Linear1DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Linear1DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Linear1DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Linear1DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_Linear1DFiniteElement

# Register Linear1DFiniteElement in _fe:
_fe.Linear1DFiniteElement_swigregister(Linear1DFiniteElement)

class Linear2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Linear2DFiniteElement 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):
        r"""__init__(Linear2DFiniteElement self) -> Linear2DFiniteElement"""
        _fe.Linear2DFiniteElement_swiginit(self, _fe.new_Linear2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Linear2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Linear2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Linear2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Linear2DFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.Linear2DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.Linear2DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_Linear2DFiniteElement

# Register Linear2DFiniteElement in _fe:
_fe.Linear2DFiniteElement_swigregister(Linear2DFiniteElement)

class BiLinear2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::BiLinear2DFiniteElement 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):
        r"""__init__(BiLinear2DFiniteElement self) -> BiLinear2DFiniteElement"""
        _fe.BiLinear2DFiniteElement_swiginit(self, _fe.new_BiLinear2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.BiLinear2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.BiLinear2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcDShape)

    def CalcHessian(self, ip, h):
        r"""CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"""
        return _fe.BiLinear2DFiniteElement_CalcHessian(self, ip, h)
    CalcHessian = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcHessian)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.BiLinear2DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_BiLinear2DFiniteElement

# Register BiLinear2DFiniteElement in _fe:
_fe.BiLinear2DFiniteElement_swigregister(BiLinear2DFiniteElement)

class GaussLinear2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::GaussLinear2DFiniteElement 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):
        r"""__init__(GaussLinear2DFiniteElement self) -> GaussLinear2DFiniteElement"""
        _fe.GaussLinear2DFiniteElement_swiginit(self, _fe.new_GaussLinear2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.GaussLinear2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.GaussLinear2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.GaussLinear2DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_GaussLinear2DFiniteElement

# Register GaussLinear2DFiniteElement in _fe:
_fe.GaussLinear2DFiniteElement_swigregister(GaussLinear2DFiniteElement)

class GaussBiLinear2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::GaussBiLinear2DFiniteElement 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):
        r"""__init__(GaussBiLinear2DFiniteElement self) -> GaussBiLinear2DFiniteElement"""
        _fe.GaussBiLinear2DFiniteElement_swiginit(self, _fe.new_GaussBiLinear2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.GaussBiLinear2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.GaussBiLinear2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.GaussBiLinear2DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_GaussBiLinear2DFiniteElement

# Register GaussBiLinear2DFiniteElement in _fe:
_fe.GaussBiLinear2DFiniteElement_swigregister(GaussBiLinear2DFiniteElement)

class P1OnQuadFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P1OnQuadFiniteElement 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):
        r"""__init__(P1OnQuadFiniteElement self) -> P1OnQuadFiniteElement"""
        _fe.P1OnQuadFiniteElement_swiginit(self, _fe.new_P1OnQuadFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P1OnQuadFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P1OnQuadFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"""
        return _fe.P1OnQuadFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_P1OnQuadFiniteElement

# Register P1OnQuadFiniteElement in _fe:
_fe.P1OnQuadFiniteElement_swigregister(P1OnQuadFiniteElement)

class Quad1DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Quad1DFiniteElement 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):
        r"""__init__(Quad1DFiniteElement self) -> Quad1DFiniteElement"""
        _fe.Quad1DFiniteElement_swiginit(self, _fe.new_Quad1DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Quad1DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Quad1DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Quad1DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Quad1DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_Quad1DFiniteElement

# Register Quad1DFiniteElement in _fe:
_fe.Quad1DFiniteElement_swigregister(Quad1DFiniteElement)

class QuadPos1DFiniteElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::QuadPos1DFiniteElement 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):
        r"""__init__(QuadPos1DFiniteElement self) -> QuadPos1DFiniteElement"""
        _fe.QuadPos1DFiniteElement_swiginit(self, _fe.new_QuadPos1DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.QuadPos1DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.QuadPos1DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.QuadPos1DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.QuadPos1DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_QuadPos1DFiniteElement

# Register QuadPos1DFiniteElement in _fe:
_fe.QuadPos1DFiniteElement_swigregister(QuadPos1DFiniteElement)

class Quad2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Quad2DFiniteElement 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):
        r"""__init__(Quad2DFiniteElement self) -> Quad2DFiniteElement"""
        _fe.Quad2DFiniteElement_swiginit(self, _fe.new_Quad2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Quad2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Quad2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcDShape)

    def CalcHessian(self, ip, h):
        r"""CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"""
        return _fe.Quad2DFiniteElement_CalcHessian(self, ip, h)
    CalcHessian = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcHessian)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.Quad2DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.Quad2DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_Quad2DFiniteElement

# Register Quad2DFiniteElement in _fe:
_fe.Quad2DFiniteElement_swigregister(Quad2DFiniteElement)

class GaussQuad2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::GaussQuad2DFiniteElement 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):
        r"""__init__(GaussQuad2DFiniteElement self) -> GaussQuad2DFiniteElement"""
        _fe.GaussQuad2DFiniteElement_swiginit(self, _fe.new_GaussQuad2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.GaussQuad2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.GaussQuad2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.GaussQuad2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.GaussQuad2DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_GaussQuad2DFiniteElement

# Register GaussQuad2DFiniteElement in _fe:
_fe.GaussQuad2DFiniteElement_swigregister(GaussQuad2DFiniteElement)

class BiQuad2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::BiQuad2DFiniteElement 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):
        r"""__init__(BiQuad2DFiniteElement self) -> BiQuad2DFiniteElement"""
        _fe.BiQuad2DFiniteElement_swiginit(self, _fe.new_BiQuad2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.BiQuad2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.BiQuad2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.BiQuad2DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_BiQuad2DFiniteElement

# Register BiQuad2DFiniteElement in _fe:
_fe.BiQuad2DFiniteElement_swigregister(BiQuad2DFiniteElement)

class BiQuadPos2DFiniteElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::BiQuadPos2DFiniteElement 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):
        r"""__init__(BiQuadPos2DFiniteElement self) -> BiQuadPos2DFiniteElement"""
        _fe.BiQuadPos2DFiniteElement_swiginit(self, _fe.new_BiQuadPos2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.BiQuadPos2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.BiQuadPos2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_CalcDShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.BiQuadPos2DFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(BiQuadPos2DFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.BiQuadPos2DFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_Project)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.BiQuadPos2DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_BiQuadPos2DFiniteElement

# Register BiQuadPos2DFiniteElement in _fe:
_fe.BiQuadPos2DFiniteElement_swigregister(BiQuadPos2DFiniteElement)

class GaussBiQuad2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::GaussBiQuad2DFiniteElement 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):
        r"""__init__(GaussBiQuad2DFiniteElement self) -> GaussBiQuad2DFiniteElement"""
        _fe.GaussBiQuad2DFiniteElement_swiginit(self, _fe.new_GaussBiQuad2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.GaussBiQuad2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.GaussBiQuad2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.GaussBiQuad2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.GaussBiQuad2DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_GaussBiQuad2DFiniteElement

# Register GaussBiQuad2DFiniteElement in _fe:
_fe.GaussBiQuad2DFiniteElement_swigregister(GaussBiQuad2DFiniteElement)

class BiCubic2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::BiCubic2DFiniteElement 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):
        r"""__init__(BiCubic2DFiniteElement self) -> BiCubic2DFiniteElement"""
        _fe.BiCubic2DFiniteElement_swiginit(self, _fe.new_BiCubic2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.BiCubic2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.BiCubic2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcDShape)

    def CalcHessian(self, ip, h):
        r"""CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"""
        return _fe.BiCubic2DFiniteElement_CalcHessian(self, ip, h)
    CalcHessian = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcHessian)
    __swig_destroy__ = _fe.delete_BiCubic2DFiniteElement

# Register BiCubic2DFiniteElement in _fe:
_fe.BiCubic2DFiniteElement_swigregister(BiCubic2DFiniteElement)

class Cubic1DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Cubic1DFiniteElement 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):
        r"""__init__(Cubic1DFiniteElement self) -> Cubic1DFiniteElement"""
        _fe.Cubic1DFiniteElement_swiginit(self, _fe.new_Cubic1DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Cubic1DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Cubic1DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Cubic1DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Cubic1DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_Cubic1DFiniteElement

# Register Cubic1DFiniteElement in _fe:
_fe.Cubic1DFiniteElement_swigregister(Cubic1DFiniteElement)

class Cubic2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Cubic2DFiniteElement 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):
        r"""__init__(Cubic2DFiniteElement self) -> Cubic2DFiniteElement"""
        _fe.Cubic2DFiniteElement_swiginit(self, _fe.new_Cubic2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Cubic2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Cubic2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcDShape)

    def CalcHessian(self, ip, h):
        r"""CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"""
        return _fe.Cubic2DFiniteElement_CalcHessian(self, ip, h)
    CalcHessian = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcHessian)
    __swig_destroy__ = _fe.delete_Cubic2DFiniteElement

# Register Cubic2DFiniteElement in _fe:
_fe.Cubic2DFiniteElement_swigregister(Cubic2DFiniteElement)

class Cubic3DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Cubic3DFiniteElement 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):
        r"""__init__(Cubic3DFiniteElement self) -> Cubic3DFiniteElement"""
        _fe.Cubic3DFiniteElement_swiginit(self, _fe.new_Cubic3DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Cubic3DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Cubic3DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Cubic3DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Cubic3DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_Cubic3DFiniteElement

# Register Cubic3DFiniteElement in _fe:
_fe.Cubic3DFiniteElement_swigregister(Cubic3DFiniteElement)

class P0TriangleFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P0TriangleFiniteElement 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):
        r"""__init__(P0TriangleFiniteElement self) -> P0TriangleFiniteElement"""
        _fe.P0TriangleFiniteElement_swiginit(self, _fe.new_P0TriangleFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P0TriangleFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P0TriangleFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P0TriangleFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P0TriangleFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"""
        return _fe.P0TriangleFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.P0TriangleFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_P0TriangleFiniteElement

# Register P0TriangleFiniteElement in _fe:
_fe.P0TriangleFiniteElement_swigregister(P0TriangleFiniteElement)

class P0QuadFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P0QuadFiniteElement 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):
        r"""__init__(P0QuadFiniteElement self) -> P0QuadFiniteElement"""
        _fe.P0QuadFiniteElement_swiginit(self, _fe.new_P0QuadFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P0QuadFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P0QuadFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P0QuadFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P0QuadFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"""
        return _fe.P0QuadFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.P0QuadFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_P0QuadFiniteElement

# Register P0QuadFiniteElement in _fe:
_fe.P0QuadFiniteElement_swigregister(P0QuadFiniteElement)

class Linear3DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Linear3DFiniteElement 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):
        r"""__init__(Linear3DFiniteElement self) -> Linear3DFiniteElement"""
        _fe.Linear3DFiniteElement_swiginit(self, _fe.new_Linear3DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Linear3DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Linear3DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Linear3DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Linear3DFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.Linear3DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.Linear3DFiniteElement_ProjectDelta)

    def GetFaceDofs(self, face, dofs, ndofs):
        r"""GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"""
        return _fe.Linear3DFiniteElement_GetFaceDofs(self, face, dofs, ndofs)
    GetFaceDofs = _swig_new_instance_method(_fe.Linear3DFiniteElement_GetFaceDofs)
    __swig_destroy__ = _fe.delete_Linear3DFiniteElement

# Register Linear3DFiniteElement in _fe:
_fe.Linear3DFiniteElement_swigregister(Linear3DFiniteElement)

class Quadratic3DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Quadratic3DFiniteElement 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):
        r"""__init__(Quadratic3DFiniteElement self) -> Quadratic3DFiniteElement"""
        _fe.Quadratic3DFiniteElement_swiginit(self, _fe.new_Quadratic3DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Quadratic3DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Quadratic3DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Quadratic3DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Quadratic3DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_Quadratic3DFiniteElement

# Register Quadratic3DFiniteElement in _fe:
_fe.Quadratic3DFiniteElement_swigregister(Quadratic3DFiniteElement)

class TriLinear3DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::TriLinear3DFiniteElement 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):
        r"""__init__(TriLinear3DFiniteElement self) -> TriLinear3DFiniteElement"""
        _fe.TriLinear3DFiniteElement_swiginit(self, _fe.new_TriLinear3DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.TriLinear3DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.TriLinear3DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"""
        return _fe.TriLinear3DFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_TriLinear3DFiniteElement

# Register TriLinear3DFiniteElement in _fe:
_fe.TriLinear3DFiniteElement_swigregister(TriLinear3DFiniteElement)

class CrouzeixRaviartFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::CrouzeixRaviartFiniteElement 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):
        r"""__init__(CrouzeixRaviartFiniteElement self) -> CrouzeixRaviartFiniteElement"""
        _fe.CrouzeixRaviartFiniteElement_swiginit(self, _fe.new_CrouzeixRaviartFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.CrouzeixRaviartFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.CrouzeixRaviartFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"""
        return _fe.CrouzeixRaviartFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_CrouzeixRaviartFiniteElement

# Register CrouzeixRaviartFiniteElement in _fe:
_fe.CrouzeixRaviartFiniteElement_swigregister(CrouzeixRaviartFiniteElement)

class CrouzeixRaviartQuadFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::CrouzeixRaviartQuadFiniteElement 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):
        r"""__init__(CrouzeixRaviartQuadFiniteElement self) -> CrouzeixRaviartQuadFiniteElement"""
        _fe.CrouzeixRaviartQuadFiniteElement_swiginit(self, _fe.new_CrouzeixRaviartQuadFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.CrouzeixRaviartQuadFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.CrouzeixRaviartQuadFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.CrouzeixRaviartQuadFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.CrouzeixRaviartQuadFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_CrouzeixRaviartQuadFiniteElement

# Register CrouzeixRaviartQuadFiniteElement in _fe:
_fe.CrouzeixRaviartQuadFiniteElement_swigregister(CrouzeixRaviartQuadFiniteElement)

class P0SegmentFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P0SegmentFiniteElement 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, Ord=0):
        r"""__init__(P0SegmentFiniteElement self, int Ord=0) -> P0SegmentFiniteElement"""
        _fe.P0SegmentFiniteElement_swiginit(self, _fe.new_P0SegmentFiniteElement(Ord))

    def CalcShape(self, ip, shape):
        r"""CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P0SegmentFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P0SegmentFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P0SegmentFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P0SegmentFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_P0SegmentFiniteElement

# Register P0SegmentFiniteElement in _fe:
_fe.P0SegmentFiniteElement_swigregister(P0SegmentFiniteElement)

class RT0TriangleFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT0TriangleFiniteElement 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):
        r"""__init__(RT0TriangleFiniteElement self) -> RT0TriangleFiniteElement"""
        _fe.RT0TriangleFiniteElement_swiginit(self, _fe.new_RT0TriangleFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT0TriangleFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT0TriangleFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT0TriangleFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT0TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0TriangleFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT0TriangleFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT0TriangleFiniteElement

# Register RT0TriangleFiniteElement in _fe:
_fe.RT0TriangleFiniteElement_swigregister(RT0TriangleFiniteElement)

class RT0QuadFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT0QuadFiniteElement 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):
        r"""__init__(RT0QuadFiniteElement self) -> RT0QuadFiniteElement"""
        _fe.RT0QuadFiniteElement_swiginit(self, _fe.new_RT0QuadFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT0QuadFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT0QuadFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT0QuadFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT0QuadFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT0QuadFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT0QuadFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT0QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT0QuadFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT0QuadFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT0QuadFiniteElement

# Register RT0QuadFiniteElement in _fe:
_fe.RT0QuadFiniteElement_swigregister(RT0QuadFiniteElement)

class RT1TriangleFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT1TriangleFiniteElement 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):
        r"""__init__(RT1TriangleFiniteElement self) -> RT1TriangleFiniteElement"""
        _fe.RT1TriangleFiniteElement_swiginit(self, _fe.new_RT1TriangleFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT1TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT1TriangleFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT1TriangleFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT1TriangleFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT1TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT1TriangleFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT1TriangleFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT1TriangleFiniteElement

# Register RT1TriangleFiniteElement in _fe:
_fe.RT1TriangleFiniteElement_swigregister(RT1TriangleFiniteElement)

class RT1QuadFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT1QuadFiniteElement 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):
        r"""__init__(RT1QuadFiniteElement self) -> RT1QuadFiniteElement"""
        _fe.RT1QuadFiniteElement_swiginit(self, _fe.new_RT1QuadFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT1QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT1QuadFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT1QuadFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT1QuadFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT1QuadFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT1QuadFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT1QuadFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT1QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT1QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT1QuadFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT1QuadFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT1QuadFiniteElement

# Register RT1QuadFiniteElement in _fe:
_fe.RT1QuadFiniteElement_swigregister(RT1QuadFiniteElement)

class RT2TriangleFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT2TriangleFiniteElement 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):
        r"""__init__(RT2TriangleFiniteElement self) -> RT2TriangleFiniteElement"""
        _fe.RT2TriangleFiniteElement_swiginit(self, _fe.new_RT2TriangleFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT2TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT2TriangleFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT2TriangleFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT2TriangleFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT2TriangleFiniteElement_CalcDivShape)
    __swig_destroy__ = _fe.delete_RT2TriangleFiniteElement

# Register RT2TriangleFiniteElement in _fe:
_fe.RT2TriangleFiniteElement_swigregister(RT2TriangleFiniteElement)

class RT2QuadFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT2QuadFiniteElement 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):
        r"""__init__(RT2QuadFiniteElement self) -> RT2QuadFiniteElement"""
        _fe.RT2QuadFiniteElement_swiginit(self, _fe.new_RT2QuadFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT2QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT2QuadFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT2QuadFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT2QuadFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT2QuadFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT2QuadFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT2QuadFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT2QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT2QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT2QuadFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT2QuadFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT2QuadFiniteElement

# Register RT2QuadFiniteElement in _fe:
_fe.RT2QuadFiniteElement_swigregister(RT2QuadFiniteElement)

class P1SegmentFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P1SegmentFiniteElement 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):
        r"""__init__(P1SegmentFiniteElement self) -> P1SegmentFiniteElement"""
        _fe.P1SegmentFiniteElement_swiginit(self, _fe.new_P1SegmentFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P1SegmentFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P1SegmentFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P1SegmentFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P1SegmentFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_P1SegmentFiniteElement

# Register P1SegmentFiniteElement in _fe:
_fe.P1SegmentFiniteElement_swigregister(P1SegmentFiniteElement)

class P2SegmentFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P2SegmentFiniteElement 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):
        r"""__init__(P2SegmentFiniteElement self) -> P2SegmentFiniteElement"""
        _fe.P2SegmentFiniteElement_swiginit(self, _fe.new_P2SegmentFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P2SegmentFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P2SegmentFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P2SegmentFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P2SegmentFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_P2SegmentFiniteElement

# Register P2SegmentFiniteElement in _fe:
_fe.P2SegmentFiniteElement_swigregister(P2SegmentFiniteElement)

class Lagrange1DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::Lagrange1DFiniteElement 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, degree):
        r"""__init__(Lagrange1DFiniteElement self, int degree) -> Lagrange1DFiniteElement"""
        _fe.Lagrange1DFiniteElement_swiginit(self, _fe.new_Lagrange1DFiniteElement(degree))

    def CalcShape(self, ip, shape):
        r"""CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.Lagrange1DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.Lagrange1DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.Lagrange1DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.Lagrange1DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_Lagrange1DFiniteElement

# Register Lagrange1DFiniteElement in _fe:
_fe.Lagrange1DFiniteElement_swigregister(Lagrange1DFiniteElement)

class P1TetNonConfFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P1TetNonConfFiniteElement 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):
        r"""__init__(P1TetNonConfFiniteElement self) -> P1TetNonConfFiniteElement"""
        _fe.P1TetNonConfFiniteElement_swiginit(self, _fe.new_P1TetNonConfFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P1TetNonConfFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P1TetNonConfFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P1TetNonConfFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P1TetNonConfFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_P1TetNonConfFiniteElement

# Register P1TetNonConfFiniteElement in _fe:
_fe.P1TetNonConfFiniteElement_swigregister(P1TetNonConfFiniteElement)

class P0TetFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P0TetFiniteElement 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):
        r"""__init__(P0TetFiniteElement self) -> P0TetFiniteElement"""
        _fe.P0TetFiniteElement_swiginit(self, _fe.new_P0TetFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P0TetFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P0TetFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P0TetFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P0TetFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"""
        return _fe.P0TetFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.P0TetFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_P0TetFiniteElement

# Register P0TetFiniteElement in _fe:
_fe.P0TetFiniteElement_swigregister(P0TetFiniteElement)

class P0HexFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::P0HexFiniteElement 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):
        r"""__init__(P0HexFiniteElement self) -> P0HexFiniteElement"""
        _fe.P0HexFiniteElement_swiginit(self, _fe.new_P0HexFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.P0HexFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.P0HexFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.P0HexFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.P0HexFiniteElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"""
        return _fe.P0HexFiniteElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.P0HexFiniteElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_P0HexFiniteElement

# Register P0HexFiniteElement in _fe:
_fe.P0HexFiniteElement_swigregister(P0HexFiniteElement)

class LagrangeHexFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::LagrangeHexFiniteElement 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, degree):
        r"""__init__(LagrangeHexFiniteElement self, int degree) -> LagrangeHexFiniteElement"""
        _fe.LagrangeHexFiniteElement_swiginit(self, _fe.new_LagrangeHexFiniteElement(degree))

    def CalcShape(self, ip, shape):
        r"""CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.LagrangeHexFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.LagrangeHexFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.LagrangeHexFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.LagrangeHexFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_LagrangeHexFiniteElement

# Register LagrangeHexFiniteElement in _fe:
_fe.LagrangeHexFiniteElement_swigregister(LagrangeHexFiniteElement)

class RefinedLinear1DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::RefinedLinear1DFiniteElement 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):
        r"""__init__(RefinedLinear1DFiniteElement self) -> RefinedLinear1DFiniteElement"""
        _fe.RefinedLinear1DFiniteElement_swiginit(self, _fe.new_RefinedLinear1DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.RefinedLinear1DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.RefinedLinear1DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.RefinedLinear1DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.RefinedLinear1DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_RefinedLinear1DFiniteElement

# Register RefinedLinear1DFiniteElement in _fe:
_fe.RefinedLinear1DFiniteElement_swigregister(RefinedLinear1DFiniteElement)

class RefinedLinear2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::RefinedLinear2DFiniteElement 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):
        r"""__init__(RefinedLinear2DFiniteElement self) -> RefinedLinear2DFiniteElement"""
        _fe.RefinedLinear2DFiniteElement_swiginit(self, _fe.new_RefinedLinear2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.RefinedLinear2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.RefinedLinear2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.RefinedLinear2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.RefinedLinear2DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_RefinedLinear2DFiniteElement

# Register RefinedLinear2DFiniteElement in _fe:
_fe.RefinedLinear2DFiniteElement_swigregister(RefinedLinear2DFiniteElement)

class RefinedLinear3DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::RefinedLinear3DFiniteElement 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):
        r"""__init__(RefinedLinear3DFiniteElement self) -> RefinedLinear3DFiniteElement"""
        _fe.RefinedLinear3DFiniteElement_swiginit(self, _fe.new_RefinedLinear3DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.RefinedLinear3DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.RefinedLinear3DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.RefinedLinear3DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.RefinedLinear3DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_RefinedLinear3DFiniteElement

# Register RefinedLinear3DFiniteElement in _fe:
_fe.RefinedLinear3DFiniteElement_swigregister(RefinedLinear3DFiniteElement)

class RefinedBiLinear2DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::RefinedBiLinear2DFiniteElement 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):
        r"""__init__(RefinedBiLinear2DFiniteElement self) -> RefinedBiLinear2DFiniteElement"""
        _fe.RefinedBiLinear2DFiniteElement_swiginit(self, _fe.new_RefinedBiLinear2DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.RefinedBiLinear2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.RefinedBiLinear2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.RefinedBiLinear2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.RefinedBiLinear2DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_RefinedBiLinear2DFiniteElement

# Register RefinedBiLinear2DFiniteElement in _fe:
_fe.RefinedBiLinear2DFiniteElement_swigregister(RefinedBiLinear2DFiniteElement)

class RefinedTriLinear3DFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::RefinedTriLinear3DFiniteElement 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):
        r"""__init__(RefinedTriLinear3DFiniteElement self) -> RefinedTriLinear3DFiniteElement"""
        _fe.RefinedTriLinear3DFiniteElement_swiginit(self, _fe.new_RefinedTriLinear3DFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.RefinedTriLinear3DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.RefinedTriLinear3DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.RefinedTriLinear3DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.RefinedTriLinear3DFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_RefinedTriLinear3DFiniteElement

# Register RefinedTriLinear3DFiniteElement in _fe:
_fe.RefinedTriLinear3DFiniteElement_swigregister(RefinedTriLinear3DFiniteElement)

class Nedelec1HexFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::Nedelec1HexFiniteElement 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):
        r"""__init__(Nedelec1HexFiniteElement self) -> Nedelec1HexFiniteElement"""
        _fe.Nedelec1HexFiniteElement_swiginit(self, _fe.new_Nedelec1HexFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.Nedelec1HexFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_CalcVShape)

    def CalcCurlShape(self, ip, curl_shape):
        r"""CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"""
        return _fe.Nedelec1HexFiniteElement_CalcCurlShape(self, ip, curl_shape)
    CalcCurlShape = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_CalcCurlShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.Nedelec1HexFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(Nedelec1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(Nedelec1HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.Nedelec1HexFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_Project)
    __swig_destroy__ = _fe.delete_Nedelec1HexFiniteElement

# Register Nedelec1HexFiniteElement in _fe:
_fe.Nedelec1HexFiniteElement_swigregister(Nedelec1HexFiniteElement)

class Nedelec1TetFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::Nedelec1TetFiniteElement 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):
        r"""__init__(Nedelec1TetFiniteElement self) -> Nedelec1TetFiniteElement"""
        _fe.Nedelec1TetFiniteElement_swiginit(self, _fe.new_Nedelec1TetFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.Nedelec1TetFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_CalcVShape)

    def CalcCurlShape(self, ip, curl_shape):
        r"""CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"""
        return _fe.Nedelec1TetFiniteElement_CalcCurlShape(self, ip, curl_shape)
    CalcCurlShape = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_CalcCurlShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.Nedelec1TetFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(Nedelec1TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(Nedelec1TetFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.Nedelec1TetFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_Project)
    __swig_destroy__ = _fe.delete_Nedelec1TetFiniteElement

# Register Nedelec1TetFiniteElement in _fe:
_fe.Nedelec1TetFiniteElement_swigregister(Nedelec1TetFiniteElement)

class RT0HexFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT0HexFiniteElement 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):
        r"""__init__(RT0HexFiniteElement self) -> RT0HexFiniteElement"""
        _fe.RT0HexFiniteElement_swiginit(self, _fe.new_RT0HexFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT0HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT0HexFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT0HexFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT0HexFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT0HexFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT0HexFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT0HexFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT0HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT0HexFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT0HexFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT0HexFiniteElement

# Register RT0HexFiniteElement in _fe:
_fe.RT0HexFiniteElement_swigregister(RT0HexFiniteElement)

class RT1HexFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT1HexFiniteElement 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):
        r"""__init__(RT1HexFiniteElement self) -> RT1HexFiniteElement"""
        _fe.RT1HexFiniteElement_swiginit(self, _fe.new_RT1HexFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT1HexFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT1HexFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT1HexFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT1HexFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT1HexFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT1HexFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT1HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT1HexFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT1HexFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT1HexFiniteElement

# Register RT1HexFiniteElement in _fe:
_fe.RT1HexFiniteElement_swigregister(RT1HexFiniteElement)

class RT0TetFiniteElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT0TetFiniteElement 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):
        r"""__init__(RT0TetFiniteElement self) -> RT0TetFiniteElement"""
        _fe.RT0TetFiniteElement_swiginit(self, _fe.new_RT0TetFiniteElement())

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT0TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT0TetFiniteElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT0TetFiniteElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT0TetFiniteElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT0TetFiniteElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT0TetFiniteElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT0TetFiniteElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(RT0TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT0TetFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        """
        return _fe.RT0TetFiniteElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT0TetFiniteElement_Project)
    __swig_destroy__ = _fe.delete_RT0TetFiniteElement

# Register RT0TetFiniteElement in _fe:
_fe.RT0TetFiniteElement_swigregister(RT0TetFiniteElement)

class RotTriLinearHexFiniteElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::RotTriLinearHexFiniteElement 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):
        r"""__init__(RotTriLinearHexFiniteElement self) -> RotTriLinearHexFiniteElement"""
        _fe.RotTriLinearHexFiniteElement_swiginit(self, _fe.new_RotTriLinearHexFiniteElement())

    def CalcShape(self, ip, shape):
        r"""CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.RotTriLinearHexFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.RotTriLinearHexFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.RotTriLinearHexFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.RotTriLinearHexFiniteElement_CalcDShape)
    __swig_destroy__ = _fe.delete_RotTriLinearHexFiniteElement

# Register RotTriLinearHexFiniteElement in _fe:
_fe.RotTriLinearHexFiniteElement_swigregister(RotTriLinearHexFiniteElement)

class Poly_1D(object):
    r"""Proxy of C++ mfem::Poly_1D class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ChangeOfBasis = _fe.Poly_1D_ChangeOfBasis
    
    Barycentric = _fe.Poly_1D_Barycentric
    
    Positive = _fe.Poly_1D_Positive
    
    NumEvalTypes = _fe.Poly_1D_NumEvalTypes
    

    def __init__(self):
        r"""__init__(Poly_1D self) -> Poly_1D"""
        _fe.Poly_1D_swiginit(self, _fe.new_Poly_1D())

    @staticmethod
    def Binom(p):
        r"""Binom(int const p) -> int const *"""
        return _fe.Poly_1D_Binom(p)
    Binom = _swig_new_static_method(_fe.Poly_1D_Binom)

    def GetPoints(self, p, btype):
        r"""GetPoints(Poly_1D self, int const p, int const btype) -> double const *"""
        return _fe.Poly_1D_GetPoints(self, p, btype)
    GetPoints = _swig_new_instance_method(_fe.Poly_1D_GetPoints)

    def OpenPoints(self, *args, **kwargs):
        r"""OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const *"""
        return _fe.Poly_1D_OpenPoints(self, *args, **kwargs)
    OpenPoints = _swig_new_instance_method(_fe.Poly_1D_OpenPoints)

    def ClosedPoints(self, *args, **kwargs):
        r"""ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const *"""
        return _fe.Poly_1D_ClosedPoints(self, *args, **kwargs)
    ClosedPoints = _swig_new_instance_method(_fe.Poly_1D_ClosedPoints)

    def GetBasis(self, p, btype):
        r"""GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"""
        return _fe.Poly_1D_GetBasis(self, p, btype)
    GetBasis = _swig_new_instance_method(_fe.Poly_1D_GetBasis)

    @staticmethod
    def CalcBasis(*args):
        r"""
        CalcBasis(int const p, double const x, double * u)
        CalcBasis(int const p, double const x, double * u, double * d)
        CalcBasis(int const p, double const x, double * u, double * d, double * dd)
        """
        return _fe.Poly_1D_CalcBasis(*args)
    CalcBasis = _swig_new_static_method(_fe.Poly_1D_CalcBasis)

    @staticmethod
    def CalcDelta(p, x):
        r"""CalcDelta(int const p, double const x) -> double"""
        return _fe.Poly_1D_CalcDelta(p, x)
    CalcDelta = _swig_new_static_method(_fe.Poly_1D_CalcDelta)

    @staticmethod
    def ChebyshevPoints(p, x):
        r"""ChebyshevPoints(int const p, double * x)"""
        return _fe.Poly_1D_ChebyshevPoints(p, x)
    ChebyshevPoints = _swig_new_static_method(_fe.Poly_1D_ChebyshevPoints)

    @staticmethod
    def CalcBinomTerms(*args):
        r"""
        CalcBinomTerms(int const p, double const x, double const y, double * u)
        CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)
        """
        return _fe.Poly_1D_CalcBinomTerms(*args)
    CalcBinomTerms = _swig_new_static_method(_fe.Poly_1D_CalcBinomTerms)

    @staticmethod
    def CalcDBinomTerms(p, x, y, d):
        r"""CalcDBinomTerms(int const p, double const x, double const y, double * d)"""
        return _fe.Poly_1D_CalcDBinomTerms(p, x, y, d)
    CalcDBinomTerms = _swig_new_static_method(_fe.Poly_1D_CalcDBinomTerms)

    @staticmethod
    def CalcBernstein(*args):
        r"""
        CalcBernstein(int const p, double const x, double * u)
        CalcBernstein(int const p, double const x, double * u, double * d)
        """
        return _fe.Poly_1D_CalcBernstein(*args)
    CalcBernstein = _swig_new_static_method(_fe.Poly_1D_CalcBernstein)

    @staticmethod
    def CalcLegendre(*args):
        r"""
        CalcLegendre(int const p, double const x, double * u)
        CalcLegendre(int const p, double const x, double * u, double * d)
        """
        return _fe.Poly_1D_CalcLegendre(*args)
    CalcLegendre = _swig_new_static_method(_fe.Poly_1D_CalcLegendre)
    __swig_destroy__ = _fe.delete_Poly_1D

# Register Poly_1D in _fe:
_fe.Poly_1D_swigregister(Poly_1D)

def Poly_1D_Binom(p):
    r"""Poly_1D_Binom(int const p) -> int const *"""
    return _fe.Poly_1D_Binom(p)
Poly_1D_Binom = _fe.Poly_1D_Binom

def Poly_1D_CalcBasis(*args):
    r"""
    Poly_1D_CalcBasis(int const p, double const x, double * u)
    Poly_1D_CalcBasis(int const p, double const x, double * u, double * d)
    Poly_1D_CalcBasis(int const p, double const x, double * u, double * d, double * dd)
    """
    return _fe.Poly_1D_CalcBasis(*args)
Poly_1D_CalcBasis = _fe.Poly_1D_CalcBasis

def Poly_1D_CalcDelta(p, x):
    r"""Poly_1D_CalcDelta(int const p, double const x) -> double"""
    return _fe.Poly_1D_CalcDelta(p, x)
Poly_1D_CalcDelta = _fe.Poly_1D_CalcDelta

def Poly_1D_ChebyshevPoints(p, x):
    r"""Poly_1D_ChebyshevPoints(int const p, double * x)"""
    return _fe.Poly_1D_ChebyshevPoints(p, x)
Poly_1D_ChebyshevPoints = _fe.Poly_1D_ChebyshevPoints

def Poly_1D_CalcBinomTerms(*args):
    r"""
    Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u)
    Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)
    """
    return _fe.Poly_1D_CalcBinomTerms(*args)
Poly_1D_CalcBinomTerms = _fe.Poly_1D_CalcBinomTerms

def Poly_1D_CalcDBinomTerms(p, x, y, d):
    r"""Poly_1D_CalcDBinomTerms(int const p, double const x, double const y, double * d)"""
    return _fe.Poly_1D_CalcDBinomTerms(p, x, y, d)
Poly_1D_CalcDBinomTerms = _fe.Poly_1D_CalcDBinomTerms

def Poly_1D_CalcBernstein(*args):
    r"""
    Poly_1D_CalcBernstein(int const p, double const x, double * u)
    Poly_1D_CalcBernstein(int const p, double const x, double * u, double * d)
    """
    return _fe.Poly_1D_CalcBernstein(*args)
Poly_1D_CalcBernstein = _fe.Poly_1D_CalcBernstein

def Poly_1D_CalcLegendre(*args):
    r"""
    Poly_1D_CalcLegendre(int const p, double const x, double * u)
    Poly_1D_CalcLegendre(int const p, double const x, double * u, double * d)
    """
    return _fe.Poly_1D_CalcLegendre(*args)
Poly_1D_CalcLegendre = _fe.Poly_1D_CalcLegendre

class TensorBasisElement(object):
    r"""Proxy of C++ mfem::TensorBasisElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    L2_DOF_MAP = _fe.TensorBasisElement_L2_DOF_MAP
    
    H1_DOF_MAP = _fe.TensorBasisElement_H1_DOF_MAP
    
    Sr_DOF_MAP = _fe.TensorBasisElement_Sr_DOF_MAP
    

    def __init__(self, dims, p, btype, dmtype):
        r"""__init__(TensorBasisElement self, int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"""
        _fe.TensorBasisElement_swiginit(self, _fe.new_TensorBasisElement(dims, p, btype, dmtype))

    def GetBasisType(self):
        r"""GetBasisType(TensorBasisElement self) -> int"""
        return _fe.TensorBasisElement_GetBasisType(self)
    GetBasisType = _swig_new_instance_method(_fe.TensorBasisElement_GetBasisType)

    def GetBasis1D(self):
        r"""GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &"""
        return _fe.TensorBasisElement_GetBasis1D(self)
    GetBasis1D = _swig_new_instance_method(_fe.TensorBasisElement_GetBasis1D)

    def GetDofMap(self):
        r"""GetDofMap(TensorBasisElement self) -> intArray"""
        return _fe.TensorBasisElement_GetDofMap(self)
    GetDofMap = _swig_new_instance_method(_fe.TensorBasisElement_GetDofMap)

    @staticmethod
    def GetTensorProductGeometry(dim):
        r"""GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"""
        return _fe.TensorBasisElement_GetTensorProductGeometry(dim)
    GetTensorProductGeometry = _swig_new_static_method(_fe.TensorBasisElement_GetTensorProductGeometry)

    @staticmethod
    def Pow(base, dim):
        r"""Pow(int base, int dim) -> int"""
        return _fe.TensorBasisElement_Pow(base, dim)
    Pow = _swig_new_static_method(_fe.TensorBasisElement_Pow)
    __swig_destroy__ = _fe.delete_TensorBasisElement

# Register TensorBasisElement in _fe:
_fe.TensorBasisElement_swigregister(TensorBasisElement)

def TensorBasisElement_GetTensorProductGeometry(dim):
    r"""TensorBasisElement_GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"""
    return _fe.TensorBasisElement_GetTensorProductGeometry(dim)
TensorBasisElement_GetTensorProductGeometry = _fe.TensorBasisElement_GetTensorProductGeometry

def TensorBasisElement_Pow(base, dim):
    r"""TensorBasisElement_Pow(int base, int dim) -> int"""
    return _fe.TensorBasisElement_Pow(base, dim)
TensorBasisElement_Pow = _fe.TensorBasisElement_Pow

class NodalTensorFiniteElement(NodalFiniteElement, TensorBasisElement):
    r"""Proxy of C++ mfem::NodalTensorFiniteElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetDofToQuad(self, ir, mode):
        r"""GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"""
        return _fe.NodalTensorFiniteElement_GetDofToQuad(self, ir, mode)
    GetDofToQuad = _swig_new_instance_method(_fe.NodalTensorFiniteElement_GetDofToQuad)
    __swig_destroy__ = _fe.delete_NodalTensorFiniteElement

# Register NodalTensorFiniteElement in _fe:
_fe.NodalTensorFiniteElement_swigregister(NodalTensorFiniteElement)

class PositiveTensorFiniteElement(PositiveFiniteElement, TensorBasisElement):
    r"""Proxy of C++ mfem::PositiveTensorFiniteElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetDofToQuad(self, ir, mode):
        r"""GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"""
        return _fe.PositiveTensorFiniteElement_GetDofToQuad(self, ir, mode)
    GetDofToQuad = _swig_new_instance_method(_fe.PositiveTensorFiniteElement_GetDofToQuad)
    __swig_destroy__ = _fe.delete_PositiveTensorFiniteElement

# Register PositiveTensorFiniteElement in _fe:
_fe.PositiveTensorFiniteElement_swigregister(PositiveTensorFiniteElement)

class VectorTensorFiniteElement(VectorFiniteElement, TensorBasisElement):
    r"""Proxy of C++ mfem::VectorTensorFiniteElement 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, dims, d, p, cbtype, obtype, M, dmtype):
        r"""__init__(VectorTensorFiniteElement self, int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"""
        _fe.VectorTensorFiniteElement_swiginit(self, _fe.new_VectorTensorFiniteElement(dims, d, p, cbtype, obtype, M, dmtype))

    def GetDofToQuad(self, ir, mode):
        r"""GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"""
        return _fe.VectorTensorFiniteElement_GetDofToQuad(self, ir, mode)
    GetDofToQuad = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetDofToQuad)

    def GetDofToQuadOpen(self, ir, mode):
        r"""GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"""
        return _fe.VectorTensorFiniteElement_GetDofToQuadOpen(self, ir, mode)
    GetDofToQuadOpen = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetDofToQuadOpen)

    def GetTensorDofToQuad(self, ir, mode, closed):
        r"""GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"""
        return _fe.VectorTensorFiniteElement_GetTensorDofToQuad(self, ir, mode, closed)
    GetTensorDofToQuad = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetTensorDofToQuad)
    __swig_destroy__ = _fe.delete_VectorTensorFiniteElement

# Register VectorTensorFiniteElement in _fe:
_fe.VectorTensorFiniteElement_swigregister(VectorTensorFiniteElement)

class H1_SegmentElement(NodalTensorFiniteElement):
    r"""Proxy of C++ mfem::H1_SegmentElement 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, **kwargs):
        r"""__init__(H1_SegmentElement self, int const p, int const btype=GaussLobatto) -> H1_SegmentElement"""
        _fe.H1_SegmentElement_swiginit(self, _fe.new_H1_SegmentElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1_SegmentElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1_SegmentElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1_SegmentElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1_SegmentElement_CalcDShape)

    def CalcHessian(self, ip, Hessian):
        r"""CalcHessian(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix Hessian)"""
        return _fe.H1_SegmentElement_CalcHessian(self, ip, Hessian)
    CalcHessian = _swig_new_instance_method(_fe.H1_SegmentElement_CalcHessian)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"""
        return _fe.H1_SegmentElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.H1_SegmentElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_H1_SegmentElement

# Register H1_SegmentElement in _fe:
_fe.H1_SegmentElement_swigregister(H1_SegmentElement)

class H1_QuadrilateralElement(NodalTensorFiniteElement):
    r"""Proxy of C++ mfem::H1_QuadrilateralElement 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, **kwargs):
        r"""__init__(H1_QuadrilateralElement self, int const p, int const btype=GaussLobatto) -> H1_QuadrilateralElement"""
        _fe.H1_QuadrilateralElement_swiginit(self, _fe.new_H1_QuadrilateralElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1_QuadrilateralElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1_QuadrilateralElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1_QuadrilateralElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1_QuadrilateralElement_CalcDShape)

    def CalcHessian(self, ip, Hessian):
        r"""CalcHessian(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix Hessian)"""
        return _fe.H1_QuadrilateralElement_CalcHessian(self, ip, Hessian)
    CalcHessian = _swig_new_instance_method(_fe.H1_QuadrilateralElement_CalcHessian)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"""
        return _fe.H1_QuadrilateralElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.H1_QuadrilateralElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_H1_QuadrilateralElement

# Register H1_QuadrilateralElement in _fe:
_fe.H1_QuadrilateralElement_swigregister(H1_QuadrilateralElement)

class H1_HexahedronElement(NodalTensorFiniteElement):
    r"""Proxy of C++ mfem::H1_HexahedronElement 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, **kwargs):
        r"""__init__(H1_HexahedronElement self, int const p, int const btype=GaussLobatto) -> H1_HexahedronElement"""
        _fe.H1_HexahedronElement_swiginit(self, _fe.new_H1_HexahedronElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1_HexahedronElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1_HexahedronElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1_HexahedronElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1_HexahedronElement_CalcDShape)

    def CalcHessian(self, ip, Hessian):
        r"""CalcHessian(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix Hessian)"""
        return _fe.H1_HexahedronElement_CalcHessian(self, ip, Hessian)
    CalcHessian = _swig_new_instance_method(_fe.H1_HexahedronElement_CalcHessian)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"""
        return _fe.H1_HexahedronElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.H1_HexahedronElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_H1_HexahedronElement

# Register H1_HexahedronElement in _fe:
_fe.H1_HexahedronElement_swigregister(H1_HexahedronElement)

class H1Pos_SegmentElement(PositiveTensorFiniteElement):
    r"""Proxy of C++ mfem::H1Pos_SegmentElement 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, p):
        r"""__init__(H1Pos_SegmentElement self, int const p) -> H1Pos_SegmentElement"""
        _fe.H1Pos_SegmentElement_swiginit(self, _fe.new_H1Pos_SegmentElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1Pos_SegmentElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1Pos_SegmentElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1Pos_SegmentElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1Pos_SegmentElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"""
        return _fe.H1Pos_SegmentElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.H1Pos_SegmentElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_H1Pos_SegmentElement

# Register H1Pos_SegmentElement in _fe:
_fe.H1Pos_SegmentElement_swigregister(H1Pos_SegmentElement)

class H1Pos_QuadrilateralElement(PositiveTensorFiniteElement):
    r"""Proxy of C++ mfem::H1Pos_QuadrilateralElement 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, p):
        r"""__init__(H1Pos_QuadrilateralElement self, int const p) -> H1Pos_QuadrilateralElement"""
        _fe.H1Pos_QuadrilateralElement_swiginit(self, _fe.new_H1Pos_QuadrilateralElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1Pos_QuadrilateralElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1Pos_QuadrilateralElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"""
        return _fe.H1Pos_QuadrilateralElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_H1Pos_QuadrilateralElement

# Register H1Pos_QuadrilateralElement in _fe:
_fe.H1Pos_QuadrilateralElement_swigregister(H1Pos_QuadrilateralElement)

class H1Ser_QuadrilateralElement(ScalarFiniteElement):
    r"""Proxy of C++ mfem::H1Ser_QuadrilateralElement 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, p):
        r"""__init__(H1Ser_QuadrilateralElement self, int const p) -> H1Ser_QuadrilateralElement"""
        _fe.H1Ser_QuadrilateralElement_swiginit(self, _fe.new_H1Ser_QuadrilateralElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1Ser_QuadrilateralElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1Ser_QuadrilateralElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_CalcDShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.H1Ser_QuadrilateralElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_GetLocalInterpolation)

    def Project(self, *args):
        r"""
        Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(H1Ser_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.H1Ser_QuadrilateralElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_Project)
    __swig_destroy__ = _fe.delete_H1Ser_QuadrilateralElement

# Register H1Ser_QuadrilateralElement in _fe:
_fe.H1Ser_QuadrilateralElement_swigregister(H1Ser_QuadrilateralElement)

class H1Pos_HexahedronElement(PositiveTensorFiniteElement):
    r"""Proxy of C++ mfem::H1Pos_HexahedronElement 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, p):
        r"""__init__(H1Pos_HexahedronElement self, int const p) -> H1Pos_HexahedronElement"""
        _fe.H1Pos_HexahedronElement_swiginit(self, _fe.new_H1Pos_HexahedronElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1Pos_HexahedronElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1Pos_HexahedronElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"""
        return _fe.H1Pos_HexahedronElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_H1Pos_HexahedronElement

# Register H1Pos_HexahedronElement in _fe:
_fe.H1Pos_HexahedronElement_swigregister(H1Pos_HexahedronElement)

class H1_TriangleElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::H1_TriangleElement 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, **kwargs):
        r"""__init__(H1_TriangleElement self, int const p, int const btype=GaussLobatto) -> H1_TriangleElement"""
        _fe.H1_TriangleElement_swiginit(self, _fe.new_H1_TriangleElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1_TriangleElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1_TriangleElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1_TriangleElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1_TriangleElement_CalcDShape)

    def CalcHessian(self, ip, ddshape):
        r"""CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"""
        return _fe.H1_TriangleElement_CalcHessian(self, ip, ddshape)
    CalcHessian = _swig_new_instance_method(_fe.H1_TriangleElement_CalcHessian)
    __swig_destroy__ = _fe.delete_H1_TriangleElement

# Register H1_TriangleElement in _fe:
_fe.H1_TriangleElement_swigregister(H1_TriangleElement)

class H1_TetrahedronElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::H1_TetrahedronElement 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, **kwargs):
        r"""__init__(H1_TetrahedronElement self, int const p, int const btype=GaussLobatto) -> H1_TetrahedronElement"""
        _fe.H1_TetrahedronElement_swiginit(self, _fe.new_H1_TetrahedronElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1_TetrahedronElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1_TetrahedronElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcDShape)

    def CalcHessian(self, ip, ddshape):
        r"""CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"""
        return _fe.H1_TetrahedronElement_CalcHessian(self, ip, ddshape)
    CalcHessian = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcHessian)
    __swig_destroy__ = _fe.delete_H1_TetrahedronElement

# Register H1_TetrahedronElement in _fe:
_fe.H1_TetrahedronElement_swigregister(H1_TetrahedronElement)

class H1Pos_TriangleElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::H1Pos_TriangleElement 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, p):
        r"""__init__(H1Pos_TriangleElement self, int const p) -> H1Pos_TriangleElement"""
        _fe.H1Pos_TriangleElement_swiginit(self, _fe.new_H1Pos_TriangleElement(p))

    def CalcShape(self, *args):
        r"""
        CalcShape(H1Pos_TriangleElement self, int const p, double const x, double const y, double * shape)
        CalcShape(H1Pos_TriangleElement self, IntegrationPoint ip, Vector shape)
        """
        return _fe.H1Pos_TriangleElement_CalcShape(self, *args)
    CalcShape = _swig_new_instance_method(_fe.H1Pos_TriangleElement_CalcShape)

    def CalcDShape(self, *args):
        r"""
        CalcDShape(H1Pos_TriangleElement self, int const p, double const x, double const y, double * dshape_1d, double * dshape)
        CalcDShape(H1Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)
        """
        return _fe.H1Pos_TriangleElement_CalcDShape(self, *args)
    CalcDShape = _swig_new_instance_method(_fe.H1Pos_TriangleElement_CalcDShape)
    __swig_destroy__ = _fe.delete_H1Pos_TriangleElement

# Register H1Pos_TriangleElement in _fe:
_fe.H1Pos_TriangleElement_swigregister(H1Pos_TriangleElement)

class H1Pos_TetrahedronElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::H1Pos_TetrahedronElement 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, p):
        r"""__init__(H1Pos_TetrahedronElement self, int const p) -> H1Pos_TetrahedronElement"""
        _fe.H1Pos_TetrahedronElement_swiginit(self, _fe.new_H1Pos_TetrahedronElement(p))

    def CalcShape(self, *args):
        r"""
        CalcShape(H1Pos_TetrahedronElement self, int const p, double const x, double const y, double const z, double * shape)
        CalcShape(H1Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)
        """
        return _fe.H1Pos_TetrahedronElement_CalcShape(self, *args)
    CalcShape = _swig_new_instance_method(_fe.H1Pos_TetrahedronElement_CalcShape)

    def CalcDShape(self, *args):
        r"""
        CalcDShape(H1Pos_TetrahedronElement self, int const p, double const x, double const y, double const z, double * dshape_1d, double * dshape)
        CalcDShape(H1Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)
        """
        return _fe.H1Pos_TetrahedronElement_CalcDShape(self, *args)
    CalcDShape = _swig_new_instance_method(_fe.H1Pos_TetrahedronElement_CalcDShape)
    __swig_destroy__ = _fe.delete_H1Pos_TetrahedronElement

# Register H1Pos_TetrahedronElement in _fe:
_fe.H1Pos_TetrahedronElement_swigregister(H1Pos_TetrahedronElement)

class H1_WedgeElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::H1_WedgeElement 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, **kwargs):
        r"""__init__(H1_WedgeElement self, int const p, int const btype=GaussLobatto) -> H1_WedgeElement"""
        _fe.H1_WedgeElement_swiginit(self, _fe.new_H1_WedgeElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1_WedgeElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1_WedgeElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1_WedgeElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1_WedgeElement_CalcDShape)
    __swig_destroy__ = _fe.delete_H1_WedgeElement

# Register H1_WedgeElement in _fe:
_fe.H1_WedgeElement_swigregister(H1_WedgeElement)

class BiLinear3DFiniteElement(H1_WedgeElement):
    r"""Proxy of C++ mfem::BiLinear3DFiniteElement 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):
        r"""__init__(BiLinear3DFiniteElement self) -> BiLinear3DFiniteElement"""
        _fe.BiLinear3DFiniteElement_swiginit(self, _fe.new_BiLinear3DFiniteElement())
    __swig_destroy__ = _fe.delete_BiLinear3DFiniteElement

# Register BiLinear3DFiniteElement in _fe:
_fe.BiLinear3DFiniteElement_swigregister(BiLinear3DFiniteElement)

class BiQuadratic3DFiniteElement(H1_WedgeElement):
    r"""Proxy of C++ mfem::BiQuadratic3DFiniteElement 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):
        r"""__init__(BiQuadratic3DFiniteElement self) -> BiQuadratic3DFiniteElement"""
        _fe.BiQuadratic3DFiniteElement_swiginit(self, _fe.new_BiQuadratic3DFiniteElement())
    __swig_destroy__ = _fe.delete_BiQuadratic3DFiniteElement

# Register BiQuadratic3DFiniteElement in _fe:
_fe.BiQuadratic3DFiniteElement_swigregister(BiQuadratic3DFiniteElement)

class BiCubic3DFiniteElement(H1_WedgeElement):
    r"""Proxy of C++ mfem::BiCubic3DFiniteElement 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):
        r"""__init__(BiCubic3DFiniteElement self) -> BiCubic3DFiniteElement"""
        _fe.BiCubic3DFiniteElement_swiginit(self, _fe.new_BiCubic3DFiniteElement())
    __swig_destroy__ = _fe.delete_BiCubic3DFiniteElement

# Register BiCubic3DFiniteElement in _fe:
_fe.BiCubic3DFiniteElement_swigregister(BiCubic3DFiniteElement)

class H1Pos_WedgeElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::H1Pos_WedgeElement 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, p):
        r"""__init__(H1Pos_WedgeElement self, int const p) -> H1Pos_WedgeElement"""
        _fe.H1Pos_WedgeElement_swiginit(self, _fe.new_H1Pos_WedgeElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.H1Pos_WedgeElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.H1Pos_WedgeElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.H1Pos_WedgeElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.H1Pos_WedgeElement_CalcDShape)
    __swig_destroy__ = _fe.delete_H1Pos_WedgeElement

# Register H1Pos_WedgeElement in _fe:
_fe.H1Pos_WedgeElement_swigregister(H1Pos_WedgeElement)

class L2_SegmentElement(NodalTensorFiniteElement):
    r"""Proxy of C++ mfem::L2_SegmentElement 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, **kwargs):
        r"""__init__(L2_SegmentElement self, int const p, int const btype=GaussLegendre) -> L2_SegmentElement"""
        _fe.L2_SegmentElement_swiginit(self, _fe.new_L2_SegmentElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2_SegmentElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2_SegmentElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2_SegmentElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2_SegmentElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"""
        return _fe.L2_SegmentElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2_SegmentElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2_SegmentElement

# Register L2_SegmentElement in _fe:
_fe.L2_SegmentElement_swigregister(L2_SegmentElement)

class L2Pos_SegmentElement(PositiveTensorFiniteElement):
    r"""Proxy of C++ mfem::L2Pos_SegmentElement 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, p):
        r"""__init__(L2Pos_SegmentElement self, int const p) -> L2Pos_SegmentElement"""
        _fe.L2Pos_SegmentElement_swiginit(self, _fe.new_L2Pos_SegmentElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2Pos_SegmentElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2Pos_SegmentElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2Pos_SegmentElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2Pos_SegmentElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"""
        return _fe.L2Pos_SegmentElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2Pos_SegmentElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2Pos_SegmentElement

# Register L2Pos_SegmentElement in _fe:
_fe.L2Pos_SegmentElement_swigregister(L2Pos_SegmentElement)

class L2_QuadrilateralElement(NodalTensorFiniteElement):
    r"""Proxy of C++ mfem::L2_QuadrilateralElement 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, **kwargs):
        r"""__init__(L2_QuadrilateralElement self, int const p, int const btype=GaussLegendre) -> L2_QuadrilateralElement"""
        _fe.L2_QuadrilateralElement_swiginit(self, _fe.new_L2_QuadrilateralElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2_QuadrilateralElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2_QuadrilateralElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2_QuadrilateralElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2_QuadrilateralElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"""
        return _fe.L2_QuadrilateralElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2_QuadrilateralElement_ProjectDelta)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.L2_QuadrilateralElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.L2_QuadrilateralElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_L2_QuadrilateralElement

# Register L2_QuadrilateralElement in _fe:
_fe.L2_QuadrilateralElement_swigregister(L2_QuadrilateralElement)

class L2Pos_QuadrilateralElement(PositiveTensorFiniteElement):
    r"""Proxy of C++ mfem::L2Pos_QuadrilateralElement 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, p):
        r"""__init__(L2Pos_QuadrilateralElement self, int const p) -> L2Pos_QuadrilateralElement"""
        _fe.L2Pos_QuadrilateralElement_swiginit(self, _fe.new_L2Pos_QuadrilateralElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2Pos_QuadrilateralElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2Pos_QuadrilateralElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"""
        return _fe.L2Pos_QuadrilateralElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2Pos_QuadrilateralElement

# Register L2Pos_QuadrilateralElement in _fe:
_fe.L2Pos_QuadrilateralElement_swigregister(L2Pos_QuadrilateralElement)

class L2_HexahedronElement(NodalTensorFiniteElement):
    r"""Proxy of C++ mfem::L2_HexahedronElement 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, **kwargs):
        r"""__init__(L2_HexahedronElement self, int const p, int const btype=GaussLegendre) -> L2_HexahedronElement"""
        _fe.L2_HexahedronElement_swiginit(self, _fe.new_L2_HexahedronElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2_HexahedronElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2_HexahedronElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2_HexahedronElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2_HexahedronElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"""
        return _fe.L2_HexahedronElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2_HexahedronElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2_HexahedronElement

# Register L2_HexahedronElement in _fe:
_fe.L2_HexahedronElement_swigregister(L2_HexahedronElement)

class L2Pos_HexahedronElement(PositiveTensorFiniteElement):
    r"""Proxy of C++ mfem::L2Pos_HexahedronElement 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, p):
        r"""__init__(L2Pos_HexahedronElement self, int const p) -> L2Pos_HexahedronElement"""
        _fe.L2Pos_HexahedronElement_swiginit(self, _fe.new_L2Pos_HexahedronElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2Pos_HexahedronElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2Pos_HexahedronElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"""
        return _fe.L2Pos_HexahedronElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2Pos_HexahedronElement

# Register L2Pos_HexahedronElement in _fe:
_fe.L2Pos_HexahedronElement_swigregister(L2Pos_HexahedronElement)

class L2_TriangleElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::L2_TriangleElement 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, **kwargs):
        r"""__init__(L2_TriangleElement self, int const p, int const btype=GaussLegendre) -> L2_TriangleElement"""
        _fe.L2_TriangleElement_swiginit(self, _fe.new_L2_TriangleElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2_TriangleElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2_TriangleElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2_TriangleElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2_TriangleElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"""
        return _fe.L2_TriangleElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2_TriangleElement_ProjectDelta)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.L2_TriangleElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.L2_TriangleElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_L2_TriangleElement

# Register L2_TriangleElement in _fe:
_fe.L2_TriangleElement_swigregister(L2_TriangleElement)

class L2Pos_TriangleElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::L2Pos_TriangleElement 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, p):
        r"""__init__(L2Pos_TriangleElement self, int const p) -> L2Pos_TriangleElement"""
        _fe.L2Pos_TriangleElement_swiginit(self, _fe.new_L2Pos_TriangleElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2Pos_TriangleElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2Pos_TriangleElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2Pos_TriangleElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2Pos_TriangleElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"""
        return _fe.L2Pos_TriangleElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2Pos_TriangleElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2Pos_TriangleElement

# Register L2Pos_TriangleElement in _fe:
_fe.L2Pos_TriangleElement_swigregister(L2Pos_TriangleElement)

class L2_TetrahedronElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::L2_TetrahedronElement 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, **kwargs):
        r"""__init__(L2_TetrahedronElement self, int const p, int const btype=GaussLegendre) -> L2_TetrahedronElement"""
        _fe.L2_TetrahedronElement_swiginit(self, _fe.new_L2_TetrahedronElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2_TetrahedronElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2_TetrahedronElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2_TetrahedronElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2_TetrahedronElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"""
        return _fe.L2_TetrahedronElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2_TetrahedronElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2_TetrahedronElement

# Register L2_TetrahedronElement in _fe:
_fe.L2_TetrahedronElement_swigregister(L2_TetrahedronElement)

class L2Pos_TetrahedronElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::L2Pos_TetrahedronElement 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, p):
        r"""__init__(L2Pos_TetrahedronElement self, int const p) -> L2Pos_TetrahedronElement"""
        _fe.L2Pos_TetrahedronElement_swiginit(self, _fe.new_L2Pos_TetrahedronElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2Pos_TetrahedronElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2Pos_TetrahedronElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_CalcDShape)

    def ProjectDelta(self, vertex, dofs):
        r"""ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"""
        return _fe.L2Pos_TetrahedronElement_ProjectDelta(self, vertex, dofs)
    ProjectDelta = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_ProjectDelta)
    __swig_destroy__ = _fe.delete_L2Pos_TetrahedronElement

# Register L2Pos_TetrahedronElement in _fe:
_fe.L2Pos_TetrahedronElement_swigregister(L2Pos_TetrahedronElement)

class L2_WedgeElement(NodalFiniteElement):
    r"""Proxy of C++ mfem::L2_WedgeElement 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, **kwargs):
        r"""__init__(L2_WedgeElement self, int const p, int const btype=GaussLegendre) -> L2_WedgeElement"""
        _fe.L2_WedgeElement_swiginit(self, _fe.new_L2_WedgeElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2_WedgeElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2_WedgeElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2_WedgeElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2_WedgeElement_CalcDShape)
    __swig_destroy__ = _fe.delete_L2_WedgeElement

# Register L2_WedgeElement in _fe:
_fe.L2_WedgeElement_swigregister(L2_WedgeElement)

class P0WedgeFiniteElement(L2_WedgeElement):
    r"""Proxy of C++ mfem::P0WedgeFiniteElement 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):
        r"""__init__(P0WedgeFiniteElement self) -> P0WedgeFiniteElement"""
        _fe.P0WedgeFiniteElement_swiginit(self, _fe.new_P0WedgeFiniteElement())
    __swig_destroy__ = _fe.delete_P0WedgeFiniteElement

# Register P0WedgeFiniteElement in _fe:
_fe.P0WedgeFiniteElement_swigregister(P0WedgeFiniteElement)

class L2Pos_WedgeElement(PositiveFiniteElement):
    r"""Proxy of C++ mfem::L2Pos_WedgeElement 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, p):
        r"""__init__(L2Pos_WedgeElement self, int const p) -> L2Pos_WedgeElement"""
        _fe.L2Pos_WedgeElement_swiginit(self, _fe.new_L2Pos_WedgeElement(p))

    def CalcShape(self, ip, shape):
        r"""CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.L2Pos_WedgeElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.L2Pos_WedgeElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.L2Pos_WedgeElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.L2Pos_WedgeElement_CalcDShape)
    __swig_destroy__ = _fe.delete_L2Pos_WedgeElement

# Register L2Pos_WedgeElement in _fe:
_fe.L2Pos_WedgeElement_swigregister(L2Pos_WedgeElement)

class RT_QuadrilateralElement(VectorTensorFiniteElement):
    r"""Proxy of C++ mfem::RT_QuadrilateralElement 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, **kwargs):
        r"""__init__(RT_QuadrilateralElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_QuadrilateralElement"""
        _fe.RT_QuadrilateralElement_swiginit(self, _fe.new_RT_QuadrilateralElement(*args, **kwargs))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT_QuadrilateralElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT_QuadrilateralElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT_QuadrilateralElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT_QuadrilateralElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_QuadrilateralElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.RT_QuadrilateralElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_QuadrilateralElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(RT_QuadrilateralElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.RT_QuadrilateralElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.RT_QuadrilateralElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(RT_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.RT_QuadrilateralElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT_QuadrilateralElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.RT_QuadrilateralElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectGrad)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.RT_QuadrilateralElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_RT_QuadrilateralElement

# Register RT_QuadrilateralElement in _fe:
_fe.RT_QuadrilateralElement_swigregister(RT_QuadrilateralElement)

class RT_HexahedronElement(VectorTensorFiniteElement):
    r"""Proxy of C++ mfem::RT_HexahedronElement 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, **kwargs):
        r"""__init__(RT_HexahedronElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_HexahedronElement"""
        _fe.RT_HexahedronElement_swiginit(self, _fe.new_RT_HexahedronElement(*args, **kwargs))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT_HexahedronElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT_HexahedronElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT_HexahedronElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT_HexahedronElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_HexahedronElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT_HexahedronElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.RT_HexahedronElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.RT_HexahedronElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_HexahedronElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.RT_HexahedronElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(RT_HexahedronElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.RT_HexahedronElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.RT_HexahedronElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.RT_HexahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_HexahedronElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(RT_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.RT_HexahedronElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT_HexahedronElement_Project)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.RT_HexahedronElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.RT_HexahedronElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_RT_HexahedronElement

# Register RT_HexahedronElement in _fe:
_fe.RT_HexahedronElement_swigregister(RT_HexahedronElement)

class RT_TriangleElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT_TriangleElement 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, p):
        r"""__init__(RT_TriangleElement self, int const p) -> RT_TriangleElement"""
        _fe.RT_TriangleElement_swiginit(self, _fe.new_RT_TriangleElement(p))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT_TriangleElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT_TriangleElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT_TriangleElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT_TriangleElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_TriangleElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT_TriangleElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.RT_TriangleElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.RT_TriangleElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_TriangleElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.RT_TriangleElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(RT_TriangleElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.RT_TriangleElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.RT_TriangleElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(RT_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.RT_TriangleElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT_TriangleElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.RT_TriangleElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectGrad)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.RT_TriangleElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_RT_TriangleElement

# Register RT_TriangleElement in _fe:
_fe.RT_TriangleElement_swigregister(RT_TriangleElement)

class RT_TetrahedronElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::RT_TetrahedronElement 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, p):
        r"""__init__(RT_TetrahedronElement self, int const p) -> RT_TetrahedronElement"""
        _fe.RT_TetrahedronElement_swiginit(self, _fe.new_RT_TetrahedronElement(p))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(RT_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.RT_TetrahedronElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.RT_TetrahedronElement_CalcVShape)

    def CalcDivShape(self, ip, divshape):
        r"""CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"""
        return _fe.RT_TetrahedronElement_CalcDivShape(self, ip, divshape)
    CalcDivShape = _swig_new_instance_method(_fe.RT_TetrahedronElement_CalcDivShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_TetrahedronElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.RT_TetrahedronElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.RT_TetrahedronElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(RT_TetrahedronElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.RT_TetrahedronElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.RT_TetrahedronElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.RT_TetrahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_TetrahedronElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(RT_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.RT_TetrahedronElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.RT_TetrahedronElement_Project)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.RT_TetrahedronElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.RT_TetrahedronElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_RT_TetrahedronElement

# Register RT_TetrahedronElement in _fe:
_fe.RT_TetrahedronElement_swigregister(RT_TetrahedronElement)

class ND_HexahedronElement(VectorTensorFiniteElement):
    r"""Proxy of C++ mfem::ND_HexahedronElement 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, **kwargs):
        r"""__init__(ND_HexahedronElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_HexahedronElement"""
        _fe.ND_HexahedronElement_swiginit(self, _fe.new_ND_HexahedronElement(*args, **kwargs))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.ND_HexahedronElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.ND_HexahedronElement_CalcVShape)

    def CalcCurlShape(self, ip, curl_shape):
        r"""CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"""
        return _fe.ND_HexahedronElement_CalcCurlShape(self, ip, curl_shape)
    CalcCurlShape = _swig_new_instance_method(_fe.ND_HexahedronElement_CalcCurlShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_HexahedronElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.ND_HexahedronElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.ND_HexahedronElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.ND_HexahedronElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_HexahedronElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.ND_HexahedronElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(ND_HexahedronElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.ND_HexahedronElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.ND_HexahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(ND_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.ND_HexahedronElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.ND_HexahedronElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.ND_HexahedronElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectGrad)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.ND_HexahedronElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_ND_HexahedronElement

# Register ND_HexahedronElement in _fe:
_fe.ND_HexahedronElement_swigregister(ND_HexahedronElement)

class ND_QuadrilateralElement(VectorTensorFiniteElement):
    r"""Proxy of C++ mfem::ND_QuadrilateralElement 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, **kwargs):
        r"""__init__(ND_QuadrilateralElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_QuadrilateralElement"""
        _fe.ND_QuadrilateralElement_swiginit(self, _fe.new_ND_QuadrilateralElement(*args, **kwargs))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.ND_QuadrilateralElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.ND_QuadrilateralElement_CalcVShape)

    def CalcCurlShape(self, ip, curl_shape):
        r"""CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"""
        return _fe.ND_QuadrilateralElement_CalcCurlShape(self, ip, curl_shape)
    CalcCurlShape = _swig_new_instance_method(_fe.ND_QuadrilateralElement_CalcCurlShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_QuadrilateralElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.ND_QuadrilateralElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_QuadrilateralElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(ND_QuadrilateralElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.ND_QuadrilateralElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.ND_QuadrilateralElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.ND_QuadrilateralElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_QuadrilateralElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(ND_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.ND_QuadrilateralElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.ND_QuadrilateralElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.ND_QuadrilateralElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.ND_QuadrilateralElement_ProjectGrad)
    __swig_destroy__ = _fe.delete_ND_QuadrilateralElement

# Register ND_QuadrilateralElement in _fe:
_fe.ND_QuadrilateralElement_swigregister(ND_QuadrilateralElement)

class ND_TetrahedronElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::ND_TetrahedronElement 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, p):
        r"""__init__(ND_TetrahedronElement self, int const p) -> ND_TetrahedronElement"""
        _fe.ND_TetrahedronElement_swiginit(self, _fe.new_ND_TetrahedronElement(p))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.ND_TetrahedronElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.ND_TetrahedronElement_CalcVShape)

    def CalcCurlShape(self, ip, curl_shape):
        r"""CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"""
        return _fe.ND_TetrahedronElement_CalcCurlShape(self, ip, curl_shape)
    CalcCurlShape = _swig_new_instance_method(_fe.ND_TetrahedronElement_CalcCurlShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_TetrahedronElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.ND_TetrahedronElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_TetrahedronElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(ND_TetrahedronElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.ND_TetrahedronElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.ND_TetrahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(ND_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.ND_TetrahedronElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.ND_TetrahedronElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.ND_TetrahedronElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectGrad)

    def ProjectCurl(self, fe, Trans, curl):
        r"""ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"""
        return _fe.ND_TetrahedronElement_ProjectCurl(self, fe, Trans, curl)
    ProjectCurl = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectCurl)
    __swig_destroy__ = _fe.delete_ND_TetrahedronElement

# Register ND_TetrahedronElement in _fe:
_fe.ND_TetrahedronElement_swigregister(ND_TetrahedronElement)

class ND_TriangleElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::ND_TriangleElement 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, p):
        r"""__init__(ND_TriangleElement self, int const p) -> ND_TriangleElement"""
        _fe.ND_TriangleElement_swiginit(self, _fe.new_ND_TriangleElement(p))

    def CalcVShape(self, *args):
        r"""
        CalcVShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.ND_TriangleElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.ND_TriangleElement_CalcVShape)

    def CalcCurlShape(self, ip, curl_shape):
        r"""CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"""
        return _fe.ND_TriangleElement_CalcCurlShape(self, ip, curl_shape)
    CalcCurlShape = _swig_new_instance_method(_fe.ND_TriangleElement_CalcCurlShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_TriangleElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.ND_TriangleElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.ND_TriangleElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.ND_TriangleElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_TriangleElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.ND_TriangleElement_GetTransferMatrix)

    def ProjectFromNodes(self, vc, Trans, dofs):
        r"""ProjectFromNodes(ND_TriangleElement self, Vector vc, mfem::ElementTransformation & Trans, Vector dofs)"""
        return _fe.ND_TriangleElement_ProjectFromNodes(self, vc, Trans, dofs)
    ProjectFromNodes = _swig_new_instance_method(_fe.ND_TriangleElement_ProjectFromNodes)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.ND_TriangleElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_TriangleElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(ND_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.ND_TriangleElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.ND_TriangleElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.ND_TriangleElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.ND_TriangleElement_ProjectGrad)
    __swig_destroy__ = _fe.delete_ND_TriangleElement

# Register ND_TriangleElement in _fe:
_fe.ND_TriangleElement_swigregister(ND_TriangleElement)

class ND_SegmentElement(VectorFiniteElement):
    r"""Proxy of C++ mfem::ND_SegmentElement 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, **kwargs):
        r"""__init__(ND_SegmentElement self, int const p, int const ob_type=GaussLegendre) -> ND_SegmentElement"""
        _fe.ND_SegmentElement_swiginit(self, _fe.new_ND_SegmentElement(*args, **kwargs))

    def CalcShape(self, ip, shape):
        r"""CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.ND_SegmentElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.ND_SegmentElement_CalcShape)

    def CalcVShape(self, *args):
        r"""
        CalcVShape(ND_SegmentElement self, IntegrationPoint ip, DenseMatrix shape)
        CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)
        """
        return _fe.ND_SegmentElement_CalcVShape(self, *args)
    CalcVShape = _swig_new_instance_method(_fe.ND_SegmentElement_CalcVShape)

    def GetLocalInterpolation(self, Trans, I):
        r"""GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_SegmentElement_GetLocalInterpolation(self, Trans, I)
    GetLocalInterpolation = _swig_new_instance_method(_fe.ND_SegmentElement_GetLocalInterpolation)

    def GetLocalRestriction(self, Trans, R):
        r"""GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"""
        return _fe.ND_SegmentElement_GetLocalRestriction(self, Trans, R)
    GetLocalRestriction = _swig_new_instance_method(_fe.ND_SegmentElement_GetLocalRestriction)

    def GetTransferMatrix(self, fe, Trans, I):
        r"""GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"""
        return _fe.ND_SegmentElement_GetTransferMatrix(self, fe, Trans, I)
    GetTransferMatrix = _swig_new_instance_method(_fe.ND_SegmentElement_GetTransferMatrix)

    def ProjectMatrixCoefficient(self, mc, T, dofs):
        r"""ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"""
        return _fe.ND_SegmentElement_ProjectMatrixCoefficient(self, mc, T, dofs)
    ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_SegmentElement_ProjectMatrixCoefficient)

    def Project(self, *args):
        r"""
        Project(ND_SegmentElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)
        Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)
        """
        return _fe.ND_SegmentElement_Project(self, *args)
    Project = _swig_new_instance_method(_fe.ND_SegmentElement_Project)

    def ProjectGrad(self, fe, Trans, grad):
        r"""ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"""
        return _fe.ND_SegmentElement_ProjectGrad(self, fe, Trans, grad)
    ProjectGrad = _swig_new_instance_method(_fe.ND_SegmentElement_ProjectGrad)
    __swig_destroy__ = _fe.delete_ND_SegmentElement

# Register ND_SegmentElement in _fe:
_fe.ND_SegmentElement_swigregister(ND_SegmentElement)

class NURBSFiniteElement(ScalarFiniteElement):
    r"""Proxy of C++ mfem::NURBSFiniteElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Reset(self):
        r"""Reset(NURBSFiniteElement self)"""
        return _fe.NURBSFiniteElement_Reset(self)
    Reset = _swig_new_instance_method(_fe.NURBSFiniteElement_Reset)

    def SetIJK(self, IJK):
        r"""SetIJK(NURBSFiniteElement self, int const * IJK)"""
        return _fe.NURBSFiniteElement_SetIJK(self, IJK)
    SetIJK = _swig_new_instance_method(_fe.NURBSFiniteElement_SetIJK)

    def GetPatch(self):
        r"""GetPatch(NURBSFiniteElement self) -> int"""
        return _fe.NURBSFiniteElement_GetPatch(self)
    GetPatch = _swig_new_instance_method(_fe.NURBSFiniteElement_GetPatch)

    def SetPatch(self, p):
        r"""SetPatch(NURBSFiniteElement self, int p)"""
        return _fe.NURBSFiniteElement_SetPatch(self, p)
    SetPatch = _swig_new_instance_method(_fe.NURBSFiniteElement_SetPatch)

    def GetElement(self):
        r"""GetElement(NURBSFiniteElement self) -> int"""
        return _fe.NURBSFiniteElement_GetElement(self)
    GetElement = _swig_new_instance_method(_fe.NURBSFiniteElement_GetElement)

    def SetElement(self, e):
        r"""SetElement(NURBSFiniteElement self, int e)"""
        return _fe.NURBSFiniteElement_SetElement(self, e)
    SetElement = _swig_new_instance_method(_fe.NURBSFiniteElement_SetElement)

    def KnotVectors(self):
        r"""KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &"""
        return _fe.NURBSFiniteElement_KnotVectors(self)
    KnotVectors = _swig_new_instance_method(_fe.NURBSFiniteElement_KnotVectors)

    def Weights(self):
        r"""Weights(NURBSFiniteElement self) -> Vector"""
        return _fe.NURBSFiniteElement_Weights(self)
    Weights = _swig_new_instance_method(_fe.NURBSFiniteElement_Weights)

    def SetOrder(self):
        r"""SetOrder(NURBSFiniteElement self)"""
        return _fe.NURBSFiniteElement_SetOrder(self)
    SetOrder = _swig_new_instance_method(_fe.NURBSFiniteElement_SetOrder)
    __swig_destroy__ = _fe.delete_NURBSFiniteElement

# Register NURBSFiniteElement in _fe:
_fe.NURBSFiniteElement_swigregister(NURBSFiniteElement)

class NURBS1DFiniteElement(NURBSFiniteElement):
    r"""Proxy of C++ mfem::NURBS1DFiniteElement 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, p):
        r"""__init__(NURBS1DFiniteElement self, int p) -> NURBS1DFiniteElement"""
        _fe.NURBS1DFiniteElement_swiginit(self, _fe.new_NURBS1DFiniteElement(p))

    def SetOrder(self):
        r"""SetOrder(NURBS1DFiniteElement self)"""
        return _fe.NURBS1DFiniteElement_SetOrder(self)
    SetOrder = _swig_new_instance_method(_fe.NURBS1DFiniteElement_SetOrder)

    def CalcShape(self, ip, shape):
        r"""CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.NURBS1DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.NURBS1DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcDShape)

    def CalcHessian(self, ip, hessian):
        r"""CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"""
        return _fe.NURBS1DFiniteElement_CalcHessian(self, ip, hessian)
    CalcHessian = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcHessian)
    __swig_destroy__ = _fe.delete_NURBS1DFiniteElement

# Register NURBS1DFiniteElement in _fe:
_fe.NURBS1DFiniteElement_swigregister(NURBS1DFiniteElement)

class NURBS2DFiniteElement(NURBSFiniteElement):
    r"""Proxy of C++ mfem::NURBS2DFiniteElement 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__(NURBS2DFiniteElement self, int p) -> NURBS2DFiniteElement
        __init__(NURBS2DFiniteElement self, int px, int py) -> NURBS2DFiniteElement
        """
        _fe.NURBS2DFiniteElement_swiginit(self, _fe.new_NURBS2DFiniteElement(*args))

    def SetOrder(self):
        r"""SetOrder(NURBS2DFiniteElement self)"""
        return _fe.NURBS2DFiniteElement_SetOrder(self)
    SetOrder = _swig_new_instance_method(_fe.NURBS2DFiniteElement_SetOrder)

    def CalcShape(self, ip, shape):
        r"""CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.NURBS2DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.NURBS2DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcDShape)

    def CalcHessian(self, ip, hessian):
        r"""CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"""
        return _fe.NURBS2DFiniteElement_CalcHessian(self, ip, hessian)
    CalcHessian = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcHessian)
    __swig_destroy__ = _fe.delete_NURBS2DFiniteElement

# Register NURBS2DFiniteElement in _fe:
_fe.NURBS2DFiniteElement_swigregister(NURBS2DFiniteElement)

class NURBS3DFiniteElement(NURBSFiniteElement):
    r"""Proxy of C++ mfem::NURBS3DFiniteElement 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__(NURBS3DFiniteElement self, int p) -> NURBS3DFiniteElement
        __init__(NURBS3DFiniteElement self, int px, int py, int pz) -> NURBS3DFiniteElement
        """
        _fe.NURBS3DFiniteElement_swiginit(self, _fe.new_NURBS3DFiniteElement(*args))

    def SetOrder(self):
        r"""SetOrder(NURBS3DFiniteElement self)"""
        return _fe.NURBS3DFiniteElement_SetOrder(self)
    SetOrder = _swig_new_instance_method(_fe.NURBS3DFiniteElement_SetOrder)

    def CalcShape(self, ip, shape):
        r"""CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"""
        return _fe.NURBS3DFiniteElement_CalcShape(self, ip, shape)
    CalcShape = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcShape)

    def CalcDShape(self, ip, dshape):
        r"""CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"""
        return _fe.NURBS3DFiniteElement_CalcDShape(self, ip, dshape)
    CalcDShape = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcDShape)

    def CalcHessian(self, ip, hessian):
        r"""CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"""
        return _fe.NURBS3DFiniteElement_CalcHessian(self, ip, hessian)
    CalcHessian = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcHessian)
    __swig_destroy__ = _fe.delete_NURBS3DFiniteElement

# Register NURBS3DFiniteElement in _fe:
_fe.NURBS3DFiniteElement_swigregister(NURBS3DFiniteElement)



