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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _coefficient.SWIG_PyInstanceMethod_New
_swig_new_static_method = _coefficient.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.globals
import mfem._ser.array
import mfem._ser.mem_manager
import mfem._ser.matrix
import mfem._ser.vector
import mfem._ser.operators
import mfem._ser.intrules
import mfem._ser.sparsemat
import mfem._ser.densemat
import mfem._ser.eltrans
import mfem._ser.fe
import mfem._ser.geom
class Coefficient(object):
    r"""Proxy of C++ mfem::Coefficient 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 SetTime(self, t):
        r"""SetTime(Coefficient self, double t)"""
        return _coefficient.Coefficient_SetTime(self, t)
    SetTime = _swig_new_instance_method(_coefficient.Coefficient_SetTime)

    def GetTime(self):
        r"""GetTime(Coefficient self) -> double"""
        return _coefficient.Coefficient_GetTime(self)
    GetTime = _swig_new_instance_method(_coefficient.Coefficient_GetTime)

    def Eval(self, *args):
        r"""
        Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip) -> double
        Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip, double t) -> double
        """
        return _coefficient.Coefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.Coefficient_Eval)
    __swig_destroy__ = _coefficient.delete_Coefficient

# Register Coefficient in _coefficient:
_coefficient.Coefficient_swigregister(Coefficient)

class ConstantCoefficient(Coefficient):
    r"""Proxy of C++ mfem::ConstantCoefficient class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    constant = property(_coefficient.ConstantCoefficient_constant_get, _coefficient.ConstantCoefficient_constant_set, doc=r"""constant : double""")

    def __init__(self, c=1.0):
        r"""__init__(ConstantCoefficient self, double c=1.0) -> ConstantCoefficient"""
        _coefficient.ConstantCoefficient_swiginit(self, _coefficient.new_ConstantCoefficient(c))

    def Eval(self, T, ip):
        r"""Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.ConstantCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.ConstantCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_ConstantCoefficient

# Register ConstantCoefficient in _coefficient:
_coefficient.ConstantCoefficient_swigregister(ConstantCoefficient)

class PWConstCoefficient(Coefficient):
    r"""Proxy of C++ mfem::PWConstCoefficient 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__(PWConstCoefficient self, int NumOfSubD=0) -> PWConstCoefficient
        __init__(PWConstCoefficient self, Vector c) -> PWConstCoefficient
        """
        _coefficient.PWConstCoefficient_swiginit(self, _coefficient.new_PWConstCoefficient(*args))

    def UpdateConstants(self, c):
        r"""UpdateConstants(PWConstCoefficient self, Vector c)"""
        return _coefficient.PWConstCoefficient_UpdateConstants(self, c)
    UpdateConstants = _swig_new_instance_method(_coefficient.PWConstCoefficient_UpdateConstants)

    def __call__(self, i):
        r"""__call__(PWConstCoefficient self, int i) -> double &"""
        return _coefficient.PWConstCoefficient___call__(self, i)
    __call__ = _swig_new_instance_method(_coefficient.PWConstCoefficient___call__)

    def GetNConst(self):
        r"""GetNConst(PWConstCoefficient self) -> int"""
        return _coefficient.PWConstCoefficient_GetNConst(self)
    GetNConst = _swig_new_instance_method(_coefficient.PWConstCoefficient_GetNConst)

    def Eval(self, T, ip):
        r"""Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.PWConstCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.PWConstCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_PWConstCoefficient

# Register PWConstCoefficient in _coefficient:
_coefficient.PWConstCoefficient_swigregister(PWConstCoefficient)

class FunctionCoefficient(Coefficient):
    r"""Proxy of C++ mfem::FunctionCoefficient 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__(FunctionCoefficient self, std::function< double (mfem::Vector const &) > F) -> FunctionCoefficient
        __init__(FunctionCoefficient self, std::function< double (mfem::Vector const &,double) > TDF) -> FunctionCoefficient
        __init__(FunctionCoefficient self, double (*)(mfem::Vector &) f) -> FunctionCoefficient
        __init__(FunctionCoefficient self, double (*)(mfem::Vector &,double) tdf) -> FunctionCoefficient
        """
        _coefficient.FunctionCoefficient_swiginit(self, _coefficient.new_FunctionCoefficient(*args))

    def Eval(self, T, ip):
        r"""Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.FunctionCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.FunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_FunctionCoefficient

# Register FunctionCoefficient in _coefficient:
_coefficient.FunctionCoefficient_swigregister(FunctionCoefficient)

class GridFunctionCoefficient(Coefficient):
    r"""Proxy of C++ mfem::GridFunctionCoefficient 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__(GridFunctionCoefficient self) -> GridFunctionCoefficient
        __init__(GridFunctionCoefficient self, mfem::GridFunction const * gf, int comp=1) -> GridFunctionCoefficient
        """
        _coefficient.GridFunctionCoefficient_swiginit(self, _coefficient.new_GridFunctionCoefficient(*args))

    def SetGridFunction(self, gf):
        r"""SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction const * gf)"""
        return _coefficient.GridFunctionCoefficient_SetGridFunction(self, gf)
    SetGridFunction = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_SetGridFunction)

    def GetGridFunction(self):
        r"""GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction const *"""
        return _coefficient.GridFunctionCoefficient_GetGridFunction(self)
    GetGridFunction = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_GetGridFunction)

    def Eval(self, T, ip):
        r"""Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.GridFunctionCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_GridFunctionCoefficient

# Register GridFunctionCoefficient in _coefficient:
_coefficient.GridFunctionCoefficient_swigregister(GridFunctionCoefficient)

