text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 4.0.2
  #
  # Do not make changes to this file unless you know what you are doing--modify
  # the SWIG interface file instead.
  
  from sys import version_info as _swig_python_version_info
  if _swig_python_version_info < (2, 7, 0):
      raise RuntimeError("Python 2.7 or later required")
  
  # Import the low-level C/C++ module
  if __package__ or "." in __name__:
      from . import _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
  
  MFEM_VERSION = _coefficient.MFEM_VERSION
  
  MFEM_VERSION_STRING = _coefficient.MFEM_VERSION_STRING
  
  MFEM_VERSION_TYPE = _coefficient.MFEM_VERSION_TYPE
  
  MFEM_VERSION_TYPE_RELEASE = _coefficient.MFEM_VERSION_TYPE_RELEASE
  
  MFEM_VERSION_TYPE_DEVELOPMENT = _coefficient.MFEM_VERSION_TYPE_DEVELOPMENT
  
  MFEM_VERSION_MAJOR = _coefficient.MFEM_VERSION_MAJOR
  
  MFEM_VERSION_MINOR = _coefficient.MFEM_VERSION_MINOR
  
  MFEM_VERSION_PATCH = _coefficient.MFEM_VERSION_PATCH
  
  MFEM_HYPRE_VERSION = _coefficient.MFEM_HYPRE_VERSION
  
  import mfem._par.globals
  import mfem._par.array
  import mfem._par.mem_manager
  import mfem._par.matrix
  import mfem._par.vector
  import mfem._par.operators
  import mfem._par.intrules
  import mfem._par.sparsemat
  import mfem._par.densemat
  import mfem._par.eltrans
  import mfem._par.fe
  import mfem._par.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._par.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._par.vector.Vector(np.transpose(value).flatten())
             m = mfem._par.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 ComputeGlobalLpNorm(*args):
      r"""
      ComputeGlobalLpNorm(double p, Coefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double
      ComputeGlobalLpNorm(double p, VectorCoefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double
      """
      return _coefficient.ComputeGlobalLpNorm(*args)
  ComputeGlobalLpNorm = _coefficient.ComputeGlobalLpNorm
  
  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.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.0,0.0], [0.0,0.0,0.0]])
  
  
  
  
  