class TransformedCoefficient(Coefficient):
    r"""Proxy of C++ mfem::TransformedCoefficient 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__(TransformedCoefficient self, Coefficient q, double (*)(double) F) -> TransformedCoefficient
        __init__(TransformedCoefficient self, Coefficient q1, Coefficient q2, double (*)(double,double) F) -> TransformedCoefficient
        """
        _coefficient.TransformedCoefficient_swiginit(self, _coefficient.new_TransformedCoefficient(*args))

    def Eval(self, T, ip):
        r"""Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.TransformedCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.TransformedCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_TransformedCoefficient

# Register TransformedCoefficient in _coefficient:
_coefficient.TransformedCoefficient_swigregister(TransformedCoefficient)

class DeltaCoefficient(Coefficient):
    r"""Proxy of C++ mfem::DeltaCoefficient 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__(DeltaCoefficient self) -> DeltaCoefficient
        __init__(DeltaCoefficient self, double x, double s) -> DeltaCoefficient
        __init__(DeltaCoefficient self, double x, double y, double s) -> DeltaCoefficient
        __init__(DeltaCoefficient self, double x, double y, double z, double s) -> DeltaCoefficient
        """
        _coefficient.DeltaCoefficient_swiginit(self, _coefficient.new_DeltaCoefficient(*args))

    def SetDeltaCenter(self, center):
        r"""SetDeltaCenter(DeltaCoefficient self, Vector center)"""
        return _coefficient.DeltaCoefficient_SetDeltaCenter(self, center)
    SetDeltaCenter = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetDeltaCenter)

    def SetScale(self, _s):
        r"""SetScale(DeltaCoefficient self, double _s)"""
        return _coefficient.DeltaCoefficient_SetScale(self, _s)
    SetScale = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetScale)

    def SetFunction(self, f):
        r"""SetFunction(DeltaCoefficient self, double (*)(double) f)"""
        return _coefficient.DeltaCoefficient_SetFunction(self, f)
    SetFunction = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetFunction)

    def SetTol(self, _tol):
        r"""SetTol(DeltaCoefficient self, double _tol)"""
        return _coefficient.DeltaCoefficient_SetTol(self, _tol)
    SetTol = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetTol)

    def SetWeight(self, w):
        r"""SetWeight(DeltaCoefficient self, Coefficient w)"""

        w.thisown=0 


        return _coefficient.DeltaCoefficient_SetWeight(self, w)


    def Center(self):
        r"""Center(DeltaCoefficient self) -> double const *"""
        return _coefficient.DeltaCoefficient_Center(self)
    Center = _swig_new_instance_method(_coefficient.DeltaCoefficient_Center)

    def Scale(self):
        r"""Scale(DeltaCoefficient self) -> double"""
        return _coefficient.DeltaCoefficient_Scale(self)
    Scale = _swig_new_instance_method(_coefficient.DeltaCoefficient_Scale)

    def Tol(self):
        r"""Tol(DeltaCoefficient self) -> double"""
        return _coefficient.DeltaCoefficient_Tol(self)
    Tol = _swig_new_instance_method(_coefficient.DeltaCoefficient_Tol)

    def Weight(self):
        r"""Weight(DeltaCoefficient self) -> Coefficient"""
        return _coefficient.DeltaCoefficient_Weight(self)
    Weight = _swig_new_instance_method(_coefficient.DeltaCoefficient_Weight)

    def GetDeltaCenter(self, center):
        r"""GetDeltaCenter(DeltaCoefficient self, Vector center)"""
        return _coefficient.DeltaCoefficient_GetDeltaCenter(self, center)
    GetDeltaCenter = _swig_new_instance_method(_coefficient.DeltaCoefficient_GetDeltaCenter)

    def EvalDelta(self, T, ip):
        r"""EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.DeltaCoefficient_EvalDelta(self, T, ip)
    EvalDelta = _swig_new_instance_method(_coefficient.DeltaCoefficient_EvalDelta)

    def Eval(self, T, ip):
        r"""Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.DeltaCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.DeltaCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_DeltaCoefficient

# Register DeltaCoefficient in _coefficient:
_coefficient.DeltaCoefficient_swigregister(DeltaCoefficient)

class RestrictedCoefficient(Coefficient):
    r"""Proxy of C++ mfem::RestrictedCoefficient 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, _c, attr):
        r"""__init__(RestrictedCoefficient self, Coefficient _c, intArray attr) -> RestrictedCoefficient"""
        _coefficient.RestrictedCoefficient_swiginit(self, _coefficient.new_RestrictedCoefficient(_c, attr))

        self._ref_to_c = _c




    def Eval(self, T, ip):
        r"""Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.RestrictedCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.RestrictedCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_RestrictedCoefficient

# Register RestrictedCoefficient in _coefficient:
_coefficient.RestrictedCoefficient_swigregister(RestrictedCoefficient)

class VectorCoefficient(object):
    r"""Proxy of C++ mfem::VectorCoefficient 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 SetTime(self, t):
        r"""SetTime(VectorCoefficient self, double t)"""
        return _coefficient.VectorCoefficient_SetTime(self, t)
    SetTime = _swig_new_instance_method(_coefficient.VectorCoefficient_SetTime)

    def GetTime(self):
        r"""GetTime(VectorCoefficient self) -> double"""
        return _coefficient.VectorCoefficient_GetTime(self)
    GetTime = _swig_new_instance_method(_coefficient.VectorCoefficient_GetTime)

    def GetVDim(self):
        r"""GetVDim(VectorCoefficient self) -> int"""
        return _coefficient.VectorCoefficient_GetVDim(self)
    GetVDim = _swig_new_instance_method(_coefficient.VectorCoefficient_GetVDim)

    def Eval(self, *args):
        r"""
        Eval(VectorCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.VectorCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorCoefficient

# Register VectorCoefficient in _coefficient:
_coefficient.VectorCoefficient_swigregister(VectorCoefficient)

class VectorConstantCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorConstantCoefficient 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, v):
        r"""__init__(VectorConstantCoefficient self, Vector v) -> VectorConstantCoefficient"""

        try:
           import numpy as np
           value = np.array(v, copy=False, dtype=float).flatten()
           can_np_array = True
        except:
           can_np_array = False

        if can_np_array:
           v = mfem._ser.vector.Vector(value)
           self._value = v
        else:
           pass 


        _coefficient.VectorConstantCoefficient_swiginit(self, _coefficient.new_VectorConstantCoefficient(v))

    def Eval(self, *args):
        r"""
        Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.VectorConstantCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorConstantCoefficient_Eval)

    def GetVec(self):
        r"""GetVec(VectorConstantCoefficient self) -> Vector"""
        return _coefficient.VectorConstantCoefficient_GetVec(self)
    GetVec = _swig_new_instance_method(_coefficient.VectorConstantCoefficient_GetVec)
    __swig_destroy__ = _coefficient.delete_VectorConstantCoefficient

# Register VectorConstantCoefficient in _coefficient:
_coefficient.VectorConstantCoefficient_swigregister(VectorConstantCoefficient)

class VectorFunctionCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorFunctionCoefficient 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__(VectorFunctionCoefficient self, int dim, std::function< void (mfem::Vector const &,mfem::Vector &) > F, Coefficient q=None) -> VectorFunctionCoefficient
        __init__(VectorFunctionCoefficient self, int dim, std::function< void (mfem::Vector const &,double,mfem::Vector &) > TDF, Coefficient q=None) -> VectorFunctionCoefficient
        """
        _coefficient.VectorFunctionCoefficient_swiginit(self, _coefficient.new_VectorFunctionCoefficient(*args))

    def Eval(self, *args):
        r"""
        Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.VectorFunctionCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorFunctionCoefficient

# Register VectorFunctionCoefficient in _coefficient:
_coefficient.VectorFunctionCoefficient_swigregister(VectorFunctionCoefficient)

class VectorArrayCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorArrayCoefficient 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, dim):
        r"""__init__(VectorArrayCoefficient self, int dim) -> VectorArrayCoefficient"""
        _coefficient.VectorArrayCoefficient_swiginit(self, _coefficient.new_VectorArrayCoefficient(dim))

    def GetCoeff(self, i):
        r"""GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"""
        return _coefficient.VectorArrayCoefficient_GetCoeff(self, i)
    GetCoeff = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_GetCoeff)

    def GetCoeffs(self):
        r"""GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **"""
        return _coefficient.VectorArrayCoefficient_GetCoeffs(self)
    GetCoeffs = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_GetCoeffs)

    def Set(self, i, c, own=True):
        r"""Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"""

        c.thisown=0 


        return _coefficient.VectorArrayCoefficient_Set(self, i, c, own)


    def Eval(self, *args):
        r"""
        Eval(VectorArrayCoefficient self, int i, ElementTransformation T, IntegrationPoint ip) -> double
        Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorArrayCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.VectorArrayCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorArrayCoefficient

# Register VectorArrayCoefficient in _coefficient:
_coefficient.VectorArrayCoefficient_swigregister(VectorArrayCoefficient)

class VectorGridFunctionCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorGridFunctionCoefficient 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__(VectorGridFunctionCoefficient self) -> VectorGridFunctionCoefficient
        __init__(VectorGridFunctionCoefficient self, mfem::GridFunction const * gf) -> VectorGridFunctionCoefficient
        """
        _coefficient.VectorGridFunctionCoefficient_swiginit(self, _coefficient.new_VectorGridFunctionCoefficient(*args))

    def SetGridFunction(self, gf):
        r"""SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction const * gf)"""
        return _coefficient.VectorGridFunctionCoefficient_SetGridFunction(self, gf)
    SetGridFunction = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_SetGridFunction)

    def GetGridFunction(self):
        r"""GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction const *"""
        return _coefficient.VectorGridFunctionCoefficient_GetGridFunction(self)
    GetGridFunction = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_GetGridFunction)

    def Eval(self, *args):
        r"""
        Eval(VectorGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.VectorGridFunctionCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorGridFunctionCoefficient

# Register VectorGridFunctionCoefficient in _coefficient:
_coefficient.VectorGridFunctionCoefficient_swigregister(VectorGridFunctionCoefficient)

class GradientGridFunctionCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::GradientGridFunctionCoefficient 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, gf):
        r"""__init__(GradientGridFunctionCoefficient self, mfem::GridFunction const * gf) -> GradientGridFunctionCoefficient"""
        _coefficient.GradientGridFunctionCoefficient_swiginit(self, _coefficient.new_GradientGridFunctionCoefficient(gf))

    def SetGridFunction(self, gf):
        r"""SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction const * gf)"""
        return _coefficient.GradientGridFunctionCoefficient_SetGridFunction(self, gf)
    SetGridFunction = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_SetGridFunction)

    def GetGridFunction(self):
        r"""GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction const *"""
        return _coefficient.GradientGridFunctionCoefficient_GetGridFunction(self)
    GetGridFunction = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_GetGridFunction)

    def Eval(self, *args):
        r"""
        Eval(GradientGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(GradientGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.GradientGridFunctionCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_GradientGridFunctionCoefficient

# Register GradientGridFunctionCoefficient in _coefficient:
_coefficient.GradientGridFunctionCoefficient_swigregister(GradientGridFunctionCoefficient)

class CurlGridFunctionCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::CurlGridFunctionCoefficient 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 SetGridFunction(self, gf):
        r"""SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction const * gf)"""
        return _coefficient.CurlGridFunctionCoefficient_SetGridFunction(self, gf)
    SetGridFunction = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_SetGridFunction)

    def GetGridFunction(self):
        r"""GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction const *"""
        return _coefficient.CurlGridFunctionCoefficient_GetGridFunction(self)
    GetGridFunction = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_GetGridFunction)

    def Eval(self, *args):
        r"""
        Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(CurlGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.CurlGridFunctionCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_CurlGridFunctionCoefficient

# Register CurlGridFunctionCoefficient in _coefficient:
_coefficient.CurlGridFunctionCoefficient_swigregister(CurlGridFunctionCoefficient)

class DivergenceGridFunctionCoefficient(Coefficient):
    r"""Proxy of C++ mfem::DivergenceGridFunctionCoefficient 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, gf):
        r"""__init__(DivergenceGridFunctionCoefficient self, mfem::GridFunction const * gf) -> DivergenceGridFunctionCoefficient"""
        _coefficient.DivergenceGridFunctionCoefficient_swiginit(self, _coefficient.new_DivergenceGridFunctionCoefficient(gf))

    def SetGridFunction(self, gf):
        r"""SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction const * gf)"""
        return _coefficient.DivergenceGridFunctionCoefficient_SetGridFunction(self, gf)
    SetGridFunction = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_SetGridFunction)

    def GetGridFunction(self):
        r"""GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction const *"""
        return _coefficient.DivergenceGridFunctionCoefficient_GetGridFunction(self)
    GetGridFunction = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_GetGridFunction)

    def Eval(self, T, ip):
        r"""Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.DivergenceGridFunctionCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_DivergenceGridFunctionCoefficient

# Register DivergenceGridFunctionCoefficient in _coefficient:
_coefficient.DivergenceGridFunctionCoefficient_swigregister(DivergenceGridFunctionCoefficient)

class VectorDeltaCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorDeltaCoefficient 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__(VectorDeltaCoefficient self, int _vdim) -> VectorDeltaCoefficient
        __init__(VectorDeltaCoefficient self, Vector _dir) -> VectorDeltaCoefficient
        __init__(VectorDeltaCoefficient self, Vector _dir, double x, double s) -> VectorDeltaCoefficient
        __init__(VectorDeltaCoefficient self, Vector _dir, double x, double y, double s) -> VectorDeltaCoefficient
        __init__(VectorDeltaCoefficient self, Vector _dir, double x, double y, double z, double s) -> VectorDeltaCoefficient
        """
        _coefficient.VectorDeltaCoefficient_swiginit(self, _coefficient.new_VectorDeltaCoefficient(*args))

    def SetDeltaCoefficient(self, _d):
        r"""SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"""
        return _coefficient.VectorDeltaCoefficient_SetDeltaCoefficient(self, _d)
    SetDeltaCoefficient = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDeltaCoefficient)

    def GetDeltaCoefficient(self):
        r"""GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient"""
        return _coefficient.VectorDeltaCoefficient_GetDeltaCoefficient(self)
    GetDeltaCoefficient = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_GetDeltaCoefficient)

    def SetScale(self, s):
        r"""SetScale(VectorDeltaCoefficient self, double s)"""
        return _coefficient.VectorDeltaCoefficient_SetScale(self, s)
    SetScale = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetScale)

    def SetDirection(self, _d):
        r"""SetDirection(VectorDeltaCoefficient self, Vector _d)"""
        return _coefficient.VectorDeltaCoefficient_SetDirection(self, _d)
    SetDirection = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDirection)

    def SetDeltaCenter(self, center):
        r"""SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"""
        return _coefficient.VectorDeltaCoefficient_SetDeltaCenter(self, center)
    SetDeltaCenter = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDeltaCenter)

    def GetDeltaCenter(self, center):
        r"""GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"""
        return _coefficient.VectorDeltaCoefficient_GetDeltaCenter(self, center)
    GetDeltaCenter = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_GetDeltaCenter)

    def EvalDelta(self, V, T, ip):
        r"""EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.VectorDeltaCoefficient_EvalDelta(self, V, T, ip)
    EvalDelta = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_EvalDelta)

    def Eval(self, *args):
        r"""
        Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorDeltaCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.VectorDeltaCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorDeltaCoefficient

# Register VectorDeltaCoefficient in _coefficient:
_coefficient.VectorDeltaCoefficient_swigregister(VectorDeltaCoefficient)

class VectorRestrictedCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorRestrictedCoefficient 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, vc, attr):
        r"""__init__(VectorRestrictedCoefficient self, VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"""
        _coefficient.VectorRestrictedCoefficient_swiginit(self, _coefficient.new_VectorRestrictedCoefficient(vc, attr))

        self._ref_to_vc = vc




    def Eval(self, *args):
        r"""
        Eval(VectorRestrictedCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.VectorRestrictedCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorRestrictedCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorRestrictedCoefficient

# Register VectorRestrictedCoefficient in _coefficient:
_coefficient.VectorRestrictedCoefficient_swigregister(VectorRestrictedCoefficient)

class MatrixCoefficient(object):
    r"""Proxy of C++ mfem::MatrixCoefficient 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 SetTime(self, t):
        r"""SetTime(MatrixCoefficient self, double t)"""
        return _coefficient.MatrixCoefficient_SetTime(self, t)
    SetTime = _swig_new_instance_method(_coefficient.MatrixCoefficient_SetTime)

    def GetTime(self):
        r"""GetTime(MatrixCoefficient self) -> double"""
        return _coefficient.MatrixCoefficient_GetTime(self)
    GetTime = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetTime)

    def GetHeight(self):
        r"""GetHeight(MatrixCoefficient self) -> int"""
        return _coefficient.MatrixCoefficient_GetHeight(self)
    GetHeight = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetHeight)

    def GetWidth(self):
        r"""GetWidth(MatrixCoefficient self) -> int"""
        return _coefficient.MatrixCoefficient_GetWidth(self)
    GetWidth = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetWidth)

    def GetVDim(self):
        r"""GetVDim(MatrixCoefficient self) -> int"""
        return _coefficient.MatrixCoefficient_GetVDim(self)
    GetVDim = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetVDim)

    def IsSymmetric(self):
        r"""IsSymmetric(MatrixCoefficient self) -> bool"""
        return _coefficient.MatrixCoefficient_IsSymmetric(self)
    IsSymmetric = _swig_new_instance_method(_coefficient.MatrixCoefficient_IsSymmetric)

    def Eval(self, K, T, ip):
        r"""Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.MatrixCoefficient_Eval(self, K, T, ip)
    Eval = _swig_new_instance_method(_coefficient.MatrixCoefficient_Eval)

    def EvalSymmetric(self, K, T, ip):
        r"""EvalSymmetric(MatrixCoefficient self, Vector K, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.MatrixCoefficient_EvalSymmetric(self, K, T, ip)
    EvalSymmetric = _swig_new_instance_method(_coefficient.MatrixCoefficient_EvalSymmetric)
    __swig_destroy__ = _coefficient.delete_MatrixCoefficient

# Register MatrixCoefficient in _coefficient:
_coefficient.MatrixCoefficient_swigregister(MatrixCoefficient)

class MatrixConstantCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::MatrixConstantCoefficient 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, m):
        r"""__init__(MatrixConstantCoefficient self, DenseMatrix m) -> MatrixConstantCoefficient"""

        try:
           import numpy as np
           value = np.array(m, copy=False, dtype=float)
           can_np_array = True
        except:
           can_np_array = False

        if can_np_array:
           v = mfem._ser.vector.Vector(np.transpose(value).flatten())
           m = mfem._ser.densemat.DenseMatrix(v.GetData(), value.shape[0], value.shape[1])       
           self._value = (v,m)
        else:
           pass 


        _coefficient.MatrixConstantCoefficient_swiginit(self, _coefficient.new_MatrixConstantCoefficient(m))

    def Eval(self, *args):
        r"""
        Eval(MatrixConstantCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)
        Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.MatrixConstantCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.MatrixConstantCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_MatrixConstantCoefficient

# Register MatrixConstantCoefficient in _coefficient:
_coefficient.MatrixConstantCoefficient_swigregister(MatrixConstantCoefficient)

class MatrixFunctionCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::MatrixFunctionCoefficient 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__(MatrixFunctionCoefficient self, int dim, std::function< void (mfem::Vector const &,mfem::DenseMatrix &) > F, Coefficient q=None) -> MatrixFunctionCoefficient
        __init__(MatrixFunctionCoefficient self, DenseMatrix m, Coefficient q) -> MatrixFunctionCoefficient
        __init__(MatrixFunctionCoefficient self, int dim, std::function< void (mfem::Vector const &,double,mfem::DenseMatrix &) > TDF, Coefficient q=None) -> MatrixFunctionCoefficient
        __init__(MatrixFunctionCoefficient self, int dim, std::function< void (mfem::Vector const &,mfem::Vector &) > SymmF, Coefficient q=None) -> MatrixFunctionCoefficient
        """
        _coefficient.MatrixFunctionCoefficient_swiginit(self, _coefficient.new_MatrixFunctionCoefficient(*args))

    def Eval(self, K, T, ip):
        r"""Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.MatrixFunctionCoefficient_Eval(self, K, T, ip)
    Eval = _swig_new_instance_method(_coefficient.MatrixFunctionCoefficient_Eval)

    def EvalSymmetric(self, K, T, ip):
        r"""EvalSymmetric(MatrixFunctionCoefficient self, Vector K, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.MatrixFunctionCoefficient_EvalSymmetric(self, K, T, ip)
    EvalSymmetric = _swig_new_instance_method(_coefficient.MatrixFunctionCoefficient_EvalSymmetric)
    __swig_destroy__ = _coefficient.delete_MatrixFunctionCoefficient

# Register MatrixFunctionCoefficient in _coefficient:
_coefficient.MatrixFunctionCoefficient_swigregister(MatrixFunctionCoefficient)

class MatrixArrayCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::MatrixArrayCoefficient 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, dim):
        r"""__init__(MatrixArrayCoefficient self, int dim) -> MatrixArrayCoefficient"""
        _coefficient.MatrixArrayCoefficient_swiginit(self, _coefficient.new_MatrixArrayCoefficient(dim))

    def GetCoeff(self, i, j):
        r"""GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"""
        return _coefficient.MatrixArrayCoefficient_GetCoeff(self, i, j)
    GetCoeff = _swig_new_instance_method(_coefficient.MatrixArrayCoefficient_GetCoeff)

    def Set(self, i, j, c, own=True):
        r"""Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"""

        c.thisown=0 


        return _coefficient.MatrixArrayCoefficient_Set(self, i, j, c, own)


    def Eval(self, *args):
        r"""
        Eval(MatrixArrayCoefficient self, int i, int j, ElementTransformation T, IntegrationPoint ip) -> double
        Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.MatrixArrayCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.MatrixArrayCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_MatrixArrayCoefficient

# Register MatrixArrayCoefficient in _coefficient:
_coefficient.MatrixArrayCoefficient_swigregister(MatrixArrayCoefficient)

class MatrixRestrictedCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::MatrixRestrictedCoefficient 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, mc, attr):
        r"""__init__(MatrixRestrictedCoefficient self, MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"""
        _coefficient.MatrixRestrictedCoefficient_swiginit(self, _coefficient.new_MatrixRestrictedCoefficient(mc, attr))

        self._ref_to_mc = mc




    def Eval(self, K, T, ip):
        r"""Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.MatrixRestrictedCoefficient_Eval(self, K, T, ip)
    Eval = _swig_new_instance_method(_coefficient.MatrixRestrictedCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_MatrixRestrictedCoefficient

# Register MatrixRestrictedCoefficient in _coefficient:
_coefficient.MatrixRestrictedCoefficient_swigregister(MatrixRestrictedCoefficient)

class SumCoefficient(Coefficient):
    r"""Proxy of C++ mfem::SumCoefficient 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__(SumCoefficient self, double A, Coefficient B, double _alpha=1.0, double _beta=1.0) -> SumCoefficient
        __init__(SumCoefficient self, Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0) -> SumCoefficient
        """
        _coefficient.SumCoefficient_swiginit(self, _coefficient.new_SumCoefficient(*args))

    def SetAConst(self, A):
        r"""SetAConst(SumCoefficient self, double A)"""
        return _coefficient.SumCoefficient_SetAConst(self, A)
    SetAConst = _swig_new_instance_method(_coefficient.SumCoefficient_SetAConst)

    def GetAConst(self):
        r"""GetAConst(SumCoefficient self) -> double"""
        return _coefficient.SumCoefficient_GetAConst(self)
    GetAConst = _swig_new_instance_method(_coefficient.SumCoefficient_GetAConst)

    def SetACoef(self, A):
        r"""SetACoef(SumCoefficient self, Coefficient A)"""
        return _coefficient.SumCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.SumCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(SumCoefficient self) -> Coefficient"""
        return _coefficient.SumCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.SumCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(SumCoefficient self, Coefficient B)"""
        return _coefficient.SumCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.SumCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(SumCoefficient self) -> Coefficient"""
        return _coefficient.SumCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.SumCoefficient_GetBCoef)

    def SetAlpha(self, _alpha):
        r"""SetAlpha(SumCoefficient self, double _alpha)"""
        return _coefficient.SumCoefficient_SetAlpha(self, _alpha)
    SetAlpha = _swig_new_instance_method(_coefficient.SumCoefficient_SetAlpha)

    def GetAlpha(self):
        r"""GetAlpha(SumCoefficient self) -> double"""
        return _coefficient.SumCoefficient_GetAlpha(self)
    GetAlpha = _swig_new_instance_method(_coefficient.SumCoefficient_GetAlpha)

    def SetBeta(self, _beta):
        r"""SetBeta(SumCoefficient self, double _beta)"""
        return _coefficient.SumCoefficient_SetBeta(self, _beta)
    SetBeta = _swig_new_instance_method(_coefficient.SumCoefficient_SetBeta)

    def GetBeta(self):
        r"""GetBeta(SumCoefficient self) -> double"""
        return _coefficient.SumCoefficient_GetBeta(self)
    GetBeta = _swig_new_instance_method(_coefficient.SumCoefficient_GetBeta)

    def Eval(self, T, ip):
        r"""Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.SumCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.SumCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_SumCoefficient

# Register SumCoefficient in _coefficient:
_coefficient.SumCoefficient_swigregister(SumCoefficient)

class ProductCoefficient(Coefficient):
    r"""Proxy of C++ mfem::ProductCoefficient 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__(ProductCoefficient self, double A, Coefficient B) -> ProductCoefficient
        __init__(ProductCoefficient self, Coefficient A, Coefficient B) -> ProductCoefficient
        """
        _coefficient.ProductCoefficient_swiginit(self, _coefficient.new_ProductCoefficient(*args))

    def SetAConst(self, A):
        r"""SetAConst(ProductCoefficient self, double A)"""
        return _coefficient.ProductCoefficient_SetAConst(self, A)
    SetAConst = _swig_new_instance_method(_coefficient.ProductCoefficient_SetAConst)

    def GetAConst(self):
        r"""GetAConst(ProductCoefficient self) -> double"""
        return _coefficient.ProductCoefficient_GetAConst(self)
    GetAConst = _swig_new_instance_method(_coefficient.ProductCoefficient_GetAConst)

    def SetACoef(self, A):
        r"""SetACoef(ProductCoefficient self, Coefficient A)"""
        return _coefficient.ProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.ProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(ProductCoefficient self) -> Coefficient"""
        return _coefficient.ProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.ProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(ProductCoefficient self, Coefficient B)"""
        return _coefficient.ProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.ProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(ProductCoefficient self) -> Coefficient"""
        return _coefficient.ProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.ProductCoefficient_GetBCoef)

    def Eval(self, T, ip):
        r"""Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.ProductCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.ProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_ProductCoefficient

# Register ProductCoefficient in _coefficient:
_coefficient.ProductCoefficient_swigregister(ProductCoefficient)

class RatioCoefficient(Coefficient):
    r"""Proxy of C++ mfem::RatioCoefficient 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__(RatioCoefficient self, double A, Coefficient B) -> RatioCoefficient
        __init__(RatioCoefficient self, Coefficient A, Coefficient B) -> RatioCoefficient
        __init__(RatioCoefficient self, Coefficient A, double B) -> RatioCoefficient
        """
        _coefficient.RatioCoefficient_swiginit(self, _coefficient.new_RatioCoefficient(*args))

    def SetAConst(self, A):
        r"""SetAConst(RatioCoefficient self, double A)"""
        return _coefficient.RatioCoefficient_SetAConst(self, A)
    SetAConst = _swig_new_instance_method(_coefficient.RatioCoefficient_SetAConst)

    def GetAConst(self):
        r"""GetAConst(RatioCoefficient self) -> double"""
        return _coefficient.RatioCoefficient_GetAConst(self)
    GetAConst = _swig_new_instance_method(_coefficient.RatioCoefficient_GetAConst)

    def SetBConst(self, B):
        r"""SetBConst(RatioCoefficient self, double B)"""
        return _coefficient.RatioCoefficient_SetBConst(self, B)
    SetBConst = _swig_new_instance_method(_coefficient.RatioCoefficient_SetBConst)

    def GetBConst(self):
        r"""GetBConst(RatioCoefficient self) -> double"""
        return _coefficient.RatioCoefficient_GetBConst(self)
    GetBConst = _swig_new_instance_method(_coefficient.RatioCoefficient_GetBConst)

    def SetACoef(self, A):
        r"""SetACoef(RatioCoefficient self, Coefficient A)"""
        return _coefficient.RatioCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.RatioCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(RatioCoefficient self) -> Coefficient"""
        return _coefficient.RatioCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.RatioCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(RatioCoefficient self, Coefficient B)"""
        return _coefficient.RatioCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.RatioCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(RatioCoefficient self) -> Coefficient"""
        return _coefficient.RatioCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.RatioCoefficient_GetBCoef)

    def Eval(self, T, ip):
        r"""Eval(RatioCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.RatioCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.RatioCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_RatioCoefficient

# Register RatioCoefficient in _coefficient:
_coefficient.RatioCoefficient_swigregister(RatioCoefficient)

class PowerCoefficient(Coefficient):
    r"""Proxy of C++ mfem::PowerCoefficient 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, A, _p):
        r"""__init__(PowerCoefficient self, Coefficient A, double _p) -> PowerCoefficient"""
        _coefficient.PowerCoefficient_swiginit(self, _coefficient.new_PowerCoefficient(A, _p))

    def SetACoef(self, A):
        r"""SetACoef(PowerCoefficient self, Coefficient A)"""
        return _coefficient.PowerCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.PowerCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(PowerCoefficient self) -> Coefficient"""
        return _coefficient.PowerCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.PowerCoefficient_GetACoef)

    def SetExponent(self, _p):
        r"""SetExponent(PowerCoefficient self, double _p)"""
        return _coefficient.PowerCoefficient_SetExponent(self, _p)
    SetExponent = _swig_new_instance_method(_coefficient.PowerCoefficient_SetExponent)

    def GetExponent(self):
        r"""GetExponent(PowerCoefficient self) -> double"""
        return _coefficient.PowerCoefficient_GetExponent(self)
    GetExponent = _swig_new_instance_method(_coefficient.PowerCoefficient_GetExponent)

    def Eval(self, T, ip):
        r"""Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.PowerCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.PowerCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_PowerCoefficient

# Register PowerCoefficient in _coefficient:
_coefficient.PowerCoefficient_swigregister(PowerCoefficient)

class InnerProductCoefficient(Coefficient):
    r"""Proxy of C++ mfem::InnerProductCoefficient 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, A, B):
        r"""__init__(InnerProductCoefficient self, VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"""
        _coefficient.InnerProductCoefficient_swiginit(self, _coefficient.new_InnerProductCoefficient(A, B))

    def SetACoef(self, A):
        r"""SetACoef(InnerProductCoefficient self, VectorCoefficient A)"""
        return _coefficient.InnerProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.InnerProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(InnerProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.InnerProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.InnerProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(InnerProductCoefficient self, VectorCoefficient B)"""
        return _coefficient.InnerProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.InnerProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(InnerProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.InnerProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.InnerProductCoefficient_GetBCoef)

    def Eval(self, T, ip):
        r"""Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.InnerProductCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.InnerProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_InnerProductCoefficient

# Register InnerProductCoefficient in _coefficient:
_coefficient.InnerProductCoefficient_swigregister(InnerProductCoefficient)

class VectorRotProductCoefficient(Coefficient):
    r"""Proxy of C++ mfem::VectorRotProductCoefficient 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, A, B):
        r"""__init__(VectorRotProductCoefficient self, VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"""
        _coefficient.VectorRotProductCoefficient_swiginit(self, _coefficient.new_VectorRotProductCoefficient(A, B))

    def SetACoef(self, A):
        r"""SetACoef(VectorRotProductCoefficient self, VectorCoefficient A)"""
        return _coefficient.VectorRotProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.VectorRotProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(VectorRotProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.VectorRotProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.VectorRotProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(VectorRotProductCoefficient self, VectorCoefficient B)"""
        return _coefficient.VectorRotProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.VectorRotProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(VectorRotProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.VectorRotProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.VectorRotProductCoefficient_GetBCoef)

    def Eval(self, T, ip):
        r"""Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.VectorRotProductCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.VectorRotProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorRotProductCoefficient

# Register VectorRotProductCoefficient in _coefficient:
_coefficient.VectorRotProductCoefficient_swigregister(VectorRotProductCoefficient)

class DeterminantCoefficient(Coefficient):
    r"""Proxy of C++ mfem::DeterminantCoefficient 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, A):
        r"""__init__(DeterminantCoefficient self, MatrixCoefficient A) -> DeterminantCoefficient"""
        _coefficient.DeterminantCoefficient_swiginit(self, _coefficient.new_DeterminantCoefficient(A))

    def SetACoef(self, A):
        r"""SetACoef(DeterminantCoefficient self, MatrixCoefficient A)"""
        return _coefficient.DeterminantCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.DeterminantCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(DeterminantCoefficient self) -> MatrixCoefficient"""
        return _coefficient.DeterminantCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.DeterminantCoefficient_GetACoef)

    def Eval(self, T, ip):
        r"""Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.DeterminantCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.DeterminantCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_DeterminantCoefficient

# Register DeterminantCoefficient in _coefficient:
_coefficient.DeterminantCoefficient_swigregister(DeterminantCoefficient)

class VectorSumCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorSumCoefficient 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__(VectorSumCoefficient self, int dim) -> VectorSumCoefficient
        __init__(VectorSumCoefficient self, VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0) -> VectorSumCoefficient
        __init__(VectorSumCoefficient self, VectorCoefficient _A, VectorCoefficient _B, Coefficient _alpha, Coefficient _beta) -> VectorSumCoefficient
        """
        _coefficient.VectorSumCoefficient_swiginit(self, _coefficient.new_VectorSumCoefficient(*args))

    def SetACoef(self, A):
        r"""SetACoef(VectorSumCoefficient self, VectorCoefficient A)"""
        return _coefficient.VectorSumCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(VectorSumCoefficient self) -> VectorCoefficient"""
        return _coefficient.VectorSumCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(VectorSumCoefficient self, VectorCoefficient B)"""
        return _coefficient.VectorSumCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(VectorSumCoefficient self) -> VectorCoefficient"""
        return _coefficient.VectorSumCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetBCoef)

    def SetAlphaCoef(self, A):
        r"""SetAlphaCoef(VectorSumCoefficient self, Coefficient A)"""
        return _coefficient.VectorSumCoefficient_SetAlphaCoef(self, A)
    SetAlphaCoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetAlphaCoef)

    def GetAlphaCoef(self):
        r"""GetAlphaCoef(VectorSumCoefficient self) -> Coefficient"""
        return _coefficient.VectorSumCoefficient_GetAlphaCoef(self)
    GetAlphaCoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetAlphaCoef)

    def SetBetaCoef(self, B):
        r"""SetBetaCoef(VectorSumCoefficient self, Coefficient B)"""
        return _coefficient.VectorSumCoefficient_SetBetaCoef(self, B)
    SetBetaCoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetBetaCoef)

    def GetBetaCoef(self):
        r"""GetBetaCoef(VectorSumCoefficient self) -> Coefficient"""
        return _coefficient.VectorSumCoefficient_GetBetaCoef(self)
    GetBetaCoef = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetBetaCoef)

    def SetA(self, _A):
        r"""SetA(VectorSumCoefficient self, Vector _A)"""
        return _coefficient.VectorSumCoefficient_SetA(self, _A)
    SetA = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetA)

    def GetA(self):
        r"""GetA(VectorSumCoefficient self) -> Vector"""
        return _coefficient.VectorSumCoefficient_GetA(self)
    GetA = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetA)

    def SetB(self, _B):
        r"""SetB(VectorSumCoefficient self, Vector _B)"""
        return _coefficient.VectorSumCoefficient_SetB(self, _B)
    SetB = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetB)

    def GetB(self):
        r"""GetB(VectorSumCoefficient self) -> Vector"""
        return _coefficient.VectorSumCoefficient_GetB(self)
    GetB = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetB)

    def SetAlpha(self, _alpha):
        r"""SetAlpha(VectorSumCoefficient self, double _alpha)"""
        return _coefficient.VectorSumCoefficient_SetAlpha(self, _alpha)
    SetAlpha = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetAlpha)

    def GetAlpha(self):
        r"""GetAlpha(VectorSumCoefficient self) -> double"""
        return _coefficient.VectorSumCoefficient_GetAlpha(self)
    GetAlpha = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetAlpha)

    def SetBeta(self, _beta):
        r"""SetBeta(VectorSumCoefficient self, double _beta)"""
        return _coefficient.VectorSumCoefficient_SetBeta(self, _beta)
    SetBeta = _swig_new_instance_method(_coefficient.VectorSumCoefficient_SetBeta)

    def GetBeta(self):
        r"""GetBeta(VectorSumCoefficient self) -> double"""
        return _coefficient.VectorSumCoefficient_GetBeta(self)
    GetBeta = _swig_new_instance_method(_coefficient.VectorSumCoefficient_GetBeta)

    def Eval(self, *args):
        r"""
        Eval(VectorSumCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.VectorSumCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorSumCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorSumCoefficient

# Register VectorSumCoefficient in _coefficient:
_coefficient.VectorSumCoefficient_swigregister(VectorSumCoefficient)

class ScalarVectorProductCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::ScalarVectorProductCoefficient 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__(ScalarVectorProductCoefficient self, double A, VectorCoefficient B) -> ScalarVectorProductCoefficient
        __init__(ScalarVectorProductCoefficient self, Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient
        """
        _coefficient.ScalarVectorProductCoefficient_swiginit(self, _coefficient.new_ScalarVectorProductCoefficient(*args))

    def SetAConst(self, A):
        r"""SetAConst(ScalarVectorProductCoefficient self, double A)"""
        return _coefficient.ScalarVectorProductCoefficient_SetAConst(self, A)
    SetAConst = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_SetAConst)

    def GetAConst(self):
        r"""GetAConst(ScalarVectorProductCoefficient self) -> double"""
        return _coefficient.ScalarVectorProductCoefficient_GetAConst(self)
    GetAConst = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_GetAConst)

    def SetACoef(self, A):
        r"""SetACoef(ScalarVectorProductCoefficient self, Coefficient A)"""
        return _coefficient.ScalarVectorProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(ScalarVectorProductCoefficient self) -> Coefficient"""
        return _coefficient.ScalarVectorProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(ScalarVectorProductCoefficient self, VectorCoefficient B)"""
        return _coefficient.ScalarVectorProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(ScalarVectorProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.ScalarVectorProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_GetBCoef)

    def Eval(self, *args):
        r"""
        Eval(ScalarVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.ScalarVectorProductCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_ScalarVectorProductCoefficient

# Register ScalarVectorProductCoefficient in _coefficient:
_coefficient.ScalarVectorProductCoefficient_swigregister(ScalarVectorProductCoefficient)

class NormalizedVectorCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::NormalizedVectorCoefficient 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, A, tol=1e-6):
        r"""__init__(NormalizedVectorCoefficient self, VectorCoefficient A, double tol=1e-6) -> NormalizedVectorCoefficient"""
        _coefficient.NormalizedVectorCoefficient_swiginit(self, _coefficient.new_NormalizedVectorCoefficient(A, tol))

    def SetACoef(self, A):
        r"""SetACoef(NormalizedVectorCoefficient self, VectorCoefficient A)"""
        return _coefficient.NormalizedVectorCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.NormalizedVectorCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(NormalizedVectorCoefficient self) -> VectorCoefficient"""
        return _coefficient.NormalizedVectorCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.NormalizedVectorCoefficient_GetACoef)

    def Eval(self, *args):
        r"""
        Eval(NormalizedVectorCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(NormalizedVectorCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.NormalizedVectorCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.NormalizedVectorCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_NormalizedVectorCoefficient

# Register NormalizedVectorCoefficient in _coefficient:
_coefficient.NormalizedVectorCoefficient_swigregister(NormalizedVectorCoefficient)

class VectorCrossProductCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorCrossProductCoefficient 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, A, B):
        r"""__init__(VectorCrossProductCoefficient self, VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"""
        _coefficient.VectorCrossProductCoefficient_swiginit(self, _coefficient.new_VectorCrossProductCoefficient(A, B))

    def SetACoef(self, A):
        r"""SetACoef(VectorCrossProductCoefficient self, VectorCoefficient A)"""
        return _coefficient.VectorCrossProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.VectorCrossProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(VectorCrossProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.VectorCrossProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.VectorCrossProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(VectorCrossProductCoefficient self, VectorCoefficient B)"""
        return _coefficient.VectorCrossProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.VectorCrossProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(VectorCrossProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.VectorCrossProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.VectorCrossProductCoefficient_GetBCoef)

    def Eval(self, *args):
        r"""
        Eval(VectorCrossProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.VectorCrossProductCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorCrossProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorCrossProductCoefficient

# Register VectorCrossProductCoefficient in _coefficient:
_coefficient.VectorCrossProductCoefficient_swigregister(VectorCrossProductCoefficient)

class MatrixVectorProductCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::MatrixVectorProductCoefficient 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, A, B):
        r"""__init__(MatrixVectorProductCoefficient self, MatrixCoefficient A, VectorCoefficient B) -> MatrixVectorProductCoefficient"""
        _coefficient.MatrixVectorProductCoefficient_swiginit(self, _coefficient.new_MatrixVectorProductCoefficient(A, B))

    def SetACoef(self, A):
        r"""SetACoef(MatrixVectorProductCoefficient self, MatrixCoefficient A)"""
        return _coefficient.MatrixVectorProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.MatrixVectorProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(MatrixVectorProductCoefficient self) -> MatrixCoefficient"""
        return _coefficient.MatrixVectorProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.MatrixVectorProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(MatrixVectorProductCoefficient self, VectorCoefficient B)"""
        return _coefficient.MatrixVectorProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.MatrixVectorProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(MatrixVectorProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.MatrixVectorProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.MatrixVectorProductCoefficient_GetBCoef)

    def Eval(self, *args):
        r"""
        Eval(MatrixVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(MatrixVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        """
        return _coefficient.MatrixVectorProductCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.MatrixVectorProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_MatrixVectorProductCoefficient

# Register MatrixVectorProductCoefficient in _coefficient:
_coefficient.MatrixVectorProductCoefficient_swigregister(MatrixVectorProductCoefficient)

class IdentityMatrixCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::IdentityMatrixCoefficient 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, d):
        r"""__init__(IdentityMatrixCoefficient self, int d) -> IdentityMatrixCoefficient"""
        _coefficient.IdentityMatrixCoefficient_swiginit(self, _coefficient.new_IdentityMatrixCoefficient(d))

    def Eval(self, M, T, ip):
        r"""Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.IdentityMatrixCoefficient_Eval(self, M, T, ip)
    Eval = _swig_new_instance_method(_coefficient.IdentityMatrixCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_IdentityMatrixCoefficient

# Register IdentityMatrixCoefficient in _coefficient:
_coefficient.IdentityMatrixCoefficient_swigregister(IdentityMatrixCoefficient)

class MatrixSumCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::MatrixSumCoefficient 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, A, B, _alpha=1.0, _beta=1.0):
        r"""__init__(MatrixSumCoefficient self, MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0) -> MatrixSumCoefficient"""
        _coefficient.MatrixSumCoefficient_swiginit(self, _coefficient.new_MatrixSumCoefficient(A, B, _alpha, _beta))

    def SetACoef(self, A):
        r"""SetACoef(MatrixSumCoefficient self, MatrixCoefficient A)"""
        return _coefficient.MatrixSumCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(MatrixSumCoefficient self) -> MatrixCoefficient"""
        return _coefficient.MatrixSumCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(MatrixSumCoefficient self, MatrixCoefficient B)"""
        return _coefficient.MatrixSumCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(MatrixSumCoefficient self) -> MatrixCoefficient"""
        return _coefficient.MatrixSumCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_GetBCoef)

    def SetAlpha(self, _alpha):
        r"""SetAlpha(MatrixSumCoefficient self, double _alpha)"""
        return _coefficient.MatrixSumCoefficient_SetAlpha(self, _alpha)
    SetAlpha = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_SetAlpha)

    def GetAlpha(self):
        r"""GetAlpha(MatrixSumCoefficient self) -> double"""
        return _coefficient.MatrixSumCoefficient_GetAlpha(self)
    GetAlpha = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_GetAlpha)

    def SetBeta(self, _beta):
        r"""SetBeta(MatrixSumCoefficient self, double _beta)"""
        return _coefficient.MatrixSumCoefficient_SetBeta(self, _beta)
    SetBeta = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_SetBeta)

    def GetBeta(self):
        r"""GetBeta(MatrixSumCoefficient self) -> double"""
        return _coefficient.MatrixSumCoefficient_GetBeta(self)
    GetBeta = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_GetBeta)

    def Eval(self, M, T, ip):
        r"""Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.MatrixSumCoefficient_Eval(self, M, T, ip)
    Eval = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_MatrixSumCoefficient

# Register MatrixSumCoefficient in _coefficient:
_coefficient.MatrixSumCoefficient_swigregister(MatrixSumCoefficient)

class ScalarMatrixProductCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::ScalarMatrixProductCoefficient 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__(ScalarMatrixProductCoefficient self, double A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient
        __init__(ScalarMatrixProductCoefficient self, Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient
        """
        _coefficient.ScalarMatrixProductCoefficient_swiginit(self, _coefficient.new_ScalarMatrixProductCoefficient(*args))

    def SetAConst(self, A):
        r"""SetAConst(ScalarMatrixProductCoefficient self, double A)"""
        return _coefficient.ScalarMatrixProductCoefficient_SetAConst(self, A)
    SetAConst = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_SetAConst)

    def GetAConst(self):
        r"""GetAConst(ScalarMatrixProductCoefficient self) -> double"""
        return _coefficient.ScalarMatrixProductCoefficient_GetAConst(self)
    GetAConst = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_GetAConst)

    def SetACoef(self, A):
        r"""SetACoef(ScalarMatrixProductCoefficient self, Coefficient A)"""
        return _coefficient.ScalarMatrixProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(ScalarMatrixProductCoefficient self) -> Coefficient"""
        return _coefficient.ScalarMatrixProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(ScalarMatrixProductCoefficient self, MatrixCoefficient B)"""
        return _coefficient.ScalarMatrixProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(ScalarMatrixProductCoefficient self) -> MatrixCoefficient"""
        return _coefficient.ScalarMatrixProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_GetBCoef)

    def Eval(self, M, T, ip):
        r"""Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.ScalarMatrixProductCoefficient_Eval(self, M, T, ip)
    Eval = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_ScalarMatrixProductCoefficient

# Register ScalarMatrixProductCoefficient in _coefficient:
_coefficient.ScalarMatrixProductCoefficient_swigregister(ScalarMatrixProductCoefficient)

class TransposeMatrixCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::TransposeMatrixCoefficient 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, A):
        r"""__init__(TransposeMatrixCoefficient self, MatrixCoefficient A) -> TransposeMatrixCoefficient"""
        _coefficient.TransposeMatrixCoefficient_swiginit(self, _coefficient.new_TransposeMatrixCoefficient(A))

    def SetACoef(self, A):
        r"""SetACoef(TransposeMatrixCoefficient self, MatrixCoefficient A)"""
        return _coefficient.TransposeMatrixCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.TransposeMatrixCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(TransposeMatrixCoefficient self) -> MatrixCoefficient"""
        return _coefficient.TransposeMatrixCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.TransposeMatrixCoefficient_GetACoef)

    def Eval(self, M, T, ip):
        r"""Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.TransposeMatrixCoefficient_Eval(self, M, T, ip)
    Eval = _swig_new_instance_method(_coefficient.TransposeMatrixCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_TransposeMatrixCoefficient

# Register TransposeMatrixCoefficient in _coefficient:
_coefficient.TransposeMatrixCoefficient_swigregister(TransposeMatrixCoefficient)

class InverseMatrixCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::InverseMatrixCoefficient 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, A):
        r"""__init__(InverseMatrixCoefficient self, MatrixCoefficient A) -> InverseMatrixCoefficient"""
        _coefficient.InverseMatrixCoefficient_swiginit(self, _coefficient.new_InverseMatrixCoefficient(A))

    def SetACoef(self, A):
        r"""SetACoef(InverseMatrixCoefficient self, MatrixCoefficient A)"""
        return _coefficient.InverseMatrixCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.InverseMatrixCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(InverseMatrixCoefficient self) -> MatrixCoefficient"""
        return _coefficient.InverseMatrixCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.InverseMatrixCoefficient_GetACoef)

    def Eval(self, M, T, ip):
        r"""Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.InverseMatrixCoefficient_Eval(self, M, T, ip)
    Eval = _swig_new_instance_method(_coefficient.InverseMatrixCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_InverseMatrixCoefficient

# Register InverseMatrixCoefficient in _coefficient:
_coefficient.InverseMatrixCoefficient_swigregister(InverseMatrixCoefficient)

class OuterProductCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::OuterProductCoefficient 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, A, B):
        r"""__init__(OuterProductCoefficient self, VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"""
        _coefficient.OuterProductCoefficient_swiginit(self, _coefficient.new_OuterProductCoefficient(A, B))

    def SetACoef(self, A):
        r"""SetACoef(OuterProductCoefficient self, VectorCoefficient A)"""
        return _coefficient.OuterProductCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.OuterProductCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(OuterProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.OuterProductCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.OuterProductCoefficient_GetACoef)

    def SetBCoef(self, B):
        r"""SetBCoef(OuterProductCoefficient self, VectorCoefficient B)"""
        return _coefficient.OuterProductCoefficient_SetBCoef(self, B)
    SetBCoef = _swig_new_instance_method(_coefficient.OuterProductCoefficient_SetBCoef)

    def GetBCoef(self):
        r"""GetBCoef(OuterProductCoefficient self) -> VectorCoefficient"""
        return _coefficient.OuterProductCoefficient_GetBCoef(self)
    GetBCoef = _swig_new_instance_method(_coefficient.OuterProductCoefficient_GetBCoef)

    def Eval(self, M, T, ip):
        r"""Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.OuterProductCoefficient_Eval(self, M, T, ip)
    Eval = _swig_new_instance_method(_coefficient.OuterProductCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_OuterProductCoefficient

# Register OuterProductCoefficient in _coefficient:
_coefficient.OuterProductCoefficient_swigregister(OuterProductCoefficient)

class CrossCrossCoefficient(MatrixCoefficient):
    r"""Proxy of C++ mfem::CrossCrossCoefficient 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, A, K):
        r"""__init__(CrossCrossCoefficient self, Coefficient A, VectorCoefficient K) -> CrossCrossCoefficient"""
        _coefficient.CrossCrossCoefficient_swiginit(self, _coefficient.new_CrossCrossCoefficient(A, K))

    def SetAConst(self, A):
        r"""SetAConst(CrossCrossCoefficient self, double A)"""
        return _coefficient.CrossCrossCoefficient_SetAConst(self, A)
    SetAConst = _swig_new_instance_method(_coefficient.CrossCrossCoefficient_SetAConst)

    def GetAConst(self):
        r"""GetAConst(CrossCrossCoefficient self) -> double"""
        return _coefficient.CrossCrossCoefficient_GetAConst(self)
    GetAConst = _swig_new_instance_method(_coefficient.CrossCrossCoefficient_GetAConst)

    def SetACoef(self, A):
        r"""SetACoef(CrossCrossCoefficient self, Coefficient A)"""
        return _coefficient.CrossCrossCoefficient_SetACoef(self, A)
    SetACoef = _swig_new_instance_method(_coefficient.CrossCrossCoefficient_SetACoef)

    def GetACoef(self):
        r"""GetACoef(CrossCrossCoefficient self) -> Coefficient"""
        return _coefficient.CrossCrossCoefficient_GetACoef(self)
    GetACoef = _swig_new_instance_method(_coefficient.CrossCrossCoefficient_GetACoef)

    def SetKCoef(self, K):
        r"""SetKCoef(CrossCrossCoefficient self, VectorCoefficient K)"""
        return _coefficient.CrossCrossCoefficient_SetKCoef(self, K)
    SetKCoef = _swig_new_instance_method(_coefficient.CrossCrossCoefficient_SetKCoef)

    def GetKCoef(self):
        r"""GetKCoef(CrossCrossCoefficient self) -> VectorCoefficient"""
        return _coefficient.CrossCrossCoefficient_GetKCoef(self)
    GetKCoef = _swig_new_instance_method(_coefficient.CrossCrossCoefficient_GetKCoef)

    def Eval(self, M, T, ip):
        r"""Eval(CrossCrossCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.CrossCrossCoefficient_Eval(self, M, T, ip)
    Eval = _swig_new_instance_method(_coefficient.CrossCrossCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_CrossCrossCoefficient

# Register CrossCrossCoefficient in _coefficient:
_coefficient.CrossCrossCoefficient_swigregister(CrossCrossCoefficient)

class VectorQuadratureFunctionCoefficient(VectorCoefficient):
    r"""Proxy of C++ mfem::VectorQuadratureFunctionCoefficient 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 SetComponent(self, _index, _length):
        r"""SetComponent(VectorQuadratureFunctionCoefficient self, int _index, int _length)"""
        return _coefficient.VectorQuadratureFunctionCoefficient_SetComponent(self, _index, _length)
    SetComponent = _swig_new_instance_method(_coefficient.VectorQuadratureFunctionCoefficient_SetComponent)

    def GetQuadFunction(self):
        r"""GetQuadFunction(VectorQuadratureFunctionCoefficient self) -> mfem::QuadratureFunction const &"""
        return _coefficient.VectorQuadratureFunctionCoefficient_GetQuadFunction(self)
    GetQuadFunction = _swig_new_instance_method(_coefficient.VectorQuadratureFunctionCoefficient_GetQuadFunction)

    def Eval(self, *args):
        r"""
        Eval(VectorQuadratureFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        Eval(VectorQuadratureFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        Eval(VectorQuadratureFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.VectorQuadratureFunctionCoefficient_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorQuadratureFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_VectorQuadratureFunctionCoefficient

# Register VectorQuadratureFunctionCoefficient in _coefficient:
_coefficient.VectorQuadratureFunctionCoefficient_swigregister(VectorQuadratureFunctionCoefficient)

class QuadratureFunctionCoefficient(Coefficient):
    r"""Proxy of C++ mfem::QuadratureFunctionCoefficient 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, qf):
        r"""__init__(QuadratureFunctionCoefficient self, mfem::QuadratureFunction & qf) -> QuadratureFunctionCoefficient"""
        _coefficient.QuadratureFunctionCoefficient_swiginit(self, _coefficient.new_QuadratureFunctionCoefficient(qf))

    def GetQuadFunction(self):
        r"""GetQuadFunction(QuadratureFunctionCoefficient self) -> mfem::QuadratureFunction const &"""
        return _coefficient.QuadratureFunctionCoefficient_GetQuadFunction(self)
    GetQuadFunction = _swig_new_instance_method(_coefficient.QuadratureFunctionCoefficient_GetQuadFunction)

    def Eval(self, T, ip):
        r"""Eval(QuadratureFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.QuadratureFunctionCoefficient_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.QuadratureFunctionCoefficient_Eval)
    __swig_destroy__ = _coefficient.delete_QuadratureFunctionCoefficient

# Register QuadratureFunctionCoefficient in _coefficient:
_coefficient.QuadratureFunctionCoefficient_swigregister(QuadratureFunctionCoefficient)


def ComputeLpNorm(*args):
    r"""
    ComputeLpNorm(double p, Coefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double
    ComputeLpNorm(double p, VectorCoefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double
    """
    return _coefficient.ComputeLpNorm(*args)
ComputeLpNorm = _coefficient.ComputeLpNorm

def fake_func(x):
    r"""fake_func(Vector x) -> double"""
    return _coefficient.fake_func(x)
fake_func = _coefficient.fake_func

def fake_func_vec(x, Ht):
    r"""fake_func_vec(Vector x, Vector Ht)"""
    return _coefficient.fake_func_vec(x, Ht)
fake_func_vec = _coefficient.fake_func_vec

def fake_func_mat(x, Kt):
    r"""fake_func_mat(Vector x, DenseMatrix Kt)"""
    return _coefficient.fake_func_mat(x, Kt)
fake_func_mat = _coefficient.fake_func_mat
class PyCoefficientBase(FunctionCoefficient):
    r"""Proxy of C++ mfem::PyCoefficientBase 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, tdep):
        r"""__init__(PyCoefficientBase self, int tdep) -> PyCoefficientBase"""
        if self.__class__ == PyCoefficientBase:
            _self = None
        else:
            _self = self
        _coefficient.PyCoefficientBase_swiginit(self, _coefficient.new_PyCoefficientBase(_self, tdep))

    def Eval(self, T, ip):
        r"""Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"""
        return _coefficient.PyCoefficientBase_Eval(self, T, ip)
    Eval = _swig_new_instance_method(_coefficient.PyCoefficientBase_Eval)

    def _EvalPy(self, arg0):
        r"""_EvalPy(PyCoefficientBase self, Vector arg0) -> double"""
        return _coefficient.PyCoefficientBase__EvalPy(self, arg0)
    _EvalPy = _swig_new_instance_method(_coefficient.PyCoefficientBase__EvalPy)

    def _EvalPyT(self, arg0, arg1):
        r"""_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"""
        return _coefficient.PyCoefficientBase__EvalPyT(self, arg0, arg1)
    _EvalPyT = _swig_new_instance_method(_coefficient.PyCoefficientBase__EvalPyT)
    __swig_destroy__ = _coefficient.delete_PyCoefficientBase
    def __disown__(self):
        self.this.disown()
        _coefficient.disown_PyCoefficientBase(self)
        return weakref.proxy(self)

# Register PyCoefficientBase in _coefficient:
_coefficient.PyCoefficientBase_swigregister(PyCoefficientBase)

class VectorPyCoefficientBase(VectorFunctionCoefficient):
    r"""Proxy of C++ mfem::VectorPyCoefficientBase 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, dim, tdep, q=None):
        r"""__init__(VectorPyCoefficientBase self, int dim, int tdep, Coefficient q=None) -> VectorPyCoefficientBase"""
        if self.__class__ == VectorPyCoefficientBase:
            _self = None
        else:
            _self = self
        _coefficient.VectorPyCoefficientBase_swiginit(self, _coefficient.new_VectorPyCoefficientBase(_self, dim, tdep, q))

    def Eval(self, *args):
        r"""
        Eval(VectorPyCoefficientBase self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)
        Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip)
        """
        return _coefficient.VectorPyCoefficientBase_Eval(self, *args)
    Eval = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase_Eval)

    def _EvalPy(self, arg0, arg1):
        r"""_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"""
        return _coefficient.VectorPyCoefficientBase__EvalPy(self, arg0, arg1)
    _EvalPy = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase__EvalPy)

    def _EvalPyT(self, arg0, arg1, arg2):
        r"""_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"""
        return _coefficient.VectorPyCoefficientBase__EvalPyT(self, arg0, arg1, arg2)
    _EvalPyT = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase__EvalPyT)
    __swig_destroy__ = _coefficient.delete_VectorPyCoefficientBase
    def __disown__(self):
        self.this.disown()
        _coefficient.disown_VectorPyCoefficientBase(self)
        return weakref.proxy(self)

# Register VectorPyCoefficientBase in _coefficient:
_coefficient.VectorPyCoefficientBase_swigregister(VectorPyCoefficientBase)

class MatrixPyCoefficientBase(MatrixFunctionCoefficient):
    r"""Proxy of C++ mfem::MatrixPyCoefficientBase 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, dim, tdep):
        r"""__init__(MatrixPyCoefficientBase self, int dim, int tdep) -> MatrixPyCoefficientBase"""
        if self.__class__ == MatrixPyCoefficientBase:
            _self = None
        else:
            _self = self
        _coefficient.MatrixPyCoefficientBase_swiginit(self, _coefficient.new_MatrixPyCoefficientBase(_self, dim, tdep))

    def Eval(self, K, T, ip):
        r"""Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"""
        return _coefficient.MatrixPyCoefficientBase_Eval(self, K, T, ip)
    Eval = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase_Eval)

    def _EvalPy(self, arg0, arg1):
        r"""_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"""
        return _coefficient.MatrixPyCoefficientBase__EvalPy(self, arg0, arg1)
    _EvalPy = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase__EvalPy)

    def _EvalPyT(self, arg0, arg1, arg2):
        r"""_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"""
        return _coefficient.MatrixPyCoefficientBase__EvalPyT(self, arg0, arg1, arg2)
    _EvalPyT = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase__EvalPyT)
    __swig_destroy__ = _coefficient.delete_MatrixPyCoefficientBase
    def __disown__(self):
        self.this.disown()
        _coefficient.disown_MatrixPyCoefficientBase(self)
        return weakref.proxy(self)

# Register MatrixPyCoefficientBase in _coefficient:
_coefficient.MatrixPyCoefficientBase_swigregister(MatrixPyCoefficientBase)


class PyCoefficient(PyCoefficientBase):
   def __init__(self):
       PyCoefficientBase.__init__(self, 0)
   def _EvalPy(self, x):
       return self.EvalValue(x.GetDataArray())
   def EvalValue(self, x):
       return 0.0

class PyCoefficientT(PyCoefficientBase):
   def __init__(self):
       PyCoefficientBase.__init__(self, 1)
   def _EvalPyT(self, x, t):
       return self.EvalValue(x.GetDataArray(), t)
   def EvalValue(self, x, t):
       return 0.0

class VectorPyCoefficient(VectorPyCoefficientBase):
   def __init__(self, dim):
       self.sdim = dim
       VectorPyCoefficientBase.__init__(self, dim, 0)
   def _EvalPy(self, x, V):
       v = self.EvalValue(x.GetDataArray())
       V.Assign(v)

   def _EvalPyT(self, x, t, V):
       v = self.EvalValue(x.GetDataArray())
       V.Assign(v)	 

   def EvalValue(self, x):
       return [0,0,0]

class VectorPyCoefficientT(VectorPyCoefficientBase):
   def __init__(self, dim):
       self.sdim = dim  
       VectorPyCoefficientBase.__init__(self, dim, 1)
   def _EvalPy(self, x, V):
       v = self.EvalValue(x.GetDataArray(), 0)
       V.Assign(v)	 	 

   def _EvalPyT(self, x, t, V):
       v = self.EvalValue(x.GetDataArray(), t)
       V.Assign(v)	 	 	 

   def EvalValue(self, x, t):
       return [0,0,0]

class MatrixPyCoefficient(MatrixPyCoefficientBase):
   def __init__(self, dim):
       self.sdim = dim
       MatrixPyCoefficientBase.__init__(self, dim, 0)
   def _EvalPy(self, x, K):
       k = self.EvalValue(x.GetDataArray())
       K.Assign(k)	 	 	 	 

   def EvalValue(self, x):
       return np.array([[0,0,0], [0,0,0], [0,0,0]])

class MatrixPyCoefficientT(MatrixPyCoefficientBase):
   def __init__(self, dim):
       self.sdim = dim  
       MatrixPyCoefficientBase.__init__(self, dim, 1)
   def _EvalPyT(self, x, t, K):
       k = self.EvalValue(x.GetDataArray(), t)
       K.Assign(k)	 	 	 	 	 

   def EvalValue(self, x, t):
       return np.array([[0,0,0], [0,0,0], [0,0,0]])




