python-dolfin 1.0.0-1 / usr / share / pyshared / dolfin / cpp.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# 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
if version_info >= (3,0,0):
    new_instancemethod = lambda func, inst, cls: _cpp.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_cpp', [dirname(__file__)])
        except ImportError:
            import _cpp
            return _cpp
        if fp is not None:
            try:
                _mod = imp.load_module('_cpp', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _cpp = swig_import_helper()
    del swig_import_helper
else:
    import _cpp
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


SHARED_PTR_DISOWN = _cpp.SHARED_PTR_DISOWN
import ufc

def init(*args):
  """
    Initialize DOLFIN (and PETSc) with command-line arguments. This
    should not be needed in most cases since the initialization is
    otherwise handled automatically.

    """
  return _cpp.init(*args)

def has_openmp(*args):
  return _cpp.has_openmp(*args)
has_openmp = _cpp.has_openmp

def has_mpi(*args):
  return _cpp.has_mpi(*args)
has_mpi = _cpp.has_mpi

def has_slepc(*args):
  return _cpp.has_slepc(*args)
has_slepc = _cpp.has_slepc

def has_trilinos(*args):
  return _cpp.has_trilinos(*args)
has_trilinos = _cpp.has_trilinos

def has_scotch(*args):
  return _cpp.has_scotch(*args)
has_scotch = _cpp.has_scotch

def has_cgal(*args):
  return _cpp.has_cgal(*args)
has_cgal = _cpp.has_cgal

def has_umfpack(*args):
  return _cpp.has_umfpack(*args)
has_umfpack = _cpp.has_umfpack

def has_cholmod(*args):
  return _cpp.has_cholmod(*args)
has_cholmod = _cpp.has_cholmod

def has_parmetis(*args):
  return _cpp.has_parmetis(*args)
has_parmetis = _cpp.has_parmetis

def has_gmp(*args):
  return _cpp.has_gmp(*args)
has_gmp = _cpp.has_gmp

def has_zlib(*args):
  return _cpp.has_zlib(*args)
has_zlib = _cpp.has_zlib

def has_linear_algebra_backend(*args):
  return _cpp.has_linear_algebra_backend(*args)
has_linear_algebra_backend = _cpp.has_linear_algebra_backend
DOLFIN_EPS = _cpp.DOLFIN_EPS
DOLFIN_SQRT_EPS = _cpp.DOLFIN_SQRT_EPS
DOLFIN_PI = _cpp.DOLFIN_PI
DOLFIN_LINELENGTH = _cpp.DOLFIN_LINELENGTH
DOLFIN_TERM_WIDTH = _cpp.DOLFIN_TERM_WIDTH

def tic(*args):
  """
    Timing functions measure CPU time as determined by clock(),
    the precision of which seems to be 0.01 seconds.
    Start timing (should not be used internally in DOLFIN!)

    """
  return _cpp.tic(*args)

def toc(*args):
  """
    Return elapsed CPU time (should not be used internally in DOLFIN!)

    """
  return _cpp.toc(*args)

def time(*args):
  """
    Return current CPU time used by process

    """
  return _cpp.time(*args)
class IndexSet(object):
    """
    This class provides an efficient data structure for index sets.
    The cost of checking whether a given index is in the set is O(1)
    and very very fast (optimal) at the cost of extra storage.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create index set of given size

        """
        _cpp.IndexSet_swiginit(self,_cpp.new_IndexSet(*args))
    __swig_destroy__ = _cpp.delete_IndexSet
    def size(self, *args):
        """
        Return size of set

        """
        return _cpp.IndexSet_size(self, *args)

    def has_index(self, *args):
        """
        Check whether index is in set

        """
        return _cpp.IndexSet_has_index(self, *args)

    def find(self, *args):
        """
        Return position (if any) for given index

        """
        return _cpp.IndexSet_find(self, *args)

    def insert(self, *args):
        """
        Insert index into set

        """
        return _cpp.IndexSet_insert(self, *args)

    def fill(self, *args):
        """
        Fill index set with indices 0, 1, 2, ..., size - 1

        """
        return _cpp.IndexSet_fill(self, *args)

    def clear(self, *args):
        """
        Clear set

        """
        return _cpp.IndexSet_clear(self, *args)

IndexSet.size = new_instancemethod(_cpp.IndexSet_size,None,IndexSet)
IndexSet.has_index = new_instancemethod(_cpp.IndexSet_has_index,None,IndexSet)
IndexSet.find = new_instancemethod(_cpp.IndexSet_find,None,IndexSet)
IndexSet.insert = new_instancemethod(_cpp.IndexSet_insert,None,IndexSet)
IndexSet.fill = new_instancemethod(_cpp.IndexSet_fill,None,IndexSet)
IndexSet.clear = new_instancemethod(_cpp.IndexSet_clear,None,IndexSet)
IndexSet_swigregister = _cpp.IndexSet_swigregister
IndexSet_swigregister(IndexSet)

class Timer(object):
    """
    A timer can be used for timing tasks. The basic usage is

      Timer timer("Assembling over cells");

    The timer is started at construction and timing ends
    when the timer is destroyed (goes out of scope). It is
    also possible to start and stop a timer explicitly by

      timer.start();
      timer.stop();

    Timings are stored globally and a summary may be printed
    by calling

      summary();

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create timer

        """
        _cpp.Timer_swiginit(self,_cpp.new_Timer(*args))
    __swig_destroy__ = _cpp.delete_Timer
    def start(self, *args):
        """
        Start timer

        """
        return _cpp.Timer_start(self, *args)

    def stop(self, *args):
        """
        Stop timer

        """
        return _cpp.Timer_stop(self, *args)

    def value(self, *args):
        """
        Return value of timer (or time at start if not stopped)

        """
        return _cpp.Timer_value(self, *args)

Timer.start = new_instancemethod(_cpp.Timer_start,None,Timer)
Timer.stop = new_instancemethod(_cpp.Timer_stop,None,Timer)
Timer.value = new_instancemethod(_cpp.Timer_value,None,Timer)
Timer_swigregister = _cpp.Timer_swigregister
Timer_swigregister(Timer)

class Variable(object):
    """
    Common base class for DOLFIN variables.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Variable\ ()

          Create unnamed variable

        * Variable\ (name, label)

          Create variable with given name and label

        * Variable\ (variable)

          Copy constructor

        """
        _cpp.Variable_swiginit(self,_cpp.new_Variable(*args))
    __swig_destroy__ = _cpp.delete_Variable
    def rename(self, *args):
        """
        Rename variable

        """
        return _cpp.Variable_rename(self, *args)

    def name(self, *args):
        """
        Return name

        """
        return _cpp.Variable_name(self, *args)

    def label(self, *args):
        """
        Return label (description)

        """
        return _cpp.Variable_label(self, *args)

    def id(self, *args):
        """
        Get unique identifier.

        *Returns*
            _uint_
                The unique integer identifier associated with the object.

        """
        return _cpp.Variable_id(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.Variable_str(self, *args)

    parameters = _swig_property(_cpp.Variable_parameters_get, _cpp.Variable_parameters_set)
    def __str__(self, *args):
        """Missing docstring"""
        return _cpp.Variable___str__(self, *args)

Variable.rename = new_instancemethod(_cpp.Variable_rename,None,Variable)
Variable.name = new_instancemethod(_cpp.Variable_name,None,Variable)
Variable.label = new_instancemethod(_cpp.Variable_label,None,Variable)
Variable.id = new_instancemethod(_cpp.Variable_id,None,Variable)
Variable.str = new_instancemethod(_cpp.Variable_str,None,Variable)
Variable.__str__ = new_instancemethod(_cpp.Variable___str__,None,Variable)
Variable_swigregister = _cpp.Variable_swigregister
Variable_swigregister(Variable)

class MPICommunicator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create communicator (copy of MPI_COMM_WORLD)

        """
        _cpp.MPICommunicator_swiginit(self,_cpp.new_MPICommunicator(*args))
    __swig_destroy__ = _cpp.delete_MPICommunicator
    def __ref__(self, *args):
        """
        Dereference operator

        """
        return _cpp.MPICommunicator___ref__(self, *args)

MPICommunicator.__ref__ = new_instancemethod(_cpp.MPICommunicator___ref__,None,MPICommunicator)
MPICommunicator_swigregister = _cpp.MPICommunicator_swigregister
MPICommunicator_swigregister(MPICommunicator)

class MPI(object):
    """
    This class provides utility functions for easy communcation with MPI.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def process_number(*args):
        """
        Return proccess number

        """
        return _cpp.MPI_process_number(*args)

    process_number = staticmethod(process_number)
    def num_processes(*args):
        """
        Return number of processes

        """
        return _cpp.MPI_num_processes(*args)

    num_processes = staticmethod(num_processes)
    def is_broadcaster(*args):
        """
        Determine whether we should broadcast (based on current parallel policy)

        """
        return _cpp.MPI_is_broadcaster(*args)

    is_broadcaster = staticmethod(is_broadcaster)
    def is_receiver(*args):
        """
        Determine whether we should receive (based on current parallel policy)

        """
        return _cpp.MPI_is_receiver(*args)

    is_receiver = staticmethod(is_receiver)
    def barrier(*args):
        """
        Set a barrier (synchronization point)

        """
        return _cpp.MPI_barrier(*args)

    barrier = staticmethod(barrier)
    def global_offset(*args):
        """
        Find global offset (index) (wrapper for MPI_(Ex)Scan with MPI_SUM as
        reduction op)

        """
        return _cpp.MPI_global_offset(*args)

    global_offset = staticmethod(global_offset)
    def local_range(*args):
        """
        **Overloaded versions**

        * local_range\ (N)

          Return local range for local process, splitting [0, N - 1] into
          num_processes() portions of almost equal size

        * local_range\ (process, N)

          Return local range for given process, splitting [0, N - 1] into
          num_processes() portions of almost equal size

        * local_range\ (process, N, num_processes)

          Return local range for given process, splitting [0, N - 1] into
          num_processes portions of almost equal size

        """
        return _cpp.MPI_local_range(*args)

    local_range = staticmethod(local_range)
    def index_owner(*args):
        """
        Return which process owns index (inverse of local_range)

        """
        return _cpp.MPI_index_owner(*args)

    index_owner = staticmethod(index_owner)
    max = staticmethod(_cpp.MPI_max)
    min = staticmethod(_cpp.MPI_min)
    sum = staticmethod(_cpp.MPI_sum)
    def __init__(self, *args): 
        _cpp.MPI_swiginit(self,_cpp.new_MPI(*args))
    __swig_destroy__ = _cpp.delete_MPI
MPI_swigregister = _cpp.MPI_swigregister
MPI_swigregister(MPI)

def MPI_process_number(*args):
  """
    Return proccess number

    """
  return _cpp.MPI_process_number(*args)

def MPI_num_processes(*args):
  """
    Return number of processes

    """
  return _cpp.MPI_num_processes(*args)

def MPI_is_broadcaster(*args):
  """
    Determine whether we should broadcast (based on current parallel policy)

    """
  return _cpp.MPI_is_broadcaster(*args)

def MPI_is_receiver(*args):
  """
    Determine whether we should receive (based on current parallel policy)

    """
  return _cpp.MPI_is_receiver(*args)

def MPI_barrier(*args):
  """
    Set a barrier (synchronization point)

    """
  return _cpp.MPI_barrier(*args)

def MPI_global_offset(*args):
  """
    Find global offset (index) (wrapper for MPI_(Ex)Scan with MPI_SUM as
    reduction op)

    """
  return _cpp.MPI_global_offset(*args)

def MPI_local_range(*args):
  """
    **Overloaded versions**

    * local_range\ (N)

      Return local range for local process, splitting [0, N - 1] into
      num_processes() portions of almost equal size

    * local_range\ (process, N)

      Return local range for given process, splitting [0, N - 1] into
      num_processes() portions of almost equal size

    * local_range\ (process, N, num_processes)

      Return local range for given process, splitting [0, N - 1] into
      num_processes portions of almost equal size

    """
  return _cpp.MPI_local_range(*args)

def MPI_index_owner(*args):
  """
    Return which process owns index (inverse of local_range)

    """
  return _cpp.MPI_index_owner(*args)

def MPI_max(*args):
  return _cpp.MPI_max(*args)
MPI_max = _cpp.MPI_max

def MPI_min(*args):
  return _cpp.MPI_min(*args)
MPI_min = _cpp.MPI_min

def MPI_sum(*args):
  return _cpp.MPI_sum(*args)
MPI_sum = _cpp.MPI_sum

class SubSystemsManager(object):
    """
    This is a singleton class which manages the initialisation and
    finalisation of various sub systems, such as MPI and PETSc.

    """
    thisown = _swig_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")
    __repr__ = _swig_repr
    def init_mpi(*args):
        """
        Initialise MPI

        """
        return _cpp.SubSystemsManager_init_mpi(*args)

    init_mpi = staticmethod(init_mpi)
    def init_petsc(*args):
        """
        **Overloaded versions**

        * init_petsc\ ()

          Initialize PETSc without command-line arguments

        * init_petsc\ (argc, argv[])

          Initialize PETSc with command-line arguments. Note that PETSc
          command-line arguments may also be filtered and sent to PETSc
          by parameters.parse(argc, argv).

        """
        return _cpp.SubSystemsManager_init_petsc(*args)

    init_petsc = staticmethod(init_petsc)
    def finalize(*args):
        """
        Finalize subsytems. This will be called by the destructor, but in
        special cases it may be necessary to call finalize() explicitly.

        """
        return _cpp.SubSystemsManager_finalize(*args)

    finalize = staticmethod(finalize)
    responsible_mpi = staticmethod(_cpp.SubSystemsManager_responsible_mpi)
    responsible_petsc = staticmethod(_cpp.SubSystemsManager_responsible_petsc)
    mpi_initialized = staticmethod(_cpp.SubSystemsManager_mpi_initialized)
    mpi_finalized = staticmethod(_cpp.SubSystemsManager_mpi_finalized)
SubSystemsManager_swigregister = _cpp.SubSystemsManager_swigregister
SubSystemsManager_swigregister(SubSystemsManager)

def SubSystemsManager_init_mpi(*args):
  """
    Initialise MPI

    """
  return _cpp.SubSystemsManager_init_mpi(*args)

def SubSystemsManager_init_petsc(*args):
  """
    **Overloaded versions**

    * init_petsc\ ()

      Initialize PETSc without command-line arguments

    * init_petsc\ (argc, argv[])

      Initialize PETSc with command-line arguments. Note that PETSc
      command-line arguments may also be filtered and sent to PETSc
      by parameters.parse(argc, argv).

    """
  return _cpp.SubSystemsManager_init_petsc(*args)

def SubSystemsManager_finalize(*args):
  """
    Finalize subsytems. This will be called by the destructor, but in
    special cases it may be necessary to call finalize() explicitly.

    """
  return _cpp.SubSystemsManager_finalize(*args)

def SubSystemsManager_responsible_mpi(*args):
  return _cpp.SubSystemsManager_responsible_mpi(*args)
SubSystemsManager_responsible_mpi = _cpp.SubSystemsManager_responsible_mpi

def SubSystemsManager_responsible_petsc(*args):
  return _cpp.SubSystemsManager_responsible_petsc(*args)
SubSystemsManager_responsible_petsc = _cpp.SubSystemsManager_responsible_petsc

def SubSystemsManager_mpi_initialized(*args):
  return _cpp.SubSystemsManager_mpi_initialized(*args)
SubSystemsManager_mpi_initialized = _cpp.SubSystemsManager_mpi_initialized

def SubSystemsManager_mpi_finalized(*args):
  return _cpp.SubSystemsManager_mpi_finalized(*args)
SubSystemsManager_mpi_finalized = _cpp.SubSystemsManager_mpi_finalized

class DoubleArray(object):
    """
    This class provides a simple wrapper for a pointer to an array. A purpose
    of this class is to enable the simple and safe exchange of data between
    C++ and Python.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Array\ ()

          Create empty array

        * Array\ (N)

          Create array of size N

        * Array\ (other)

          Copy constructor (arg name need to have a different name that 'x')

        * Array\ (N, x)

          Construct array from a shared pointer

        * Array\ (N, x)

          Construct array from a pointer. Array will not take ownership.

        """
        _cpp.DoubleArray_swiginit(self,_cpp.new_DoubleArray(*args))
    def update(self, *args):
        """
        Construct array from a pointer. Array will not take ownership.

        """
        return _cpp.DoubleArray_update(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print).
        Note that the Array class is not a subclass of Variable (for
        efficiency) which means that one needs to call str() directly
        instead of using the info() function on Array objects.

        """
        return _cpp.DoubleArray_str(self, *args)

    def clear(self, *args):
        """
        Clear array

        """
        return _cpp.DoubleArray_clear(self, *args)

    def resize(self, *args):
        """
        Resize array to size N. If size changes, contents will be destroyed.

        """
        return _cpp.DoubleArray_resize(self, *args)

    def size(self, *args):
        """
        Return size of array

        """
        return _cpp.DoubleArray_size(self, *args)

    def zero(self, *args):
        """
        Zero array

        """
        return _cpp.DoubleArray_zero(self, *args)

    def zero_eps(self, *args):
        """
        Set entries which meet (abs(x[i]) < eps) to zero

        """
        return _cpp.DoubleArray_zero_eps(self, *args)

    def min(self, *args):
        """
        Return minimum value of array

        """
        return _cpp.DoubleArray_min(self, *args)

    def max(self, *args):
        """
        Return maximum value of array

        """
        return _cpp.DoubleArray_max(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Return pointer to data (const version)

        * data\ ()

          Return pointer to data (non-const version)

        """
        return _cpp.DoubleArray_data(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.DoubleArray___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.DoubleArray___setitem__(self, *args)

    def array(self, *args):
        """Missing docstring"""
        return _cpp.DoubleArray_array(self, *args)

    __swig_destroy__ = _cpp.delete_DoubleArray
DoubleArray.update = new_instancemethod(_cpp.DoubleArray_update,None,DoubleArray)
DoubleArray.str = new_instancemethod(_cpp.DoubleArray_str,None,DoubleArray)
DoubleArray.clear = new_instancemethod(_cpp.DoubleArray_clear,None,DoubleArray)
DoubleArray.resize = new_instancemethod(_cpp.DoubleArray_resize,None,DoubleArray)
DoubleArray.size = new_instancemethod(_cpp.DoubleArray_size,None,DoubleArray)
DoubleArray.zero = new_instancemethod(_cpp.DoubleArray_zero,None,DoubleArray)
DoubleArray.zero_eps = new_instancemethod(_cpp.DoubleArray_zero_eps,None,DoubleArray)
DoubleArray.min = new_instancemethod(_cpp.DoubleArray_min,None,DoubleArray)
DoubleArray.max = new_instancemethod(_cpp.DoubleArray_max,None,DoubleArray)
DoubleArray.data = new_instancemethod(_cpp.DoubleArray_data,None,DoubleArray)
DoubleArray.__getitem__ = new_instancemethod(_cpp.DoubleArray___getitem__,None,DoubleArray)
DoubleArray.__setitem__ = new_instancemethod(_cpp.DoubleArray___setitem__,None,DoubleArray)
DoubleArray.array = new_instancemethod(_cpp.DoubleArray_array,None,DoubleArray)
DoubleArray_swigregister = _cpp.DoubleArray_swigregister
DoubleArray_swigregister(DoubleArray)

class ConstDoubleArray(object):
    """
    This class provides a simple wrapper for a pointer to an array. A purpose
    of this class is to enable the simple and safe exchange of data between
    C++ and Python.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Array\ ()

          Create empty array

        * Array\ (N)

          Create array of size N

        * Array\ (other)

          Copy constructor (arg name need to have a different name that 'x')

        * Array\ (N, x)

          Construct array from a shared pointer

        * Array\ (N, x)

          Construct array from a pointer. Array will not take ownership.

        """
        _cpp.ConstDoubleArray_swiginit(self,_cpp.new_ConstDoubleArray(*args))
    def update(self, *args):
        """
        Construct array from a pointer. Array will not take ownership.

        """
        return _cpp.ConstDoubleArray_update(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print).
        Note that the Array class is not a subclass of Variable (for
        efficiency) which means that one needs to call str() directly
        instead of using the info() function on Array objects.

        """
        return _cpp.ConstDoubleArray_str(self, *args)

    def clear(self, *args):
        """
        Clear array

        """
        return _cpp.ConstDoubleArray_clear(self, *args)

    def size(self, *args):
        """
        Return size of array

        """
        return _cpp.ConstDoubleArray_size(self, *args)

    def zero_eps(self, *args):
        """
        Set entries which meet (abs(x[i]) < eps) to zero

        """
        return _cpp.ConstDoubleArray_zero_eps(self, *args)

    def min(self, *args):
        """
        Return minimum value of array

        """
        return _cpp.ConstDoubleArray_min(self, *args)

    def max(self, *args):
        """
        Return maximum value of array

        """
        return _cpp.ConstDoubleArray_max(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Return pointer to data (const version)

        * data\ ()

          Return pointer to data (non-const version)

        """
        return _cpp.ConstDoubleArray_data(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.ConstDoubleArray___getitem__(self, *args)

    __swig_destroy__ = _cpp.delete_ConstDoubleArray
ConstDoubleArray.update = new_instancemethod(_cpp.ConstDoubleArray_update,None,ConstDoubleArray)
ConstDoubleArray.str = new_instancemethod(_cpp.ConstDoubleArray_str,None,ConstDoubleArray)
ConstDoubleArray.clear = new_instancemethod(_cpp.ConstDoubleArray_clear,None,ConstDoubleArray)
ConstDoubleArray.size = new_instancemethod(_cpp.ConstDoubleArray_size,None,ConstDoubleArray)
ConstDoubleArray.zero_eps = new_instancemethod(_cpp.ConstDoubleArray_zero_eps,None,ConstDoubleArray)
ConstDoubleArray.min = new_instancemethod(_cpp.ConstDoubleArray_min,None,ConstDoubleArray)
ConstDoubleArray.max = new_instancemethod(_cpp.ConstDoubleArray_max,None,ConstDoubleArray)
ConstDoubleArray.data = new_instancemethod(_cpp.ConstDoubleArray_data,None,ConstDoubleArray)
ConstDoubleArray.__getitem__ = new_instancemethod(_cpp.ConstDoubleArray___getitem__,None,ConstDoubleArray)
ConstDoubleArray_swigregister = _cpp.ConstDoubleArray_swigregister
ConstDoubleArray_swigregister(ConstDoubleArray)

class UIntArray(object):
    """
    This class provides a simple wrapper for a pointer to an array. A purpose
    of this class is to enable the simple and safe exchange of data between
    C++ and Python.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Array\ ()

          Create empty array

        * Array\ (N)

          Create array of size N

        * Array\ (other)

          Copy constructor (arg name need to have a different name that 'x')

        * Array\ (N, x)

          Construct array from a shared pointer

        * Array\ (N, x)

          Construct array from a pointer. Array will not take ownership.

        """
        _cpp.UIntArray_swiginit(self,_cpp.new_UIntArray(*args))
    def update(self, *args):
        """
        Construct array from a pointer. Array will not take ownership.

        """
        return _cpp.UIntArray_update(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print).
        Note that the Array class is not a subclass of Variable (for
        efficiency) which means that one needs to call str() directly
        instead of using the info() function on Array objects.

        """
        return _cpp.UIntArray_str(self, *args)

    def clear(self, *args):
        """
        Clear array

        """
        return _cpp.UIntArray_clear(self, *args)

    def resize(self, *args):
        """
        Resize array to size N. If size changes, contents will be destroyed.

        """
        return _cpp.UIntArray_resize(self, *args)

    def size(self, *args):
        """
        Return size of array

        """
        return _cpp.UIntArray_size(self, *args)

    def zero(self, *args):
        """
        Zero array

        """
        return _cpp.UIntArray_zero(self, *args)

    def zero_eps(self, *args):
        """
        Set entries which meet (abs(x[i]) < eps) to zero

        """
        return _cpp.UIntArray_zero_eps(self, *args)

    def min(self, *args):
        """
        Return minimum value of array

        """
        return _cpp.UIntArray_min(self, *args)

    def max(self, *args):
        """
        Return maximum value of array

        """
        return _cpp.UIntArray_max(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Return pointer to data (const version)

        * data\ ()

          Return pointer to data (non-const version)

        """
        return _cpp.UIntArray_data(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.UIntArray___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.UIntArray___setitem__(self, *args)

    def array(self, *args):
        """Missing docstring"""
        return _cpp.UIntArray_array(self, *args)

    __swig_destroy__ = _cpp.delete_UIntArray
UIntArray.update = new_instancemethod(_cpp.UIntArray_update,None,UIntArray)
UIntArray.str = new_instancemethod(_cpp.UIntArray_str,None,UIntArray)
UIntArray.clear = new_instancemethod(_cpp.UIntArray_clear,None,UIntArray)
UIntArray.resize = new_instancemethod(_cpp.UIntArray_resize,None,UIntArray)
UIntArray.size = new_instancemethod(_cpp.UIntArray_size,None,UIntArray)
UIntArray.zero = new_instancemethod(_cpp.UIntArray_zero,None,UIntArray)
UIntArray.zero_eps = new_instancemethod(_cpp.UIntArray_zero_eps,None,UIntArray)
UIntArray.min = new_instancemethod(_cpp.UIntArray_min,None,UIntArray)
UIntArray.max = new_instancemethod(_cpp.UIntArray_max,None,UIntArray)
UIntArray.data = new_instancemethod(_cpp.UIntArray_data,None,UIntArray)
UIntArray.__getitem__ = new_instancemethod(_cpp.UIntArray___getitem__,None,UIntArray)
UIntArray.__setitem__ = new_instancemethod(_cpp.UIntArray___setitem__,None,UIntArray)
UIntArray.array = new_instancemethod(_cpp.UIntArray_array,None,UIntArray)
UIntArray_swigregister = _cpp.UIntArray_swigregister
UIntArray_swigregister(UIntArray)

class IntArray(object):
    """
    This class provides a simple wrapper for a pointer to an array. A purpose
    of this class is to enable the simple and safe exchange of data between
    C++ and Python.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Array\ ()

          Create empty array

        * Array\ (N)

          Create array of size N

        * Array\ (other)

          Copy constructor (arg name need to have a different name that 'x')

        * Array\ (N, x)

          Construct array from a shared pointer

        * Array\ (N, x)

          Construct array from a pointer. Array will not take ownership.

        """
        _cpp.IntArray_swiginit(self,_cpp.new_IntArray(*args))
    def update(self, *args):
        """
        Construct array from a pointer. Array will not take ownership.

        """
        return _cpp.IntArray_update(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print).
        Note that the Array class is not a subclass of Variable (for
        efficiency) which means that one needs to call str() directly
        instead of using the info() function on Array objects.

        """
        return _cpp.IntArray_str(self, *args)

    def clear(self, *args):
        """
        Clear array

        """
        return _cpp.IntArray_clear(self, *args)

    def resize(self, *args):
        """
        Resize array to size N. If size changes, contents will be destroyed.

        """
        return _cpp.IntArray_resize(self, *args)

    def size(self, *args):
        """
        Return size of array

        """
        return _cpp.IntArray_size(self, *args)

    def zero(self, *args):
        """
        Zero array

        """
        return _cpp.IntArray_zero(self, *args)

    def zero_eps(self, *args):
        """
        Set entries which meet (abs(x[i]) < eps) to zero

        """
        return _cpp.IntArray_zero_eps(self, *args)

    def min(self, *args):
        """
        Return minimum value of array

        """
        return _cpp.IntArray_min(self, *args)

    def max(self, *args):
        """
        Return maximum value of array

        """
        return _cpp.IntArray_max(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Return pointer to data (const version)

        * data\ ()

          Return pointer to data (non-const version)

        """
        return _cpp.IntArray_data(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.IntArray___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.IntArray___setitem__(self, *args)

    def array(self, *args):
        """Missing docstring"""
        return _cpp.IntArray_array(self, *args)

    __swig_destroy__ = _cpp.delete_IntArray
IntArray.update = new_instancemethod(_cpp.IntArray_update,None,IntArray)
IntArray.str = new_instancemethod(_cpp.IntArray_str,None,IntArray)
IntArray.clear = new_instancemethod(_cpp.IntArray_clear,None,IntArray)
IntArray.resize = new_instancemethod(_cpp.IntArray_resize,None,IntArray)
IntArray.size = new_instancemethod(_cpp.IntArray_size,None,IntArray)
IntArray.zero = new_instancemethod(_cpp.IntArray_zero,None,IntArray)
IntArray.zero_eps = new_instancemethod(_cpp.IntArray_zero_eps,None,IntArray)
IntArray.min = new_instancemethod(_cpp.IntArray_min,None,IntArray)
IntArray.max = new_instancemethod(_cpp.IntArray_max,None,IntArray)
IntArray.data = new_instancemethod(_cpp.IntArray_data,None,IntArray)
IntArray.__getitem__ = new_instancemethod(_cpp.IntArray___getitem__,None,IntArray)
IntArray.__setitem__ = new_instancemethod(_cpp.IntArray___setitem__,None,IntArray)
IntArray.array = new_instancemethod(_cpp.IntArray_array,None,IntArray)
IntArray_swigregister = _cpp.IntArray_swigregister
IntArray_swigregister(IntArray)

class ParameterValue(object):
    """
    Base class for parameters.

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_ParameterValue
    def key(self, *args):
        """
        Return parameter key

        """
        return _cpp.ParameterValue_key(self, *args)

    def description(self, *args):
        """
        Return parameter description

        """
        return _cpp.ParameterValue_description(self, *args)

    def is_set(self, *args):
        """
        Return true if parameter is set, return false otherwise

        """
        return _cpp.ParameterValue_is_set(self, *args)

    def access_count(self, *args):
        """
        Return access count (number of times parameter has been accessed)

        """
        return _cpp.ParameterValue_access_count(self, *args)

    def change_count(self, *args):
        """
        Return change count (number of times parameter has been changed)

        """
        return _cpp.ParameterValue_change_count(self, *args)

    def set_range(self, *args):
        """
        **Overloaded versions**

        * set_range\ (min_value, max_value)

          Set range for int-valued parameter

        * set_range\ (min_value, max_value)

          Set range for double-valued parameter

        * set_range\ (range)

          Set range for string-valued parameter

        """
        return _cpp.ParameterValue_set_range(self, *args)

    def _get_int_range(self, *args):
        """
        **Overloaded versions**

        * get_range\ (min_value, max_value)

          Get range for int-valued parameter

        * get_range\ (min_value, max_value)

          Get range for double-valued parameter

        * get_range\ (range)

          Get range for string-valued parameter

        """
        return _cpp.ParameterValue__get_int_range(self, *args)

    def _get_double_range(self, *args):
        """
        **Overloaded versions**

        * get_range\ (min_value, max_value)

          Get range for int-valued parameter

        * get_range\ (min_value, max_value)

          Get range for double-valued parameter

        * get_range\ (range)

          Get range for string-valued parameter

        """
        return _cpp.ParameterValue__get_double_range(self, *args)

    def _get_string_range(self, *args):
        """
        **Overloaded versions**

        * get_range\ (min_value, max_value)

          Get range for int-valued parameter

        * get_range\ (min_value, max_value)

          Get range for double-valued parameter

        * get_range\ (range)

          Get range for string-valued parameter

        """
        return _cpp.ParameterValue__get_string_range(self, *args)

    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (value)

          Assignment from int

        * operator=\ (value)

          Assignment from double

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from bool

        """
        return _cpp.ParameterValue__assign(self, *args)

    def _assign_bool(self, *args):
        """
        **Overloaded versions**

        * operator=\ (value)

          Assignment from int

        * operator=\ (value)

          Assignment from double

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from bool

        """
        return _cpp.ParameterValue__assign_bool(self, *args)

    def __int__(self, *args):
        """
        Cast parameter to int

        """
        return _cpp.ParameterValue___int__(self, *args)

    def __float__(self, *args):
        """
        Cast parameter to double

        """
        return _cpp.ParameterValue___float__(self, *args)

    def __str__(self, *args):
        """
        Cast parameter to string

        """
        return _cpp.ParameterValue___str__(self, *args)

    def __nonzero__(self):
        return _cpp.ParameterValue___nonzero__(self)
    __bool__ = __nonzero__


    def type_str(self, *args):
        """
        Return value type string

        """
        return _cpp.ParameterValue_type_str(self, *args)

    def value_str(self, *args):
        """
        Return value string

        """
        return _cpp.ParameterValue_value_str(self, *args)

    def range_str(self, *args):
        """
        Return range string

        """
        return _cpp.ParameterValue_range_str(self, *args)

    def str(self, *args):
        """
        Return short string description

        """
        return _cpp.ParameterValue_str(self, *args)

    check_key = staticmethod(_cpp.ParameterValue_check_key)
    def warn_once(self, msg):
        cls = self.__class__
        if not hasattr(cls, '_warned'):
            cls._warned = set()
        if not msg in cls._warned:
            cls._warned.add(msg)
            print msg

    def value(self):
        val_type = self.type_str()
        if val_type == "string":
            return str(self)
        elif  val_type == "int":
            return int(self)
        elif val_type == "bool":
            return bool(self)
        elif val_type == "double":
            return float(self)
        else:
            raise TypeError, "unknown value type '%s' of parameter '%s'"%(val_type, self.key())

    def get_range(self):
        val_type = self.type_str()
        if val_type == "string":
            local_range = self._get_string_range()
            if len(local_range) == 0:
                return
            return local_range
        elif  val_type == "int":
            local_range = self._get_int_range()
            if local_range[0] == 0 and local_range[0] == local_range[0]:
                return
            return local_range
        elif val_type == "bool":
            return
        elif val_type == "double":
            from logging import DEBUG
            local_range = self._get_double_range()
            if local_range[0] == 0 and local_range[0] == local_range[0]:
                return
            return local_range
        else:
            raise TypeError, "unknown value type '%s' of parameter '%s'"%(val_type, self.key())

    def data(self):
        return self.value(), self.get_range(), self.access_count(), self.change_count()

ParameterValue.key = new_instancemethod(_cpp.ParameterValue_key,None,ParameterValue)
ParameterValue.description = new_instancemethod(_cpp.ParameterValue_description,None,ParameterValue)
ParameterValue.is_set = new_instancemethod(_cpp.ParameterValue_is_set,None,ParameterValue)
ParameterValue.access_count = new_instancemethod(_cpp.ParameterValue_access_count,None,ParameterValue)
ParameterValue.change_count = new_instancemethod(_cpp.ParameterValue_change_count,None,ParameterValue)
ParameterValue.set_range = new_instancemethod(_cpp.ParameterValue_set_range,None,ParameterValue)
ParameterValue._get_int_range = new_instancemethod(_cpp.ParameterValue__get_int_range,None,ParameterValue)
ParameterValue._get_double_range = new_instancemethod(_cpp.ParameterValue__get_double_range,None,ParameterValue)
ParameterValue._get_string_range = new_instancemethod(_cpp.ParameterValue__get_string_range,None,ParameterValue)
ParameterValue._assign = new_instancemethod(_cpp.ParameterValue__assign,None,ParameterValue)
ParameterValue._assign_bool = new_instancemethod(_cpp.ParameterValue__assign_bool,None,ParameterValue)
ParameterValue.__int__ = new_instancemethod(_cpp.ParameterValue___int__,None,ParameterValue)
ParameterValue.__float__ = new_instancemethod(_cpp.ParameterValue___float__,None,ParameterValue)
ParameterValue.__str__ = new_instancemethod(_cpp.ParameterValue___str__,None,ParameterValue)
ParameterValue.type_str = new_instancemethod(_cpp.ParameterValue_type_str,None,ParameterValue)
ParameterValue.value_str = new_instancemethod(_cpp.ParameterValue_value_str,None,ParameterValue)
ParameterValue.range_str = new_instancemethod(_cpp.ParameterValue_range_str,None,ParameterValue)
ParameterValue.str = new_instancemethod(_cpp.ParameterValue_str,None,ParameterValue)
ParameterValue_swigregister = _cpp.ParameterValue_swigregister
ParameterValue_swigregister(ParameterValue)

def ParameterValue_check_key(*args):
  return _cpp.ParameterValue_check_key(*args)
ParameterValue_check_key = _cpp.ParameterValue_check_key

class IntParameter(ParameterValue):
    """
    Parameter with value type int

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * IntParameter\ (key)

          Create unset int-valued

        * IntParameter\ (key, value)

          Create int-valued parameter

        """
        _cpp.IntParameter_swiginit(self,_cpp.new_IntParameter(*args))
    __swig_destroy__ = _cpp.delete_IntParameter
    def _assign(self, *args):
        """
        Assignment

        """
        return _cpp.IntParameter__assign(self, *args)

IntParameter._assign = new_instancemethod(_cpp.IntParameter__assign,None,IntParameter)
IntParameter_swigregister = _cpp.IntParameter_swigregister
IntParameter_swigregister(IntParameter)

class DoubleParameter(ParameterValue):
    """
    Parameter with value type double

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * DoubleParameter\ (key)

          Create unset double-valued parameter

        * DoubleParameter\ (key, value)

          Create double-valued parameter

        """
        _cpp.DoubleParameter_swiginit(self,_cpp.new_DoubleParameter(*args))
    __swig_destroy__ = _cpp.delete_DoubleParameter
    def _assign(self, *args):
        """
        Assignment

        """
        return _cpp.DoubleParameter__assign(self, *args)

DoubleParameter._assign = new_instancemethod(_cpp.DoubleParameter__assign,None,DoubleParameter)
DoubleParameter_swigregister = _cpp.DoubleParameter_swigregister
DoubleParameter_swigregister(DoubleParameter)

class StringParameter(ParameterValue):
    """
    Parameter with value type string

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * StringParameter\ (key)

          Create unset string-valued parameter

        * StringParameter\ (key, value)

          Create string-valued parameter

        """
        _cpp.StringParameter_swiginit(self,_cpp.new_StringParameter(*args))
    __swig_destroy__ = _cpp.delete_StringParameter
    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (value)

          Assignment

        * operator=\ (value)

          Assignment

        """
        return _cpp.StringParameter__assign(self, *args)

StringParameter._assign = new_instancemethod(_cpp.StringParameter__assign,None,StringParameter)
StringParameter_swigregister = _cpp.StringParameter_swigregister
StringParameter_swigregister(StringParameter)

class BoolParameter(ParameterValue):
    """
    Parameter with value type bool

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * BoolParameter\ (key)

          Create unset bool-valued parameter

        * BoolParameter\ (key, value)

          Create bool-valued parameter

        """
        _cpp.BoolParameter_swiginit(self,_cpp.new_BoolParameter(*args))
    __swig_destroy__ = _cpp.delete_BoolParameter
    def _assign_bool(self, *args):
        """
        Assignment

        """
        return _cpp.BoolParameter__assign_bool(self, *args)

BoolParameter._assign_bool = new_instancemethod(_cpp.BoolParameter__assign_bool,None,BoolParameter)
BoolParameter_swigregister = _cpp.BoolParameter_swigregister
BoolParameter_swigregister(BoolParameter)

class Parameters(object):
    """
    This class stores a set of parameters. Each parameter is
    identified by a unique string (the key) and a value of some
    given value type. Parameter sets can be nested at arbitrary
    depths.

    A parameter may be either int, double, string or boolean valued.

    Parameters may be added as follows:

      Parameters p("my_parameters");
      p.add("relative_tolerance",  1e-15);
      p.add("absolute_tolerance",  1e-15);
      p.add("gmres_restart",       30);
      p.add("monitor_convergence", false);

    Parameters may be changed as follows:

      p["gmres_restart"] = 50;

    Parameter values may be retrieved as follows:

      int gmres_restart = p["gmres_restart"];

    Parameter sets may be nested as follows:

      Parameters q("nested_parameters");
      p.add(q);

    Nested parameters may then be accessed by

      p("nested_parameters")["..."]

    Parameters may be nested at arbitrary depths.

    Parameters may be parsed from the command-line as follows:

      p.parse(argc, argv);

    Note: spaces in parameter keys are not allowed (to simplify
    usage from command-line).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _cpp.delete_Parameters
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Parameters\ ("parameters")

          Create empty parameter set

        * Parameters\ (parameters)

          Copy constructor

        """
        _cpp.Parameters_swiginit(self,_cpp.new_Parameters(*args))
    def name(self, *args):
        """
        Return name for parameter set

        """
        return _cpp.Parameters_name(self, *args)

    def rename(self, *args):
        """
        Rename parameter set

        """
        return _cpp.Parameters_rename(self, *args)

    def clear(self, *args):
        """
        Clear parameter set

        """
        return _cpp.Parameters_clear(self, *args)

    def _add_bool(self, *args):
        """
        **Overloaded versions**

        * add\ (key)

          Add an unset parameter of type T. For example, to create a unset
          parameter of type bool, do parameters.add<bool>("my_setting")

        * add\ (key, value)

          Add int-valued parameter

        * add\ (key, value, min_value, max_value)

          Add int-valued parameter with given range

        * add\ (key, value)

          Add double-valued parameter

        * add\ (key, value, min_value, max_value)

          Add double-valued parameter with given range

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value)

          Add bool-valued parameter

        * add\ (parameters)

          Add nested parameter set

        """
        return _cpp.Parameters__add_bool(self, *args)

    def _add(self, *args):
        """
        **Overloaded versions**

        * add\ (key)

          Add an unset parameter of type T. For example, to create a unset
          parameter of type bool, do parameters.add<bool>("my_setting")

        * add\ (key, value)

          Add int-valued parameter

        * add\ (key, value, min_value, max_value)

          Add int-valued parameter with given range

        * add\ (key, value)

          Add double-valued parameter

        * add\ (key, value, min_value, max_value)

          Add double-valued parameter with given range

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value)

          Add bool-valued parameter

        * add\ (parameters)

          Add nested parameter set

        """
        return _cpp.Parameters__add(self, *args)

    def remove(self, *args):
        """
        Remove parameter or parameter set with given key

        """
        return _cpp.Parameters_remove(self, *args)

    def _get_parameter(self, *args):
        """
        **Overloaded versions**

        * operator[]\ (key)

          Return parameter for given key

        * operator[]\ (key)

          Return parameter for given key (const version)

        """
        return _cpp.Parameters__get_parameter(self, *args)

    def assign(self, *args):
        """
        Assignment operator

        """
        return _cpp.Parameters_assign(self, *args)

    def has_key(self, *args):
        """
        Check if parameter set has key (parameter or nested parameter set)

        """
        return _cpp.Parameters_has_key(self, *args)

    def has_parameter(self, *args):
        """
        Check if parameter set has given parameter

        """
        return _cpp.Parameters_has_parameter(self, *args)

    def has_parameter_set(self, *args):
        """
        Check if parameter set has given nested parameter set

        """
        return _cpp.Parameters_has_parameter_set(self, *args)

    def _get_parameter_keys(self, *args):
        """
        Return a vector of parameter keys

        """
        return _cpp.Parameters__get_parameter_keys(self, *args)

    def _get_parameter_set_keys(self, *args):
        """
        Return a vector of parameter set keys

        """
        return _cpp.Parameters__get_parameter_set_keys(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.Parameters_str(self, *args)

    def _parse(self, *args):
        """Missing docstring"""
        return _cpp.Parameters__parse(self, *args)

    def add(self,*args):
        """Add a parameter to the parameter set"""
        if len(args) == 2 and isinstance(args[1],bool):
            self._add_bool(*args)
        else:
            self._add(*args)

    def parse(self,argv=None):
        "Parse command line arguments"
        if argv is None:
            import sys
            argv = sys.argv
        self._parse(argv)

    def keys(self):
        "Returns a list of the parameter keys"
        ret = self._get_parameter_keys()
        ret += self._get_parameter_set_keys()
        return ret

    def iterkeys(self):
        "Returns an iterator for the parameter keys"
        for key in self.keys():
            yield key

    def __iter__(self):
        return self.iterkeys()

    def values(self):
        "Returns a list of the parameter values"
        return [self[key] for key in self.keys()]

    def itervalues(self):
        "Returns an iterator to the parameter values"
        return (self[key] for key in self.keys())

    def items(self):
        return zip(self.keys(),self.values())

    def iteritems(self):
        "Returns an iterator over the (key, value) items of the Parameters"
        for key, value in self.items():
            yield key, value

    def set_range(self, key, *arg):
        "Set the range for the given parameter"
        if key not in self._get_parameter_keys():
            raise KeyError, "no parameter with name '%s'"%key
        self._get_parameter(key).set_range(*arg)

    def __getitem__(self, key):
        "Return the parameter corresponding to the given key"
        if key in self._get_parameter_keys():
            return self._get_parameter(key).value()

        if key in self._get_parameter_set_keys():
            return self._get_parameter_set(key)

        raise KeyError, "'%s'"%key

    def __setitem__(self, key, value):
        "Set the parameter 'key', with given 'value'"
        if key not in self._get_parameter_keys():
            raise KeyError, "'%s' is not a parameter"%key
        if not isinstance(value,(int,str,float,bool)):
            raise TypeError, "can only set 'int', 'bool', 'float' and 'str' parameters"
        par = self._get_parameter(key)
        if isinstance(value,bool):
            par._assign_bool(value)
        else:
            par._assign(value)

    def update(self, other):
        "A recursive update that handles parameter subsets correctly."
        if not isinstance(other,(Parameters, dict)):
            raise TypeError, "expected a 'dict' or a '%s'"%Parameters.__name__
        for key, other_value in other.iteritems():
            self_value  = self[key]
            if isinstance(self_value, Parameters):
                self_value.update(other_value)
            else:
                setattr(self, key, other_value)

    def to_dict(self):
        """Convert the Parameters to a dict"""
        ret = {}
        for key, value in self.iteritems():
            if isinstance(value, Parameters):
                ret[key] = value.to_dict()
            else:
                ret[key] = value
        return ret

    def copy(self):
        "Return a copy of it self"
        return Parameters(self)

    def option_string(self):
        "Return an option string representation of the Parameters"
        def option_list(parent,basename):
            ret_list = []
            for key, value in parent.iteritems():
                if isinstance(value, Parameters):
                    ret_list.extend(option_list(value,basename + key + '.'))
                else:
                    ret_list.append(basename + key + " " + str(value))
            return ret_list

        return " ".join(option_list(self,"--"))

    def __str__(self):
        "p.__str__() <==> str(x)"
        return self.str(False)

    __getattr__ = __getitem__
    __setattr__ = __setitem__

    def iterdata(self):
        """Returns an iterator of a tuple of a parameter key together with its value"""
        for key in self.iterkeys():
            yield key, self.get(key)

    def get(self, key):
        """Return all data available for a certain parameter

        The data is returned in a tuple:
        value, range, access_count, change_count = parameters.get('name')
        """
        if key in self._get_parameter_keys():
            return self._get_parameter(key).data()

        if key in self._get_parameter_set_keys():
            return self._get_parameter_set(key)

        raise KeyError, "'%s'"%key


Parameters.name = new_instancemethod(_cpp.Parameters_name,None,Parameters)
Parameters.rename = new_instancemethod(_cpp.Parameters_rename,None,Parameters)
Parameters.clear = new_instancemethod(_cpp.Parameters_clear,None,Parameters)
Parameters._add_bool = new_instancemethod(_cpp.Parameters__add_bool,None,Parameters)
Parameters._add = new_instancemethod(_cpp.Parameters__add,None,Parameters)
Parameters.remove = new_instancemethod(_cpp.Parameters_remove,None,Parameters)
Parameters._get_parameter = new_instancemethod(_cpp.Parameters__get_parameter,None,Parameters)
Parameters._get_parameter_set = new_instancemethod(_cpp.Parameters__get_parameter_set,None,Parameters)
Parameters.assign = new_instancemethod(_cpp.Parameters_assign,None,Parameters)
Parameters.has_key = new_instancemethod(_cpp.Parameters_has_key,None,Parameters)
Parameters.has_parameter = new_instancemethod(_cpp.Parameters_has_parameter,None,Parameters)
Parameters.has_parameter_set = new_instancemethod(_cpp.Parameters_has_parameter_set,None,Parameters)
Parameters._get_parameter_keys = new_instancemethod(_cpp.Parameters__get_parameter_keys,None,Parameters)
Parameters._get_parameter_set_keys = new_instancemethod(_cpp.Parameters__get_parameter_set_keys,None,Parameters)
Parameters.str = new_instancemethod(_cpp.Parameters_str,None,Parameters)
Parameters._parse = new_instancemethod(_cpp.Parameters__parse,None,Parameters)
Parameters_swigregister = _cpp.Parameters_swigregister
Parameters_swigregister(Parameters)

class GlobalParameters(Parameters):
    """
    This class defines the global DOLFIN parameter database.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.GlobalParameters_swiginit(self,_cpp.new_GlobalParameters(*args))
    __swig_destroy__ = _cpp.delete_GlobalParameters
    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.GlobalParameters_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
GlobalParameters_swigregister = _cpp.GlobalParameters_swigregister
GlobalParameters_swigregister(GlobalParameters)
cvar = _cpp.cvar

def GlobalParameters_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.GlobalParameters_default_parameters(*args)

old_init = Parameters.__init__
def __new_Parameter_init__(self,*args,**kwargs):
    """Initialize Parameters

    Usage:

    Parameters()
       create empty parameter set

    Parameters(name)
       create empty parameter set with given name

    Parameters(other_parameters)
       create copy of parameter set

    Parameters(name, dim=3, tol=0.1, foo="Foo")
       create parameter set with given parameters

    Parameters(name, dim=(3, 0, 4), foo=("Foo", ["Foo", "Bar"])
       create parameter set with given parameters and ranges
    """

    if len(args) == 0:
        old_init(self, "parameters")
    elif len(args) == 1 and isinstance(args[0], (str,type(self))):
        old_init(self, args[0])
    else:
        raise TypeError, "expected a single optional argument of type 'str' or ''"%type(self).__name__
    if len(kwargs) == 0:
        return

    from numpy import isscalar
    for key, value in kwargs.iteritems():
        if isinstance(value,type(self)):
            self.add(value)
        elif isinstance(value,tuple):
            if isscalar(value[0]) and len(value) == 3:
                self.add(key, *value)
            elif isinstance(value[0], str) and len(value) == 2:
                if not isinstance(value[1], list):
                    raise TypeError, "expected a list as second item of tuple, when first is a 'str'"
                self.add(key, *value)
            else:
                raise TypeError,"expected a range tuple of size 2 for 'str' values and 3 for scalars"
        else:
            self.add(key,value)

Parameters.__init__ = __new_Parameter_init__



def get_global_parameters(*args):
  return _cpp.get_global_parameters(*args)
get_global_parameters = _cpp.get_global_parameters
parameters = _cpp.get_global_parameters()
del _cpp.get_global_parameters


def _info(*args):
  """
    **Overloaded versions**

    * info\ (msg, ...)

      The DOLFIN log system provides the following set of functions for
      uniform handling of log messages, warnings and errors. In addition,
      macros are provided for debug messages and dolfin_assertions.
      
      Only messages with a debug level higher than or equal to the current
      log level are printed (the default being zero). Logging may also be
      turned off by calling set_log_active(false).
      Print message

    * info\ (parameters, verbose=false)

      Print parameter (using output of str() method)

    * info\ (variable, verbose=false)

      Print variable (using output of str() method)

    """
  return _cpp._info(*args)

def info_stream(*args):
  """
    Print message to stream

    """
  return _cpp.info_stream(*args)

def info_underline(*args):
  """
    Print underlined message

    """
  return _cpp.info_underline(*args)

def warning(*args):
  """
    Print warning

    """
  return _cpp.warning(*args)

def error(*args):
  """
    Print error message and throw an exception.
    Note to developers: this function should not be used internally
    in DOLFIN. Use the more informative dolfin_error instead.

    """
  return _cpp.error(*args)

def dolfin_error(*args):
  """
    Print error message. Prefer this to the above generic error message.

    *Arguments*
        location (str)
            Name of the file from which the error message was generated.
        task (str)
            Name of the task that failed.
            Note that this string should begin with lowercase.
            Note that this string should not be punctuated.
        reason (str)
            A format string explaining the reason for the failure.
            Note that this string should begin with uppercase.
            Note that this string should not be punctuated.
            Note that this string may contain printf style formatting.
        ... (primitive types like int, uint, double, bool)
            Optional arguments for the format string.

    Developers should read the file dolfin/log/README in the DOLFIN
    source tree for further notes about the use of this function.

    """
  return _cpp.dolfin_error(*args)

def log(*args):
  """
    Print message at given debug level

    """
  return _cpp.log(*args)

def end(*args):
  """
    End task (decrease indentation level)

    """
  return _cpp.end(*args)

def set_log_active(*args):
  """
    Turn logging on or off

    """
  return _cpp.set_log_active(*args)

def set_log_level(*args):
  """
    Set log level

    """
  return _cpp.set_log_level(*args)

def set_output_stream(*args):
  """
    Set output stream

    """
  return _cpp.set_output_stream(*args)

def get_log_level(*args):
  """
    Get log level

    """
  return _cpp.get_log_level(*args)

def list_timings(*args):
  """
    List a summary of timings and tasks, optionally clearing stored timings

    """
  return _cpp.list_timings(*args)

def summary(*args):
  """
    This function is deprecated, use list_timings

    """
  return _cpp.summary(*args)

def timing(*args):
  """
    Return timing (average) for given task, optionally clearing timing for task

    """
  return _cpp.timing(*args)

def not_working_in_parallel(*args):
  """
    Report that functionality has not (yet) been implemented to work in parallel

    """
  return _cpp.not_working_in_parallel(*args)

def __debug(*args):
  return _cpp.__debug(*args)
__debug = _cpp.__debug

def __dolfin_assert(*args):
  return _cpp.__dolfin_assert(*args)
__dolfin_assert = _cpp.__dolfin_assert
class Event(object):
    """
    A event is a string message which is displayed
    only a limited number of times.

    *Example*
        .. code-block:: python
        
            >>> event = dolfin.Event("System is stiff, damping is needed.", 3)
            >>> for i in range(10):
            ...     if i > 7:
            ...         print i
            ...         event()

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.Event_swiginit(self,_cpp.new_Event(*args))
    __swig_destroy__ = _cpp.delete_Event
    def count(self, *args):
        """
        Display count

        """
        return _cpp.Event_count(self, *args)

    def maxcount(self, *args):
        """
        Maximum display count

        """
        return _cpp.Event_maxcount(self, *args)

Event.__call__ = new_instancemethod(_cpp.Event___call__,None,Event)
Event.count = new_instancemethod(_cpp.Event_count,None,Event)
Event.maxcount = new_instancemethod(_cpp.Event_maxcount,None,Event)
Event_swigregister = _cpp.Event_swigregister
Event_swigregister(Event)

def begin(*args):
  """
    **Overloaded versions**

    * begin\ (msg, ...)

      Begin task (increase indentation level)

    * begin\ (debug_level, msg, ...)

      Begin task (increase indentation level)

    """
  return _cpp.begin(*args)

class Progress(object):
    """
    This class provides a simple way to create and update progress
    bars during a computation.

    *Example*
        A progress bar may be used either in an iteration with a known number
        of steps:
        
        .. code-block:: python
        
            >>> n = 1000000
            >>> p = dolfin.Progress("Iterating...", n)
            >>> for i in range(n):
            ...     p += 1
        
        or in an iteration with an unknown number of steps:
        
        .. code-block:: python
        
            >>> pr = dolfin.Progress("Iterating")
            >>> t = 0.0
            >>> n = 1000000.0
            >>> while t < n:
            ...     t += 1.0
            ...     p += t/n

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Progress\ (title, n)

          Create progress bar with a known number of steps
          
          *Arguments*
              title (str)
                  The title.
              n (int)
                  Number of steps.

        * Progress\ (title)

          Create progress bar with an unknown number of steps
          
          *Arguments*
              title (str)
                  The title.

        """
        _cpp.Progress_swiginit(self,_cpp.new_Progress(*args))
    __swig_destroy__ = _cpp.delete_Progress
    def _add(self, *args):
        """Missing docstring"""
        return _cpp.Progress__add(self, *args)

    def _set(self, *args):
        """Missing docstring"""
        return _cpp.Progress__set(self, *args)

    def __iadd__(self, other):
        if isinstance(other, int):
            self._add(other)
        elif isinstance(other, float):
            self._set(other)
        return self

    def update(self, other):
        "Update the progress with given number"
        if isinstance(other, float):
            self._set(other)

Progress._add = new_instancemethod(_cpp.Progress__add,None,Progress)
Progress._set = new_instancemethod(_cpp.Progress__set,None,Progress)
Progress_swigregister = _cpp.Progress_swigregister
Progress_swigregister(Progress)

class Table(Variable):
    """
    This class provides storage and pretty-printing for tables.
    Example usage:

      Table table("Timings");

      table("uBLAS",  "Assemble") = 0.010;
      table("uBLAS",  "Solve")    = 0.020;
      table("PETSc",  "Assemble") = 0.011;
      table("PETSc",  "Solve")    = 0.019;
      table("Epetra", "Assemble") = 0.012;
      table("Epetra", "Solve")    = 0.018;

      info(table);

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create empty table

        """
        _cpp.Table_swiginit(self,_cpp.new_Table(*args))
    __swig_destroy__ = _cpp.delete_Table
    def set(self, *args):
        """
        **Overloaded versions**

        * set\ (row, col, value)

          Set value of table entry

        * set\ (row, col, value)

          Set value of table entry

        * set\ (row, col, value)

          Set value of table entry

        * set\ (row, col, value)

          Set value of table entry

        """
        return _cpp.Table_set(self, *args)

    def get(self, *args):
        """
        Get value of table entry

        """
        return _cpp.Table_get(self, *args)

    def get_value(self, *args):
        """
        Get value of table entry

        """
        return _cpp.Table_get_value(self, *args)

    def title(self, *args):
        """
        Return table title

        """
        return _cpp.Table_title(self, *args)

    def str_latex(self, *args):
        """
        Return informal string representation for LaTeX

        """
        return _cpp.Table_str_latex(self, *args)

Table.__call__ = new_instancemethod(_cpp.Table___call__,None,Table)
Table.set = new_instancemethod(_cpp.Table_set,None,Table)
Table.get = new_instancemethod(_cpp.Table_get,None,Table)
Table.get_value = new_instancemethod(_cpp.Table_get_value,None,Table)
Table.title = new_instancemethod(_cpp.Table_title,None,Table)
Table.str_latex = new_instancemethod(_cpp.Table_str_latex,None,Table)
Table_swigregister = _cpp.Table_swigregister
Table_swigregister(Table)

class TableEntry(object):
    """
    This class represents an entry in a Table

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create table entry

        """
        _cpp.TableEntry_swiginit(self,_cpp.new_TableEntry(*args))
    __swig_destroy__ = _cpp.delete_TableEntry
TableEntry_swigregister = _cpp.TableEntry_swigregister
TableEntry_swigregister(TableEntry)

CRITICAL = _cpp.CRITICAL
ERROR = _cpp.ERROR
WARNING = _cpp.WARNING
INFO = _cpp.INFO
PROGRESS = _cpp.PROGRESS
TRACE = _cpp.TRACE
DBG = _cpp.DBG
def debug(message):
    import traceback
    file, line, func, txt = traceback.extract_stack(None, 2)[0]
    __debug(file, line, func, message)

def info(object, verbose=False):
    """Print string or object.

    *Arguments*
        object
            A string or a DOLFIN object (:py:class:`Variable <dolfin.cpp.Variable>`
            or :py:class:`Parameters <dolfin.cpp.Parameters>`)
        verbose
            An optional argument that indicates whether verbose object data
            should be printed. If False, a short one-line summary is printed.
            If True, verbose and sometimes very exhaustive object data are
            printed.
    """

    if isinstance(object, (Variable, Parameters)):
        _info(object.str(verbose))
    else:
        _info(object)

class GenericLinearSolver(Variable):
    """
    This class provides a general solver for linear systems Ax = b.

    """
    thisown = _swig_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 set_operator(self, *args):
        """
        Set operator (matrix)

        """
        return _cpp.GenericLinearSolver_set_operator(self, *args)

    def set_operators(self, *args):
        """
        Set operator (matrix) and preconditioner matrix

        """
        return _cpp.GenericLinearSolver_set_operators(self, *args)

    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (A, x, b)

          Solve linear system Ax = b

        * solve\ (x, b)

          Solve linear system Ax = b

        """
        return _cpp.GenericLinearSolver_solve(self, *args)

    __swig_destroy__ = _cpp.delete_GenericLinearSolver
GenericLinearSolver.set_operator = new_instancemethod(_cpp.GenericLinearSolver_set_operator,None,GenericLinearSolver)
GenericLinearSolver.set_operators = new_instancemethod(_cpp.GenericLinearSolver_set_operators,None,GenericLinearSolver)
GenericLinearSolver.solve = new_instancemethod(_cpp.GenericLinearSolver_solve,None,GenericLinearSolver)
GenericLinearSolver_swigregister = _cpp.GenericLinearSolver_swigregister
GenericLinearSolver_swigregister(GenericLinearSolver)

class GenericLUSolver(GenericLinearSolver):
    """
    This a base class for LU solvers

    """
    thisown = _swig_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 solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (x, b)

          Solve linear system Ax = b

        * solve\ (A, x, b)

          Solve linear system Ax = b

        """
        return _cpp.GenericLUSolver_solve(self, *args)

    __swig_destroy__ = _cpp.delete_GenericLUSolver
GenericLUSolver.solve = new_instancemethod(_cpp.GenericLUSolver_solve,None,GenericLUSolver)
GenericLUSolver_swigregister = _cpp.GenericLUSolver_swigregister
GenericLUSolver_swigregister(GenericLUSolver)

class GenericTensor(Variable):
    """
    This class defines a common interface for arbitrary rank tensors.

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_GenericTensor
    def distributed(self, *args):
        """
        Return true if tensor is distributed

        """
        return _cpp.GenericTensor_distributed(self, *args)

    def init(self, *args):
        """
        Initialize zero tensor using sparsity pattern

        """
        return _cpp.GenericTensor_init(self, *args)

    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.GenericTensor_copy(self, *args)

    def rank(self, *args):
        """
        Return tensor rank (number of dimensions)

        """
        return _cpp.GenericTensor_rank(self, *args)

    def size(self, *args):
        """
        Return size of given dimension

        """
        return _cpp.GenericTensor_size(self, *args)

    def local_range(self, *args):
        """
        Return local ownership range

        """
        return _cpp.GenericTensor_local_range(self, *args)

    def add(self, *args):
        """
        **Overloaded versions**

        * add\ (block, rows)

          Add block of values

        * add\ (block, rows)

          Add block of values

        * add\ (block, num_rows, rows)

          Add block of values

        """
        return _cpp.GenericTensor_add(self, *args)

    def zero(self, *args):
        """
        Set all entries to zero and keep any sparse structure

        """
        return _cpp.GenericTensor_zero(self, *args)

    def apply(self, *args):
        """
        Finalize assembly of tensor

        """
        return _cpp.GenericTensor_apply(self, *args)

    def factory(self, *args):
        """
        Return linear algebra backend factory

        """
        return _cpp.GenericTensor_factory(self, *args)

    def shared_instance(self, *args):
        """
        **Overloaded versions**

        * shared_instance\ ()

          Return concrete shared ptr instance / unwrap (const version)

        * shared_instance\ ()

          Return concrete shared ptr instance / unwrap

        """
        return _cpp.GenericTensor_shared_instance(self, *args)

GenericTensor.distributed = new_instancemethod(_cpp.GenericTensor_distributed,None,GenericTensor)
GenericTensor.init = new_instancemethod(_cpp.GenericTensor_init,None,GenericTensor)
GenericTensor.copy = new_instancemethod(_cpp.GenericTensor_copy,None,GenericTensor)
GenericTensor.rank = new_instancemethod(_cpp.GenericTensor_rank,None,GenericTensor)
GenericTensor.size = new_instancemethod(_cpp.GenericTensor_size,None,GenericTensor)
GenericTensor.local_range = new_instancemethod(_cpp.GenericTensor_local_range,None,GenericTensor)
GenericTensor.add = new_instancemethod(_cpp.GenericTensor_add,None,GenericTensor)
GenericTensor.zero = new_instancemethod(_cpp.GenericTensor_zero,None,GenericTensor)
GenericTensor.apply = new_instancemethod(_cpp.GenericTensor_apply,None,GenericTensor)
GenericTensor.factory = new_instancemethod(_cpp.GenericTensor_factory,None,GenericTensor)
GenericTensor.shared_instance = new_instancemethod(_cpp.GenericTensor_shared_instance,None,GenericTensor)
GenericTensor_swigregister = _cpp.GenericTensor_swigregister
GenericTensor_swigregister(GenericTensor)

class GenericMatrix(GenericTensor):
    """
    This class defines a common interface for matrices.

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_GenericMatrix
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.GenericMatrix_copy(self, *args)

    def resize(self, *args):
        """
        Resize vector y such that is it compatible with matrix for
        multuplication Ax = b (dim = 0 -> b, dim = 1 -> x). In parallel
        case, size and layout are important.

        """
        return _cpp.GenericMatrix_resize(self, *args)

    def get(self, *args):
        """
        **Overloaded versions**

        * get\ (block, num_rows, rows)

          Get block of values

        * get\ (block, m, rows, n, cols)

          Get block of values

        """
        return _cpp.GenericMatrix_get(self, *args)

    def set(self, *args):
        """
        **Overloaded versions**

        * set\ (block, num_rows, rows)

          Set block of values

        * set\ (block, m, rows, n, cols)

          Set block of values

        """
        return _cpp.GenericMatrix_set(self, *args)

    def add(self, *args):
        """
        **Overloaded versions**

        * add\ (block, num_rows, rows)

          Add block of values

        * add\ (block, rows)

          Add block of values

        * add\ (block, rows)

          Add block of values

        * add\ (block, m, rows, n, cols)

          Add block of values

        """
        return _cpp.GenericMatrix_add(self, *args)

    def axpy(self, *args):
        """
        Add multiple of given matrix (AXPY operation)

        """
        return _cpp.GenericMatrix_axpy(self, *args)

    def norm(self, *args):
        """
        Return norm of matrix

        """
        return _cpp.GenericMatrix_norm(self, *args)

    def getrow(self, *args):
        """
        Get non-zero values of given row on local process

        """
        return _cpp.GenericMatrix_getrow(self, *args)

    def setrow(self, *args):
        """
        Set values for given row on local process

        """
        return _cpp.GenericMatrix_setrow(self, *args)

    def zero(self, *args):
        """
        **Overloaded versions**

        * zero\ ()

          Set all entries to zero and keep any sparse structure

        * zero\ (m, rows)

          Set given rows to zero

        """
        return _cpp.GenericMatrix_zero(self, *args)

    def ident(self, *args):
        """
        Set given rows to identity matrix

        """
        return _cpp.GenericMatrix_ident(self, *args)

    def mult(self, *args):
        """
        Matrix-vector product, y = Ax

        """
        return _cpp.GenericMatrix_mult(self, *args)

    def transpmult(self, *args):
        """
        Matrix-vector product, y = A^T x

        """
        return _cpp.GenericMatrix_transpmult(self, *args)

    def assign(self, *args):
        """
        Assignment operator

        """
        return _cpp.GenericMatrix_assign(self, *args)

    def ident_zeros(self, *args):
        """
        Insert one on the diagonal for all zero rows

        """
        return _cpp.GenericMatrix_ident_zeros(self, *args)

    def _scale(self, *args):
        """Missing docstring"""
        return _cpp.GenericMatrix__scale(self, *args)

    def _data(self, *args):
        """Missing docstring"""
        return _cpp.GenericMatrix__data(self, *args)

    def __is_compatible(self,other):
        "Returns True if self, and other are compatible Vectors"
        if not isinstance(other,GenericMatrix):
            return False
        self_type = get_tensor_type(self)
        return self_type == get_tensor_type(other)

    def array(self):
        "Return a numpy array representation of Matrix"
        from numpy import zeros
        m_range = self.local_range(0);
        A = zeros((m_range[1] - m_range[0], self.size(1)))
        for i, row in enumerate(xrange(*m_range)):
            column, values = self.getrow(row)
            A[i, column] = values
        return A

    def data(self, deepcopy=True):
        """
        Return arrays to underlaying compresssed row/column storage data

        This method is only available for the uBLAS and MTL4 linear algebra
        backends.

        *Arguments*
            deepcopy
                Return a copy of the data. If set to False a reference
                to the Matrix need to be kept, otherwise the data will be
                destroyed together with the destruction of the Matrix
        """
        rows, cols, values = self._data()
        if deepcopy:
            rows, cols, values = rows.copy(), cols.copy(), values.copy()

        return rows, cols, values

    # FIXME: Getting matrix entries need to be carefully examined, especially for
    #        parallel objects.
    """
    def __getitem__(self,indices):
        from numpy import ndarray
        from types import SliceType
        if not (isinstance(indices, tuple) and len(indices) == 2):
            raise TypeError, "expected two indices"
        if not all(isinstance(ind, (int, SliceType, list, ndarray)) for ind in indices):
            raise TypeError, "an int, slice, list or numpy array as indices"

        if isinstance(indices[0], int):
            if isinstance(indices[1], int):
                return _get_matrix_single_item(self,indices[0],indices[1])
            return down_cast(_get_matrix_sub_vector(self,indices[0], indices[1], True))
        elif isinstance(indices[1],int):
            return down_cast(_get_matrix_sub_vector(self,indices[1], indices[0], False))
        else:
            same_indices = id(indices[0]) == id(indices[1])

            if not same_indices and ( type(indices[0]) == type(indices[1]) ):
                if isinstance(indices[0],(list,SliceType)):
                    same_indices = indices[0] == indices[1]
                else:
                    same_indices = (indices[0] == indices[1]).all()

            if same_indices:
                return down_cast(_get_matrix_sub_matrix(self, indices[0], None))
            else:
                return down_cast(_get_matrix_sub_matrix(self, indices[0], indices[1]))

    def __setitem__(self, indices, values):
        from numpy import ndarray, isscalar
        from types import SliceType
        if not (isinstance(indices, tuple) and len(indices) == 2):
            raise TypeError, "expected two indices"
        if not all(isinstance(ind, (int, SliceType, list, ndarray)) for ind in indices):
            raise TypeError, "an int, slice, list or numpy array as indices"

        if isinstance(indices[0], int):
            if isinstance(indices[1], int):
                if not isscalar(values):
                    raise TypeError, "expected scalar for single value assigment"
                _set_matrix_single_item(self, indices[0], indices[1], values)
            else:
                raise NotImplementedError
                if isinstance(values,GenericVector):
                    _set_matrix_items_vector(self, indices[0], indices[1], values, True)
                elif isinstance(values,ndarray):
                    _set_matrix_items_array_of_float(self, indices[0], indices[1], values, True)
                else:
                    raise TypeError, "expected a GenericVector or numpy array of float"
        elif isinstance(indices[1], int):
            raise NotImplementedError
            if isinstance(values, GenericVector):
                _set_matrix_items_vector(self, indices[1], indices[0], values, False)
            elif isinstance(values, ndarray):
                _set_matrix_items_array_of_float(self, indices[1], indices[0], values, False)
            else:
                raise TypeError, "expected a GenericVector or numpy array of float"

        else:
            raise NotImplementedError
            same_indices = id(indices[0]) == id(indices[1])

            if not same_indices and ( type(indices[0]) == type(indices[1]) ):
                if isinstance(indices[0], (list, SliceType)):
                    same_indices = indices[0] == indices[1]
                else:
                    same_indices = (indices[0] == indices[1]).all()

            if same_indices:
                if isinstance(values,GenericMatrix):
                    _set_matrix_items_matrix(self, indices[0], None, values)
                elif isinstance(values, ndarray) and len(values.shape)==2:
                    _set_matrix_items_array_of_float(self, indices[0], None, values)
                else:
                    raise TypeError, "expected a GenericMatrix or 2D numpy array of float"
            else:
                if isinstance(values,GenericMatrix):
                    _set_matrix_items_matrix(self, indices[0], indices[1], values)
                elif isinstance(values,ndarray) and len(values.shape) == 2:
                    _set_matrix_items_array_of_float(self, indices[0], indices[1], values)
                else:
                    raise TypeError, "expected a GenericMatrix or 2D numpy array of float"
    """

    def __add__(self,other):
        """x.__add__(y) <==> x+y"""
        if self.__is_compatible(other):
            ret = self.copy()
            ret.axpy(1.0, other, False)
            return ret
        return NotImplemented

    def __sub__(self,other):
        """x.__sub__(y) <==> x-y"""
        if self.__is_compatible(other):
            ret = self.copy()
            ret.axpy(-1.0, other, False)
            return ret
        return NotImplemented

    def __mul__(self,other):
        """x.__mul__(y) <==> x*y"""
        from numpy import ndarray, isscalar
        if isscalar(other):
            ret = self.copy()
            ret._scale(other)
            return ret
        elif isinstance(other,GenericVector):
            matrix_type = get_tensor_type(self)
            vector_type = get_tensor_type(other)
            if vector_type not in _matrix_vector_mul_map[matrix_type]:
                raise TypeError, "Provide a Vector which can be down_casted to ''"%vector_type.__name__
            if type(other) == Vector:
                ret = Vector(self.size(0))
            else:
                ret = vector_type(self.size(0))
            self.mult(other, ret)
            return ret
        elif isinstance(other, ndarray):
            if len(other.shape) != 1:
                raise ValueError, "Provide an 1D NumPy array"
            vec_size = other.shape[0]
            if vec_size != self.size(1):
                raise ValueError, "Provide a NumPy array with length %d"%self.size(1)
            vec_type = _matrix_vector_mul_map[get_tensor_type(self)][0]
            vec  = vec_type(vec_size)
            vec.set_local(other)
            result_vec = vec.copy()
            self.mult(vec, result_vec)
            ret = other.copy()
            result_vec.get_local(ret)
            return ret
        return NotImplemented

    def __div__(self,other):
        """x.__div__(y) <==> x/y"""
        from numpy import isscalar
        if isscalar(other):
            ret = self.copy()
            ret._scale(1.0/other)
            return ret
        return NotImplemented

    def __radd__(self,other):
        """x.__radd__(y) <==> y+x"""
        return self.__add__(other)

    def __rsub__(self,other):
        """x.__rsub__(y) <==> y-x"""
        return self.__sub__(other)

    def __rmul__(self,other):
        """x.__rmul__(y) <==> y*x"""
        from numpy import isscalar
        if isscalar(other):
            ret = self.copy()
            ret._scale(other)
            return ret
        return NotImplemented

    def __rdiv__(self,other):
        """x.__rdiv__(y) <==> y/x"""
        return NotImplemented

    def __iadd__(self,other):
        """x.__iadd__(y) <==> x+y"""
        if self.__is_compatible(other):
            self.axpy(1.0, other, False)
            return self
        return NotImplemented

    def __isub__(self,other):
        """x.__isub__(y) <==> x-y"""
        if self.__is_compatible(other):
            self.axpy(-1.0, other, False)
            return self
        return NotImplemented

    def __imul__(self,other):
        """x.__imul__(y) <==> x*y"""
        from numpy import isscalar
        if isscalar(other):
            self._scale(other)
            return self
        return NotImplemented

    def __idiv__(self,other):
        """x.__idiv__(y) <==> x/y"""
        from numpy import isscalar
        if isscalar(other):
            self._scale(1.0 / other)
            return self
        return NotImplemented


GenericMatrix.copy = new_instancemethod(_cpp.GenericMatrix_copy,None,GenericMatrix)
GenericMatrix.resize = new_instancemethod(_cpp.GenericMatrix_resize,None,GenericMatrix)
GenericMatrix.get = new_instancemethod(_cpp.GenericMatrix_get,None,GenericMatrix)
GenericMatrix.set = new_instancemethod(_cpp.GenericMatrix_set,None,GenericMatrix)
GenericMatrix.add = new_instancemethod(_cpp.GenericMatrix_add,None,GenericMatrix)
GenericMatrix.axpy = new_instancemethod(_cpp.GenericMatrix_axpy,None,GenericMatrix)
GenericMatrix.norm = new_instancemethod(_cpp.GenericMatrix_norm,None,GenericMatrix)
GenericMatrix.getrow = new_instancemethod(_cpp.GenericMatrix_getrow,None,GenericMatrix)
GenericMatrix.setrow = new_instancemethod(_cpp.GenericMatrix_setrow,None,GenericMatrix)
GenericMatrix.zero = new_instancemethod(_cpp.GenericMatrix_zero,None,GenericMatrix)
GenericMatrix.ident = new_instancemethod(_cpp.GenericMatrix_ident,None,GenericMatrix)
GenericMatrix.mult = new_instancemethod(_cpp.GenericMatrix_mult,None,GenericMatrix)
GenericMatrix.transpmult = new_instancemethod(_cpp.GenericMatrix_transpmult,None,GenericMatrix)
GenericMatrix.assign = new_instancemethod(_cpp.GenericMatrix_assign,None,GenericMatrix)
GenericMatrix.ident_zeros = new_instancemethod(_cpp.GenericMatrix_ident_zeros,None,GenericMatrix)
GenericMatrix._scale = new_instancemethod(_cpp.GenericMatrix__scale,None,GenericMatrix)
GenericMatrix._data = new_instancemethod(_cpp.GenericMatrix__data,None,GenericMatrix)
GenericMatrix_swigregister = _cpp.GenericMatrix_swigregister
GenericMatrix_swigregister(GenericMatrix)

class GenericSparsityPattern(Variable):
    """
    Base class (interface) for generic tensor sparsity patterns.
    Currently, this interface is mostly limited to matrices.

    """
    thisown = _swig_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
    sorted = _cpp.GenericSparsityPattern_sorted
    unsorted = _cpp.GenericSparsityPattern_unsorted
    __swig_destroy__ = _cpp.delete_GenericSparsityPattern
    def init(self, *args):
        """
        Initialize sparsity pattern for a generic tensor

        """
        return _cpp.GenericSparsityPattern_init(self, *args)

    def insert(self, *args):
        """
        Insert non-zero entries

        """
        return _cpp.GenericSparsityPattern_insert(self, *args)

    def rank(self, *args):
        """
        Return rank

        """
        return _cpp.GenericSparsityPattern_rank(self, *args)

    def size(self, *args):
        """
        Return global size for dimension i

        """
        return _cpp.GenericSparsityPattern_size(self, *args)

    def local_range(self, *args):
        """
        Return local range for dimension dim

        """
        return _cpp.GenericSparsityPattern_local_range(self, *args)

    def num_nonzeros(self, *args):
        """
        Return total number of nonzeros in local_range for dimension 0

        """
        return _cpp.GenericSparsityPattern_num_nonzeros(self, *args)

    def num_nonzeros_diagonal(self, *args):
        """
        Fill vector with number of nonzeros for diagonal block in local_range for dimension 0

        """
        return _cpp.GenericSparsityPattern_num_nonzeros_diagonal(self, *args)

    def num_nonzeros_off_diagonal(self, *args):
        """
        Fill vector with number of nonzeros for off-diagonal block in local_range for dimension 0

        """
        return _cpp.GenericSparsityPattern_num_nonzeros_off_diagonal(self, *args)

    def diagonal_pattern(self, *args):
        """
        Return underlying sparsity pattern (diagonal). Options are
        'sorted' and 'unsorted'.

        """
        return _cpp.GenericSparsityPattern_diagonal_pattern(self, *args)

    def off_diagonal_pattern(self, *args):
        """
        Return underlying sparsity pattern (off-diagional). Options are
        'sorted' and 'unsorted'.

        """
        return _cpp.GenericSparsityPattern_off_diagonal_pattern(self, *args)

    def apply(self, *args):
        """
        Finalize sparsity pattern

        """
        return _cpp.GenericSparsityPattern_apply(self, *args)

GenericSparsityPattern.init = new_instancemethod(_cpp.GenericSparsityPattern_init,None,GenericSparsityPattern)
GenericSparsityPattern.insert = new_instancemethod(_cpp.GenericSparsityPattern_insert,None,GenericSparsityPattern)
GenericSparsityPattern.rank = new_instancemethod(_cpp.GenericSparsityPattern_rank,None,GenericSparsityPattern)
GenericSparsityPattern.size = new_instancemethod(_cpp.GenericSparsityPattern_size,None,GenericSparsityPattern)
GenericSparsityPattern.local_range = new_instancemethod(_cpp.GenericSparsityPattern_local_range,None,GenericSparsityPattern)
GenericSparsityPattern.num_nonzeros = new_instancemethod(_cpp.GenericSparsityPattern_num_nonzeros,None,GenericSparsityPattern)
GenericSparsityPattern.num_nonzeros_diagonal = new_instancemethod(_cpp.GenericSparsityPattern_num_nonzeros_diagonal,None,GenericSparsityPattern)
GenericSparsityPattern.num_nonzeros_off_diagonal = new_instancemethod(_cpp.GenericSparsityPattern_num_nonzeros_off_diagonal,None,GenericSparsityPattern)
GenericSparsityPattern.diagonal_pattern = new_instancemethod(_cpp.GenericSparsityPattern_diagonal_pattern,None,GenericSparsityPattern)
GenericSparsityPattern.off_diagonal_pattern = new_instancemethod(_cpp.GenericSparsityPattern_off_diagonal_pattern,None,GenericSparsityPattern)
GenericSparsityPattern.apply = new_instancemethod(_cpp.GenericSparsityPattern_apply,None,GenericSparsityPattern)
GenericSparsityPattern_swigregister = _cpp.GenericSparsityPattern_swigregister
GenericSparsityPattern_swigregister(GenericSparsityPattern)

class GenericVector(GenericTensor):
    """
    This class defines a common interface for vectors.

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_GenericVector
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.GenericVector_copy(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (rank, dims)

          Resize tensor with given dimensions

        * resize\ (N)

          Resize vector to global size N

        * resize\ (range)

          Resize vector with given ownership range

        * resize\ (range, ghost_indices)

          Resize vector with given ownership range and with ghost values

        """
        return _cpp.GenericVector_resize(self, *args)

    def size(self, *args):
        """
        **Overloaded versions**

        * size\ (dim)

          Return size of given dimension

        * size\ ()

          Return global size of vector

        """
        return _cpp.GenericVector_size(self, *args)

    def local_size(self, *args):
        """
        Return local size of vector

        """
        return _cpp.GenericVector_local_size(self, *args)

    def local_range(self, *args):
        """
        **Overloaded versions**

        * local_range\ (dim)

          Return local ownership range

        * local_range\ ()

          Return local ownership range of a vector

        """
        return _cpp.GenericVector_local_range(self, *args)

    def owns_index(self, *args):
        """
        Determine whether global vector index is owned by this process

        """
        return _cpp.GenericVector_owns_index(self, *args)

    def add(self, *args):
        """
        **Overloaded versions**

        * add\ (block, num_rows, rows)

          Add block of values

        * add\ (block, rows)

          Add block of values

        * add\ (block, rows)

          Add block of values

        * add\ (block, m, rows)

          Add block of values

        """
        return _cpp.GenericVector_add(self, *args)

    def get_local(self, *args):
        """
        **Overloaded versions**

        * get_local\ (block, m, rows)

          Get block of values (values must all live on the local process)

        * get_local\ (values)

          Get all values on local process

        """
        return _cpp.GenericVector_get_local(self, *args)

    def set_local(self, *args):
        """
        Set all values on local process

        """
        return _cpp.GenericVector_set_local(self, *args)

    def add_local(self, *args):
        """
        Add values to each entry on local process

        """
        return _cpp.GenericVector_add_local(self, *args)

    def gather(self, *args):
        """
        **Overloaded versions**

        * gather\ (x, indices)

          Gather entries into local vector x

        * gather\ (x, indices)

          Gather entries into Array x

        """
        return _cpp.GenericVector_gather(self, *args)

    def gather_on_zero(self, *args):
        """
        Gather all entries into Array x on process 0

        """
        return _cpp.GenericVector_gather_on_zero(self, *args)

    def axpy(self, *args):
        """
        Add multiple of given vector (AXPY operation)

        """
        return _cpp.GenericVector_axpy(self, *args)

    def abs(self, *args):
        """
        Replace all entries in the vector by their absolute values

        """
        return _cpp.GenericVector_abs(self, *args)

    def inner(self, *args):
        """
        Return inner product with given vector

        """
        return _cpp.GenericVector_inner(self, *args)

    def norm(self, *args):
        """
        Return norm of vector

        """
        return _cpp.GenericVector_norm(self, *args)

    def min(self, *args):
        """
        Return minimum value of vector

        """
        return _cpp.GenericVector_min(self, *args)

    def max(self, *args):
        """
        Return maximum value of vector

        """
        return _cpp.GenericVector_max(self, *args)

    def sum(self, *args):
        """
        **Overloaded versions**

        * sum\ ()

          Return sum of vector

        * sum\ (rows)

          Return sum of selected rows in vector. Repeated entries are only summed once.

        """
        return _cpp.GenericVector_sum(self, *args)

    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (x)

          Assignment operator

        * operator=\ (a)

          Assignment operator

        """
        return _cpp.GenericVector__assign(self, *args)

    def update_ghost_values(self, *args):
        """
        Update ghost values

        """
        return _cpp.GenericVector_update_ghost_values(self, *args)

    def _scale(self, *args):
        """Missing docstring"""
        return _cpp.GenericVector__scale(self, *args)

    def _vec_mul(self, *args):
        """Missing docstring"""
        return _cpp.GenericVector__vec_mul(self, *args)

    def __in_parallel(self):
        first, last = self.local_range()
        return first > 0 or len(self) > last

    def __is_compatible(self, other):
        "Returns True if self, and other are compatible Vectors"
        if not isinstance(other, GenericVector):
            return False
        self_type = get_tensor_type(self)
        return self_type == get_tensor_type(other)

    def array(self):
        "Return a numpy array representation of the local part of a Vector"
        from numpy import zeros, arange, uint0
        v = zeros(self.local_size())
        self.get_local(v)
        return v

    def __contains__(self, value):
        from numpy import isscalar
        if not isscalar(value):
            raise TypeError, "expected scalar"
        return _contains(self,value)

    def __gt__(self, value):
        from numpy import isscalar
        if isscalar(value):
            return _compare_vector_with_value(self, value, dolfin_gt)
        if isinstance(value, GenericVector):
            return _compare_vector_with_vector(self, value, dolfin_gt)
        return NotImplemented

    def __ge__(self,value):
        from numpy import isscalar
        if isscalar(value):
            return _compare_vector_with_value(self, value, dolfin_ge)
        if isinstance(value, GenericVector):
            return _compare_vector_with_vector(self, value, dolfin_ge)
        return NotImplemented

    def __lt__(self,value):
        from numpy import isscalar
        if isscalar(value):
            return _compare_vector_with_value(self, value, dolfin_lt)
        if isinstance(value, GenericVector):
            return _compare_vector_with_vector(self, value, dolfin_lt)
        return NotImplemented

    def __le__(self,value):
        from numpy import isscalar
        if isscalar(value):
            return _compare_vector_with_value(self, value, dolfin_le)
        if isinstance(value, GenericVector):
            return _compare_vector_with_vector(self, value, dolfin_le)
        return NotImplemented

    def __eq__(self,value):
        from numpy import isscalar
        if isscalar(value):
            return _compare_vector_with_value(self, value, dolfin_eq)
        if isinstance(value, GenericVector):
            return _compare_vector_with_vector(self, value, dolfin_eq)
        return NotImplemented

    def __neq__(self,value):
        from numpy import isscalar
        if isscalar(value):
            return _compare_vector_with_value(self, value, dolfin_neq)
        if isinstance(value, GenericVector):
            return _compare_vector_with_vector(self, value, dolfin_neq)
        return NotImplemented

    def __neg__(self):
        ret = self.copy()
        ret *= -1
        return ret

    def __delitem__(self,i):
        raise ValueError, "cannot delete Vector elements"

    def __delslice__(self,i,j):
        raise ValueError, "cannot delete Vector elements"

    def __setslice__(self, i, j, values):
        if i == 0 and (j >= len(self) or j == -1): # slice == whole
            from numpy import isscalar
            # No test for equal lengths because this is checked by DOLFIN in _assign
            if isinstance(values, GenericVector) or isscalar(values):
                self._assign(values)
                return
        self.__setitem__(slice(i, j, 1), values)

    def __getslice__(self, i, j):
        if i == 0 and (j >= len(self) or j == -1):
            return self.copy()
        return self.__getitem__(slice(i, j, 1))

    def __getitem__(self, indices):
        from numpy import ndarray, integer
        from types import SliceType
        if isinstance(indices, (int, integer)):
            return _get_vector_single_item(self, indices)
        elif isinstance(indices, (SliceType, ndarray, list) ):
            return down_cast(_get_vector_sub_vector(self, indices))
        else:
            raise TypeError, "expected an int, slice, list or numpy array of integers"

    def __setitem__(self, indices, values):
        from numpy import ndarray, integer, isscalar
        from types import SliceType
        if isinstance(indices, (int, integer)):
            if isscalar(values):
                return _set_vector_items_value(self, indices, values)
            else:
                raise TypeError, "provide a scalar to set single item"
        elif isinstance(indices, (SliceType, ndarray, list)):
            if isscalar(values):
                _set_vector_items_value(self, indices, values)
            elif isinstance(values, GenericVector):
                _set_vector_items_vector(self, indices, values)
            elif isinstance(values, ndarray):
                _set_vector_items_array_of_float(self, indices, values)
            else:
                raise TypeError, "provide a scalar, GenericVector or numpy array of float to set items in Vector"
        else:
            raise TypeError, "index must be an int, slice or a list or numpy array of integers"

    def __len__(self):
        return self.size()

    def __iter__(self):
        for i in xrange(self.size()):
            yield _get_vector_single_item(self, i)

    def __add__(self, other):
        """x.__add__(y) <==> x+y"""
        if self.__is_compatible(other):
            ret = self.copy()
            ret.axpy(1.0, other)
            return ret
        return NotImplemented

    def __sub__(self,other):
        """x.__sub__(y) <==> x-y"""
        if self.__is_compatible(other):
            ret = self.copy()
            ret.axpy(-1.0, other)
            return ret
        return NotImplemented

    def __mul__(self,other):
        """x.__mul__(y) <==> x*y"""
        from numpy import isscalar
        if isscalar(other):
            ret = self.copy()
            ret._scale(other)
            return ret
        if isinstance(other,GenericVector):
            ret = self.copy()
            ret._vec_mul(other)
            return ret
        return NotImplemented

    def __div__(self,other):
        """x.__div__(y) <==> x/y"""
        from numpy import isscalar
        if isscalar(other):
            ret = self.copy()
            ret._scale(1.0 / other)
            return ret
        return NotImplemented

    def __radd__(self,other):
        """x.__radd__(y) <==> y+x"""
        return self.__add__(other)

    def __rsub__(self, other):
        """x.__rsub__(y) <==> y-x"""
        return self.__sub__(other)

    def __rmul__(self, other):
        """x.__rmul__(y) <==> y*x"""
        from numpy import isscalar
        if isscalar(other):
            ret = self.copy()
            ret._scale(other)
            return ret
        return NotImplemented

    def __rdiv__(self, other):
        """x.__rdiv__(y) <==> y/x"""
        return NotImplemented

    def __iadd__(self, other):
        """x.__iadd__(y) <==> x+y"""
        if self.__is_compatible(other):
            self.axpy(1.0, other)
            return self
        return NotImplemented

    def __isub__(self, other):
        """x.__isub__(y) <==> x-y"""
        if self.__is_compatible(other):
            self.axpy(-1.0, other)
            return self
        return NotImplemented

    def __imul__(self, other):
        """x.__imul__(y) <==> x*y"""
        from numpy import isscalar
        if isscalar(other):
            self._scale(other)
            return self
        if isinstance(other, GenericVector):
            self._vec_mul(other)
            return self
        return NotImplemented

    def __idiv__(self, other):
        """x.__idiv__(y) <==> x/y"""
        from numpy import isscalar
        if isscalar(other):
            self._scale(1.0 / other)
            return self
        return NotImplemented


GenericVector.copy = new_instancemethod(_cpp.GenericVector_copy,None,GenericVector)
GenericVector.resize = new_instancemethod(_cpp.GenericVector_resize,None,GenericVector)
GenericVector.size = new_instancemethod(_cpp.GenericVector_size,None,GenericVector)
GenericVector.local_size = new_instancemethod(_cpp.GenericVector_local_size,None,GenericVector)
GenericVector.local_range = new_instancemethod(_cpp.GenericVector_local_range,None,GenericVector)
GenericVector.owns_index = new_instancemethod(_cpp.GenericVector_owns_index,None,GenericVector)
GenericVector.add = new_instancemethod(_cpp.GenericVector_add,None,GenericVector)
GenericVector.get_local = new_instancemethod(_cpp.GenericVector_get_local,None,GenericVector)
GenericVector.set_local = new_instancemethod(_cpp.GenericVector_set_local,None,GenericVector)
GenericVector.add_local = new_instancemethod(_cpp.GenericVector_add_local,None,GenericVector)
GenericVector.gather = new_instancemethod(_cpp.GenericVector_gather,None,GenericVector)
GenericVector.gather_on_zero = new_instancemethod(_cpp.GenericVector_gather_on_zero,None,GenericVector)
GenericVector.axpy = new_instancemethod(_cpp.GenericVector_axpy,None,GenericVector)
GenericVector.abs = new_instancemethod(_cpp.GenericVector_abs,None,GenericVector)
GenericVector.inner = new_instancemethod(_cpp.GenericVector_inner,None,GenericVector)
GenericVector.norm = new_instancemethod(_cpp.GenericVector_norm,None,GenericVector)
GenericVector.min = new_instancemethod(_cpp.GenericVector_min,None,GenericVector)
GenericVector.max = new_instancemethod(_cpp.GenericVector_max,None,GenericVector)
GenericVector.sum = new_instancemethod(_cpp.GenericVector_sum,None,GenericVector)
GenericVector._assign = new_instancemethod(_cpp.GenericVector__assign,None,GenericVector)
GenericVector.update_ghost_values = new_instancemethod(_cpp.GenericVector_update_ghost_values,None,GenericVector)
GenericVector._scale = new_instancemethod(_cpp.GenericVector__scale,None,GenericVector)
GenericVector._vec_mul = new_instancemethod(_cpp.GenericVector__vec_mul,None,GenericVector)
GenericVector_swigregister = _cpp.GenericVector_swigregister
GenericVector_swigregister(GenericVector)

class PETScObject(object):
    """
    This class calls SubSystemsManager to initialise PETSc.

    All PETSc objects must be derived from this class.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.PETScObject_swiginit(self,_cpp.new_PETScObject(*args))
    __swig_destroy__ = _cpp.delete_PETScObject
PETScObject_swigregister = _cpp.PETScObject_swigregister
PETScObject_swigregister(PETScObject)

class PETScMatrixDeleter(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.PETScMatrixDeleter_swiginit(self,_cpp.new_PETScMatrixDeleter(*args))
    __swig_destroy__ = _cpp.delete_PETScMatrixDeleter
PETScMatrixDeleter.__call__ = new_instancemethod(_cpp.PETScMatrixDeleter___call__,None,PETScMatrixDeleter)
PETScMatrixDeleter_swigregister = _cpp.PETScMatrixDeleter_swigregister
PETScMatrixDeleter_swigregister(PETScMatrixDeleter)

class PETScBaseMatrix(PETScObject,Variable):
    """
    This class is a base class for matrices that can be used in
    PETScKrylovSolver.

    """
    thisown = _swig_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 size(self, *args):
        """
        Return number of rows (dim = 0) or columns (dim = 1)

        """
        return _cpp.PETScBaseMatrix_size(self, *args)

    def local_range(self, *args):
        """
        Return local range along dimension dim

        """
        return _cpp.PETScBaseMatrix_local_range(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (m, n)

          Resize virtual matrix

        * resize\ (y, dim)

          Resize vector y such that is it compatible with matrix for
          multuplication Ax = b (dim = 0 -> b, dim = 1 -> x) In parallel
          case, size and layout are important.

        """
        return _cpp.PETScBaseMatrix_resize(self, *args)

    def mat(self, *args):
        """
        Return PETSc Mat pointer

        """
        return _cpp.PETScBaseMatrix_mat(self, *args)

    __swig_destroy__ = _cpp.delete_PETScBaseMatrix
PETScBaseMatrix.size = new_instancemethod(_cpp.PETScBaseMatrix_size,None,PETScBaseMatrix)
PETScBaseMatrix.local_range = new_instancemethod(_cpp.PETScBaseMatrix_local_range,None,PETScBaseMatrix)
PETScBaseMatrix.resize = new_instancemethod(_cpp.PETScBaseMatrix_resize,None,PETScBaseMatrix)
PETScBaseMatrix.mat = new_instancemethod(_cpp.PETScBaseMatrix_mat,None,PETScBaseMatrix)
PETScBaseMatrix_swigregister = _cpp.PETScBaseMatrix_swigregister
PETScBaseMatrix_swigregister(PETScBaseMatrix)

class uBLASKrylovMatrix(object):
    """
    This class provides an interface for matrices that define linear
    systems for the uBLASKrylovSolver. This interface is implemented
    by the classes uBLASSparseMatrix and DenseMatrix. Users may also
    overload the mult() function to specify a linear system only in
    terms of its action.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        if self.__class__ == uBLASKrylovMatrix:
            _self = None
        else:
            _self = self
        _cpp.uBLASKrylovMatrix_swiginit(self,_cpp.new_uBLASKrylovMatrix(_self, *args))
    __swig_destroy__ = _cpp.delete_uBLASKrylovMatrix
    def size(self, *args):
        """
        Return number of rows (dim = 0) or columns (dim = 1)

        """
        return _cpp.uBLASKrylovMatrix_size(self, *args)

    def mult(self, *args):
        """
        Compute product y = Ax

        """
        return _cpp.uBLASKrylovMatrix_mult(self, *args)

    def solve(self, *args):
        """
        Solve linear system Ax = b for a Krylov matrix using uBLAS and dense matrices

        """
        return _cpp.uBLASKrylovMatrix_solve(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.uBLASKrylovMatrix_str(self, *args)

    def __disown__(self):
        self.this.disown()
        _cpp.disown_uBLASKrylovMatrix(self)
        return weakref_proxy(self)
uBLASKrylovMatrix.size = new_instancemethod(_cpp.uBLASKrylovMatrix_size,None,uBLASKrylovMatrix)
uBLASKrylovMatrix.mult = new_instancemethod(_cpp.uBLASKrylovMatrix_mult,None,uBLASKrylovMatrix)
uBLASKrylovMatrix.solve = new_instancemethod(_cpp.uBLASKrylovMatrix_solve,None,uBLASKrylovMatrix)
uBLASKrylovMatrix.str = new_instancemethod(_cpp.uBLASKrylovMatrix_str,None,uBLASKrylovMatrix)
uBLASKrylovMatrix_swigregister = _cpp.uBLASKrylovMatrix_swigregister
uBLASKrylovMatrix_swigregister(uBLASKrylovMatrix)

class PETScMatrix(GenericMatrix,PETScBaseMatrix):
    """
    This class provides a simple matrix class based on PETSc.
    It is a wrapper for a PETSc matrix pointer (Mat)
    implementing the GenericMatrix interface.

    The interface is intentionally simple. For advanced usage,
    access the PETSc Mat pointer using the function mat() and
    use the standard PETSc interface.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * PETScMatrix\ ()

          Create empty matrix

        * PETScMatrix\ (A)

          Copy constructor

        * PETScMatrix\ (A)

          Create matrix from given PETSc Mat pointer

        """
        _cpp.PETScMatrix_swiginit(self,_cpp.new_PETScMatrix(*args))
    __swig_destroy__ = _cpp.delete_PETScMatrix
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.PETScMatrix_copy(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (M, N)

          Resize matrix to M x N

        * resize\ (y, dim)

          Resize vector y such that is it compatible with matrix for
          multuplication Ax = b (dim = 0 -> b, dim = 1 -> x) In parallel
          case, size and layout are important.

        """
        return _cpp.PETScMatrix_resize(self, *args)

    def zero(self, *args):
        """
        **Overloaded versions**

        * zero\ ()

          Set all entries to zero and keep any sparse structure

        * zero\ (m, rows)

          Set given rows to zero

        """
        return _cpp.PETScMatrix_zero(self, *args)

    def assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (A)

          Assignment operator

        * operator=\ (A)

          Assignment operator

        """
        return _cpp.PETScMatrix_assign(self, *args)

    def binary_dump(self, *args):
        """
        Dump matrix to PETSc binary format

        """
        return _cpp.PETScMatrix_binary_dump(self, *args)

PETScMatrix.copy = new_instancemethod(_cpp.PETScMatrix_copy,None,PETScMatrix)
PETScMatrix.resize = new_instancemethod(_cpp.PETScMatrix_resize,None,PETScMatrix)
PETScMatrix.zero = new_instancemethod(_cpp.PETScMatrix_zero,None,PETScMatrix)
PETScMatrix.assign = new_instancemethod(_cpp.PETScMatrix_assign,None,PETScMatrix)
PETScMatrix.binary_dump = new_instancemethod(_cpp.PETScMatrix_binary_dump,None,PETScMatrix)
PETScMatrix_swigregister = _cpp.PETScMatrix_swigregister
PETScMatrix_swigregister(PETScMatrix)

class PETScKrylovMatrix(PETScBaseMatrix):
    """
    This class represents a matrix-free matrix of dimension m x m.
    It is a simple wrapper for a PETSc shell matrix. The interface
    is intentionally simple. For advanced usage, access the PETSc
    Mat pointer using the function mat() and use the standard PETSc
    interface.

    The class PETScKrylovMatrix enables the use of Krylov subspace
    methods for linear systems Ax = b, without having to explicitly
    store the matrix A. All that is needed is that the user-defined
    PETScKrylovMatrix implements multiplication with vectors. Note that
    the multiplication operator needs to be defined in terms of
    PETSc data structures (Vec), since it will be called from PETSc.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * PETScKrylovMatrix\ ()

          Constructor

        * PETScKrylovMatrix\ (m, n)

          Create a virtual matrix matching the given vectors

        """
        if self.__class__ == PETScKrylovMatrix:
            _self = None
        else:
            _self = self
        _cpp.PETScKrylovMatrix_swiginit(self,_cpp.new_PETScKrylovMatrix(_self, *args))
    __swig_destroy__ = _cpp.delete_PETScKrylovMatrix
    def resize(self, *args):
        """
        Resize virtual matrix

        """
        return _cpp.PETScKrylovMatrix_resize(self, *args)

    def mult(self, *args):
        """
        Compute product y = Ax

        """
        return _cpp.PETScKrylovMatrix_mult(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.PETScKrylovMatrix_str(self, *args)

    def __disown__(self):
        self.this.disown()
        _cpp.disown_PETScKrylovMatrix(self)
        return weakref_proxy(self)
PETScKrylovMatrix.resize = new_instancemethod(_cpp.PETScKrylovMatrix_resize,None,PETScKrylovMatrix)
PETScKrylovMatrix.mult = new_instancemethod(_cpp.PETScKrylovMatrix_mult,None,PETScKrylovMatrix)
PETScKrylovMatrix.str = new_instancemethod(_cpp.PETScKrylovMatrix_str,None,PETScKrylovMatrix)
PETScKrylovMatrix_swigregister = _cpp.PETScKrylovMatrix_swigregister
PETScKrylovMatrix_swigregister(PETScKrylovMatrix)

class PETScPreconditioner(PETScObject,Variable):
    """
    This class is a wrapper for configuring PETSc preconditioners. It does
    not own a preconditioner. It can take a PETScKrylovSolver and set the
    preconditioner type and parameters.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create a particular preconditioner object

        """
        _cpp.PETScPreconditioner_swiginit(self,_cpp.new_PETScPreconditioner(*args))
    __swig_destroy__ = _cpp.delete_PETScPreconditioner
    def set(self, *args):
        """
        Set the precondtioner type and parameters

        """
        return _cpp.PETScPreconditioner_set(self, *args)

    preconditioners = staticmethod(_cpp.PETScPreconditioner_preconditioners)
    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.PETScPreconditioner_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
PETScPreconditioner.set = new_instancemethod(_cpp.PETScPreconditioner_set,None,PETScPreconditioner)
PETScPreconditioner_swigregister = _cpp.PETScPreconditioner_swigregister
PETScPreconditioner_swigregister(PETScPreconditioner)

def PETScPreconditioner_preconditioners(*args):
  return _cpp.PETScPreconditioner_preconditioners(*args)
PETScPreconditioner_preconditioners = _cpp.PETScPreconditioner_preconditioners

def PETScPreconditioner_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.PETScPreconditioner_default_parameters(*args)

class PETScKrylovSolver(GenericLinearSolver,PETScObject):
    """
    This class implements Krylov methods for linear systems
    of the form Ax = b. It is a wrapper for the Krylov solvers
    of PETSc.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * PETScKrylovSolver\ ("default", "default")

          Create Krylov solver for a particular method and names preconditioner

        * PETScKrylovSolver\ (method, preconditioner)

          Create Krylov solver for a particular method and PETScPreconditioner

        * PETScKrylovSolver\ (method, preconditioner)

          Create Krylov solver for a particular method and PETScPreconditioner

        * PETScKrylovSolver\ (ksp)

          Create solver from given PETSc KSP pointer

        """
        _cpp.PETScKrylovSolver_swiginit(self,_cpp.new_PETScKrylovSolver(*args))
    __swig_destroy__ = _cpp.delete_PETScKrylovSolver
    def set_operator(self, *args):
        """
        **Overloaded versions**

        * set_operator\ (A)

          Set operator (matrix)

        * set_operator\ (A)

          Set operator (matrix)

        """
        return _cpp.PETScKrylovSolver_set_operator(self, *args)

    def set_operators(self, *args):
        """
        **Overloaded versions**

        * set_operators\ (A, P)

          Set operator (matrix) and preconditioner matrix

        * set_operators\ (A, P)

          Set operator (matrix) and preconditioner matrix

        """
        return _cpp.PETScKrylovSolver_set_operators(self, *args)

    def get_operator(self, *args):
        """
        Get operator (matrix)

        """
        return _cpp.PETScKrylovSolver_get_operator(self, *args)

    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (x, b)

          Solve linear system Ax = b and return number of iterations

        * solve\ (x, b)

          Solve linear system Ax = b and return number of iterations

        * solve\ (A, x, b)

          Solve linear system Ax = b and return number of iterations

        * solve\ (A, x, b)

          Solve linear system Ax = b and return number of iterations

        """
        return _cpp.PETScKrylovSolver_solve(self, *args)

    def ksp(self, *args):
        """
        Return PETSc KSP pointer

        """
        return _cpp.PETScKrylovSolver_ksp(self, *args)

    def methods(*args):
        """
        Return a list of available solver methods

        """
        return _cpp.PETScKrylovSolver_methods(*args)

    methods = staticmethod(methods)
    def preconditioners(*args):
        """
        Return a list of available preconditioners

        """
        return _cpp.PETScKrylovSolver_preconditioners(*args)

    preconditioners = staticmethod(preconditioners)
    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.PETScKrylovSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
PETScKrylovSolver.set_operator = new_instancemethod(_cpp.PETScKrylovSolver_set_operator,None,PETScKrylovSolver)
PETScKrylovSolver.set_operators = new_instancemethod(_cpp.PETScKrylovSolver_set_operators,None,PETScKrylovSolver)
PETScKrylovSolver.get_operator = new_instancemethod(_cpp.PETScKrylovSolver_get_operator,None,PETScKrylovSolver)
PETScKrylovSolver.solve = new_instancemethod(_cpp.PETScKrylovSolver_solve,None,PETScKrylovSolver)
PETScKrylovSolver.ksp = new_instancemethod(_cpp.PETScKrylovSolver_ksp,None,PETScKrylovSolver)
PETScKrylovSolver_swigregister = _cpp.PETScKrylovSolver_swigregister
PETScKrylovSolver_swigregister(PETScKrylovSolver)

def PETScKrylovSolver_methods(*args):
  """
    Return a list of available solver methods

    """
  return _cpp.PETScKrylovSolver_methods(*args)

def PETScKrylovSolver_preconditioners(*args):
  """
    Return a list of available preconditioners

    """
  return _cpp.PETScKrylovSolver_preconditioners(*args)

def PETScKrylovSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.PETScKrylovSolver_default_parameters(*args)

class PETScLUSolver(GenericLUSolver,PETScObject):
    """
    This class implements the direct solution (LU factorization) for
    linear systems of the form Ax = b. It is a wrapper for the LU
    solver of PETSc.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * PETScLUSolver\ (method="default")

          Constructor

        * PETScLUSolver\ (A, method="default")

          Constructor

        """
        _cpp.PETScLUSolver_swiginit(self,_cpp.new_PETScLUSolver(*args))
    __swig_destroy__ = _cpp.delete_PETScLUSolver
    def set_operator(self, *args):
        """
        **Overloaded versions**

        * set_operator\ (A)

          Set operator (matrix)

        * set_operator\ (A)

          Set operator (matrix)

        """
        return _cpp.PETScLUSolver_set_operator(self, *args)

    def get_operator(self, *args):
        """
        Get operator (matrix)

        """
        return _cpp.PETScLUSolver_get_operator(self, *args)

    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (x, b)

          Solve linear system Ax = b

        * solve\ (A, x, b)

          Solve linear system Ax = b

        * solve\ (A, x, b)

          Solve linear system Ax = b

        """
        return _cpp.PETScLUSolver_solve(self, *args)

    def ksp(self, *args):
        """
        Return PETSc KSP pointer

        """
        return _cpp.PETScLUSolver_ksp(self, *args)

    def methods(*args):
        """
        Return a list of available solver methods

        """
        return _cpp.PETScLUSolver_methods(*args)

    methods = staticmethod(methods)
    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.PETScLUSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
PETScLUSolver.set_operator = new_instancemethod(_cpp.PETScLUSolver_set_operator,None,PETScLUSolver)
PETScLUSolver.get_operator = new_instancemethod(_cpp.PETScLUSolver_get_operator,None,PETScLUSolver)
PETScLUSolver.solve = new_instancemethod(_cpp.PETScLUSolver_solve,None,PETScLUSolver)
PETScLUSolver.ksp = new_instancemethod(_cpp.PETScLUSolver_ksp,None,PETScLUSolver)
PETScLUSolver_swigregister = _cpp.PETScLUSolver_swigregister
PETScLUSolver_swigregister(PETScLUSolver)

def PETScLUSolver_methods(*args):
  """
    Return a list of available solver methods

    """
  return _cpp.PETScLUSolver_methods(*args)

def PETScLUSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.PETScLUSolver_default_parameters(*args)

class CholmodCholeskySolver(GenericLinearSolver):
    """
    This class implements the direct solution (Cholesky
    factorization) of linear systems of the form Ax = b. Sparse
    matrices are solved using CHOLMOD
    http://www.cise.ufl.edu/research/sparse/cholmod/ if installed.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * CholmodCholeskySolver\ ()

          Constructor

        * CholmodCholeskySolver\ (A)

          Constructor

        """
        _cpp.CholmodCholeskySolver_swiginit(self,_cpp.new_CholmodCholeskySolver(*args))
    __swig_destroy__ = _cpp.delete_CholmodCholeskySolver
    def factorize(self, *args):
        """
        Cholesky-factor sparse matrix A if CHOLMOD is installed

        """
        return _cpp.CholmodCholeskySolver_factorize(self, *args)

    def factorized_solve(self, *args):
        """
        Solve factorized system (CHOLMOD).

        """
        return _cpp.CholmodCholeskySolver_factorized_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.CholmodCholeskySolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
CholmodCholeskySolver.factorize = new_instancemethod(_cpp.CholmodCholeskySolver_factorize,None,CholmodCholeskySolver)
CholmodCholeskySolver.factorized_solve = new_instancemethod(_cpp.CholmodCholeskySolver_factorized_solve,None,CholmodCholeskySolver)
CholmodCholeskySolver_swigregister = _cpp.CholmodCholeskySolver_swigregister
CholmodCholeskySolver_swigregister(CholmodCholeskySolver)

def CholmodCholeskySolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.CholmodCholeskySolver_default_parameters(*args)

class UmfpackLUSolver(GenericLUSolver):
    """
    This class implements the direct solution (LU factorization) of
    linear systems of the form Ax = b using UMFPACK
    (http://www.cise.ufl.edu/research/sparse/umfpack/) if installed.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * UmfpackLUSolver\ ()

          Constructor

        * UmfpackLUSolver\ (A)

          Constructor

        """
        _cpp.UmfpackLUSolver_swiginit(self,_cpp.new_UmfpackLUSolver(*args))
    __swig_destroy__ = _cpp.delete_UmfpackLUSolver
    def get_operator(self, *args):
        """
        Return the operator (matrix)

        """
        return _cpp.UmfpackLUSolver_get_operator(self, *args)

    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (x, b)

          Solve linear system Ax = b for a sparse matrix using UMFPACK if installed

        * solve\ (A, x, b)

          Solve linear system

        """
        return _cpp.UmfpackLUSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.UmfpackLUSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
UmfpackLUSolver.get_operator = new_instancemethod(_cpp.UmfpackLUSolver_get_operator,None,UmfpackLUSolver)
UmfpackLUSolver.solve = new_instancemethod(_cpp.UmfpackLUSolver_solve,None,UmfpackLUSolver)
UmfpackLUSolver_swigregister = _cpp.UmfpackLUSolver_swigregister
UmfpackLUSolver_swigregister(UmfpackLUSolver)

def UmfpackLUSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.UmfpackLUSolver_default_parameters(*args)

class STLMatrix(GenericMatrix):
    """
    Simple STL-based implementation of the GenericMatrix interface.
    The sparse matrix is stored as a pair of std::vector of
    std::vector, one for the columns and one for the values.

    Historically, this class has undergone a number of different
    incarnations, based on various combinations of std::vector,
    std::set and std::map. The current implementation has proven to
    be the fastest.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * STLMatrix\ ()

          Create empty matrix

        * STLMatrix\ (M, N)

          Create M x N matrix

        * STLMatrix\ (A)

          Copy constructor

        """
        _cpp.STLMatrix_swiginit(self,_cpp.new_STLMatrix(*args))
    __swig_destroy__ = _cpp.delete_STLMatrix
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.STLMatrix_copy(self, *args)

    def zero(self, *args):
        """
        **Overloaded versions**

        * zero\ ()

          Set all entries to zero and keep any sparse structure

        * zero\ (m, rows)

          Set given rows to zero

        """
        return _cpp.STLMatrix_zero(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (M, N)

          Initialize M x N matrix

        * resize\ (y, dim)

          Resize vector y such that is it compatible with matrix for
          multuplication Ax = b (dim = 0 -> b, dim = 1 -> x) In parallel
          case, size and layout are important.

        * resize\ (rank, dims, reset)

          Resize tensor of given rank and dimensions

        """
        return _cpp.STLMatrix_resize(self, *args)

STLMatrix.copy = new_instancemethod(_cpp.STLMatrix_copy,None,STLMatrix)
STLMatrix.zero = new_instancemethod(_cpp.STLMatrix_zero,None,STLMatrix)
STLMatrix.resize = new_instancemethod(_cpp.STLMatrix_resize,None,STLMatrix)
STLMatrix_swigregister = _cpp.STLMatrix_swigregister
STLMatrix_swigregister(STLMatrix)

class uBLASVector(GenericVector):
    """
    This class provides a simple vector class based on uBLAS.
    It is a simple wrapper for a uBLAS vector implementing the
    GenericVector interface.

    The interface is intentionally simple. For advanced usage,
    access the underlying uBLAS vector and use the standard
    uBLAS interface which is documented at
    http://www.boost.org/libs/numeric/ublas/doc/index.htm.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * uBLASVector\ ()

          Create empty vector

        * uBLASVector\ (N)

          Create vector of size N

        * uBLASVector\ (x)

          Copy constructor

        * uBLASVector\ (x)

          Construct vector from a ublas_vector

        """
        _cpp.uBLASVector_swiginit(self,_cpp.new_uBLASVector(*args))
    __swig_destroy__ = _cpp.delete_uBLASVector
    def copy(self, *args):
        """
        Create copy of tensor

        """
        return _cpp.uBLASVector_copy(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (N)

          Resize vector to size N

        * resize\ (range)

          Resize vector with given ownership range

        * resize\ (range, ghost_indices)

          Resize vector with given ownership range and with ghost values

        """
        return _cpp.uBLASVector_resize(self, *args)

    def get_local(self, *args):
        """
        **Overloaded versions**

        * get_local\ (block, m, rows)

          Get block of values

        * get_local\ (values)

          Get all values on local process

        """
        return _cpp.uBLASVector_get_local(self, *args)

    def gather(self, *args):
        """
        **Overloaded versions**

        * gather\ (x, indices)

          Gather entries into local vector x

        * gather\ (x, indices)

          Gather entries into Array x

        """
        return _cpp.uBLASVector_gather(self, *args)

    def sum(self, *args):
        """
        **Overloaded versions**

        * sum\ ()

          Return sum of values of vector

        * sum\ (rows)

          Return sum of selected rows in vector. Repeated entries are only summed once.

        """
        return _cpp.uBLASVector_sum(self, *args)

    def vec(self, *args):
        """
        **Overloaded versions**

        * vec\ ()

          Return reference to uBLAS vector (const version)

        * vec\ ()

          Return reference to uBLAS vector (non-const version)

        """
        return _cpp.uBLASVector_vec(self, *args)

    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (x)

          Assignment operator

        * operator=\ (a)

          Assignment operator

        * operator=\ (x)

          Assignment operator

        """
        return _cpp.uBLASVector__assign(self, *args)

    def _data(self, *args):
        """Missing docstring"""
        return _cpp.uBLASVector__data(self, *args)

    def data(self, deepcopy=True):
        """
        Return an array to underlaying data

        This method is only available for the uBLAS and MTL4 linear algebra
        backends.

        *Arguments*
            deepcopy
                Return a copy of the data. If set to False a reference
                to the Matrix need to be kept, otherwise the data will be
                destroyed together with the destruction of the Matrix
        """
        ret = self._data()
        if deepcopy:
            ret = ret.copy()

        return ret

uBLASVector.copy = new_instancemethod(_cpp.uBLASVector_copy,None,uBLASVector)
uBLASVector.resize = new_instancemethod(_cpp.uBLASVector_resize,None,uBLASVector)
uBLASVector.get_local = new_instancemethod(_cpp.uBLASVector_get_local,None,uBLASVector)
uBLASVector.gather = new_instancemethod(_cpp.uBLASVector_gather,None,uBLASVector)
uBLASVector.sum = new_instancemethod(_cpp.uBLASVector_sum,None,uBLASVector)
uBLASVector.vec = new_instancemethod(_cpp.uBLASVector_vec,None,uBLASVector)
uBLASVector._assign = new_instancemethod(_cpp.uBLASVector__assign,None,uBLASVector)
uBLASVector._data = new_instancemethod(_cpp.uBLASVector__data,None,uBLASVector)
uBLASVector_swigregister = _cpp.uBLASVector_swigregister
uBLASVector_swigregister(uBLASVector)

class PETScVectorDeleter(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.PETScVectorDeleter_swiginit(self,_cpp.new_PETScVectorDeleter(*args))
    __swig_destroy__ = _cpp.delete_PETScVectorDeleter
PETScVectorDeleter.__call__ = new_instancemethod(_cpp.PETScVectorDeleter___call__,None,PETScVectorDeleter)
PETScVectorDeleter_swigregister = _cpp.PETScVectorDeleter_swigregister
PETScVectorDeleter_swigregister(PETScVectorDeleter)

class PETScVector(GenericVector,PETScObject):
    """
    This class provides a simple vector class based on PETSc.
    It is a simple wrapper for a PETSc vector pointer (Vec)
    implementing the GenericVector interface.

    The interface is intentionally simple. For advanced usage,
    access the PETSc Vec pointer using the function vec() and
    use the standard PETSc interface.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * PETScVector\ (type="global")

          Create empty vector

        * PETScVector\ (N, type="global")

          Create vector of size N

        * PETScVector\ (sparsity_pattern)

          Create vector

        * PETScVector\ (x)

          Copy constructor

        * PETScVector\ (x)

          Create vector from given PETSc Vec pointer

        """
        _cpp.PETScVector_swiginit(self,_cpp.new_PETScVector(*args))
    __swig_destroy__ = _cpp.delete_PETScVector
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.PETScVector_copy(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (N)

          Resize vector to global size N

        * resize\ (range)

          Resize vector with given ownership range

        * resize\ (range, ghost_indices)

          Resize vector with given ownership range and with ghost values

        """
        return _cpp.PETScVector_resize(self, *args)

    def get_local(self, *args):
        """
        **Overloaded versions**

        * get_local\ (block, m, rows)

          Get block of values (values must all live on the local process)

        * get_local\ (values)

          Get all values on local process

        """
        return _cpp.PETScVector_get_local(self, *args)

    def gather(self, *args):
        """
        **Overloaded versions**

        * gather\ (y, indices)

          Gather vector entries into a local vector

        * gather\ (x, indices)

          Gather entries into Array x

        """
        return _cpp.PETScVector_gather(self, *args)

    def sum(self, *args):
        """
        **Overloaded versions**

        * sum\ ()

          Return sum of values of vector

        * sum\ (rows)

          Return sum of selected rows in vector

        """
        return _cpp.PETScVector_sum(self, *args)

    def reset(self, *args):
        """
        Reset data and PETSc vector object

        """
        return _cpp.PETScVector_reset(self, *args)

    def vec(self, *args):
        """
        Return shared_ptr to PETSc Vec object

        """
        return _cpp.PETScVector_vec(self, *args)

    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (x)

          Assignment operator

        * operator=\ (a)

          Assignment operator

        * operator=\ (x)

          Assignment operator

        """
        return _cpp.PETScVector__assign(self, *args)

PETScVector.copy = new_instancemethod(_cpp.PETScVector_copy,None,PETScVector)
PETScVector.resize = new_instancemethod(_cpp.PETScVector_resize,None,PETScVector)
PETScVector.get_local = new_instancemethod(_cpp.PETScVector_get_local,None,PETScVector)
PETScVector.gather = new_instancemethod(_cpp.PETScVector_gather,None,PETScVector)
PETScVector.sum = new_instancemethod(_cpp.PETScVector_sum,None,PETScVector)
PETScVector.reset = new_instancemethod(_cpp.PETScVector_reset,None,PETScVector)
PETScVector.vec = new_instancemethod(_cpp.PETScVector_vec,None,PETScVector)
PETScVector._assign = new_instancemethod(_cpp.PETScVector__assign,None,PETScVector)
PETScVector_swigregister = _cpp.PETScVector_swigregister
PETScVector_swigregister(PETScVector)

class SparsityPattern(GenericSparsityPattern):
    """
    This class implements the GenericSparsityPattern interface.
    It is used by most linear algebra backends.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create empty sparsity pattern

        """
        _cpp.SparsityPattern_swiginit(self,_cpp.new_SparsityPattern(*args))
    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.SparsityPattern_str(self, *args)

    __swig_destroy__ = _cpp.delete_SparsityPattern
SparsityPattern.str = new_instancemethod(_cpp.SparsityPattern_str,None,SparsityPattern)
SparsityPattern_swigregister = _cpp.SparsityPattern_swigregister
SparsityPattern_swigregister(SparsityPattern)

class LinearAlgebraFactory(object):
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_LinearAlgebraFactory
    def create_matrix(self, *args):
        """
        Create empty matrix

        """
        return _cpp.LinearAlgebraFactory_create_matrix(self, *args)

    def create_vector(self, *args):
        """
        Create empty vector (global)

        """
        return _cpp.LinearAlgebraFactory_create_vector(self, *args)

    def create_local_vector(self, *args):
        """
        Create empty vector (local)

        """
        return _cpp.LinearAlgebraFactory_create_local_vector(self, *args)

    def create_pattern(self, *args):
        """
        Create empty sparsity pattern (returning zero if not used/needed)

        """
        return _cpp.LinearAlgebraFactory_create_pattern(self, *args)

    def create_lu_solver(self, *args):
        """
        Create LU solver

        """
        return _cpp.LinearAlgebraFactory_create_lu_solver(self, *args)

    def create_krylov_solver(self, *args):
        """
        Create Krylov solver

        """
        return _cpp.LinearAlgebraFactory_create_krylov_solver(self, *args)

    def lu_solver_methods(self, *args):
        """
        Return a list of available LU solver methods.
        This function should be overloaded by subclass if non-empty.

        """
        return _cpp.LinearAlgebraFactory_lu_solver_methods(self, *args)

    def krylov_solver_methods(self, *args):
        """
        Return a list of available Krylov solver methods.
        This function should be overloaded by subclass if non-empty.

        """
        return _cpp.LinearAlgebraFactory_krylov_solver_methods(self, *args)

    def krylov_solver_preconditioners(self, *args):
        """
        Return a list of available preconditioners.
        This function should be overloaded by subclass if non-empty.

        """
        return _cpp.LinearAlgebraFactory_krylov_solver_preconditioners(self, *args)

LinearAlgebraFactory.create_matrix = new_instancemethod(_cpp.LinearAlgebraFactory_create_matrix,None,LinearAlgebraFactory)
LinearAlgebraFactory.create_vector = new_instancemethod(_cpp.LinearAlgebraFactory_create_vector,None,LinearAlgebraFactory)
LinearAlgebraFactory.create_local_vector = new_instancemethod(_cpp.LinearAlgebraFactory_create_local_vector,None,LinearAlgebraFactory)
LinearAlgebraFactory.create_pattern = new_instancemethod(_cpp.LinearAlgebraFactory_create_pattern,None,LinearAlgebraFactory)
LinearAlgebraFactory.create_lu_solver = new_instancemethod(_cpp.LinearAlgebraFactory_create_lu_solver,None,LinearAlgebraFactory)
LinearAlgebraFactory.create_krylov_solver = new_instancemethod(_cpp.LinearAlgebraFactory_create_krylov_solver,None,LinearAlgebraFactory)
LinearAlgebraFactory.lu_solver_methods = new_instancemethod(_cpp.LinearAlgebraFactory_lu_solver_methods,None,LinearAlgebraFactory)
LinearAlgebraFactory.krylov_solver_methods = new_instancemethod(_cpp.LinearAlgebraFactory_krylov_solver_methods,None,LinearAlgebraFactory)
LinearAlgebraFactory.krylov_solver_preconditioners = new_instancemethod(_cpp.LinearAlgebraFactory_krylov_solver_preconditioners,None,LinearAlgebraFactory)
LinearAlgebraFactory_swigregister = _cpp.LinearAlgebraFactory_swigregister
LinearAlgebraFactory_swigregister(LinearAlgebraFactory)

class DefaultFactory(LinearAlgebraFactory):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.DefaultFactory_swiginit(self,_cpp.new_DefaultFactory(*args))
    __swig_destroy__ = _cpp.delete_DefaultFactory
    def factory(*args):
        """
        Return instance of default backend

        """
        return _cpp.DefaultFactory_factory(*args)

    factory = staticmethod(factory)
DefaultFactory_swigregister = _cpp.DefaultFactory_swigregister
DefaultFactory_swigregister(DefaultFactory)

def DefaultFactory_factory(*args):
  """
    Return instance of default backend

    """
  return _cpp.DefaultFactory_factory(*args)

class PETScUserPreconditioner(PETScObject):
    """
    This class specifies the interface for user-defined Krylov
    method PETScPreconditioners. A user wishing to implement her own
    PETScPreconditioner needs only supply a function that approximately
    solves the linear system given a right-hand side.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        if self.__class__ == PETScUserPreconditioner:
            _self = None
        else:
            _self = self
        _cpp.PETScUserPreconditioner_swiginit(self,_cpp.new_PETScUserPreconditioner(_self, *args))
    __swig_destroy__ = _cpp.delete_PETScUserPreconditioner
    setup = staticmethod(_cpp.PETScUserPreconditioner_setup)
    def solve(self, *args):
        """
        Solve linear system approximately for given right-hand side b

        """
        return _cpp.PETScUserPreconditioner_solve(self, *args)

    def __disown__(self):
        self.this.disown()
        _cpp.disown_PETScUserPreconditioner(self)
        return weakref_proxy(self)
PETScUserPreconditioner.solve = new_instancemethod(_cpp.PETScUserPreconditioner_solve,None,PETScUserPreconditioner)
PETScUserPreconditioner_swigregister = _cpp.PETScUserPreconditioner_swigregister
PETScUserPreconditioner_swigregister(PETScUserPreconditioner)

def PETScUserPreconditioner_setup(*args):
  return _cpp.PETScUserPreconditioner_setup(*args)
PETScUserPreconditioner_setup = _cpp.PETScUserPreconditioner_setup

class PETScFactory(LinearAlgebraFactory):
    thisown = _swig_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")
    __repr__ = _swig_repr
    __swig_destroy__ = _cpp.delete_PETScFactory
    def create_matrix(self, *args):
        """
        Create empty matrix

        """
        return _cpp.PETScFactory_create_matrix(self, *args)

    def create_vector(self, *args):
        """
        Create empty vector (global)

        """
        return _cpp.PETScFactory_create_vector(self, *args)

    def create_local_vector(self, *args):
        """
        Create empty vector (local)

        """
        return _cpp.PETScFactory_create_local_vector(self, *args)

    def create_pattern(self, *args):
        """
        Create empty sparsity pattern

        """
        return _cpp.PETScFactory_create_pattern(self, *args)

    def create_lu_solver(self, *args):
        """
        Create LU solver

        """
        return _cpp.PETScFactory_create_lu_solver(self, *args)

    def create_krylov_solver(self, *args):
        """
        Create Krylov solver

        """
        return _cpp.PETScFactory_create_krylov_solver(self, *args)

    def instance(*args):
        """
        Return singleton instance

        """
        return _cpp.PETScFactory_instance(*args)

    instance = staticmethod(instance)
PETScFactory.create_matrix = new_instancemethod(_cpp.PETScFactory_create_matrix,None,PETScFactory)
PETScFactory.create_vector = new_instancemethod(_cpp.PETScFactory_create_vector,None,PETScFactory)
PETScFactory.create_local_vector = new_instancemethod(_cpp.PETScFactory_create_local_vector,None,PETScFactory)
PETScFactory.create_pattern = new_instancemethod(_cpp.PETScFactory_create_pattern,None,PETScFactory)
PETScFactory.create_lu_solver = new_instancemethod(_cpp.PETScFactory_create_lu_solver,None,PETScFactory)
PETScFactory.create_krylov_solver = new_instancemethod(_cpp.PETScFactory_create_krylov_solver,None,PETScFactory)
PETScFactory_swigregister = _cpp.PETScFactory_swigregister
PETScFactory_swigregister(PETScFactory)

def PETScFactory_instance(*args):
  """
    Return singleton instance

    """
  return _cpp.PETScFactory_instance(*args)

class STLFactory(LinearAlgebraFactory):
    thisown = _swig_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")
    __repr__ = _swig_repr
    __swig_destroy__ = _cpp.delete_STLFactory
    def create_matrix(self, *args):
        """
        Create empty matrix

        """
        return _cpp.STLFactory_create_matrix(self, *args)

    def create_vector(self, *args):
        """
        Create empty vector (global)

        """
        return _cpp.STLFactory_create_vector(self, *args)

    def create_local_vector(self, *args):
        """
        Create empty vector (local)

        """
        return _cpp.STLFactory_create_local_vector(self, *args)

    def instance(*args):
        """
        Return singleton instance

        """
        return _cpp.STLFactory_instance(*args)

    instance = staticmethod(instance)
STLFactory.create_matrix = new_instancemethod(_cpp.STLFactory_create_matrix,None,STLFactory)
STLFactory.create_vector = new_instancemethod(_cpp.STLFactory_create_vector,None,STLFactory)
STLFactory.create_local_vector = new_instancemethod(_cpp.STLFactory_create_local_vector,None,STLFactory)
STLFactory_swigregister = _cpp.STLFactory_swigregister
STLFactory_swigregister(STLFactory)

def STLFactory_instance(*args):
  """
    Return singleton instance

    """
  return _cpp.STLFactory_instance(*args)

class SLEPcEigenSolver(Variable,PETScObject):
    """
    This class provides an eigenvalue solver for PETSc matrices.
    It is a wrapper for the SLEPc eigenvalue solver.

    The following parameters may be specified to control the solver.

    1. "spectrum"

    This parameter controls which part of the spectrum to compute.
    Possible values are

      "largest magnitude"   (eigenvalues with largest magnitude)
      "smallest magnitude"  (eigenvalues with smallest magnitude)
      "largest real"        (eigenvalues with largest double part)
      "smallest real"       (eigenvalues with smallest double part)
      "largest imaginary"   (eigenvalues with largest imaginary part)
      "smallest imaginary"  (eigenvalues with smallest imaginary part)

    For SLEPc versions >= 3.1 , the following values are also possible

      "target magnitude"    (eigenvalues closest to target in magnitude)
      "target real"         (eigenvalues closest to target in real part)
      "target imaginary"    (eigenvalues closest to target in imaginary part)

    The default is "largest magnitude"

    2. "solver"

    This parameter controls which algorithm is used by SLEPc.
    Possible values are

      "power"               (power iteration)
      "subspace"            (subspace iteration)
      "arnoldi"             (Arnoldi)
      "lanczos"             (Lanczos)
      "krylov-schur"        (Krylov-Schur)
      "lapack"              (LAPACK, all values, direct, small systems only)

    The default is "krylov-schur"

    3. "tolerance"

    This parameter controls the tolerance used by SLEPc.
    Possible values are positive double numbers.

    The default is 1e-15;

    4. "maximum_iterations"

    This parameter controls the maximum number of iterations used by SLEPc.
    Possible values are positive integers.

    Note that both the tolerance and the number of iterations must be
    specified if either one is specified.

    5. "problem_type"

    This parameter can be used to give extra information about the
    type of the eigenvalue problem. Some solver types require this
    extra piece of information. Possible values are:

      "hermitian"               (Hermitian)
      "non_hermitian"           (Non-Hermitian)
      "gen_hermitian"           (Generalized Hermitian)
      "gen_non_hermitian"       (Generalized Non-Hermitian)

    6. "spectral_transform"

    This parameter controls the application of a spectral transform. A
    spectral transform can be used to enhance the convergence of the
    eigensolver and in particular to only compute eigenvalues in the
    interior of the spectrum. Possible values are:

      "shift-and-invert"      (A shift-and-invert transform)

    Note that if a spectral transform is given, then also a non-zero
    spectral shift parameter has to be provided.

    The default is no spectral transform.

    7. "spectral_shift"

    This parameter controls the spectral shift used by the spectral
    transform and must be provided if a spectral transform is given. The
    possible values are real numbers.


    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * SLEPcEigenSolver\ (A)

          Create eigenvalue solver for Ax = \lambda x

        * SLEPcEigenSolver\ (A, B)

          Create eigenvalue solver Ax = \lambda Bx

        * SLEPcEigenSolver\ (A)

          Create eigenvalue solver for Ax = \lambda x

        * SLEPcEigenSolver\ (A, B)

          Create eigenvalue solver for Ax = \lambda x

        """
        _cpp.SLEPcEigenSolver_swiginit(self,_cpp.new_SLEPcEigenSolver(*args))
    __swig_destroy__ = _cpp.delete_SLEPcEigenSolver
    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ ()

          Compute all eigenpairs of the matrix A (solve Ax = \lambda x)

        * solve\ (n)

          Compute the n first eigenpairs of the matrix A (solve Ax = \lambda x)

        """
        return _cpp.SLEPcEigenSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.SLEPcEigenSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
    def _get_eigenvalue(self, *args):
        """Missing docstring"""
        return _cpp.SLEPcEigenSolver__get_eigenvalue(self, *args)

    def _get_eigenpair(self, *args):
        """Missing docstring"""
        return _cpp.SLEPcEigenSolver__get_eigenpair(self, *args)

    def get_eigenpair(self, i = 0, r_vec = None, c_vec = None,):
        """Gets the i-th solution of the eigenproblem"""
        r_vec = r_vec or PETScVector()
        c_vec = c_vec or PETScVector()
        lr, lc = self._get_eigenpair(r_vec, c_vec, i)
        return lr, lc, r_vec, c_vec

    def get_eigenvalue(self, i = 0):
        """Gets the i-th eigenvalue of the eigenproblem"""
        return self._get_eigenvalue(i)

SLEPcEigenSolver.solve = new_instancemethod(_cpp.SLEPcEigenSolver_solve,None,SLEPcEigenSolver)
SLEPcEigenSolver.get_iteration_number = new_instancemethod(_cpp.SLEPcEigenSolver_get_iteration_number,None,SLEPcEigenSolver)
SLEPcEigenSolver.get_number_converged = new_instancemethod(_cpp.SLEPcEigenSolver_get_number_converged,None,SLEPcEigenSolver)
SLEPcEigenSolver.set_deflation_space = new_instancemethod(_cpp.SLEPcEigenSolver_set_deflation_space,None,SLEPcEigenSolver)
SLEPcEigenSolver._get_eigenvalue = new_instancemethod(_cpp.SLEPcEigenSolver__get_eigenvalue,None,SLEPcEigenSolver)
SLEPcEigenSolver._get_eigenpair = new_instancemethod(_cpp.SLEPcEigenSolver__get_eigenpair,None,SLEPcEigenSolver)
SLEPcEigenSolver_swigregister = _cpp.SLEPcEigenSolver_swigregister
SLEPcEigenSolver_swigregister(SLEPcEigenSolver)

def SLEPcEigenSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.SLEPcEigenSolver_default_parameters(*args)

class uBLASPreconditioner(object):
    """
    This class specifies the interface for preconditioners for the
    uBLAS Krylov solver.

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_uBLASPreconditioner
    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (P)

          Initialise preconditioner (sparse matrix)

        * init\ (P)

          Initialise preconditioner (dense matrix)

        * init\ (P)

          Initialise preconditioner (virtual matrix)

        """
        return _cpp.uBLASPreconditioner_init(self, *args)

    def solve(self, *args):
        """
        Solve linear system (M^-1)Ax = y

        """
        return _cpp.uBLASPreconditioner_solve(self, *args)

uBLASPreconditioner.init = new_instancemethod(_cpp.uBLASPreconditioner_init,None,uBLASPreconditioner)
uBLASPreconditioner.solve = new_instancemethod(_cpp.uBLASPreconditioner_solve,None,uBLASPreconditioner)
uBLASPreconditioner_swigregister = _cpp.uBLASPreconditioner_swigregister
uBLASPreconditioner_swigregister(uBLASPreconditioner)

class uBLASKrylovSolver(GenericLinearSolver):
    """
    This class implements Krylov methods for linear systems
    of the form Ax = b using uBLAS data types.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * uBLASKrylovSolver\ (method="default", preconditioner="default")

          Create Krylov solver for a particular method and preconditioner

        * uBLASKrylovSolver\ (pc)

          Create Krylov solver for a particular uBLASPreconditioner

        * uBLASKrylovSolver\ (method, pc)

          Create Krylov solver for a particular method and uBLASPreconditioner

        """
        _cpp.uBLASKrylovSolver_swiginit(self,_cpp.new_uBLASKrylovSolver(*args))
    __swig_destroy__ = _cpp.delete_uBLASKrylovSolver
    def get_operator(self, *args):
        """
        Return the operator (matrix)

        """
        return _cpp.uBLASKrylovSolver_get_operator(self, *args)

    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (x, b)

          Solve linear system Ax = b and return number of iterations

        * solve\ (A, x, b)

          Solve linear system Ax = b and return number of iterations

        * solve\ (A, x, b)

          Solve linear system Ax = b and return number of iterations (virtual matrix)

        """
        return _cpp.uBLASKrylovSolver_solve(self, *args)

    def methods(*args):
        """
        Return a list of available solver methods

        """
        return _cpp.uBLASKrylovSolver_methods(*args)

    methods = staticmethod(methods)
    def preconditioners(*args):
        """
        Return a list of available preconditioners

        """
        return _cpp.uBLASKrylovSolver_preconditioners(*args)

    preconditioners = staticmethod(preconditioners)
    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.uBLASKrylovSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
uBLASKrylovSolver.get_operator = new_instancemethod(_cpp.uBLASKrylovSolver_get_operator,None,uBLASKrylovSolver)
uBLASKrylovSolver.solve = new_instancemethod(_cpp.uBLASKrylovSolver_solve,None,uBLASKrylovSolver)
uBLASKrylovSolver_swigregister = _cpp.uBLASKrylovSolver_swigregister
uBLASKrylovSolver_swigregister(uBLASKrylovSolver)

def uBLASKrylovSolver_methods(*args):
  """
    Return a list of available solver methods

    """
  return _cpp.uBLASKrylovSolver_methods(*args)

def uBLASKrylovSolver_preconditioners(*args):
  """
    Return a list of available preconditioners

    """
  return _cpp.uBLASKrylovSolver_preconditioners(*args)

def uBLASKrylovSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.uBLASKrylovSolver_default_parameters(*args)

class uBLASILUPreconditioner(uBLASPreconditioner):
    """
    This class implements an incomplete LU factorization (ILU)
    preconditioner for the uBLAS Krylov solver.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.uBLASILUPreconditioner_swiginit(self,_cpp.new_uBLASILUPreconditioner(*args))
    __swig_destroy__ = _cpp.delete_uBLASILUPreconditioner
uBLASILUPreconditioner_swigregister = _cpp.uBLASILUPreconditioner_swigregister
uBLASILUPreconditioner_swigregister(uBLASILUPreconditioner)

class Vector(GenericVector):
    """
    This class provides the default DOLFIN vector class,
    based on the default DOLFIN linear algebra backend.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Vector\ ()

          Create empty vector

        * Vector\ (N)

          Create vector of size N

        * Vector\ (x)

          Copy constructor

        * Vector\ (x)

          Create a Vector from a GenericVetor

        """
        _cpp.Vector_swiginit(self,_cpp.new_Vector(*args))
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.Vector_copy(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (N)

          Resize vector to size N

        * resize\ (range)

          Resize vector with given ownership range

        * resize\ (range, ghost_indices)

          Resize vector with given ownership range and with ghost values

        """
        return _cpp.Vector_resize(self, *args)

    def get_local(self, *args):
        """
        **Overloaded versions**

        * get_local\ (block, m, rows)

          Get block of values (values must all live on the local process)

        * get_local\ (values)

          Get all values on local process

        """
        return _cpp.Vector_get_local(self, *args)

    def gather(self, *args):
        """
        **Overloaded versions**

        * gather\ (x, indices)

          Gather entries into local vector x

        * gather\ (x, indices)

          Gather entries into Array x

        """
        return _cpp.Vector_gather(self, *args)

    def sum(self, *args):
        """
        Return sum of values of vector

        """
        return _cpp.Vector_sum(self, *args)

    def shared_instance(self, *args):
        """
        **Overloaded versions**

        * shared_instance\ ()

          Return concrete shared ptr instance / unwrap (const version)

        * shared_instance\ ()

          Return concrete shared ptr instance / unwrap

        """
        return _cpp.Vector_shared_instance(self, *args)

    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (x)

          Assignment operator

        * operator=\ (a)

          Assignment operator

        * operator=\ (x)

          Assignment operator

        """
        return _cpp.Vector__assign(self, *args)

    def _data(self, *args):
        """Missing docstring"""
        return _cpp.Vector__data(self, *args)

    def data(self, deepcopy=True):
        """
        Return an array to underlaying data

        This method is only available for the uBLAS and MTL4 linear algebra
        backends.

        *Arguments*
            deepcopy
                Return a copy of the data. If set to False a reference
                to the Matrix need to be kept, otherwise the data will be
                destroyed together with the destruction of the Matrix
        """
        ret = self._data()
        if deepcopy:
            ret = ret.copy()

        return ret

    __swig_destroy__ = _cpp.delete_Vector
Vector.copy = new_instancemethod(_cpp.Vector_copy,None,Vector)
Vector.resize = new_instancemethod(_cpp.Vector_resize,None,Vector)
Vector.get_local = new_instancemethod(_cpp.Vector_get_local,None,Vector)
Vector.gather = new_instancemethod(_cpp.Vector_gather,None,Vector)
Vector.sum = new_instancemethod(_cpp.Vector_sum,None,Vector)
Vector.shared_instance = new_instancemethod(_cpp.Vector_shared_instance,None,Vector)
Vector._assign = new_instancemethod(_cpp.Vector__assign,None,Vector)
Vector._data = new_instancemethod(_cpp.Vector__data,None,Vector)
Vector_swigregister = _cpp.Vector_swigregister
Vector_swigregister(Vector)

class Matrix(GenericMatrix):
    """
    This class provides the default DOLFIN matrix class,
    based on the default DOLFIN linear algebra backend.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Matrix\ ()

          Create empty matrix

        * Matrix\ (A)

          Copy constructor

        """
        _cpp.Matrix_swiginit(self,_cpp.new_Matrix(*args))
    __swig_destroy__ = _cpp.delete_Matrix
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.Matrix_copy(self, *args)

    def zero(self, *args):
        """
        **Overloaded versions**

        * zero\ ()

          Set all entries to zero and keep any sparse structure

        * zero\ (m, rows)

          Set given rows to zero

        """
        return _cpp.Matrix_zero(self, *args)

    def shared_instance(self, *args):
        """
        **Overloaded versions**

        * shared_instance\ ()

          Return concrete shared ptr instance / unwrap (const version)

        * shared_instance\ ()

          Return concrete shared ptr instance / unwrap

        """
        return _cpp.Matrix_shared_instance(self, *args)

    def assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (A)

          Assignment operator

        * operator=\ (A)

          Assignment operator

        """
        return _cpp.Matrix_assign(self, *args)

Matrix.copy = new_instancemethod(_cpp.Matrix_copy,None,Matrix)
Matrix.zero = new_instancemethod(_cpp.Matrix_zero,None,Matrix)
Matrix.shared_instance = new_instancemethod(_cpp.Matrix_shared_instance,None,Matrix)
Matrix.assign = new_instancemethod(_cpp.Matrix_assign,None,Matrix)
Matrix_swigregister = _cpp.Matrix_swigregister
Matrix_swigregister(Matrix)

class Scalar(GenericTensor):
    """
    This class represents a real-valued scalar quantity and
    implements the GenericTensor interface for scalars.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create zero scalar

        """
        _cpp.Scalar_swiginit(self,_cpp.new_Scalar(*args))
    __swig_destroy__ = _cpp.delete_Scalar
    def resize(self, *args):
        """
        Resize tensor to given dimensions

        """
        return _cpp.Scalar_resize(self, *args)

    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.Scalar_copy(self, *args)

    def add(self, *args):
        """
        **Overloaded versions**

        * add\ (block, num_rows, rows)

          Add block of values

        * add\ (block, rows)

          Add block of values

        * add\ (block, rows)

          Add block of values

        """
        return _cpp.Scalar_add(self, *args)

    def __float__(self, *args):
        """
        Cast to double

        """
        return _cpp.Scalar___float__(self, *args)

    def assign(self, *args):
        """
        Assignment from double

        """
        return _cpp.Scalar_assign(self, *args)

    def getval(self, *args):
        """
        Get value

        """
        return _cpp.Scalar_getval(self, *args)

Scalar.resize = new_instancemethod(_cpp.Scalar_resize,None,Scalar)
Scalar.copy = new_instancemethod(_cpp.Scalar_copy,None,Scalar)
Scalar.add = new_instancemethod(_cpp.Scalar_add,None,Scalar)
Scalar.__float__ = new_instancemethod(_cpp.Scalar___float__,None,Scalar)
Scalar.assign = new_instancemethod(_cpp.Scalar_assign,None,Scalar)
Scalar.getval = new_instancemethod(_cpp.Scalar_getval,None,Scalar)
Scalar_swigregister = _cpp.Scalar_swigregister
Scalar_swigregister(Scalar)

class LinearSolver(GenericLinearSolver):
    """
    This class provides a general solver for linear systems Ax = b.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create linear solver

        """
        _cpp.LinearSolver_swiginit(self,_cpp.new_LinearSolver(*args))
    __swig_destroy__ = _cpp.delete_LinearSolver
    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (A, x, b)

          Solve linear system Ax = b

        * solve\ (x, b)

          Solve linear system Ax = b

        """
        return _cpp.LinearSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.LinearSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
LinearSolver.solve = new_instancemethod(_cpp.LinearSolver_solve,None,LinearSolver)
LinearSolver_swigregister = _cpp.LinearSolver_swigregister
LinearSolver_swigregister(LinearSolver)

def LinearSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.LinearSolver_default_parameters(*args)

class KrylovSolver(GenericLinearSolver):
    """
    This class defines an interface for a Krylov solver. The approproiate solver
    is chosen on the basis of the matrix/vector type.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * KrylovSolver\ (method="default", preconditioner="default")

          Constructor

        * KrylovSolver\ (A, method="default", preconditioner="default")

          Constructor

        """
        _cpp.KrylovSolver_swiginit(self,_cpp.new_KrylovSolver(*args))
    __swig_destroy__ = _cpp.delete_KrylovSolver
    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (x, b)

          Solve linear system Ax = b

        * solve\ (A, x, b)

          Solve linear system Ax = b

        """
        return _cpp.KrylovSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.KrylovSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
KrylovSolver.solve = new_instancemethod(_cpp.KrylovSolver_solve,None,KrylovSolver)
KrylovSolver_swigregister = _cpp.KrylovSolver_swigregister
KrylovSolver_swigregister(KrylovSolver)

def KrylovSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.KrylovSolver_default_parameters(*args)

class LUSolver(GenericLUSolver):
    """
    LU solver for the built-in LA backends.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * LUSolver\ ("default")

          Constructor

        * LUSolver\ (A, method="default")

          Constructor

        """
        _cpp.LUSolver_swiginit(self,_cpp.new_LUSolver(*args))
    __swig_destroy__ = _cpp.delete_LUSolver
    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (x, b)

          Solve linear system Ax = b

        * solve\ (A, x, b)

          Solve linear system

        """
        return _cpp.LUSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.LUSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
LUSolver.solve = new_instancemethod(_cpp.LUSolver_solve,None,LUSolver)
LUSolver_swigregister = _cpp.LUSolver_swigregister
LUSolver_swigregister(LUSolver)

def LUSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.LUSolver_default_parameters(*args)

class SingularSolver(Variable):
    """
    This class provides a linear solver for singular linear systems
    Ax = b where A has a one-dimensional null-space (kernel). This
    may happen for example when solving Poisson's equation with
    pure Neumann boundary conditions.

    The solver attempts to create an extended non-singular system
    by adding the constraint [1, 1, 1, ...]^T x = 0.

    If an optional mass matrix M is supplied, the solver attempts
    to create an extended non-singular system by adding the
    constraint m^T x = 0 where m is the lumped mass matrix. This
    corresponds to setting the average (integral) of the finite
    element function with coefficients x to zero.

    The solver makes not attempt to check that the null-space is
    indeed one-dimensional. It is also assumed that the system
    Ax = b retains its sparsity pattern between calls to solve().

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create linear solver

        """
        _cpp.SingularSolver_swiginit(self,_cpp.new_SingularSolver(*args))
    __swig_destroy__ = _cpp.delete_SingularSolver
    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (A, x, b)

          Solve linear system Ax = b

        * solve\ (A, x, b, M)

          Solve linear system Ax = b using mass matrix M for setting constraint

        """
        return _cpp.SingularSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.SingularSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
SingularSolver.solve = new_instancemethod(_cpp.SingularSolver_solve,None,SingularSolver)
SingularSolver_swigregister = _cpp.SingularSolver_swigregister
SingularSolver_swigregister(SingularSolver)

def SingularSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.SingularSolver_default_parameters(*args)


def list_linear_solver_methods(*args):
  """
    List available solver methods for current linear algebra backend

    """
  return _cpp.list_linear_solver_methods(*args)

def list_lu_solver_methods(*args):
  """
    List available LU methods for current linear algebra backend

    """
  return _cpp.list_lu_solver_methods(*args)

def list_krylov_solver_methods(*args):
  """
    List available Krylov methods for current linear algebra backend

    """
  return _cpp.list_krylov_solver_methods(*args)

def list_krylov_solver_preconditioners(*args):
  """
    List available preconditioners for current linear algebra backend

    """
  return _cpp.list_krylov_solver_preconditioners(*args)

def linear_solver_methods(*args):
  """
    Return a list of available solver methods for current linear algebra backend

    """
  return _cpp.linear_solver_methods(*args)

def lu_solver_methods(*args):
  """
    Return a list of available LU methods for current linear algebra backend

    """
  return _cpp.lu_solver_methods(*args)

def krylov_solver_methods(*args):
  """
    Return a list of available Krylov methods for current linear algebra backend

    """
  return _cpp.krylov_solver_methods(*args)

def krylov_solver_preconditioners(*args):
  """
    Return a list of available preconditioners for current linear algebra backend

    """
  return _cpp.krylov_solver_preconditioners(*args)

def residual(*args):
  """
    Compute residual ||Ax - b||

    """
  return _cpp.residual(*args)

def normalize(*args):
  """
    Normalize vector according to given normalization type

    """
  return _cpp.normalize(*args)
class BlockVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.BlockVector_swiginit(self,_cpp.new_BlockVector(*args))
    __swig_destroy__ = _cpp.delete_BlockVector
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.BlockVector_copy(self, *args)

    def set_block(self, *args):
        """
        Set function

        """
        return _cpp.BlockVector_set_block(self, *args)

    def get_block(self, *args):
        """
        **Overloaded versions**

        * get_block\ (i)

          Get sub-vector (const)

        * get_block\ (uint)

          Get sub-vector (non-const)

        """
        return _cpp.BlockVector_get_block(self, *args)

    def axpy(self, *args):
        """
        Add multiple of given vector (AXPY operation)

        """
        return _cpp.BlockVector_axpy(self, *args)

    def inner(self, *args):
        """
        Return inner product with given vector

        """
        return _cpp.BlockVector_inner(self, *args)

    def norm(self, *args):
        """
        Return norm of vector

        """
        return _cpp.BlockVector_norm(self, *args)

    def min(self, *args):
        """
        Return minimum value of vector

        """
        return _cpp.BlockVector_min(self, *args)

    def max(self, *args):
        """
        Return maximum value of vector

        """
        return _cpp.BlockVector_max(self, *args)

    def __imul__(self, *args):
        """
        Multiply vector by given number

        """
        return _cpp.BlockVector___imul__(self, *args)

    def __idiv__(self, *args):
        """
        Divide vector by given number

        """
        return _cpp.BlockVector___idiv__(self, *args)

    def __iadd__(self, *args):
        """
        Add given vector

        """
        return _cpp.BlockVector___iadd__(self, *args)

    def __isub__(self, *args):
        """
        Subtract given vector

        """
        return _cpp.BlockVector___isub__(self, *args)

    def size(self, *args):
        """
        Number of vectors

        """
        return _cpp.BlockVector_size(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.BlockVector_str(self, *args)

    def __getitem__(self, i):
        return self.get_block(i)

    def __setitem__(self, i, m):
        if not hasattr(self, "_items"):
            self._items = {}
        self._items[i] = m
        self.set_block(i, m)

    def __add__(self, v):
      a = self.copy()
      a += v
      return a

    def __sub__(self, v):
      a = self.copy()
      a -= v
      return a

    def __mul__(self, v):
      a = self.copy()
      a *= v
      return a

    def __rmul__(self, v):
      return self.__mul__(v)

BlockVector.copy = new_instancemethod(_cpp.BlockVector_copy,None,BlockVector)
BlockVector.set_block = new_instancemethod(_cpp.BlockVector_set_block,None,BlockVector)
BlockVector.get_block = new_instancemethod(_cpp.BlockVector_get_block,None,BlockVector)
BlockVector.axpy = new_instancemethod(_cpp.BlockVector_axpy,None,BlockVector)
BlockVector.inner = new_instancemethod(_cpp.BlockVector_inner,None,BlockVector)
BlockVector.norm = new_instancemethod(_cpp.BlockVector_norm,None,BlockVector)
BlockVector.min = new_instancemethod(_cpp.BlockVector_min,None,BlockVector)
BlockVector.max = new_instancemethod(_cpp.BlockVector_max,None,BlockVector)
BlockVector.__imul__ = new_instancemethod(_cpp.BlockVector___imul__,None,BlockVector)
BlockVector.__idiv__ = new_instancemethod(_cpp.BlockVector___idiv__,None,BlockVector)
BlockVector.__iadd__ = new_instancemethod(_cpp.BlockVector___iadd__,None,BlockVector)
BlockVector.__isub__ = new_instancemethod(_cpp.BlockVector___isub__,None,BlockVector)
BlockVector.size = new_instancemethod(_cpp.BlockVector_size,None,BlockVector)
BlockVector.str = new_instancemethod(_cpp.BlockVector_str,None,BlockVector)
BlockVector_swigregister = _cpp.BlockVector_swigregister
BlockVector_swigregister(BlockVector)

class BlockMatrix(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.BlockMatrix_swiginit(self,_cpp.new_BlockMatrix(*args))
    __swig_destroy__ = _cpp.delete_BlockMatrix
    def set_block(self, *args):
        """
        Set block

        """
        return _cpp.BlockMatrix_set_block(self, *args)

    def get_block(self, *args):
        """
        **Overloaded versions**

        * get_block\ (i, j)

          Get block (const version)

        * get_block\ (i, j)

          Get block

        """
        return _cpp.BlockMatrix_get_block(self, *args)

    def size(self, *args):
        """
        Return size of given dimension

        """
        return _cpp.BlockMatrix_size(self, *args)

    def zero(self, *args):
        """
        Set all entries to zero and keep any sparse structure

        """
        return _cpp.BlockMatrix_zero(self, *args)

    def apply(self, *args):
        """
        Finalize assembly of tensor

        """
        return _cpp.BlockMatrix_apply(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.BlockMatrix_str(self, *args)

    def mult(self, *args):
        """
        Matrix-vector product, y = Ax

        """
        return _cpp.BlockMatrix_mult(self, *args)

    def schur_approximation(self, *args):
        """
        Create a crude explicit Schur approximation of S = D - C A^-1 B of (A B; C D)
        If symmetry != 0, then the caller promises that B = symmetry * transpose(C).

        """
        return _cpp.BlockMatrix_schur_approximation(self, *args)

    def __mul__(self, other):
        v = BlockVector(self.size(0))
        self.mult(other, v)
        return v

    def __getitem__(self, t):
        i,j = t
        return self.get_block(i, j)

    def __setitem__(self, t, m):
        if not hasattr(self, "_items"):
            self._items = {}
        self._items[t] = m
        i,j = t
        self.set_block(i, j, m)


BlockMatrix.set_block = new_instancemethod(_cpp.BlockMatrix_set_block,None,BlockMatrix)
BlockMatrix.get_block = new_instancemethod(_cpp.BlockMatrix_get_block,None,BlockMatrix)
BlockMatrix.size = new_instancemethod(_cpp.BlockMatrix_size,None,BlockMatrix)
BlockMatrix.zero = new_instancemethod(_cpp.BlockMatrix_zero,None,BlockMatrix)
BlockMatrix.apply = new_instancemethod(_cpp.BlockMatrix_apply,None,BlockMatrix)
BlockMatrix.str = new_instancemethod(_cpp.BlockMatrix_str,None,BlockMatrix)
BlockMatrix.mult = new_instancemethod(_cpp.BlockMatrix_mult,None,BlockMatrix)
BlockMatrix.schur_approximation = new_instancemethod(_cpp.BlockMatrix_schur_approximation,None,BlockMatrix)
BlockMatrix_swigregister = _cpp.BlockMatrix_swigregister
BlockMatrix_swigregister(BlockMatrix)

class uBLASSparseMatrix(GenericMatrix):
    """
    This class provides a simple matrix class based on uBLAS.
    It is a simple wrapper for a uBLAS matrix implementing the
    GenericMatrix interface.

    The interface is intentionally simple. For advanced usage,
    access the underlying uBLAS matrix and use the standard
    uBLAS interface which is documented at
    http://www.boost.org/libs/numeric/ublas/doc/index.htm.

    Developer note: specialised member functions must be
    inlined to avoid link errors.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * uBLASMatrix\ ()

          Create empty matrix

        * uBLASMatrix\ (M, N)

          Create M x N matrix

        * uBLASMatrix\ (A)

          Copy constructor

        * uBLASMatrix\ (A)

          Create matrix from given uBLAS matrix expression

        """
        _cpp.uBLASSparseMatrix_swiginit(self,_cpp.new_uBLASSparseMatrix(*args))
    __swig_destroy__ = _cpp.delete_uBLASSparseMatrix
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.uBLASSparseMatrix_copy(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (M, N)

          Resize matrix to M x N

        * resize\ (y, dim)

          Resize vector y such that is it compatible with matrix for
          multuplication Ax = b (dim = 0 -> b, dim = 1 -> x) In parallel
          case, size and layout are important.

        """
        return _cpp.uBLASSparseMatrix_resize(self, *args)

    def zero(self, *args):
        """
        **Overloaded versions**

        * zero\ ()

          Set all entries to zero and keep any sparse structure

        * zero\ (m, rows)

          Set given rows to zero

        """
        return _cpp.uBLASSparseMatrix_zero(self, *args)

    def mat(self, *args):
        """
        **Overloaded versions**

        * mat\ ()

          Return reference to uBLAS matrix (const version)

        * mat\ ()

          Return reference to uBLAS matrix (non-const version)

        """
        return _cpp.uBLASSparseMatrix_mat(self, *args)

    def solve(self, *args):
        """
        Solve Ax = b out-of-place using uBLAS (A is not destroyed)

        """
        return _cpp.uBLASSparseMatrix_solve(self, *args)

    def solveInPlace(self, *args):
        """
        **Overloaded versions**

        * solveInPlace\ (x, b)

          Solve Ax = b in-place using uBLAS(A is destroyed)

        * solveInPlace\ (X)

          General uBLAS LU solver which accepts both vector and matrix right-hand sides

        """
        return _cpp.uBLASSparseMatrix_solveInPlace(self, *args)

    def invert(self, *args):
        """
        Compute inverse of matrix

        """
        return _cpp.uBLASSparseMatrix_invert(self, *args)

    def lump(self, *args):
        """
        Lump matrix into vector m

        """
        return _cpp.uBLASSparseMatrix_lump(self, *args)

    def compress(self, *args):
        """
        Compress matrix (eliminate all non-zeros from a sparse matrix)

        """
        return _cpp.uBLASSparseMatrix_compress(self, *args)

    def assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (A)

          Assignment operator

        * operator=\ (A)

          Assignment operator

        """
        return _cpp.uBLASSparseMatrix_assign(self, *args)

uBLASSparseMatrix.copy = new_instancemethod(_cpp.uBLASSparseMatrix_copy,None,uBLASSparseMatrix)
uBLASSparseMatrix.resize = new_instancemethod(_cpp.uBLASSparseMatrix_resize,None,uBLASSparseMatrix)
uBLASSparseMatrix.zero = new_instancemethod(_cpp.uBLASSparseMatrix_zero,None,uBLASSparseMatrix)
uBLASSparseMatrix.mat = new_instancemethod(_cpp.uBLASSparseMatrix_mat,None,uBLASSparseMatrix)
uBLASSparseMatrix.solve = new_instancemethod(_cpp.uBLASSparseMatrix_solve,None,uBLASSparseMatrix)
uBLASSparseMatrix.solveInPlace = new_instancemethod(_cpp.uBLASSparseMatrix_solveInPlace,None,uBLASSparseMatrix)
uBLASSparseMatrix.invert = new_instancemethod(_cpp.uBLASSparseMatrix_invert,None,uBLASSparseMatrix)
uBLASSparseMatrix.lump = new_instancemethod(_cpp.uBLASSparseMatrix_lump,None,uBLASSparseMatrix)
uBLASSparseMatrix.compress = new_instancemethod(_cpp.uBLASSparseMatrix_compress,None,uBLASSparseMatrix)
uBLASSparseMatrix.assign = new_instancemethod(_cpp.uBLASSparseMatrix_assign,None,uBLASSparseMatrix)
uBLASSparseMatrix_swigregister = _cpp.uBLASSparseMatrix_swigregister
uBLASSparseMatrix_swigregister(uBLASSparseMatrix)

class uBLASDenseMatrix(GenericMatrix):
    """
    This class provides a simple matrix class based on uBLAS.
    It is a simple wrapper for a uBLAS matrix implementing the
    GenericMatrix interface.

    The interface is intentionally simple. For advanced usage,
    access the underlying uBLAS matrix and use the standard
    uBLAS interface which is documented at
    http://www.boost.org/libs/numeric/ublas/doc/index.htm.

    Developer note: specialised member functions must be
    inlined to avoid link errors.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * uBLASMatrix\ ()

          Create empty matrix

        * uBLASMatrix\ (M, N)

          Create M x N matrix

        * uBLASMatrix\ (A)

          Copy constructor

        * uBLASMatrix\ (A)

          Create matrix from given uBLAS matrix expression

        """
        _cpp.uBLASDenseMatrix_swiginit(self,_cpp.new_uBLASDenseMatrix(*args))
    __swig_destroy__ = _cpp.delete_uBLASDenseMatrix
    def copy(self, *args):
        """
        Return copy of tensor

        """
        return _cpp.uBLASDenseMatrix_copy(self, *args)

    def resize(self, *args):
        """
        **Overloaded versions**

        * resize\ (M, N)

          Resize matrix to M x N

        * resize\ (y, dim)

          Resize vector y such that is it compatible with matrix for
          multuplication Ax = b (dim = 0 -> b, dim = 1 -> x) In parallel
          case, size and layout are important.

        """
        return _cpp.uBLASDenseMatrix_resize(self, *args)

    def zero(self, *args):
        """
        **Overloaded versions**

        * zero\ ()

          Set all entries to zero and keep any sparse structure

        * zero\ (m, rows)

          Set given rows to zero

        """
        return _cpp.uBLASDenseMatrix_zero(self, *args)

    def mat(self, *args):
        """
        **Overloaded versions**

        * mat\ ()

          Return reference to uBLAS matrix (const version)

        * mat\ ()

          Return reference to uBLAS matrix (non-const version)

        """
        return _cpp.uBLASDenseMatrix_mat(self, *args)

    def solve(self, *args):
        """
        Solve Ax = b out-of-place using uBLAS (A is not destroyed)

        """
        return _cpp.uBLASDenseMatrix_solve(self, *args)

    def solveInPlace(self, *args):
        """
        **Overloaded versions**

        * solveInPlace\ (x, b)

          Solve Ax = b in-place using uBLAS(A is destroyed)

        * solveInPlace\ (X)

          General uBLAS LU solver which accepts both vector and matrix right-hand sides

        """
        return _cpp.uBLASDenseMatrix_solveInPlace(self, *args)

    def invert(self, *args):
        """
        Compute inverse of matrix

        """
        return _cpp.uBLASDenseMatrix_invert(self, *args)

    def lump(self, *args):
        """
        Lump matrix into vector m

        """
        return _cpp.uBLASDenseMatrix_lump(self, *args)

    def compress(self, *args):
        """
        Compress matrix (eliminate all non-zeros from a sparse matrix)

        """
        return _cpp.uBLASDenseMatrix_compress(self, *args)

    def assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (A)

          Assignment operator

        * operator=\ (A)

          Assignment operator

        """
        return _cpp.uBLASDenseMatrix_assign(self, *args)

uBLASDenseMatrix.copy = new_instancemethod(_cpp.uBLASDenseMatrix_copy,None,uBLASDenseMatrix)
uBLASDenseMatrix.resize = new_instancemethod(_cpp.uBLASDenseMatrix_resize,None,uBLASDenseMatrix)
uBLASDenseMatrix.zero = new_instancemethod(_cpp.uBLASDenseMatrix_zero,None,uBLASDenseMatrix)
uBLASDenseMatrix.mat = new_instancemethod(_cpp.uBLASDenseMatrix_mat,None,uBLASDenseMatrix)
uBLASDenseMatrix.solve = new_instancemethod(_cpp.uBLASDenseMatrix_solve,None,uBLASDenseMatrix)
uBLASDenseMatrix.solveInPlace = new_instancemethod(_cpp.uBLASDenseMatrix_solveInPlace,None,uBLASDenseMatrix)
uBLASDenseMatrix.invert = new_instancemethod(_cpp.uBLASDenseMatrix_invert,None,uBLASDenseMatrix)
uBLASDenseMatrix.lump = new_instancemethod(_cpp.uBLASDenseMatrix_lump,None,uBLASDenseMatrix)
uBLASDenseMatrix.compress = new_instancemethod(_cpp.uBLASDenseMatrix_compress,None,uBLASDenseMatrix)
uBLASDenseMatrix.assign = new_instancemethod(_cpp.uBLASDenseMatrix_assign,None,uBLASDenseMatrix)
uBLASDenseMatrix_swigregister = _cpp.uBLASDenseMatrix_swigregister
uBLASDenseMatrix_swigregister(uBLASDenseMatrix)

class uBLASSparseFactory(LinearAlgebraFactory):
    thisown = _swig_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")
    __repr__ = _swig_repr
    __swig_destroy__ = _cpp.delete_uBLASSparseFactory
    def create_matrix(self, *args):
        """
        Create empty matrix

        """
        return _cpp.uBLASSparseFactory_create_matrix(self, *args)

    def create_vector(self, *args):
        """
        Create empty vector

        """
        return _cpp.uBLASSparseFactory_create_vector(self, *args)

    def create_local_vector(self, *args):
        """
        Create empty vector (local)

        """
        return _cpp.uBLASSparseFactory_create_local_vector(self, *args)

    def create_pattern(self, *args):
        """
        Create empty sparsity pattern

        """
        return _cpp.uBLASSparseFactory_create_pattern(self, *args)

    def create_lu_solver(self, *args):
        """
        Create LU solver

        """
        return _cpp.uBLASSparseFactory_create_lu_solver(self, *args)

    def instance(*args):
        """
        Return singleton instance

        """
        return _cpp.uBLASSparseFactory_instance(*args)

    instance = staticmethod(instance)
uBLASSparseFactory.create_matrix = new_instancemethod(_cpp.uBLASSparseFactory_create_matrix,None,uBLASSparseFactory)
uBLASSparseFactory.create_vector = new_instancemethod(_cpp.uBLASSparseFactory_create_vector,None,uBLASSparseFactory)
uBLASSparseFactory.create_local_vector = new_instancemethod(_cpp.uBLASSparseFactory_create_local_vector,None,uBLASSparseFactory)
uBLASSparseFactory.create_pattern = new_instancemethod(_cpp.uBLASSparseFactory_create_pattern,None,uBLASSparseFactory)
uBLASSparseFactory.create_lu_solver = new_instancemethod(_cpp.uBLASSparseFactory_create_lu_solver,None,uBLASSparseFactory)
uBLASSparseFactory_swigregister = _cpp.uBLASSparseFactory_swigregister
uBLASSparseFactory_swigregister(uBLASSparseFactory)

def uBLASSparseFactory_instance(*args):
  """
    Return singleton instance

    """
  return _cpp.uBLASSparseFactory_instance(*args)

class uBLASDenseFactory(LinearAlgebraFactory):
    thisown = _swig_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")
    __repr__ = _swig_repr
    __swig_destroy__ = _cpp.delete_uBLASDenseFactory
    def create_matrix(self, *args):
        """
        Create empty matrix

        """
        return _cpp.uBLASDenseFactory_create_matrix(self, *args)

    def create_vector(self, *args):
        """
        Create empty vector

        """
        return _cpp.uBLASDenseFactory_create_vector(self, *args)

    def create_local_vector(self, *args):
        """
        Create empty vector (local)

        """
        return _cpp.uBLASDenseFactory_create_local_vector(self, *args)

    def create_pattern(self, *args):
        """
        Create empty sparsity pattern

        """
        return _cpp.uBLASDenseFactory_create_pattern(self, *args)

    def create_lu_solver(self, *args):
        """
        Create LU solver

        """
        return _cpp.uBLASDenseFactory_create_lu_solver(self, *args)

    def instance(*args):
        """
        Return singleton instance

        """
        return _cpp.uBLASDenseFactory_instance(*args)

    instance = staticmethod(instance)
uBLASDenseFactory.create_matrix = new_instancemethod(_cpp.uBLASDenseFactory_create_matrix,None,uBLASDenseFactory)
uBLASDenseFactory.create_vector = new_instancemethod(_cpp.uBLASDenseFactory_create_vector,None,uBLASDenseFactory)
uBLASDenseFactory.create_local_vector = new_instancemethod(_cpp.uBLASDenseFactory_create_local_vector,None,uBLASDenseFactory)
uBLASDenseFactory.create_pattern = new_instancemethod(_cpp.uBLASDenseFactory_create_pattern,None,uBLASDenseFactory)
uBLASDenseFactory.create_lu_solver = new_instancemethod(_cpp.uBLASDenseFactory_create_lu_solver,None,uBLASDenseFactory)
uBLASDenseFactory_swigregister = _cpp.uBLASDenseFactory_swigregister
uBLASDenseFactory_swigregister(uBLASDenseFactory)

def uBLASDenseFactory_instance(*args):
  """
    Return singleton instance

    """
  return _cpp.uBLASDenseFactory_instance(*args)

dolfin_gt = _cpp.dolfin_gt
dolfin_ge = _cpp.dolfin_ge
dolfin_lt = _cpp.dolfin_lt
dolfin_le = _cpp.dolfin_le
dolfin_eq = _cpp.dolfin_eq
dolfin_neq = _cpp.dolfin_neq

def _get_vector_values(*args):
  return _cpp._get_vector_values(*args)
_get_vector_values = _cpp._get_vector_values

def _contains(*args):
  return _cpp._contains(*args)
_contains = _cpp._contains

def _compare_vector_with_value(*args):
  return _cpp._compare_vector_with_value(*args)
_compare_vector_with_value = _cpp._compare_vector_with_value

def _compare_vector_with_vector(*args):
  return _cpp._compare_vector_with_vector(*args)
_compare_vector_with_vector = _cpp._compare_vector_with_vector

def _get_vector_single_item(*args):
  return _cpp._get_vector_single_item(*args)
_get_vector_single_item = _cpp._get_vector_single_item

def _get_vector_sub_vector(*args):
  return _cpp._get_vector_sub_vector(*args)
_get_vector_sub_vector = _cpp._get_vector_sub_vector

def _set_vector_items_vector(*args):
  return _cpp._set_vector_items_vector(*args)
_set_vector_items_vector = _cpp._set_vector_items_vector

def _set_vector_items_array_of_float(*args):
  return _cpp._set_vector_items_array_of_float(*args)
_set_vector_items_array_of_float = _cpp._set_vector_items_array_of_float

def _set_vector_items_value(*args):
  return _cpp._set_vector_items_value(*args)
_set_vector_items_value = _cpp._set_vector_items_value

def _get_matrix_single_item(*args):
  return _cpp._get_matrix_single_item(*args)
_get_matrix_single_item = _cpp._get_matrix_single_item

def _get_matrix_sub_vector(*args):
  return _cpp._get_matrix_sub_vector(*args)
_get_matrix_sub_vector = _cpp._get_matrix_sub_vector

def _set_matrix_single_item(*args):
  return _cpp._set_matrix_single_item(*args)
_set_matrix_single_item = _cpp._set_matrix_single_item

def _set_matrix_items_array_of_float(*args):
  return _cpp._set_matrix_items_array_of_float(*args)
_set_matrix_items_array_of_float = _cpp._set_matrix_items_array_of_float

def _set_matrix_items_matrix(*args):
  return _cpp._set_matrix_items_matrix(*args)
_set_matrix_items_matrix = _cpp._set_matrix_items_matrix

def _set_matrix_items_vector(*args):
  return _cpp._set_matrix_items_vector(*args)
_set_matrix_items_vector = _cpp._set_matrix_items_vector
_has_type_map = {}
_down_cast_map = {}
# A map with matrix types as keys and list of possible vector types as values
_matrix_vector_mul_map = {}


def has_type_uBLASVector(*args):
  return _cpp.has_type_uBLASVector(*args)
has_type_uBLASVector = _cpp.has_type_uBLASVector

def down_cast_uBLASVector(*args):
  return _cpp.down_cast_uBLASVector(*args)
down_cast_uBLASVector = _cpp.down_cast_uBLASVector
_has_type_map[uBLASVector] = has_type_uBLASVector
_down_cast_map[uBLASVector] = down_cast_uBLASVector


def has_type_uBLASDenseMatrix(*args):
  return _cpp.has_type_uBLASDenseMatrix(*args)
has_type_uBLASDenseMatrix = _cpp.has_type_uBLASDenseMatrix

def down_cast_uBLASDenseMatrix(*args):
  return _cpp.down_cast_uBLASDenseMatrix(*args)
down_cast_uBLASDenseMatrix = _cpp.down_cast_uBLASDenseMatrix

def has_type_uBLASSparseMatrix(*args):
  return _cpp.has_type_uBLASSparseMatrix(*args)
has_type_uBLASSparseMatrix = _cpp.has_type_uBLASSparseMatrix

def down_cast_uBLASSparseMatrix(*args):
  return _cpp.down_cast_uBLASSparseMatrix(*args)
down_cast_uBLASSparseMatrix = _cpp.down_cast_uBLASSparseMatrix
_has_type_map[uBLASDenseMatrix] = has_type_uBLASDenseMatrix
_down_cast_map[uBLASDenseMatrix] = down_cast_uBLASDenseMatrix
_has_type_map[uBLASSparseMatrix] = has_type_uBLASSparseMatrix
_down_cast_map[uBLASSparseMatrix] = down_cast_uBLASSparseMatrix

_matrix_vector_mul_map[uBLASSparseMatrix] = [uBLASVector]
_matrix_vector_mul_map[uBLASDenseMatrix]  = [uBLASVector]


def has_type_PETScVector(*args):
  return _cpp.has_type_PETScVector(*args)
has_type_PETScVector = _cpp.has_type_PETScVector

def down_cast_PETScVector(*args):
  return _cpp.down_cast_PETScVector(*args)
down_cast_PETScVector = _cpp.down_cast_PETScVector
_has_type_map[PETScVector] = has_type_PETScVector
_down_cast_map[PETScVector] = down_cast_PETScVector


def has_type_PETScMatrix(*args):
  return _cpp.has_type_PETScMatrix(*args)
has_type_PETScMatrix = _cpp.has_type_PETScMatrix

def down_cast_PETScMatrix(*args):
  return _cpp.down_cast_PETScMatrix(*args)
down_cast_PETScMatrix = _cpp.down_cast_PETScMatrix
_has_type_map[PETScMatrix] = has_type_PETScMatrix
_down_cast_map[PETScMatrix] = down_cast_PETScMatrix

_matrix_vector_mul_map[PETScMatrix] = [PETScVector]

def get_tensor_type(tensor):
    "Return the concrete subclass of tensor."
    for k, v in _has_type_map.items():
        if v(tensor):
            return k
    dolfin_error("Unregistered tensor type.")

def has_type(tensor, subclass):
    "Return wether tensor is of the given subclass."
    global _has_type_map
    assert _has_type_map
    assert subclass in _has_type_map
    return bool(_has_type_map[subclass](tensor))

def down_cast(tensor, subclass=None):
    "Cast tensor to the given subclass, passing the wrong class is an error."
    global _down_cast_map
    assert _down_cast_map
    if subclass is None:
        subclass = get_tensor_type(tensor)
    assert subclass in _down_cast_map
    ret = _down_cast_map[subclass](tensor)

    # Store the tensor to avoid garbage collection
    ret._org_upcasted_tensor = tensor
    return ret


class NonlinearProblem(object):
    """
    This is a base class for nonlinear problems which can return the
    nonlinear function F(u) and its Jacobian J = dF(u)/du.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        if self.__class__ == NonlinearProblem:
            _self = None
        else:
            _self = self
        _cpp.NonlinearProblem_swiginit(self,_cpp.new_NonlinearProblem(_self, *args))
    __swig_destroy__ = _cpp.delete_NonlinearProblem
    def form(self, *args):
        """
        Function called by Newton solver before requesting F or J.
        This can be used to compute F and J together

        """
        return _cpp.NonlinearProblem_form(self, *args)

    def F(self, *args):
        """
        Compute F at current point x

        """
        return _cpp.NonlinearProblem_F(self, *args)

    def J(self, *args):
        """
        Compute J = F' at current point x

        """
        return _cpp.NonlinearProblem_J(self, *args)

    def __disown__(self):
        self.this.disown()
        _cpp.disown_NonlinearProblem(self)
        return weakref_proxy(self)
NonlinearProblem.form = new_instancemethod(_cpp.NonlinearProblem_form,None,NonlinearProblem)
NonlinearProblem.F = new_instancemethod(_cpp.NonlinearProblem_F,None,NonlinearProblem)
NonlinearProblem.J = new_instancemethod(_cpp.NonlinearProblem_J,None,NonlinearProblem)
NonlinearProblem_swigregister = _cpp.NonlinearProblem_swigregister
NonlinearProblem_swigregister(NonlinearProblem)

class NewtonSolver(Variable):
    """
    This class defines a Newton solver for nonlinear systems of
    equations of the form :math:`F(x) = 0`.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * NewtonSolver\ (solver_type="lu", pc_type="default")

          Create nonlinear solver with default linear solver and default
          linear algebra backend

        * NewtonSolver\ (solver, factory)

          Create nonlinear solver using provided linear solver and linear algebra
          backend determined by factory
          
          *Arguments*
              solver (:py:class:`GenericLinearSolver`)
                  The linear solver.
              factory (:py:class:`LinearAlgebraFactory`)
                  The factory.

        """
        _cpp.NewtonSolver_swiginit(self,_cpp.new_NewtonSolver(*args))
    __swig_destroy__ = _cpp.delete_NewtonSolver
    def solve(self, *args):
        """
        Solve abstract nonlinear problem :math:`F(x) = 0` for given
        :math:`F` and Jacobian :math:`\dfrac{\partial F}{\partial x}`.

        *Arguments*
            nonlinear_function (:py:class:`NonlinearProblem`)
                The nonlinear problem.
            x (:py:class:`GenericVector`)
                The vector.

        *Returns*
            (int, bool)
                Pair of number of Newton iterations, and whether
                iteration converged)

        """
        return _cpp.NewtonSolver_solve(self, *args)

    def iteration(self, *args):
        """
        Return Newton iteration number

        *Returns*
            int
                The iteration number.

        """
        return _cpp.NewtonSolver_iteration(self, *args)

    def residual(self, *args):
        """
        Return current residual

        *Returns*
            float
                Current residual.

        """
        return _cpp.NewtonSolver_residual(self, *args)

    def relative_residual(self, *args):
        """
        Return current relative residual

        *Returns*
            float
              Current relative residual.

        """
        return _cpp.NewtonSolver_relative_residual(self, *args)

    def linear_solver(self, *args):
        """
        Return the linear solver

        *Returns*
            :py:class:`GenericLinearSolver`
                The linear solver.

        """
        return _cpp.NewtonSolver_linear_solver(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        *Returns*
            :py:class:`Parameters`
                Parameter values.

        """
        return _cpp.NewtonSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
NewtonSolver.solve = new_instancemethod(_cpp.NewtonSolver_solve,None,NewtonSolver)
NewtonSolver.iteration = new_instancemethod(_cpp.NewtonSolver_iteration,None,NewtonSolver)
NewtonSolver.residual = new_instancemethod(_cpp.NewtonSolver_residual,None,NewtonSolver)
NewtonSolver.relative_residual = new_instancemethod(_cpp.NewtonSolver_relative_residual,None,NewtonSolver)
NewtonSolver.linear_solver = new_instancemethod(_cpp.NewtonSolver_linear_solver,None,NewtonSolver)
NewtonSolver_swigregister = _cpp.NewtonSolver_swigregister
NewtonSolver_swigregister(NewtonSolver)

def NewtonSolver_default_parameters(*args):
  """
    Default parameter values

    *Returns*
        :py:class:`Parameters`
            Parameter values.

    """
  return _cpp.NewtonSolver_default_parameters(*args)

class IntersectionOperator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * IntersectionOperator\ (_mesh, "SimpleCartesian")

          Create intersection detector for a given mesh
          
          
          @param kernel_type The CGAL geometric kernel is used to compute predicates,
          intersections and such. Depending on this choice the kernel
          (kernel_type = "ExcactPredicates") can compute predicates excactly
          (without roundoff error) or only approximately (default, kernel_type =
          "SimpleCartesian").

        * IntersectionOperator\ (labels, label, "SimpleCartesian")

          Create  IntersectionOperator for a given mesh
          
          *Arguments*
              labels (_MeshFunction<unsigned int>_)
                  A MeshFunction over entities labeling the part of the Mesh
                  for which the distance will be measured to
          
              label (int)
                  The label determining the part of the mesh for which
                  the distance will be measured to
          
              kernel_type (str)
                  The CGAL geometric kernel which is used to compute predicates,
                  intersections and such. Depending on this choice the kernel
                  (kernel_type = "ExcactPredicates") can compute predicates
                  excactly (without roundoff error) or only approximately
                  default value is "SimpleCartesian".

        * IntersectionOperator\ (labels, label, kernel_type="SimpleCartesian")

          Create IntersectionOperator for a given mesh (shared data)
          
          *Arguments*
              labels (_MeshFunction<unsigned int>_)
                  A MeshFunction over facets labeling the part of the Boundary
                  for which the distance will be measured to
          
              label (int)
                  The label determining the part of the mesh for which
                  the distance will be measured to
          
              kernel_type (str)
                  The CGAL geometric kernel which is used to compute predicates,
                  intersections and such. Depending on this choice the kernel
                  (kernel_type = "ExcactPredicates") can compute predicates
                  excactly (without roundoff error) or only approximately
                  default value is "SimpleCartesian".

        """
        _cpp.IntersectionOperator_swiginit(self,_cpp.new_IntersectionOperator(*args))
    __swig_destroy__ = _cpp.delete_IntersectionOperator
    def all_intersected_entities(self, *args):
        """
        **Overloaded versions**

        * all_intersected_entities\ (point, ids_result)

          Compute all id of all cells which are intersects by a m point.
          \param[out] ids_result The ids of the intersected entities are saved in a set for efficienty
          reasons, to avoid to sort out duplicates later on.

        * all_intersected_entities\ (points, ids_result)

          Compute all id of all cells which are intersects any point in m points.
          \param[out] ids_result The ids of the intersected entities are saved in a set for efficienty
          reasons, to avoid to sort out duplicates later on.

        * all_intersected_entities\ (entity, ids_result)

          Compute all id of all cells which are intersects by a m entity.
          \param[out] ids_result The ids of the intersected entities are saved in a vector.
          This allows is more efficent than using a set and allows a map between
          the (external) cell and the intersected cell of the mesh. If you
          are only interested in intersection with a list of cells without caring about which
          cell what intersected by which one, use
          void IntersectionOperator::all_intersected_entities(const std::vector<Cell> &, std::set<uint> &) const;
          @internal
          @todo This function has to improved: 1) it requires the object the
          mesh is to be cut with to be another mesh entitiy instead of being just a
          kind of geometric object. 2) Requires a runtime switch 3) would require a
          implementation for each geometric  primitive if they have no common base
          class.

        * all_intersected_entities\ (entities, ids_result)

          Compute all id of all cells which are intersects by any of the entities in m entities. This
          \param[out] ids_result The ids of the intersected set are saved in a set for efficienty
          reasons, to avoid to sort out duplicates later on.

        * all_intersected_entities\ (another_mesh, ids_result)

          Compute all id of all cells which are intersects by the given mesh m another_mesh;
          \param[out] ids_result The ids of the intersected entities are saved in a set for efficienty
          reasons, to avoid to sort out duplicates later on.

        """
        return _cpp.IntersectionOperator_all_intersected_entities(self, *args)

    def any_intersected_entity(self, *args):
        """
        Computes only the first id of the entity, which contains the point. Returns -1 if no cell is intersected.
        @internal @remark This makes the function evaluation significantly faster.

        """
        return _cpp.IntersectionOperator_any_intersected_entity(self, *args)

    def closest_point(self, *args):
        """
        Computes the point inside the mesh which is closest to the point query.

        """
        return _cpp.IntersectionOperator_closest_point(self, *args)

    def closest_cell(self, *args):
        """
        Computes the index of the cell inside the mesh which are closest to the point query.

        """
        return _cpp.IntersectionOperator_closest_cell(self, *args)

    def closest_point_and_cell(self, *args):
        """
        Computes the point inside the mesh and the corresponding cell index
        that are closest to the point query.

        """
        return _cpp.IntersectionOperator_closest_point_and_cell(self, *args)

    def distance(self, *args):
        """
        Computes the distance between the given point and the nearest entity

        """
        return _cpp.IntersectionOperator_distance(self, *args)

    def reset_kernel(self, *args):
        """
        Rebuilds the underlying search structure from scratch and uses
        the kernel kernel_type underlying CGAL Geometry kernel.

        """
        return _cpp.IntersectionOperator_reset_kernel(self, *args)

    def clear(self, *args):
        """
        Clears search structure. Should be used if the mesh has changed

        """
        return _cpp.IntersectionOperator_clear(self, *args)

IntersectionOperator.all_intersected_entities = new_instancemethod(_cpp.IntersectionOperator_all_intersected_entities,None,IntersectionOperator)
IntersectionOperator.any_intersected_entity = new_instancemethod(_cpp.IntersectionOperator_any_intersected_entity,None,IntersectionOperator)
IntersectionOperator.closest_point = new_instancemethod(_cpp.IntersectionOperator_closest_point,None,IntersectionOperator)
IntersectionOperator.closest_cell = new_instancemethod(_cpp.IntersectionOperator_closest_cell,None,IntersectionOperator)
IntersectionOperator.closest_point_and_cell = new_instancemethod(_cpp.IntersectionOperator_closest_point_and_cell,None,IntersectionOperator)
IntersectionOperator.distance = new_instancemethod(_cpp.IntersectionOperator_distance,None,IntersectionOperator)
IntersectionOperator.reset_kernel = new_instancemethod(_cpp.IntersectionOperator_reset_kernel,None,IntersectionOperator)
IntersectionOperator.clear = new_instancemethod(_cpp.IntersectionOperator_clear,None,IntersectionOperator)
IntersectionOperator.mesh = new_instancemethod(_cpp.IntersectionOperator_mesh,None,IntersectionOperator)
IntersectionOperator_swigregister = _cpp.IntersectionOperator_swigregister
IntersectionOperator_swigregister(IntersectionOperator)

class PrimitiveIntersector(object):
    """
    This class implements an intersection detection, detecting
    whether two given (arbitrary) meshentities intersect.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def do_intersect(*args):
        """
        **Overloaded versions**

        * do_intersect\ (entity_1, entity_2)

          Computes whether two mesh entities intersect using an inexact
          geometry kernel which is fast but may suffer from floating
          point precision

        * do_intersect\ (entity_1, point)

          Computes whether a mesh entity and point intersect using an
          inexact geometry kernel which is fast but may suffer from
          floating point precision

        """
        return _cpp.PrimitiveIntersector_do_intersect(*args)

    do_intersect = staticmethod(do_intersect)
    def do_intersect_exact(*args):
        """
        **Overloaded versions**

        * do_intersect_exact\ (entity_1, entity_2)

          Computes whether two mesh entities intersect using an exact
          geometry kernel which is slow but always correct

        * do_intersect_exact\ (entity_1, point)

          Computes whether a mesh entity and point intersect using an
          exact geometry kernel which is slow but always correct

        """
        return _cpp.PrimitiveIntersector_do_intersect_exact(*args)

    do_intersect_exact = staticmethod(do_intersect_exact)
    def __init__(self, *args): 
        _cpp.PrimitiveIntersector_swiginit(self,_cpp.new_PrimitiveIntersector(*args))
    __swig_destroy__ = _cpp.delete_PrimitiveIntersector
PrimitiveIntersector_swigregister = _cpp.PrimitiveIntersector_swigregister
PrimitiveIntersector_swigregister(PrimitiveIntersector)

def PrimitiveIntersector_do_intersect(*args):
  """
    **Overloaded versions**

    * do_intersect\ (entity_1, entity_2)

      Computes whether two mesh entities intersect using an inexact
      geometry kernel which is fast but may suffer from floating
      point precision

    * do_intersect\ (entity_1, point)

      Computes whether a mesh entity and point intersect using an
      inexact geometry kernel which is fast but may suffer from
      floating point precision

    """
  return _cpp.PrimitiveIntersector_do_intersect(*args)

def PrimitiveIntersector_do_intersect_exact(*args):
  """
    **Overloaded versions**

    * do_intersect_exact\ (entity_1, entity_2)

      Computes whether two mesh entities intersect using an exact
      geometry kernel which is slow but always correct

    * do_intersect_exact\ (entity_1, point)

      Computes whether a mesh entity and point intersect using an
      exact geometry kernel which is slow but always correct

    """
  return _cpp.PrimitiveIntersector_do_intersect_exact(*args)

class HierarchicalMesh(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalMesh_swiginit(self,_cpp.new_HierarchicalMesh(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalMesh
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalMesh_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalMesh_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalMesh_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalMesh_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalMesh_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMesh_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMesh_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalMesh_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalMesh_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalMesh__debug(self, *args)

HierarchicalMesh.depth = new_instancemethod(_cpp.HierarchicalMesh_depth,None,HierarchicalMesh)
HierarchicalMesh.has_parent = new_instancemethod(_cpp.HierarchicalMesh_has_parent,None,HierarchicalMesh)
HierarchicalMesh.has_child = new_instancemethod(_cpp.HierarchicalMesh_has_child,None,HierarchicalMesh)
HierarchicalMesh.parent = new_instancemethod(_cpp.HierarchicalMesh_parent,None,HierarchicalMesh)
HierarchicalMesh.child = new_instancemethod(_cpp.HierarchicalMesh_child,None,HierarchicalMesh)
HierarchicalMesh.root_node = new_instancemethod(_cpp.HierarchicalMesh_root_node,None,HierarchicalMesh)
HierarchicalMesh.leaf_node = new_instancemethod(_cpp.HierarchicalMesh_leaf_node,None,HierarchicalMesh)
HierarchicalMesh.set_parent = new_instancemethod(_cpp.HierarchicalMesh_set_parent,None,HierarchicalMesh)
HierarchicalMesh.set_child = new_instancemethod(_cpp.HierarchicalMesh_set_child,None,HierarchicalMesh)
HierarchicalMesh._debug = new_instancemethod(_cpp.HierarchicalMesh__debug,None,HierarchicalMesh)
HierarchicalMesh_swigregister = _cpp.HierarchicalMesh_swigregister
HierarchicalMesh_swigregister(HierarchicalMesh)

class HierarchicalMeshFunctionUInt(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalMeshFunctionUInt_swiginit(self,_cpp.new_HierarchicalMeshFunctionUInt(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalMeshFunctionUInt
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalMeshFunctionUInt_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalMeshFunctionUInt_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalMeshFunctionUInt_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalMeshFunctionUInt_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalMeshFunctionUInt_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionUInt_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionUInt_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalMeshFunctionUInt_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalMeshFunctionUInt_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalMeshFunctionUInt__debug(self, *args)

HierarchicalMeshFunctionUInt.depth = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_depth,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.has_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_has_parent,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.has_child = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_has_child,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.parent = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_parent,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.child = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_child,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.root_node = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_root_node,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.leaf_node = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_leaf_node,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.set_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_set_parent,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt.set_child = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt_set_child,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt._debug = new_instancemethod(_cpp.HierarchicalMeshFunctionUInt__debug,None,HierarchicalMeshFunctionUInt)
HierarchicalMeshFunctionUInt_swigregister = _cpp.HierarchicalMeshFunctionUInt_swigregister
HierarchicalMeshFunctionUInt_swigregister(HierarchicalMeshFunctionUInt)

class HierarchicalMeshFunctionInt(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalMeshFunctionInt_swiginit(self,_cpp.new_HierarchicalMeshFunctionInt(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalMeshFunctionInt
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalMeshFunctionInt_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalMeshFunctionInt_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalMeshFunctionInt_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalMeshFunctionInt_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalMeshFunctionInt_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionInt_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionInt_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalMeshFunctionInt_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalMeshFunctionInt_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalMeshFunctionInt__debug(self, *args)

HierarchicalMeshFunctionInt.depth = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_depth,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.has_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_has_parent,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.has_child = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_has_child,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.parent = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_parent,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.child = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_child,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.root_node = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_root_node,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.leaf_node = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_leaf_node,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.set_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_set_parent,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt.set_child = new_instancemethod(_cpp.HierarchicalMeshFunctionInt_set_child,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt._debug = new_instancemethod(_cpp.HierarchicalMeshFunctionInt__debug,None,HierarchicalMeshFunctionInt)
HierarchicalMeshFunctionInt_swigregister = _cpp.HierarchicalMeshFunctionInt_swigregister
HierarchicalMeshFunctionInt_swigregister(HierarchicalMeshFunctionInt)

class HierarchicalMeshFunctionDouble(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalMeshFunctionDouble_swiginit(self,_cpp.new_HierarchicalMeshFunctionDouble(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalMeshFunctionDouble
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalMeshFunctionDouble_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalMeshFunctionDouble_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalMeshFunctionDouble_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalMeshFunctionDouble_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalMeshFunctionDouble_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionDouble_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionDouble_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalMeshFunctionDouble_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalMeshFunctionDouble_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalMeshFunctionDouble__debug(self, *args)

HierarchicalMeshFunctionDouble.depth = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_depth,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.has_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_has_parent,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.has_child = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_has_child,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.parent = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_parent,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.child = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_child,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.root_node = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_root_node,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.leaf_node = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_leaf_node,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.set_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_set_parent,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble.set_child = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble_set_child,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble._debug = new_instancemethod(_cpp.HierarchicalMeshFunctionDouble__debug,None,HierarchicalMeshFunctionDouble)
HierarchicalMeshFunctionDouble_swigregister = _cpp.HierarchicalMeshFunctionDouble_swigregister
HierarchicalMeshFunctionDouble_swigregister(HierarchicalMeshFunctionDouble)

class HierarchicalMeshFunctionBool(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalMeshFunctionBool_swiginit(self,_cpp.new_HierarchicalMeshFunctionBool(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalMeshFunctionBool
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalMeshFunctionBool_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalMeshFunctionBool_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalMeshFunctionBool_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalMeshFunctionBool_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalMeshFunctionBool_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionBool_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalMeshFunctionBool_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalMeshFunctionBool_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalMeshFunctionBool_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalMeshFunctionBool__debug(self, *args)

HierarchicalMeshFunctionBool.depth = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_depth,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.has_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_has_parent,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.has_child = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_has_child,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.parent = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_parent,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.child = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_child,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.root_node = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_root_node,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.leaf_node = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_leaf_node,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.set_parent = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_set_parent,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool.set_child = new_instancemethod(_cpp.HierarchicalMeshFunctionBool_set_child,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool._debug = new_instancemethod(_cpp.HierarchicalMeshFunctionBool__debug,None,HierarchicalMeshFunctionBool)
HierarchicalMeshFunctionBool_swigregister = _cpp.HierarchicalMeshFunctionBool_swigregister
HierarchicalMeshFunctionBool_swigregister(HierarchicalMeshFunctionBool)

class CellType(object):
    """
    This class provides a common interface for different cell types.
    Each cell type implements mesh functionality that is specific to
    a certain type of cell.

    """
    thisown = _swig_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
    point = _cpp.CellType_point
    interval = _cpp.CellType_interval
    triangle = _cpp.CellType_triangle
    tetrahedron = _cpp.CellType_tetrahedron
    __swig_destroy__ = _cpp.delete_CellType
    def create(*args):
        """
        **Overloaded versions**

        * create\ (type)

          Create cell type from type (factory function)

        * create\ (type)

          Create cell type from string (factory function)

        """
        return _cpp.CellType_create(*args)

    create = staticmethod(create)
    def string2type(*args):
        """
        Convert from string to cell type

        """
        return _cpp.CellType_string2type(*args)

    string2type = staticmethod(string2type)
    def type2string(*args):
        """
        Convert from cell type to string

        """
        return _cpp.CellType_type2string(*args)

    type2string = staticmethod(type2string)
    def cell_type(self, *args):
        """
        Return type of cell

        """
        return _cpp.CellType_cell_type(self, *args)

    def facet_type(self, *args):
        """
        Return type of cell for facets

        """
        return _cpp.CellType_facet_type(self, *args)

    def dim(self, *args):
        """
        Return topological dimension of cell

        """
        return _cpp.CellType_dim(self, *args)

    def num_entities(self, *args):
        """
        Return number of entitites of given topological dimension

        """
        return _cpp.CellType_num_entities(self, *args)

    def num_vertices(self, *args):
        """
        Return number of vertices for entity of given topological dimension

        """
        return _cpp.CellType_num_vertices(self, *args)

    def orientation(self, *args):
        """
        Return orientation of the cell

        """
        return _cpp.CellType_orientation(self, *args)

    def create_entities(self, *args):
        """
        Create entities e of given topological dimension from vertices v

        """
        return _cpp.CellType_create_entities(self, *args)

    def refine_cell(self, *args):
        """
        Refine cell uniformly

        """
        return _cpp.CellType_refine_cell(self, *args)

    def volume(self, *args):
        """
        Compute (generalized) volume of mesh entity

        """
        return _cpp.CellType_volume(self, *args)

    def diameter(self, *args):
        """
        Compute diameter of mesh entity

        """
        return _cpp.CellType_diameter(self, *args)

    def normal(self, *args):
        """
        **Overloaded versions**

        * normal\ (cell, facet, i)

          Compute component i of normal of given facet with respect to the cell

        * normal\ (cell, facet)

          Compute of given facet with respect to the cell

        """
        return _cpp.CellType_normal(self, *args)

    def facet_area(self, *args):
        """
        Compute the area/length of given facet with respect to the cell

        """
        return _cpp.CellType_facet_area(self, *args)

    def order(self, *args):
        """
        Order entities locally

        """
        return _cpp.CellType_order(self, *args)

    def ordered(self, *args):
        """
        Check if entities are ordered

        """
        return _cpp.CellType_ordered(self, *args)

    def description(self, *args):
        """
        Return description of cell type

        """
        return _cpp.CellType_description(self, *args)

CellType.cell_type = new_instancemethod(_cpp.CellType_cell_type,None,CellType)
CellType.facet_type = new_instancemethod(_cpp.CellType_facet_type,None,CellType)
CellType.dim = new_instancemethod(_cpp.CellType_dim,None,CellType)
CellType.num_entities = new_instancemethod(_cpp.CellType_num_entities,None,CellType)
CellType.num_vertices = new_instancemethod(_cpp.CellType_num_vertices,None,CellType)
CellType.orientation = new_instancemethod(_cpp.CellType_orientation,None,CellType)
CellType.create_entities = new_instancemethod(_cpp.CellType_create_entities,None,CellType)
CellType.refine_cell = new_instancemethod(_cpp.CellType_refine_cell,None,CellType)
CellType.volume = new_instancemethod(_cpp.CellType_volume,None,CellType)
CellType.diameter = new_instancemethod(_cpp.CellType_diameter,None,CellType)
CellType.normal = new_instancemethod(_cpp.CellType_normal,None,CellType)
CellType.facet_area = new_instancemethod(_cpp.CellType_facet_area,None,CellType)
CellType.order = new_instancemethod(_cpp.CellType_order,None,CellType)
CellType.ordered = new_instancemethod(_cpp.CellType_ordered,None,CellType)
CellType.description = new_instancemethod(_cpp.CellType_description,None,CellType)
CellType_swigregister = _cpp.CellType_swigregister
CellType_swigregister(CellType)

def CellType_create(*args):
  """
    **Overloaded versions**

    * create\ (type)

      Create cell type from type (factory function)

    * create\ (type)

      Create cell type from string (factory function)

    """
  return _cpp.CellType_create(*args)

def CellType_string2type(*args):
  """
    Convert from string to cell type

    """
  return _cpp.CellType_string2type(*args)

def CellType_type2string(*args):
  """
    Convert from cell type to string

    """
  return _cpp.CellType_type2string(*args)

class MeshTopology(object):
    """
    MeshTopology stores the topology of a mesh, consisting of mesh entities
    and connectivity (incidence relations for the mesh entities). Note that
    the mesh entities don't need to be stored, only the number of entities
    and the connectivity. Any numbering scheme for the mesh entities is
    stored separately in a MeshFunction over the entities.

    A mesh entity e may be identified globally as a pair e = (dim, i), where
    dim is the topological dimension and i is the index of the entity within
    that topological dimension.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshTopology\ ()

          Create empty mesh topology

        * MeshTopology\ (topology)

          Copy constructor

        """
        _cpp.MeshTopology_swiginit(self,_cpp.new_MeshTopology(*args))
    __swig_destroy__ = _cpp.delete_MeshTopology
    def dim(self, *args):
        """
        Return topological dimension

        """
        return _cpp.MeshTopology_dim(self, *args)

    def size(self, *args):
        """
        Return number of entities for given dimension

        """
        return _cpp.MeshTopology_size(self, *args)

    def clear(self, *args):
        """
        **Overloaded versions**

        * clear\ ()

          Clear all data

        * clear\ (d0, d1)

          Clear data for given pair of topological dimensions

        """
        return _cpp.MeshTopology_clear(self, *args)

    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (dim)

          Initialize topology of given maximum dimension

        * init\ (dim, size)

          Set number of entities (size) for given topological dimension

        """
        return _cpp.MeshTopology_init(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.MeshTopology_str(self, *args)

MeshTopology.dim = new_instancemethod(_cpp.MeshTopology_dim,None,MeshTopology)
MeshTopology.size = new_instancemethod(_cpp.MeshTopology_size,None,MeshTopology)
MeshTopology.clear = new_instancemethod(_cpp.MeshTopology_clear,None,MeshTopology)
MeshTopology.init = new_instancemethod(_cpp.MeshTopology_init,None,MeshTopology)
MeshTopology.__call__ = new_instancemethod(_cpp.MeshTopology___call__,None,MeshTopology)
MeshTopology.str = new_instancemethod(_cpp.MeshTopology_str,None,MeshTopology)
MeshTopology_swigregister = _cpp.MeshTopology_swigregister
MeshTopology_swigregister(MeshTopology)

class MeshGeometry(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshGeometry\ ()

          Create empty set of coordinates

        * MeshGeometry\ (geometry)

          Copy constructor

        """
        _cpp.MeshGeometry_swiginit(self,_cpp.new_MeshGeometry(*args))
    __swig_destroy__ = _cpp.delete_MeshGeometry
    def dim(self, *args):
        """
        Return Euclidean dimension of coordinate system

        """
        return _cpp.MeshGeometry_dim(self, *args)

    def size(self, *args):
        """
        Return number of coordinates

        """
        return _cpp.MeshGeometry_size(self, *args)

    def x(self, *args):
        """
        **Overloaded versions**

        * x\ (n, i)

          Return value of coordinate n in direction i

        * x\ (n, i)

          Return value of coordinate n in direction i

        * x\ (n)

          Return array of values for coordinate n

        * x\ (n)

          Return array of values for coordinate n

        * x\ ()

          Return array of values for all coordinates

        * x\ ()

          Return array of values for all coordinates

        """
        return _cpp.MeshGeometry_x(self, *args)

    def higher_order_x(self, *args):
        """
        **Overloaded versions**

        * higher_order_x\ (n)

          Return array of values for higher order coordinate n

        * higher_order_x\ (n)

          Return array of values for higher order coordinate n

        * higher_order_x\ ()

          Return array of values for all higher order coordinates

        * higher_order_x\ ()

          Return array of values for all higher order coordinates

        """
        return _cpp.MeshGeometry_higher_order_x(self, *args)

    def num_higher_order_vertices_per_cell(self, *args):
        """
        Return number of vertices used (per cell) to represent the higher order geometry

        """
        return _cpp.MeshGeometry_num_higher_order_vertices_per_cell(self, *args)

    def higher_order_cell(self, *args):
        """
        **Overloaded versions**

        * higher_order_cell\ (c)

          Return array of higher order vertex indices for a specific higher order cell

        * higher_order_cell\ (c)

          Return array of higher order vertex indices for a specific higher order cell

        """
        return _cpp.MeshGeometry_higher_order_cell(self, *args)

    def higher_order_cells(self, *args):
        """
        **Overloaded versions**

        * higher_order_cells\ ()

          Return array of values for all higher order cell data

        * higher_order_cells\ ()

          Return array of values for all higher order cell data

        """
        return _cpp.MeshGeometry_higher_order_cells(self, *args)

    def point(self, *args):
        """
        Return coordinate n as a 3D point value

        """
        return _cpp.MeshGeometry_point(self, *args)

    def affine_cell_bool(self, *args):
        """
        Return pointer to boolean affine indicator array

        """
        return _cpp.MeshGeometry_affine_cell_bool(self, *args)

    def clear(self, *args):
        """
        Clear all data

        """
        return _cpp.MeshGeometry_clear(self, *args)

    def init(self, *args):
        """
        Initialize coordinate list to given dimension and size

        """
        return _cpp.MeshGeometry_init(self, *args)

    def init_higher_order_vertices(self, *args):
        """
        Initialize higher order coordinate list to given dimension and size

        """
        return _cpp.MeshGeometry_init_higher_order_vertices(self, *args)

    def init_higher_order_cells(self, *args):
        """
        Initialize higher order cell data list to given number of cells and dofs

        """
        return _cpp.MeshGeometry_init_higher_order_cells(self, *args)

    def init_affine_indicator(self, *args):
        """
        Initialize the affine indicator array

        """
        return _cpp.MeshGeometry_init_affine_indicator(self, *args)

    def set_affine_indicator(self, *args):
        """
        set affine indicator at index i

        """
        return _cpp.MeshGeometry_set_affine_indicator(self, *args)

    def set(self, *args):
        """
        Set value of coordinate n in direction i

        """
        return _cpp.MeshGeometry_set(self, *args)

    def set_higher_order_coordinates(self, *args):
        """
        Set value of higher order coordinate N in direction i

        """
        return _cpp.MeshGeometry_set_higher_order_coordinates(self, *args)

    def set_higher_order_cell_data(self, *args):
        """
        Set higher order cell data for cell # N in direction i

        """
        return _cpp.MeshGeometry_set_higher_order_cell_data(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.MeshGeometry_str(self, *args)

MeshGeometry.dim = new_instancemethod(_cpp.MeshGeometry_dim,None,MeshGeometry)
MeshGeometry.size = new_instancemethod(_cpp.MeshGeometry_size,None,MeshGeometry)
MeshGeometry.x = new_instancemethod(_cpp.MeshGeometry_x,None,MeshGeometry)
MeshGeometry.higher_order_x = new_instancemethod(_cpp.MeshGeometry_higher_order_x,None,MeshGeometry)
MeshGeometry.num_higher_order_vertices_per_cell = new_instancemethod(_cpp.MeshGeometry_num_higher_order_vertices_per_cell,None,MeshGeometry)
MeshGeometry.higher_order_cell = new_instancemethod(_cpp.MeshGeometry_higher_order_cell,None,MeshGeometry)
MeshGeometry.higher_order_cells = new_instancemethod(_cpp.MeshGeometry_higher_order_cells,None,MeshGeometry)
MeshGeometry.point = new_instancemethod(_cpp.MeshGeometry_point,None,MeshGeometry)
MeshGeometry.affine_cell_bool = new_instancemethod(_cpp.MeshGeometry_affine_cell_bool,None,MeshGeometry)
MeshGeometry.clear = new_instancemethod(_cpp.MeshGeometry_clear,None,MeshGeometry)
MeshGeometry.init = new_instancemethod(_cpp.MeshGeometry_init,None,MeshGeometry)
MeshGeometry.init_higher_order_vertices = new_instancemethod(_cpp.MeshGeometry_init_higher_order_vertices,None,MeshGeometry)
MeshGeometry.init_higher_order_cells = new_instancemethod(_cpp.MeshGeometry_init_higher_order_cells,None,MeshGeometry)
MeshGeometry.init_affine_indicator = new_instancemethod(_cpp.MeshGeometry_init_affine_indicator,None,MeshGeometry)
MeshGeometry.set_affine_indicator = new_instancemethod(_cpp.MeshGeometry_set_affine_indicator,None,MeshGeometry)
MeshGeometry.set = new_instancemethod(_cpp.MeshGeometry_set,None,MeshGeometry)
MeshGeometry.set_higher_order_coordinates = new_instancemethod(_cpp.MeshGeometry_set_higher_order_coordinates,None,MeshGeometry)
MeshGeometry.set_higher_order_cell_data = new_instancemethod(_cpp.MeshGeometry_set_higher_order_cell_data,None,MeshGeometry)
MeshGeometry.str = new_instancemethod(_cpp.MeshGeometry_str,None,MeshGeometry)
MeshGeometry_swigregister = _cpp.MeshGeometry_swigregister
MeshGeometry_swigregister(MeshGeometry)

class MeshDomains(object):
    """
    The class :py:class:`MeshDomains` stores the division of a :py:class:`Mesh` into
    subdomains. For each topological dimension 0 <= d <= D, where D
    is the topological dimension of the :py:class:`Mesh`, a set of integer
    markers are stored for a subset of the entities of dimension d,
    indicating for each entity in the subset the number of the
    subdomain. It should be noted that the subset does not need to
    contain all entities of any given dimension; entities not
    contained in the subset are "unmarked".

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create empty mesh domains

        """
        _cpp.MeshDomains_swiginit(self,_cpp.new_MeshDomains(*args))
    __swig_destroy__ = _cpp.delete_MeshDomains
    def dim(self, *args):
        """
        Return maximal topological dimension of stored markers

        """
        return _cpp.MeshDomains_dim(self, *args)

    def num_marked(self, *args):
        """
        Return number of marked entities of given dimension

        """
        return _cpp.MeshDomains_num_marked(self, *args)

    def is_empty(self, *args):
        """
        Check whether domain data is empty

        """
        return _cpp.MeshDomains_is_empty(self, *args)

    def markers(self, *args):
        """
        **Overloaded versions**

        * markers_shared_ptr\ (dim)

          Get subdomain markers for given dimension (shared pointer version)

        * markers_shared_ptr\ (dim)

          Get subdomain markers for given dimension (const shared pointer version)

        """
        return _cpp.MeshDomains_markers(self, *args)

    def cell_domains(self, *args):
        """
        Get cell domains. This function computes the mesh function
        corresponding to markers of dimension D. The mesh function is
        cached for later access and will be computed on the first call
        to this function.

        """
        return _cpp.MeshDomains_cell_domains(self, *args)

    def facet_domains(self, *args):
        """
        Get facet domains. This function computes the mesh function
        corresponding to markers of dimension D-1. The mesh function
        is cached for later access and will be computed on the first
        call to this function.

        """
        return _cpp.MeshDomains_facet_domains(self, *args)

    def init(self, *args):
        """
        Initialize mesh domains for given topological dimension

        """
        return _cpp.MeshDomains_init(self, *args)

    def clear(self, *args):
        """
        Clear all data

        """
        return _cpp.MeshDomains_clear(self, *args)

MeshDomains.dim = new_instancemethod(_cpp.MeshDomains_dim,None,MeshDomains)
MeshDomains.num_marked = new_instancemethod(_cpp.MeshDomains_num_marked,None,MeshDomains)
MeshDomains.is_empty = new_instancemethod(_cpp.MeshDomains_is_empty,None,MeshDomains)
MeshDomains.markers = new_instancemethod(_cpp.MeshDomains_markers,None,MeshDomains)
MeshDomains.cell_domains = new_instancemethod(_cpp.MeshDomains_cell_domains,None,MeshDomains)
MeshDomains.facet_domains = new_instancemethod(_cpp.MeshDomains_facet_domains,None,MeshDomains)
MeshDomains.init = new_instancemethod(_cpp.MeshDomains_init,None,MeshDomains)
MeshDomains.clear = new_instancemethod(_cpp.MeshDomains_clear,None,MeshDomains)
MeshDomains_swigregister = _cpp.MeshDomains_swigregister
MeshDomains_swigregister(MeshDomains)

class MeshData(Variable):
    """
    The class MeshData is a container for auxiliary mesh data,
    represented either as :py:class:`MeshFunction` over topological mesh
    entities, arrays or maps. Each dataset is identified by a unique
    user-specified string. Only uint-valued data are currently
    supported.

    Auxiliary mesh data may be attached to a mesh by users as a
    convenient way to store data associated with a mesh. It is also
    used internally by DOLFIN to communicate data associated with
    meshes. The following named mesh data are recognized by DOLFIN:

    Facet orientation (used for assembly over interior facets)

      * "facet_orientation"     - :py:class:`MeshFunction` <uint> of dimension D - 1

    Sub meshes (used by the class SubMesh)

      * "parent_vertex_indices" - :py:class:`MeshFunction` <uint> of dimension 0

    Note to developers: use underscore in names in place of spaces.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.MeshData_swiginit(self,_cpp.new_MeshData(*args))
    __swig_destroy__ = _cpp.delete_MeshData
    def clear(self, *args):
        """
        Clear all data

        """
        return _cpp.MeshData_clear(self, *args)

    def create_mesh_function(self, *args):
        """
        **Overloaded versions**

        * create_mesh_function\ (name)

          Create MeshFunction with given name (uninitialized)
          
          *Arguments*
              name (str)
                  The name of the mesh function.
          
          *Returns*
              :py:class:`MeshFunction`
                  The mesh function.

        * create_mesh_function\ (name, dim)

          Create MeshFunction with given name and dimension
          
          *Arguments*
              name (str)
                  The name of the mesh function.
              dim (int)
                  The dimension of the mesh function.
          
          *Returns*
              :py:class:`MeshFunction`
                  The mesh function.

        """
        return _cpp.MeshData_create_mesh_function(self, *args)

    def create_array(self, *args):
        """
        **Overloaded versions**

        * create_array\ (name)

          Create empty array (vector) with given name
          
          *Arguments*
              name (str)
                  The name of the array.
          
          *Returns*
              numpy.array(int)
                  The array.

        * create_array\ (name, size)

          Create array (vector) with given name and size
          
          *Arguments*
              name (str)
                  The name of the array.
              size (unit)
                  The size (length) of the array.
          
          *Returns*
              numpy.array(int)
                  The array.

        """
        return _cpp.MeshData_create_array(self, *args)

    def mesh_function(self, *args):
        """
        Return MeshFunction with given name (returning zero if data is
        not available)

        *Arguments*
            name (str)
                The name of the MeshFunction.

        *Returns*
            :py:class:`MeshFunction`
                The mesh function with given name

        """
        return _cpp.MeshData_mesh_function(self, *args)

    def array(self, *args):
        """
        Return array with given name (returning zero if data is not
        available)

        *Arguments*
            name (str)
                The name of the array.

        *Returns*
            numpy.array(int)
                The array.

        """
        return _cpp.MeshData_array(self, *args)

    def erase_mesh_function(self, *args):
        """
        Erase MeshFunction with given name

        *Arguments*
            name (str)
                The name of the mesh function

        """
        return _cpp.MeshData_erase_mesh_function(self, *args)

    def erase_array(self, *args):
        """
        Erase array with given name

        *Arguments*
            name (str)
                The name of the array.

        """
        return _cpp.MeshData_erase_array(self, *args)

MeshData.clear = new_instancemethod(_cpp.MeshData_clear,None,MeshData)
MeshData.create_mesh_function = new_instancemethod(_cpp.MeshData_create_mesh_function,None,MeshData)
MeshData.create_array = new_instancemethod(_cpp.MeshData_create_array,None,MeshData)
MeshData.mesh_function = new_instancemethod(_cpp.MeshData_mesh_function,None,MeshData)
MeshData.array = new_instancemethod(_cpp.MeshData_array,None,MeshData)
MeshData.erase_mesh_function = new_instancemethod(_cpp.MeshData_erase_mesh_function,None,MeshData)
MeshData.erase_array = new_instancemethod(_cpp.MeshData_erase_array,None,MeshData)
MeshData_swigregister = _cpp.MeshData_swigregister
MeshData_swigregister(MeshData)

class ParallelData(object):
    """
    This class stores auxiliary mesh data for parallel computing.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * ParallelData\ (mesh)

          Constructor

        * ParallelData\ (data)

          Copy constructor

        """
        _cpp.ParallelData_swiginit(self,_cpp.new_ParallelData(*args))
    __swig_destroy__ = _cpp.delete_ParallelData
    def have_global_entity_indices(self, *args):
        """
        Return true if global indices have been computed for entity of
        dimension d

        """
        return _cpp.ParallelData_have_global_entity_indices(self, *args)

    def global_entity_indices(self, *args):
        """
        **Overloaded versions**

        * global_entity_indices\ (d)

          Return global indices (local-to-global) for entity of dimension d

        * global_entity_indices\ (d)

          Return global indices (local-to-global) for entity of dimension d (const version)

        """
        return _cpp.ParallelData_global_entity_indices(self, *args)

    def global_entity_indices_as_vector(self, *args):
        """
        Return global indices (local-to-global) for entity of dimension d in a vector

        """
        return _cpp.ParallelData_global_entity_indices_as_vector(self, *args)

    def global_to_local_entity_indices(self, *args):
        """
        **Overloaded versions**

        * global_to_local_entity_indices\ (d)

          Return global-to-local indices for entity of dimension d

        * global_to_local_entity_indices\ (d)

          Return global-to-local indices for entity of dimension d (const version)

        """
        return _cpp.ParallelData_global_to_local_entity_indices(self, *args)

    def shared_vertices(self, *args):
        """
        **Overloaded versions**

        * shared_vertices\ ()

          FIXME: Add description and use better name

        * shared_vertices\ ()

          FIXME: Add description and use better name

        """
        return _cpp.ParallelData_shared_vertices(self, *args)

    def exterior_facet(self, *args):
        """
        **Overloaded versions**

        * exterior_facet\ ()

          Return MeshFunction that is true for globally exterior facets,
          false otherwise

        * exterior_facet\ ()

          Return MeshFunction that is true for globally exterior facets,
          false otherwise (const version)

        """
        return _cpp.ParallelData_exterior_facet(self, *args)

    coloring = _swig_property(_cpp.ParallelData_coloring_get, _cpp.ParallelData_coloring_set)
ParallelData.have_global_entity_indices = new_instancemethod(_cpp.ParallelData_have_global_entity_indices,None,ParallelData)
ParallelData.global_entity_indices = new_instancemethod(_cpp.ParallelData_global_entity_indices,None,ParallelData)
ParallelData.global_entity_indices_as_vector = new_instancemethod(_cpp.ParallelData_global_entity_indices_as_vector,None,ParallelData)
ParallelData.global_to_local_entity_indices = new_instancemethod(_cpp.ParallelData_global_to_local_entity_indices,None,ParallelData)
ParallelData.shared_vertices = new_instancemethod(_cpp.ParallelData_shared_vertices,None,ParallelData)
ParallelData.exterior_facet = new_instancemethod(_cpp.ParallelData_exterior_facet,None,ParallelData)
ParallelData.num_global_entities = new_instancemethod(_cpp.ParallelData_num_global_entities,None,ParallelData)
ParallelData_swigregister = _cpp.ParallelData_swigregister
ParallelData_swigregister(ParallelData)

class Mesh(Variable,HierarchicalMesh):
    """
    A :py:class:`Mesh` consists of a set of connected and numbered mesh entities.

    Both the representation and the interface are
    dimension-independent, but a concrete interface is also provided
    for standard named mesh entities:

    .. tabularcolumns:: |c|c|c|

    +--------+-----------+-------------+
    | Entity | Dimension | Codimension |
    +========+===========+=============+
    | Vertex |  0        |             |
    +--------+-----------+-------------+
    | Edge   |  1        |             |
    +--------+-----------+-------------+
    | Face   |  2        |             |
    +--------+-----------+-------------+
    | Facet  |           |      1      |
    +--------+-----------+-------------+
    | Cell   |           |      0      |
    +--------+-----------+-------------+

    When working with mesh iterators, all entities and connectivity
    are precomputed automatically the first time an iterator is
    created over any given topological dimension or connectivity.

    Note that for efficiency, only entities of dimension zero
    (vertices) and entities of the maximal dimension (cells) exist
    when creating a :py:class:`Mesh`. Other entities must be explicitly created
    by calling init(). For example, all edges in a mesh may be
    created by a call to mesh.init(1). Similarly, connectivities
    such as all edges connected to a given vertex must also be
    explicitly created (in this case by a call to mesh.init(0, 1)).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Mesh\ ()

          Create empty mesh

        * Mesh\ (mesh)

          Copy constructor.
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  Object to be copied.

        * Mesh\ (filename)

          Create mesh from data file.
          
          *Arguments*
              filename (str)
                  Name of file to load.

        * Mesh\ (local_mesh_data)

          Create a distributed mesh from local (per process) data.
          
          *Arguments*
              local_mesh_data (LocalMeshData)
                  Data from which to build the mesh.

        """
        _cpp.Mesh_swiginit(self,_cpp.new_Mesh(*args))
    __swig_destroy__ = _cpp.delete_Mesh
    def num_vertices(self, *args):
        """
        Get number of vertices in mesh.

        *Returns*
            int
                Number of vertices.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.num_vertices()
                9

        """
        return _cpp.Mesh_num_vertices(self, *args)

    def num_edges(self, *args):
        """
        Get number of edges in mesh.

        *Returns*
            int
                Number of edges.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.num_edges()
                0
                >>> mesh.init(1)
                16
                >>> mesh.num_edges()
                16

        """
        return _cpp.Mesh_num_edges(self, *args)

    def num_faces(self, *args):
        """
        Get number of faces in mesh.

        *Returns*
            int
                Number of faces.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.num_faces()
                8

        """
        return _cpp.Mesh_num_faces(self, *args)

    def num_facets(self, *args):
        """
        Get number of facets in mesh.

        *Returns*
            int
                Number of facets.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.num_facets()
                0
                >>> mesh.init(0,1)
                >>> mesh.num_facets()
                16

        """
        return _cpp.Mesh_num_facets(self, *args)

    def num_cells(self, *args):
        """
        Get number of cells in mesh.

        *Returns*
            int
                Number of cells.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.num_cells()
                8

        """
        return _cpp.Mesh_num_cells(self, *args)

    def num_entities(self, *args):
        """
        Get number of entities of given topological dimension.

        *Arguments*
            d (int)
                Topological dimension.

        *Returns*
            int
                Number of entities of topological dimension d.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.init(0,1)
                >>> mesh.num_entities(0)
                9
                >>> mesh.num_entities(1)
                16
                >>> mesh.num_entities(2)
                8

        """
        return _cpp.Mesh_num_entities(self, *args)

    def size(self, *args):
        """
        Get number of entities of given topological dimension.

        *Arguments*
            dim (int)
                Topological dimension.

        *Returns*
            int
                Number of entities of topological dimension d.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.init(0,1)
                >>> mesh.size(0)
                9
                >>> mesh.size(1)
                16
                >>> mesh.size(2)
                8

        """
        return _cpp.Mesh_size(self, *args)

    def topology(self, *args):
        """
        **Overloaded versions**

        * topology\ ()

          Get mesh topology.
          
          *Returns*
              :py:class:`MeshTopology`
                  The topology object associated with the mesh.

        * topology\ ()

          Get mesh topology (const version).

        """
        return _cpp.Mesh_topology(self, *args)

    def geometry(self, *args):
        """
        **Overloaded versions**

        * geometry\ ()

          Get mesh geometry.
          
          *Returns*
              :py:class:`MeshGeometry`
                  The geometry object associated with the mesh.

        * geometry\ ()

          Get mesh geometry (const version).

        """
        return _cpp.Mesh_geometry(self, *args)

    def domains(self, *args):
        """
        **Overloaded versions**

        * domains\ ()

          Get mesh (sub)domains.
          
          *Returns*
              :py:class:`MeshDomains`
                  The (sub)domains associated with the mesh.

        * domains\ ()

          Get mesh (sub)domains.

        """
        return _cpp.Mesh_domains(self, *args)

    def intersection_operator(self, *args):
        """
        **Overloaded versions**

        * intersection_operator\ ()

          Get intersection operator.
          
          *Returns*
              :py:class:`IntersectionOperator`
                  The intersection operator object associated with the mesh.

        * intersection_operator\ ()

          Return intersection operator (const version);

        """
        return _cpp.Mesh_intersection_operator(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Get mesh data.
          
          *Returns*
              :py:class:`MeshData`
                  The mesh data object associated with the mesh.

        * data\ ()

          Get mesh data (const version).

        """
        return _cpp.Mesh_data(self, *args)

    def parallel_data(self, *args):
        """
        **Overloaded versions**

        * parallel_data\ ()

          Get parallel mesh data.
          
          *Returns*
              :py:class:`ParallelData`
                  The parallel data object associated with the mesh.

        * parallel_data\ ()

          Get parallel mesh data (const version).

        """
        return _cpp.Mesh_parallel_data(self, *args)

    def type(self, *args):
        """
        **Overloaded versions**

        * type\ ()

          Get mesh cell type.
          
          *Returns*
              :py:class:`CellType`
                  The cell type object associated with the mesh.

        * type\ ()

          Get mesh cell type (const version).

        """
        return _cpp.Mesh_type(self, *args)

    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (dim)

          Compute entities of given topological dimension.
          
          *Arguments*
              dim (int)
                  Topological dimension.
          
          *Returns*
              int
                  Number of created entities.

        * init\ (d0, d1)

          Compute connectivity between given pair of dimensions.
          
          *Arguments*
              d0 (int)
                  Topological dimension.
          
              d1 (int)
                  Topological dimension.

        * init\ ()

          Compute all entities and connectivity.

        """
        return _cpp.Mesh_init(self, *args)

    def clear(self, *args):
        """
        Clear all mesh data.

        """
        return _cpp.Mesh_clear(self, *args)

    def clean(self, *args):
        """
        Clean out all auxiliary topology data. This clears all
        topological data, except the connectivity between cells and
        vertices.

        """
        return _cpp.Mesh_clean(self, *args)

    def order(self, *args):
        """
        Order all mesh entities.

        .. seealso::

            UFC documentation (put link here!)

        """
        return _cpp.Mesh_order(self, *args)

    def ordered(self, *args):
        """
        Check if mesh is ordered according to the UFC numbering convention.

        *Returns*
            bool
                The return values is true iff the mesh is ordered.

        """
        return _cpp.Mesh_ordered(self, *args)

    def move(self, *args):
        """
        **Overloaded versions**

        * move\ (boundary)

          Move coordinates of mesh according to new boundary coordinates.
          
          *Arguments*
              boundary (:py:class:`BoundaryMesh`)
                  A mesh containing just the boundary cells.

        * move\ (mesh)

          Move coordinates of mesh according to adjacent mesh with common global
          vertices.
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  A :py:class:`Mesh` object.

        * move\ (displacement)

          Move coordinates of mesh according to displacement function.
          
          *Arguments*
              displacement (:py:class:`Function`)
                  A :py:class:`Function` object.

        """
        return _cpp.Mesh_move(self, *args)

    def smooth(self, *args):
        """
        Smooth internal vertices of mesh by local averaging.

        *Arguments*
            num_iterations (int)
                Number of iterations to perform smoothing,
                default value is 1.

        """
        return _cpp.Mesh_smooth(self, *args)

    def smooth_boundary(self, *args):
        """
        Smooth boundary vertices of mesh by local averaging.

        *Arguments*
            num_iterations (int)
                Number of iterations to perform smoothing,
                default value is 1.

            harmonic_smoothing (bool)
                Flag to turn on harmonics smoothing, default
                value is true.

        """
        return _cpp.Mesh_smooth_boundary(self, *args)

    def snap_boundary(self, *args):
        """
        Snap boundary vertices of mesh to match given sub domain.

        *Arguments*
            sub_domain (:py:class:`SubDomain`)
                A :py:class:`SubDomain` object.

            harmonic_smoothing (bool)
                Flag to turn on harmonics smoothing, default
                value is true.

        """
        return _cpp.Mesh_snap_boundary(self, *args)

    def color(self, *args):
        """
        **Overloaded versions**

        * color\ (coloring_type)

          Color the cells of the mesh such that no two neighboring cells
          share the same color. A colored mesh keeps a
          CellFunction<unsigned int> named "cell colors" as mesh data which
          holds the colors of the mesh.
          
          *Arguments*
              coloring_type (str)
                  Coloring type, specifying what relation makes two
                  cells neighbors, can be one of "vertex", "edge" or
                  "facet".
          
          *Returns*
              MeshFunction<unsigned int>
                  The colors as a mesh function over the cells of the mesh.

        * color\ (coloring_type)

          Color the cells of the mesh such that no two neighboring cells
          share the same color. A colored mesh keeps a
          CellFunction<unsigned int> named "cell colors" as mesh data which
          holds the colors of the mesh.
          
          *Arguments*
              coloring_type (numpy.array(int))
                  Coloring type given as list of topological dimensions,
                  specifying what relation makes two mesh entinties neighbors.
          
          *Returns*
              MeshFunction<unsigned int>
                  The colors as a mesh function over entities of the mesh.

        """
        return _cpp.Mesh_color(self, *args)

    def intersected_cells(self, *args):
        """
        **Overloaded versions**

        * intersected_cells\ (point, cells)

          Compute all cells which are intersected by the given point.
          
          *Arguments*
              point (:py:class:`Point`)
                  A :py:class:`Point` object.
          
              cells (set of int)
                  A set of indices of all intersected cells.

        * intersected_cells\ (points, cells)

          Compute all cells which are intersected by any of a vector of points.
          
          *Arguments*
              points (list of :py:class:`Point`)
                  A vector of :py:class:`Point` objects.
          
              cells (set of int)
                  A set of indices of all intersected cells.

        * intersected_cells\ (entity, cells)

          Compute all cells which are intersected by the given entity.
          
          *Arguments*
              entity (:py:class:`MeshEntity`)
                  A :py:class:`MeshEntity` object.
          
              cells (numpy.array(int))
                  A vector of indices of all intersected cells.

        * intersected_cells\ (entities, cells)

          Compute all cells which are intersected by any of a vector of entities.
          
          *Arguments*
              entities (list of :py:class:`MeshEntity`)
                  A vector of :py:class:`MeshEntity` objects.
          
              cells (set of int)
                  A vector of indices of all intersected cells.

        * intersected_cells\ (mesh, cells)

          Compute all cells which are intersected by the given mesh.
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  A :py:class:`Mesh` object.
          
              cells (set of int)
                  A set of indices of all intersected cells.

        """
        return _cpp.Mesh_intersected_cells(self, *args)

    def intersected_cell(self, *args):
        """
        Find the cell (if any) containing the given point. If the point
        is contained in several cells, the first cell is returned.

        *Arguments*
            point (:py:class:`Point`)
                A :py:class:`Point` object.

        *Returns*
            int
                The index of the cell containing the point. If no cell
                is found, the return value is -1.

        """
        return _cpp.Mesh_intersected_cell(self, *args)

    def closest_point(self, *args):
        """
        Find the point in the mesh closest to the given point.

        *Arguments*
            point (:py:class:`Point`)
                A :py:class:`Point` object.

        *Returns*
            :py:class:`Point`
                The closest point.

        """
        return _cpp.Mesh_closest_point(self, *args)

    def closest_cell(self, *args):
        """
        Find the cell in the mesh closest to the given point.

        *Arguments*
            point (:py:class:`Point`)
                A :py:class:`Point` object.

        *Returns*
            int
                The index of the closest cell.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(1, 1)
                >>> point = dolfin.Point(0.0, 2.0)
                >>> mesh.closest_cell(point)
                1

        """
        return _cpp.Mesh_closest_cell(self, *args)

    def closest_point_and_cell(self, *args):
        """
        Find the point and corresponding cell closest to the given point.

        *Arguments*
            point (:py:class:`Point`)
                A :py:class:`Point` object.

        *Returns*
            Swig Object< std::pair<:py:class:`Point`, int> >
                A pair consisting of the closest point and corresponding cell index.

        """
        return _cpp.Mesh_closest_point_and_cell(self, *args)

    def distance(self, *args):
        """
        Computes the distance between a given point and the mesh

        *Arguments*
            point (:py:class:`Point`)
                A :py:class:`Point` object.

        *Returns*
            float
                The distance to the mesh.

        """
        return _cpp.Mesh_distance(self, *args)

    def hmin(self, *args):
        """
        Compute minimum cell diameter.

        *Returns*
            float
                The minimum cell diameter, the diameter is computed as
                two times the circumradius
                (http://mathworld.wolfram.com).

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.hmin()
                0.70710678118654757

        """
        return _cpp.Mesh_hmin(self, *args)

    def hmax(self, *args):
        """
        Compute maximum cell diameter.

        *Returns*
            float
                The maximum cell diameter, the diameter is computed as
                two times the circumradius
                (http://mathworld.wolfram.com).

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(2,2)
                >>> mesh.hmax()
                0.70710678118654757

        """
        return _cpp.Mesh_hmax(self, *args)

    def coordinates(self, *args):
        """
        **Overloaded versions**

        * coordinates\ ()

          Get vertex coordinates.
          
          *Returns*
              numpy.array(float)
                  Coordinates of all vertices.
          
          *Example*
              .. code-block:: python
              
                  >>> mesh = dolfin.UnitSquare(1,1)
                  >>> mesh.coordinates()
                  array([[ 0.,  0.],
                         [ 1.,  0.],
                         [ 0.,  1.],
                         [ 1.,  1.]])

        * coordinates\ ()

          Return coordinates of all vertices (const version).

        """
        return _cpp.Mesh_coordinates(self, *args)

    def cells(self, *args):
        """
        Get cell connectivity.

        *Returns*
            numpy.array(int)
                Connectivity for all cells.

        *Example*
            .. code-block:: python
            
                >>> mesh = dolfin.UnitSquare(1,1)
                >>> mesh.cells()
                array([[0, 1, 3],
                      [0, 2, 3]])

        """
        return _cpp.Mesh_cells(self, *args)

    def ufl_cell(self):
        """
        Returns the ufl cell of the mesh

        The cell corresponds to the topological dimension of the mesh.
        """
        import ufl
        cells = { 1: ufl.interval, 2: ufl.triangle, 3: ufl.tetrahedron }
        return cells[self.topology().dim()]


Mesh.num_vertices = new_instancemethod(_cpp.Mesh_num_vertices,None,Mesh)
Mesh.num_edges = new_instancemethod(_cpp.Mesh_num_edges,None,Mesh)
Mesh.num_faces = new_instancemethod(_cpp.Mesh_num_faces,None,Mesh)
Mesh.num_facets = new_instancemethod(_cpp.Mesh_num_facets,None,Mesh)
Mesh.num_cells = new_instancemethod(_cpp.Mesh_num_cells,None,Mesh)
Mesh.num_entities = new_instancemethod(_cpp.Mesh_num_entities,None,Mesh)
Mesh.size = new_instancemethod(_cpp.Mesh_size,None,Mesh)
Mesh.topology = new_instancemethod(_cpp.Mesh_topology,None,Mesh)
Mesh.geometry = new_instancemethod(_cpp.Mesh_geometry,None,Mesh)
Mesh.domains = new_instancemethod(_cpp.Mesh_domains,None,Mesh)
Mesh.intersection_operator = new_instancemethod(_cpp.Mesh_intersection_operator,None,Mesh)
Mesh.data = new_instancemethod(_cpp.Mesh_data,None,Mesh)
Mesh.parallel_data = new_instancemethod(_cpp.Mesh_parallel_data,None,Mesh)
Mesh.type = new_instancemethod(_cpp.Mesh_type,None,Mesh)
Mesh.init = new_instancemethod(_cpp.Mesh_init,None,Mesh)
Mesh.clear = new_instancemethod(_cpp.Mesh_clear,None,Mesh)
Mesh.clean = new_instancemethod(_cpp.Mesh_clean,None,Mesh)
Mesh.order = new_instancemethod(_cpp.Mesh_order,None,Mesh)
Mesh.renumber_by_color = new_instancemethod(_cpp.Mesh_renumber_by_color,None,Mesh)
Mesh.ordered = new_instancemethod(_cpp.Mesh_ordered,None,Mesh)
Mesh.move = new_instancemethod(_cpp.Mesh_move,None,Mesh)
Mesh.smooth = new_instancemethod(_cpp.Mesh_smooth,None,Mesh)
Mesh.smooth_boundary = new_instancemethod(_cpp.Mesh_smooth_boundary,None,Mesh)
Mesh.snap_boundary = new_instancemethod(_cpp.Mesh_snap_boundary,None,Mesh)
Mesh.color = new_instancemethod(_cpp.Mesh_color,None,Mesh)
Mesh.intersected_cells = new_instancemethod(_cpp.Mesh_intersected_cells,None,Mesh)
Mesh.intersected_cell = new_instancemethod(_cpp.Mesh_intersected_cell,None,Mesh)
Mesh.closest_point = new_instancemethod(_cpp.Mesh_closest_point,None,Mesh)
Mesh.closest_cell = new_instancemethod(_cpp.Mesh_closest_cell,None,Mesh)
Mesh.closest_point_and_cell = new_instancemethod(_cpp.Mesh_closest_point_and_cell,None,Mesh)
Mesh.distance = new_instancemethod(_cpp.Mesh_distance,None,Mesh)
Mesh.hmin = new_instancemethod(_cpp.Mesh_hmin,None,Mesh)
Mesh.hmax = new_instancemethod(_cpp.Mesh_hmax,None,Mesh)
Mesh.coordinates = new_instancemethod(_cpp.Mesh_coordinates,None,Mesh)
Mesh.cells = new_instancemethod(_cpp.Mesh_cells,None,Mesh)
Mesh_swigregister = _cpp.Mesh_swigregister
Mesh_swigregister(Mesh)

class MeshEntity(object):
    """
    A MeshEntity represents a mesh entity associated with
    a specific topological dimension of some :py:class:`Mesh`.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshEntity\ ()

          Default Constructor

        * MeshEntity\ (mesh, dim, index)

          Constructor
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The topological dimension.
              index (int)
                  The index.

        """
        _cpp.MeshEntity_swiginit(self,_cpp.new_MeshEntity(*args))
    __swig_destroy__ = _cpp.delete_MeshEntity
    def init(self, *args):
        """
        Initialize mesh entity with given data

        *Arguments*
            mesh (:py:class:`Mesh`)
                The mesh.
            dim (int)
                The topological dimension.
            index (int)
                The index.

        """
        return _cpp.MeshEntity_init(self, *args)

    def __eq__(self, *args):
        """
        Comparision Operator

        *Arguments*
            another (:py:class:`MeshEntity`)
                Another mesh entity

        *Returns*
            bool
                True if the two mesh entities are equal.

        """
        return _cpp.MeshEntity___eq__(self, *args)

    def __ne__(self, *args):
        """
        Comparision Operator

        *Arguments*
            another (MeshEntity)
                Another mesh entity.

        *Returns*
            bool
                True if the two mesh entities are NOT equal.

        """
        return _cpp.MeshEntity___ne__(self, *args)

    def mesh(self, *args):
        """
        Return mesh associated with mesh entity

        *Returns*
            :py:class:`Mesh`
                The mesh.

        """
        return _cpp.MeshEntity_mesh(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshEntity_dim(self, *args)

    def num_entities(self, *args):
        """
        Return number of incident mesh entities of given topological dimension

        *Arguments*
            dim (int)
                The topological dimension.

        *Returns*
            int
                The number of incident MeshEntity objects of given dimension.

        """
        return _cpp.MeshEntity_num_entities(self, *args)

    def mesh_id(self, *args):
        """
        Return unique mesh ID

        *Returns*
            int
                The unique mesh ID.

        """
        return _cpp.MeshEntity_mesh_id(self, *args)

    def incident(self, *args):
        """
        Check if given entity is incident

        *Arguments*
            entity (:py:class:`MeshEntity`)
                The entity.

        *Returns*
            bool
                True if the given entity is incident

        """
        return _cpp.MeshEntity_incident(self, *args)

    def intersects(self, *args):
        """
        **Overloaded versions**

        * intersects\ (point)

          Check if given point intersects (using inexact but fast
          numerics)
          
          *Arguments*
              point (:py:class:`Point`)
                  The point.
          
          *Returns*
              bool
                  True if the given point intersects.

        * intersects\ (entity)

          Check if given entity intersects (using inexact but fast
          numerics)
          
          *Arguments*
              entity (:py:class:`MeshEntity`)
                  The mesh entity.
          
          *Returns*
              bool
                  True if the given entity intersects.

        """
        return _cpp.MeshEntity_intersects(self, *args)

    def intersects_exactly(self, *args):
        """
        **Overloaded versions**

        * intersects_exactly\ (point)

          Check if given point intersects (using exact numerics)
          
          *Arguments*
              point (:py:class:`Point`)
                  The point.
          
          *Returns*
              bool
                  True if the given point intersects.

        * intersects_exactly\ (entity)

          Check if given entity intersects (using exact numerics)
          
          *Arguments*
              entity (:py:class:`MeshEntity`)
                  The mesh entity.
          
          *Returns*
              bool
                  True if the given entity intersects.

        """
        return _cpp.MeshEntity_intersects_exactly(self, *args)

    def index(self, *args):
        """
        **Overloaded versions**

        * index\ ()

          Return index of mesh entity
          
          *Returns*
              int
                  The index.

        * index\ (entity)

          Compute local index of given incident entity (error if not
          found)
          
          *Arguments*
              entity (:py:class:`MeshEntity`)
                  The mesh entity.
          
          *Returns*
              int
                  The local index of given entity.

        """
        return _cpp.MeshEntity_index(self, *args)

    def midpoint(self, *args):
        """
        Compute midpoint of cell

        *Returns*
            :py:class:`Point`
                The midpoint of the cell.

        """
        return _cpp.MeshEntity_midpoint(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        *Arguments*
            verbose (bool)
                Flag to turn on additional output.

        *Returns*
            str
                An informal representation of the function space.

        """
        return _cpp.MeshEntity_str(self, *args)

    def entities(self, dim):
        """ Return number of incident mesh entities of given topological dimension"""
        return self.mesh().topology()(self.dim(), dim)(self.index())

    def __str__(self):
        """Pretty print of MeshEntity"""
        return self.str(0)

MeshEntity.init = new_instancemethod(_cpp.MeshEntity_init,None,MeshEntity)
MeshEntity.__eq__ = new_instancemethod(_cpp.MeshEntity___eq__,None,MeshEntity)
MeshEntity.__ne__ = new_instancemethod(_cpp.MeshEntity___ne__,None,MeshEntity)
MeshEntity.mesh = new_instancemethod(_cpp.MeshEntity_mesh,None,MeshEntity)
MeshEntity.dim = new_instancemethod(_cpp.MeshEntity_dim,None,MeshEntity)
MeshEntity.num_entities = new_instancemethod(_cpp.MeshEntity_num_entities,None,MeshEntity)
MeshEntity.mesh_id = new_instancemethod(_cpp.MeshEntity_mesh_id,None,MeshEntity)
MeshEntity.incident = new_instancemethod(_cpp.MeshEntity_incident,None,MeshEntity)
MeshEntity.intersects = new_instancemethod(_cpp.MeshEntity_intersects,None,MeshEntity)
MeshEntity.intersects_exactly = new_instancemethod(_cpp.MeshEntity_intersects_exactly,None,MeshEntity)
MeshEntity.index = new_instancemethod(_cpp.MeshEntity_index,None,MeshEntity)
MeshEntity.midpoint = new_instancemethod(_cpp.MeshEntity_midpoint,None,MeshEntity)
MeshEntity.str = new_instancemethod(_cpp.MeshEntity_str,None,MeshEntity)
MeshEntity_swigregister = _cpp.MeshEntity_swigregister
MeshEntity_swigregister(MeshEntity)

class entities(object):
    """
    MeshEntityIterator provides a common iterator for mesh entities
    over meshes, boundaries and incidence relations. The basic use
    is illustrated below.

    *Example*
        The following example shows how to iterate over all mesh entities
        of a mesh of topological dimension dim:
        
        .. code-block:: python
        
            >>> for e in dolfin.cpp.entities(mesh, 1):
            ...     print e.index()
        
        The following example shows how to iterate over mesh entities of
        topological dimension dim connected (incident) to some mesh entity f:
        
        .. code-block:: python
        
            >>> f = dolfin.cpp.MeshEntity(mesh, 0, 0)
            >>> for e in dolfin.cpp.entities(f, 1):
            ...     print e.index()
    In addition to the general iterator, a set of specific named iterators
    are provided for entities of type :py:class:`Vertex`, :py:class:`Edge`, :py:class:`Face`, :py:class:`Facet`
    and :py:class:`Cell`. These iterators are defined along with their respective
    classes.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshEntityIterator\ ()

          Default constructor

        * MeshEntityIterator\ (mesh, dim)

          Create iterator for mesh entities over given topological dimension

        * MeshEntityIterator\ (entity, dim)

          Create iterator for entities of given dimension connected to given entity

        * MeshEntityIterator\ (it)

          Copy constructor

        """
        _cpp.entities_swiginit(self,_cpp.new_entities(*args))
    __swig_destroy__ = _cpp.delete_entities
    def _increment(self, *args):
        """
        Step to next mesh entity (prefix increment)

        """
        return _cpp.entities__increment(self, *args)

    def _decrease(self, *args):
        """
        Step to the previous mesh entity (prefix decrease)

        """
        return _cpp.entities__decrease(self, *args)

    def pos(self, *args):
        """
        Return current position

        """
        return _cpp.entities_pos(self, *args)

    def __eq__(self, *args):
        """
        Comparison operator.

        """
        return _cpp.entities___eq__(self, *args)

    def __ne__(self, *args):
        """
        Comparison operator

        """
        return _cpp.entities___ne__(self, *args)

    def _dereference(self, *args):
        """
        Dereference operator

        """
        return _cpp.entities__dereference(self, *args)

    def end(self, *args):
        """
        Check if iterator has reached the end

        """
        return _cpp.entities_end(self, *args)

    def end_iterator(self, *args):
        """
        Provide a safeguard iterator pointing beyond the end of an iteration
        process, either iterating over the mesh /or incident entities. Added to
        be bit more like STL iterators, since many algorithms rely on a kind of
        beyond iterator.

        """
        return _cpp.entities_end_iterator(self, *args)

    def __iter__(self):
        self.first = True
        return self

    def next(self):
        self.first = self.first if hasattr(self,"first") else True
        if not self.first:
            self._increment()
        if self.end():
            self._decrease()
            raise StopIteration
        self.first = False
        return self._dereference()

entities._increment = new_instancemethod(_cpp.entities__increment,None,entities)
entities._decrease = new_instancemethod(_cpp.entities__decrease,None,entities)
entities.pos = new_instancemethod(_cpp.entities_pos,None,entities)
entities.__eq__ = new_instancemethod(_cpp.entities___eq__,None,entities)
entities.__ne__ = new_instancemethod(_cpp.entities___ne__,None,entities)
entities._dereference = new_instancemethod(_cpp.entities__dereference,None,entities)
entities.end = new_instancemethod(_cpp.entities_end,None,entities)
entities.end_iterator = new_instancemethod(_cpp.entities_end_iterator,None,entities)
entities_swigregister = _cpp.entities_swigregister
entities_swigregister(entities)

class SubsetIterator(object):
    """
    A :py:class:`SubsetIterator` is similar to a :py:class:`MeshEntityIterator` but
    iterates over a specified subset of the range of entities as
    specified by a :py:class:`MeshFunction` that labels the entites.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * SubsetIterator\ (labels, label)

          Create iterator for given mesh function. The iterator visits
          all entities that match the given label.

        * SubsetIterator\ (subset_iter)

          Copy Constructor

        """
        _cpp.SubsetIterator_swiginit(self,_cpp.new_SubsetIterator(*args))
    __swig_destroy__ = _cpp.delete_SubsetIterator
    def _increment(self, *args):
        """
        Step to next mesh entity (prefix increment)

        """
        return _cpp.SubsetIterator__increment(self, *args)

    def __eq__(self, *args):
        """
        Comparison operator

        """
        return _cpp.SubsetIterator___eq__(self, *args)

    def __ne__(self, *args):
        """
        Comparison operator

        """
        return _cpp.SubsetIterator___ne__(self, *args)

    def _dereference(self, *args):
        """
        Dereference operator

        """
        return _cpp.SubsetIterator__dereference(self, *args)

    def end(self, *args):
        """
        Check if iterator has reached the end

        """
        return _cpp.SubsetIterator_end(self, *args)

    def __iter__(self):
        self.first = True
        return self

    def next(self):
        self.first = self.first if hasattr(self,"first") else True
        if not self.first:
            self._increment()
        if self.end():
            raise StopIteration
        self.first = False
        return self._dereference()

SubsetIterator._increment = new_instancemethod(_cpp.SubsetIterator__increment,None,SubsetIterator)
SubsetIterator.__eq__ = new_instancemethod(_cpp.SubsetIterator___eq__,None,SubsetIterator)
SubsetIterator.__ne__ = new_instancemethod(_cpp.SubsetIterator___ne__,None,SubsetIterator)
SubsetIterator._dereference = new_instancemethod(_cpp.SubsetIterator__dereference,None,SubsetIterator)
SubsetIterator.end = new_instancemethod(_cpp.SubsetIterator_end,None,SubsetIterator)
SubsetIterator.end_iterator = new_instancemethod(_cpp.SubsetIterator_end_iterator,None,SubsetIterator)
SubsetIterator_swigregister = _cpp.SubsetIterator_swigregister
SubsetIterator_swigregister(SubsetIterator)

class Point(object):
    """
    A Point represents a point in :math:`\mathbb{R}^3` with
    coordinates :math:`x, y, z,` or alternatively, a vector in
    :math:`\mathbb{R}^3`, supporting standard operations like the
    norm, distances, scalar and vector products etc.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Point\ (x=0.0, y=0.0, z=0.0)

          Create a point at (x, y, z). Default value (0, 0, 0).
          
          *Arguments*
              x (float)
                  The x-coordinate.
              y (float)
                  The y-coordinate.
              z (float)
                  The z-coordinate.

        * Point\ (dim, x)

          Create point from array
          
          *Arguments*
              dim (int)
                  Dimension of the array.
              x (float)
                  The array to create a Point from.

        * Point\ (p)

          Copy constructor
          
          *Arguments*
              p (:py:class:`Point`)
                  The object to be copied.

        * Point\ (point)

          Constructor taking a CGAL::Point_3. Allows conversion from
          CGAL Point_3 class to Point class.

        """
        _cpp.Point_swiginit(self,_cpp.new_Point(*args))
    __swig_destroy__ = _cpp.delete_Point
    def x(self, *args):
        """
        Return x-coordinate

        *Returns*
            float
                The x-coordinate.

        """
        return _cpp.Point_x(self, *args)

    def y(self, *args):
        """
        Return y-coordinate

        *Returns*
            float
                The y-coordinate.

        """
        return _cpp.Point_y(self, *args)

    def z(self, *args):
        """
        Return z-coordinate

        *Returns*
            float
                The z-coordinate.

        """
        return _cpp.Point_z(self, *args)

    def coordinates(self, *args):
        """
        **Overloaded versions**

        * coordinates\ ()

          Return coordinate array
          
          *Returns*
              list of doubles
                  The coordinates.

        * coordinates\ ()

          Return coordinate array (const. version)
          
          *Returns*
              list of doubles
                  The coordinates.

        """
        return _cpp.Point_coordinates(self, *args)

    def __add__(self, *args):
        """
        Compute sum of two points

        """
        return _cpp.Point___add__(self, *args)

    def __sub__(self, *args):
        """
        Compute difference of two points

        """
        return _cpp.Point___sub__(self, *args)

    def __iadd__(self, *args):
        """
        Add given point

        """
        return _cpp.Point___iadd__(self, *args)

    def __isub__(self, *args):
        """
        Subtract given point

        """
        return _cpp.Point___isub__(self, *args)

    def __mul__(self, *args):
        """
        **Overloaded versions**

        * operator*\ (a)

          Multiplication with scalar

        * operator*\ (a, p)

          Multiplication with scalar

        """
        return _cpp.Point___mul__(self, *args)

    def __imul__(self, *args):
        """
        Incremental multiplication with scalar

        """
        return _cpp.Point___imul__(self, *args)

    def __div__(self, *args):
        """
        Division by scalar

        """
        return _cpp.Point___div__(self, *args)

    def __idiv__(self, *args):
        """
        Incremental division by scalar

        """
        return _cpp.Point___idiv__(self, *args)

    def distance(self, *args):
        """
        Compute distance to given point

        *Arguments*
            p (:py:class:`Point`)
                The point to compute distance to.

        *Returns*
            float
                The distance.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.Point_distance(self, *args)

    def norm(self, *args):
        """
        Compute norm of point representing a vector from the origin

        *Returns*
            float
                The (Euclidean) norm of the vector from the origin to
                the point.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.Point_norm(self, *args)

    def cross(self, *args):
        """
        Compute cross product with given vector

        *Arguments*
            p (:py:class:`Point`)
                Another point.

        *Returns*
            Point
                The cross product.

        """
        return _cpp.Point_cross(self, *args)

    def dot(self, *args):
        """
        Compute dot product with given vector

        *Arguments*
            p (:py:class:`Point`)
                Another point.

        *Returns*
            float
                The dot product.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.Point_dot(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        *Arguments*
            verbose (bool)
                Flag to turn on additional output.

        *Returns*
            str
                An informal representation of the function space.

        """
        return _cpp.Point_str(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.Point___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.Point___setitem__(self, *args)

Point.x = new_instancemethod(_cpp.Point_x,None,Point)
Point.y = new_instancemethod(_cpp.Point_y,None,Point)
Point.z = new_instancemethod(_cpp.Point_z,None,Point)
Point.coordinates = new_instancemethod(_cpp.Point_coordinates,None,Point)
Point.__add__ = new_instancemethod(_cpp.Point___add__,None,Point)
Point.__sub__ = new_instancemethod(_cpp.Point___sub__,None,Point)
Point.__iadd__ = new_instancemethod(_cpp.Point___iadd__,None,Point)
Point.__isub__ = new_instancemethod(_cpp.Point___isub__,None,Point)
Point.__mul__ = new_instancemethod(_cpp.Point___mul__,None,Point)
Point.__imul__ = new_instancemethod(_cpp.Point___imul__,None,Point)
Point.__div__ = new_instancemethod(_cpp.Point___div__,None,Point)
Point.__idiv__ = new_instancemethod(_cpp.Point___idiv__,None,Point)
Point.distance = new_instancemethod(_cpp.Point_distance,None,Point)
Point.norm = new_instancemethod(_cpp.Point_norm,None,Point)
Point.cross = new_instancemethod(_cpp.Point_cross,None,Point)
Point.dot = new_instancemethod(_cpp.Point_dot,None,Point)
Point.str = new_instancemethod(_cpp.Point_str,None,Point)
Point.__getitem__ = new_instancemethod(_cpp.Point___getitem__,None,Point)
Point.__setitem__ = new_instancemethod(_cpp.Point___setitem__,None,Point)
Point_swigregister = _cpp.Point_swigregister
Point_swigregister(Point)


def __mul__(*args):
  return _cpp.__mul__(*args)
__mul__ = _cpp.__mul__

def __lshift__(*args):
  return _cpp.__lshift__(*args)
__lshift__ = _cpp.__lshift__
class Vertex(MeshEntity):
    """
    A Vertex is a MeshEntity of topological dimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Vertex\ (mesh, index)

          Create vertex on given mesh

        * Vertex\ (entity)

          Create vertex from mesh entity

        """
        _cpp.Vertex_swiginit(self,_cpp.new_Vertex(*args))
    __swig_destroy__ = _cpp.delete_Vertex
    def point(self, *args):
        """
        Return vertex coordinates as a 3D point value

        """
        return _cpp.Vertex_point(self, *args)

    def x(self, *args):
        """
        **Overloaded versions**

        * x\ (i)

          Return value of vertex coordinate i

        * x\ ()

          Return array of vertex coordinates (const version)

        """
        return _cpp.Vertex_x(self, *args)

Vertex.point = new_instancemethod(_cpp.Vertex_point,None,Vertex)
Vertex.x = new_instancemethod(_cpp.Vertex_x,None,Vertex)
Vertex_swigregister = _cpp.Vertex_swigregister
Vertex_swigregister(Vertex)

class vertices(entities):
    """
    A VertexIterator is a MeshEntityIterator of topological dimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.vertices_swiginit(self,_cpp.new_vertices(*args))
    def _dereference(self, *args):
        """
        Dereference operator

        """
        return _cpp.vertices__dereference(self, *args)

    __swig_destroy__ = _cpp.delete_vertices
vertices._dereference = new_instancemethod(_cpp.vertices__dereference,None,vertices)
vertices_swigregister = _cpp.vertices_swigregister
vertices_swigregister(vertices)

class Edge(MeshEntity):
    """
    An Edge is a :py:class:`MeshEntity` of topological dimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Edge\ (mesh, index)

          Create edge on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              index (int)
                  Index of the edge.

        * Edge\ (entity)

          Create edge from mesh entity
          
          *Arguments*
              entity (:py:class:`MeshEntity`)
                  The mesh entity to create an edge from.

        """
        _cpp.Edge_swiginit(self,_cpp.new_Edge(*args))
    __swig_destroy__ = _cpp.delete_Edge
    def length(self, *args):
        """
        Compute Euclidean length of edge

        *Returns*
            float
                Euclidean length of edge.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.Edge_length(self, *args)

    def dot(self, *args):
        """
        Compute dot product between edge and other edge

        *Arguments*
            edge (:py:class:`Edge`)
                Another edge.

        *Returns*
            float
                The dot product.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.Edge_dot(self, *args)

Edge.length = new_instancemethod(_cpp.Edge_length,None,Edge)
Edge.dot = new_instancemethod(_cpp.Edge_dot,None,Edge)
Edge_swigregister = _cpp.Edge_swigregister
Edge_swigregister(Edge)

class edges(entities):
    """
    An EdgeIterator is a :py:class:`MeshEntityIterator` of topological dimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.edges_swiginit(self,_cpp.new_edges(*args))
    def _dereference(self, *args):
        """
        Dereference operator

        """
        return _cpp.edges__dereference(self, *args)

    __swig_destroy__ = _cpp.delete_edges
edges._dereference = new_instancemethod(_cpp.edges__dereference,None,edges)
edges_swigregister = _cpp.edges_swigregister
edges_swigregister(edges)

class Face(MeshEntity):
    """
    A Face is a MeshEntity of topological dimension 2.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.Face_swiginit(self,_cpp.new_Face(*args))
    __swig_destroy__ = _cpp.delete_Face
    def area(self, *args):
        """
        Calculate the area of the face (triangle)

        """
        return _cpp.Face_area(self, *args)

    def normal(self, *args):
        """
        **Overloaded versions**

        * normal\ (i)

          Compute component i of the normal to the face

        * normal\ ()

          Compute normal to the face

        """
        return _cpp.Face_normal(self, *args)

Face.area = new_instancemethod(_cpp.Face_area,None,Face)
Face.normal = new_instancemethod(_cpp.Face_normal,None,Face)
Face_swigregister = _cpp.Face_swigregister
Face_swigregister(Face)

class faces(entities):
    """
    A FaceIterator is a MeshEntityIterator of topological dimension 2.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.faces_swiginit(self,_cpp.new_faces(*args))
    def _dereference(self, *args):
        """
        Dereference operator

        """
        return _cpp.faces__dereference(self, *args)

    __swig_destroy__ = _cpp.delete_faces
faces._dereference = new_instancemethod(_cpp.faces__dereference,None,faces)
faces_swigregister = _cpp.faces_swigregister
faces_swigregister(faces)

class Facet(MeshEntity):
    """
    A Facet is a MeshEntity of topological codimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.Facet_swiginit(self,_cpp.new_Facet(*args))
    __swig_destroy__ = _cpp.delete_Facet
    def normal(self, *args):
        """
        **Overloaded versions**

        * normal\ (i)

          Compute component i of the normal to the facet

        * normal\ ()

          Compute normal to the facet

        """
        return _cpp.Facet_normal(self, *args)

    def exterior(self, *args):
        """
        Return true if facet is an exterior facet (relative to global mesh,
        so this function will return false for facets on partition boundaries)
        Facet connectivity must be initialized before calling this function.

        """
        return _cpp.Facet_exterior(self, *args)

    def adjacent_cells(self, *args):
        """
        Return adjacent cells. An optional argument that lists for
        each facet the index of the first cell may be given to specify
        the ordering of the two cells. If not specified, the ordering
        will depend on the (arbitrary) ordering of the mesh
        connectivity.

        """
        return _cpp.Facet_adjacent_cells(self, *args)

Facet.normal = new_instancemethod(_cpp.Facet_normal,None,Facet)
Facet.exterior = new_instancemethod(_cpp.Facet_exterior,None,Facet)
Facet.adjacent_cells = new_instancemethod(_cpp.Facet_adjacent_cells,None,Facet)
Facet_swigregister = _cpp.Facet_swigregister
Facet_swigregister(Facet)

class facets(entities):
    """
    A FacetIterator is a MeshEntityIterator of topological codimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.facets_swiginit(self,_cpp.new_facets(*args))
    def _dereference(self, *args):
        """
        Dereference operator

        """
        return _cpp.facets__dereference(self, *args)

    __swig_destroy__ = _cpp.delete_facets
facets._dereference = new_instancemethod(_cpp.facets__dereference,None,facets)
facets_swigregister = _cpp.facets_swigregister
facets_swigregister(facets)

class Cell(MeshEntity):
    """
    A Cell is a :py:class:`MeshEntity` of topological codimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Cell\ ()

          Create empty cell

        * Cell\ (mesh, index)

          Create cell on given mesh with given index
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              index (int)
                  The index.

        """
        _cpp.Cell_swiginit(self,_cpp.new_Cell(*args))
    __swig_destroy__ = _cpp.delete_Cell
    def type(self, *args):
        """
        Return type of cell

        """
        return _cpp.Cell_type(self, *args)

    def orientation(self, *args):
        """
        Compute orientation of cell

        *Returns*
            float
                Orientation of the cell (0 is right, 1 is left).

        """
        return _cpp.Cell_orientation(self, *args)

    def volume(self, *args):
        """
        Compute (generalized) volume of cell

        *Returns*
            float
                The volume of the cell.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.Cell_volume(self, *args)

    def diameter(self, *args):
        """
        Compute diameter of cell

        *Returns*
            float
                The diameter of the cell.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.Cell_diameter(self, *args)

    def normal(self, *args):
        """
        **Overloaded versions**

        * normal\ (facet, i)

          Compute component i of normal of given facet with respect to the cell
          
          *Arguments*
              facet (int)
                  Index of facet.
              i (int)
                  Component.
          
          *Returns*
              float
                  Component i of the normal of the facet.

        * normal\ (facet)

          Compute normal of given facet with respect to the cell
          
          *Arguments*
              facet (int)
                  Index of facet.
          
          *Returns*
              :py:class:`Point`
                  Normal of the facet.

        """
        return _cpp.Cell_normal(self, *args)

    def facet_area(self, *args):
        """
        Compute the area/length of given facet with respect to the cell

        *Arguments*
            facet (int)
                Index of the facet.

        *Returns*
            float
                Area/length of the facet.

        """
        return _cpp.Cell_facet_area(self, *args)

    def order(self, *args):
        """
        Order entities locally

        *Arguments*
            global_vertex_indices (:py:class:`MeshFunction`)
                The global vertex indices.

        """
        return _cpp.Cell_order(self, *args)

    def ordered(self, *args):
        """
        Check if entities are ordered

        *Arguments*
            global_vertex_indices (:py:class:`MeshFunction`)
                The global vertex indices.

        *Returns*
            bool
                True if ordered.

        """
        return _cpp.Cell_ordered(self, *args)

Cell.type = new_instancemethod(_cpp.Cell_type,None,Cell)
Cell.orientation = new_instancemethod(_cpp.Cell_orientation,None,Cell)
Cell.volume = new_instancemethod(_cpp.Cell_volume,None,Cell)
Cell.diameter = new_instancemethod(_cpp.Cell_diameter,None,Cell)
Cell.normal = new_instancemethod(_cpp.Cell_normal,None,Cell)
Cell.facet_area = new_instancemethod(_cpp.Cell_facet_area,None,Cell)
Cell.order = new_instancemethod(_cpp.Cell_order,None,Cell)
Cell.ordered = new_instancemethod(_cpp.Cell_ordered,None,Cell)
Cell_swigregister = _cpp.Cell_swigregister
Cell_swigregister(Cell)

class cells(entities):
    """
    A CellIterator is a MeshEntityIterator of topological codimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.cells_swiginit(self,_cpp.new_cells(*args))
    def _dereference(self, *args):
        """
        Dereference operator

        """
        return _cpp.cells__dereference(self, *args)

    __swig_destroy__ = _cpp.delete_cells
cells._dereference = new_instancemethod(_cpp.cells__dereference,None,cells)
cells_swigregister = _cpp.cells_swigregister
cells_swigregister(cells)

class FacetCell(Cell):
    """
    This class represents a cell in a mesh incident to a facet on
    the boundary. It is useful in cases where one needs to iterate
    over a boundary mesh and access the corresponding cells in the
    original mesh.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create cell on mesh corresponding to given facet (cell) on boundary

        """
        _cpp.FacetCell_swiginit(self,_cpp.new_FacetCell(*args))
    __swig_destroy__ = _cpp.delete_FacetCell
    def facet_index(self, *args):
        """
        Return local index of facet with respect to the cell

        """
        return _cpp.FacetCell_facet_index(self, *args)

FacetCell.facet_index = new_instancemethod(_cpp.FacetCell_facet_index,None,FacetCell)
FacetCell_swigregister = _cpp.FacetCell_swigregister
FacetCell_swigregister(FacetCell)

class MeshConnectivity(object):
    """
    Mesh connectivity stores a sparse data structure of connections
    (incidence relations) between mesh entities for a fixed pair of
    topological dimensions.

    The connectivity can be specified either by first giving the
    number of entities and the number of connections for each entity,
    which may either be equal for all entities or different, or by
    giving the entire (sparse) connectivity pattern.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshConnectivity\ (d0, d1)

          Create empty connectivity between given dimensions (d0 -- d1)

        * MeshConnectivity\ (connectivity)

          Copy constructor

        """
        _cpp.MeshConnectivity_swiginit(self,_cpp.new_MeshConnectivity(*args))
    __swig_destroy__ = _cpp.delete_MeshConnectivity
    def size(self, *args):
        """
        **Overloaded versions**

        * size\ ()

          Return total number of connections

        * size\ (entity)

          Return number of connections for given entity

        """
        return _cpp.MeshConnectivity_size(self, *args)

    def clear(self, *args):
        """
        Clear all data

        """
        return _cpp.MeshConnectivity_clear(self, *args)

    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (num_entities, num_connections)

          Initialize number of entities and number of connections (equal for all)

        * init\ (num_connections)

          Initialize number of entities and number of connections (individually)

        """
        return _cpp.MeshConnectivity_init(self, *args)

    def set(self, *args):
        """
        **Overloaded versions**

        * set\ (entity, connection, pos)

          Set given connection for given entity

        * set\ (entity, connections)

          Set all connections for given entity

        * set\ (entity, connections)

          Set all connections for given entity

        * set\ (connectivity)

          Set all connections for all entities

        """
        return _cpp.MeshConnectivity_set(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _cpp.MeshConnectivity_str(self, *args)

MeshConnectivity.size = new_instancemethod(_cpp.MeshConnectivity_size,None,MeshConnectivity)
MeshConnectivity.clear = new_instancemethod(_cpp.MeshConnectivity_clear,None,MeshConnectivity)
MeshConnectivity.init = new_instancemethod(_cpp.MeshConnectivity_init,None,MeshConnectivity)
MeshConnectivity.set = new_instancemethod(_cpp.MeshConnectivity_set,None,MeshConnectivity)
MeshConnectivity.str = new_instancemethod(_cpp.MeshConnectivity_str,None,MeshConnectivity)
MeshConnectivity.__call__ = new_instancemethod(_cpp.MeshConnectivity___call__,None,MeshConnectivity)
MeshConnectivity_swigregister = _cpp.MeshConnectivity_swigregister
MeshConnectivity_swigregister(MeshConnectivity)

class MeshEditor(object):
    """
    A simple mesh editor for creating simplicial meshes in 1D, 2D
    and 3D.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.MeshEditor_swiginit(self,_cpp.new_MeshEditor(*args))
    __swig_destroy__ = _cpp.delete_MeshEditor
    def open(self, *args):
        """
        **Overloaded versions**

        * open\ (mesh, tdim, gdim)

          Open mesh of given topological and geometrical dimension
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to open.
              tdim (int)
                  The topological dimension.
              gdim (int)
                  The geometrical dimension.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * open\ (mesh, type, tdim, gdim)

          Open mesh of given cell type, topological and geometrical dimension
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to open.
              type (CellType::Type)
                  Cell type.
              tdim (int)
                  The topological dimension.
              gdim (int)
                  The geometrical dimension.

        * open\ (mesh, type, tdim, gdim)

          Open mesh of given cell type, topological and geometrical dimension
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to open.
              type (str)
                  Cell type.
              tdim (int)
                  The topological dimension.
              gdim (int)
                  The geometrical dimension.

        """
        return _cpp.MeshEditor_open(self, *args)

    def init_vertices(self, *args):
        """
        Specify number of vertices

        *Arguments*
            num_vertices (int)
                The number of vertices.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.MeshEditor_init_vertices(self, *args)

    def init_higher_order_vertices(self, *args):
        """
        Specify number of vertices

        *Arguments*
            num_higher_order_vertices (int)
                The number of higher order vertices.

        """
        return _cpp.MeshEditor_init_higher_order_vertices(self, *args)

    def init_cells(self, *args):
        """
        Specify number of cells

        *Arguments*
            num_cells (int)
                The number of cells.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.MeshEditor_init_cells(self, *args)

    def init_higher_order_cells(self, *args):
        """
        Specify number of cells

        *Arguments*
            num_higher_order_cells (int)
                The number of higher order cells.
            num_higher_order_cell_dof (int)
                The number of cell dofs.

        """
        return _cpp.MeshEditor_init_higher_order_cells(self, *args)

    def set_affine_cell_indicator(self, *args):
        """
        Set boolean indicator inside MeshGeometry

        """
        return _cpp.MeshEditor_set_affine_cell_indicator(self, *args)

    def add_vertex(self, *args):
        """
        **Overloaded versions**

        * add_vertex\ (v, p)

          Add vertex v at given point p
          
          *Arguments*
              v (int)
                  The vertex (index).
              p (:py:class:`Point`)
                  The point.

        * add_vertex\ (v, x)

          Add vertex v at given coordinate x
          
          *Arguments*
              v (int)
                  The vertex (index).
              x (float)
                  The x-coordinate.

        * add_vertex\ (v, x, y)

          Add vertex v at given coordinate (x, y)
          
          *Arguments*
              v (int)
                  The vertex (index).
              x (float)
                  The x-coordinate.
              y (float)
                  The y-coordinate.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * add_vertex\ (v, x, y, z)

          Add vertex v at given coordinate (x, y, z)
          
          *Arguments*
              v (int)
                  The vertex (index).
              x (float)
                  The x-coordinate.
              y (float)
                  The y-coordinate.
              z (float)
                  The z-coordinate.

        """
        return _cpp.MeshEditor_add_vertex(self, *args)

    def add_higher_order_vertex(self, *args):
        """
        **Overloaded versions**

        * add_higher_order_vertex\ (v, p)

          Add vertex v at given point p
          
          *Arguments*
              v (int)
                  The vertex (index).
              p (:py:class:`Point`)
                  The point.

        * add_higher_order_vertex\ (v, x)

          Add vertex v at given coordinate x
          
          *Arguments*
              v (int)
                  The vertex (index).
              x (float)
                  The x-coordinate.

        * add_higher_order_vertex\ (v, x, y)

          Add vertex v at given coordinate (x, y)
          
          *Arguments*
              v (int)
                  The vertex (index).
              x (float)
                  The x-coordinate.
              y (float)
                  The y-coordinate.

        * add_higher_order_vertex\ (v, x, y, z)

          Add vertex v at given coordinate (x, y, z)
          
          *Arguments*
              v (int)
                  The vertex (index).
              x (float)
                  The x-coordinate.
              y (float)
                  The y-coordinate.
              z (float)
                  The z-coordinate.

        """
        return _cpp.MeshEditor_add_higher_order_vertex(self, *args)

    def add_cell(self, *args):
        """
        **Overloaded versions**

        * add_cell\ (c, v)

          Add cell with given vertices
          
          *Arguments*
              c (int)
                  The cell (index).
              v (numpy.array(int))
                  The vertex indices

        * add_cell\ (c, v0, v1)

          Add cell (interval) with given vertices
          
          *Arguments*
              c (int)
                  The cell (index).
              v0 (int)
                  Index of the first vertex.
              v1 (int)
                  Index of the second vertex.

        * add_cell\ (c, v0, v1, v2)

          Add cell (triangle) with given vertices
          
          *Arguments*
              c (int)
                  The cell (index).
              v0 (int)
                  Index of the first vertex.
              v1 (int)
                  Index of the second vertex.
              v2 (int)
                  Index of the third vertex.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * add_cell\ (c, v0, v1, v2, v3)

          Add cell (tetrahedron) with given vertices
          
          *Arguments*
              c (int)
                  The cell (index).
              v0 (int)
                  Index of the first vertex.
              v1 (int)
                  Index of the second vertex.
              v2 (int)
                  Index of the third vertex.
              v3 (int)
                  Index of the fourth vertex.

        """
        return _cpp.MeshEditor_add_cell(self, *args)

    def add_higher_order_cell_data(self, *args):
        """
        Add higher order cell data (assume P2 triangle for now)

        *Arguments*
            c (int)
                The cell (index).
            v0 (int)
                Index of the first vertex.
            v1 (int)
                Index of the second vertex.
            v2 (int)
                Index of the third vertex.
            v3 (int)
                Index of the fourth vertex.
            v4 (int)
                Index of the fifth vertex.
            v5 (int)
                Index of the sixth vertex.

        """
        return _cpp.MeshEditor_add_higher_order_cell_data(self, *args)

    def close(self, *args):
        """
        Close mesh, finish editing, and order entities locally

        *Arguments*
            order (bool)
                Order entities locally if true. Default values is true.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        return _cpp.MeshEditor_close(self, *args)

MeshEditor.open = new_instancemethod(_cpp.MeshEditor_open,None,MeshEditor)
MeshEditor.init_vertices = new_instancemethod(_cpp.MeshEditor_init_vertices,None,MeshEditor)
MeshEditor.init_higher_order_vertices = new_instancemethod(_cpp.MeshEditor_init_higher_order_vertices,None,MeshEditor)
MeshEditor.init_cells = new_instancemethod(_cpp.MeshEditor_init_cells,None,MeshEditor)
MeshEditor.init_higher_order_cells = new_instancemethod(_cpp.MeshEditor_init_higher_order_cells,None,MeshEditor)
MeshEditor.set_affine_cell_indicator = new_instancemethod(_cpp.MeshEditor_set_affine_cell_indicator,None,MeshEditor)
MeshEditor.add_vertex = new_instancemethod(_cpp.MeshEditor_add_vertex,None,MeshEditor)
MeshEditor.add_higher_order_vertex = new_instancemethod(_cpp.MeshEditor_add_higher_order_vertex,None,MeshEditor)
MeshEditor.add_cell = new_instancemethod(_cpp.MeshEditor_add_cell,None,MeshEditor)
MeshEditor.add_higher_order_cell_data = new_instancemethod(_cpp.MeshEditor_add_higher_order_cell_data,None,MeshEditor)
MeshEditor.close = new_instancemethod(_cpp.MeshEditor_close,None,MeshEditor)
MeshEditor_swigregister = _cpp.MeshEditor_swigregister
MeshEditor_swigregister(MeshEditor)

class DynamicMeshEditor(object):
    """
    This class provides an interface for dynamic editing of meshes,
    that is, when the number of vertices and cells are not known
    a priori. If the number of vertices and cells are known a priori,
    it is more efficient to use the default editor MeshEditor.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.DynamicMeshEditor_swiginit(self,_cpp.new_DynamicMeshEditor(*args))
    __swig_destroy__ = _cpp.delete_DynamicMeshEditor
    def open(self, *args):
        """
        **Overloaded versions**

        * open\ (mesh, type, tdim, gdim)

          Open mesh of given cell type, topological and geometrical dimension

        * open\ (mesh, type, tdim, gdim)

          Open mesh of given cell type, topological and geometrical dimension

        """
        return _cpp.DynamicMeshEditor_open(self, *args)

    def add_vertex(self, *args):
        """
        **Overloaded versions**

        * add_vertex\ (v, p)

          Add vertex v at given point p

        * add_vertex\ (v, x)

          Add vertex v at given coordinate x

        * add_vertex\ (v, x, y)

          Add vertex v at given coordinate (x, y)

        * add_vertex\ (v, x, y, z)

          Add vertex v at given coordinate (x, y, z)

        """
        return _cpp.DynamicMeshEditor_add_vertex(self, *args)

    def add_cell(self, *args):
        """
        **Overloaded versions**

        * add_cell\ (c, v)

          Add cell with given vertices

        * add_cell\ (c, v0, v1)

          Add cell (interval) with given vertices

        * add_cell\ (c, v0, v1, v2)

          Add cell (triangle) with given vertices

        * add_cell\ (c, v0, v1, v2, v3)

          Add cell (tetrahedron) with given vertices

        """
        return _cpp.DynamicMeshEditor_add_cell(self, *args)

    def close(self, *args):
        """
        Close mesh, finish editing, and order entities locally

        """
        return _cpp.DynamicMeshEditor_close(self, *args)

DynamicMeshEditor.open = new_instancemethod(_cpp.DynamicMeshEditor_open,None,DynamicMeshEditor)
DynamicMeshEditor.add_vertex = new_instancemethod(_cpp.DynamicMeshEditor_add_vertex,None,DynamicMeshEditor)
DynamicMeshEditor.add_cell = new_instancemethod(_cpp.DynamicMeshEditor_add_cell,None,DynamicMeshEditor)
DynamicMeshEditor.close = new_instancemethod(_cpp.DynamicMeshEditor_close,None,DynamicMeshEditor)
DynamicMeshEditor_swigregister = _cpp.DynamicMeshEditor_swigregister
DynamicMeshEditor_swigregister(DynamicMeshEditor)

class MeshPartitioning(object):
    """
    This class partitions and distributes a mesh based on
    partitioned local mesh data. Note that the local mesh data will
    also be repartitioned and redistributed during the computation
    of the mesh partitioning.

    After partitioning, each process has a local mesh and set of
    mesh data that couples the meshes together.

    The following mesh data is created:

    1. "global entity indices 0" (MeshFunction<uint>)

    This maps each local vertex to its global index.

    2. "overlap" (std::map<uint, std::vector<uint> >)

    This maps each shared vertex to a list of the processes sharing
    the vertex.

    3. "global entity indices %d" (MeshFunction<uint>)

    After partitioning, the function number_entities() may be called
    to create global indices for all entities of a given topological
    dimension. These are stored as mesh data (MeshFunction<uint>)
    named

       "global entity indices 1"
       "global entity indices 2"
       etc

    4. "num global entities" (std::vector<uint>)

    The function number_entities also records the number of global
    entities for the dimension of the numbered entities in the array
    named "num global entities". This array has size D + 1, where D
    is the topological dimension of the mesh. This array is
    initially created by the mesh and then contains only the number
    entities of dimension 0 (vertices) and dimension D (cells).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def build_distributed_mesh(*args):
        """
        **Overloaded versions**

        * build_distributed_mesh\ (mesh)

          Build a partitioned mesh based on local meshes

        * build_distributed_mesh\ (mesh, data)

          Build a partitioned mesh based on local mesh data

        """
        return _cpp.MeshPartitioning_build_distributed_mesh(*args)

    build_distributed_mesh = staticmethod(build_distributed_mesh)
    def number_entities(*args):
        """
        Create global entity indices for entities of dimension d

        """
        return _cpp.MeshPartitioning_number_entities(*args)

    number_entities = staticmethod(number_entities)
    def __init__(self, *args): 
        _cpp.MeshPartitioning_swiginit(self,_cpp.new_MeshPartitioning(*args))
    __swig_destroy__ = _cpp.delete_MeshPartitioning
MeshPartitioning_swigregister = _cpp.MeshPartitioning_swigregister
MeshPartitioning_swigregister(MeshPartitioning)

def MeshPartitioning_build_distributed_mesh(*args):
  """
    **Overloaded versions**

    * build_distributed_mesh\ (mesh)

      Build a partitioned mesh based on local meshes

    * build_distributed_mesh\ (mesh, data)

      Build a partitioned mesh based on local mesh data

    """
  return _cpp.MeshPartitioning_build_distributed_mesh(*args)

def MeshPartitioning_number_entities(*args):
  """
    Create global entity indices for entities of dimension d

    """
  return _cpp.MeshPartitioning_number_entities(*args)

class MeshColoring(object):
    """
    This class computes colorings for a local mesh. It supports
    vertex, edge, and facet-based colorings.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def color_cells(*args):
        """
        Color the cells of a mesh for given coloring type, which can
        be one of "vertex", "edge" or "facet".

        """
        return _cpp.MeshColoring_color_cells(*args)

    color_cells = staticmethod(color_cells)
    def color(*args):
        """
        Color the cells of a mesh for given coloring type specified by
        topological dimension, which can be one of 0, 1 or D - 1.

        """
        return _cpp.MeshColoring_color(*args)

    color = staticmethod(color)
    def compute_colors(*args):
        """
        Compute cell colors for given coloring type specified by
        topological dimension, which can be one of 0, 1 or D - 1.

        """
        return _cpp.MeshColoring_compute_colors(*args)

    compute_colors = staticmethod(compute_colors)
    def type_to_dim(*args):
        """
        Convert coloring type to topological dimension

        """
        return _cpp.MeshColoring_type_to_dim(*args)

    type_to_dim = staticmethod(type_to_dim)
    def __init__(self, *args): 
        _cpp.MeshColoring_swiginit(self,_cpp.new_MeshColoring(*args))
    __swig_destroy__ = _cpp.delete_MeshColoring
MeshColoring_swigregister = _cpp.MeshColoring_swigregister
MeshColoring_swigregister(MeshColoring)

def MeshColoring_color_cells(*args):
  """
    Color the cells of a mesh for given coloring type, which can
    be one of "vertex", "edge" or "facet".

    """
  return _cpp.MeshColoring_color_cells(*args)

def MeshColoring_color(*args):
  """
    Color the cells of a mesh for given coloring type specified by
    topological dimension, which can be one of 0, 1 or D - 1.

    """
  return _cpp.MeshColoring_color(*args)

def MeshColoring_compute_colors(*args):
  """
    Compute cell colors for given coloring type specified by
    topological dimension, which can be one of 0, 1 or D - 1.

    """
  return _cpp.MeshColoring_compute_colors(*args)

def MeshColoring_type_to_dim(*args):
  """
    Convert coloring type to topological dimension

    """
  return _cpp.MeshColoring_type_to_dim(*args)

class MeshRenumbering(object):
    """
    This class implements renumbering algorithms for meshes.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    renumber_by_color = staticmethod(_cpp.MeshRenumbering_renumber_by_color)
    def __init__(self, *args): 
        _cpp.MeshRenumbering_swiginit(self,_cpp.new_MeshRenumbering(*args))
    __swig_destroy__ = _cpp.delete_MeshRenumbering
MeshRenumbering_swigregister = _cpp.MeshRenumbering_swigregister
MeshRenumbering_swigregister(MeshRenumbering)

def MeshRenumbering_renumber_by_color(*args):
  return _cpp.MeshRenumbering_renumber_by_color(*args)
MeshRenumbering_renumber_by_color = _cpp.MeshRenumbering_renumber_by_color

class LocalMeshData(Variable):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * LocalMeshData\ ()

          Create empty local mesh data

        * LocalMeshData\ (mesh)

          Create local mesh data for given mesh

        """
        _cpp.LocalMeshData_swiginit(self,_cpp.new_LocalMeshData(*args))
    __swig_destroy__ = _cpp.delete_LocalMeshData
LocalMeshData_swigregister = _cpp.LocalMeshData_swigregister
LocalMeshData_swigregister(LocalMeshData)

class SubDomain(object):
    """
    This class defines the interface for definition of subdomains.
    Alternatively, subdomains may be defined by a :py:class:`Mesh` and a
    :py:class:`MeshFunction` <uint> over the mesh.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        if self.__class__ == SubDomain:
            _self = None
        else:
            _self = self
        _cpp.SubDomain_swiginit(self,_cpp.new_SubDomain(_self, *args))
    __swig_destroy__ = _cpp.delete_SubDomain
    def inside(self, *args):
        """
        Return true for points inside the subdomain

        *Arguments*
            x (numpy.array(float))
                The coordinates of the point.
            on_boundary (bool)
                True for points on the boundary.

        *Returns*
            bool
                True for points inside the subdomain.

        """
        return _cpp.SubDomain_inside(self, *args)

    def map(self, *args):
        """
        Map coordinate x in domain H to coordinate y in domain G (used for
        periodic boundary conditions)

        *Arguments*
            x (numpy.array(float))
                The coordinates in domain H.
            unnamed (numpy.array(float))
                The coordinates in domain G.

        """
        return _cpp.SubDomain_map(self, *args)

    def snap(self, *args):
        """
        Snap coordinate to boundary of subdomain

        *Arguments*
            x (numpy.array(float))
                The coordinates.

        """
        return _cpp.SubDomain_snap(self, *args)

    def mark_cells(self, *args):
        """
        Set subdomain markers (uint) on cells for given subdomain number

        *Arguments*
            mesh (:py:class:`Mesh`)
                The mesh to be marked.
            sub_domain (int)
                The subdomain number.

        """
        return _cpp.SubDomain_mark_cells(self, *args)

    def mark_facets(self, *args):
        """
        Set subdomain markers (uint) on facets for given subdomain number

        *Arguments*
            mesh (:py:class:`Mesh`)
                The mesh to be marked.
            sub_domain (int)
                The subdomain number.

        """
        return _cpp.SubDomain_mark_facets(self, *args)

    def mark(self, *args):
        """
        **Overloaded versions**

        * mark\ (mesh, dim, sub_domain)

          Set subdomain markers (uint) for given topological dimension
          and subdomain number
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to be marked.
              dim (int)
                  The topological dimension of entities to be marked.
              sub_domain (int)
                  The subdomain number.

        * mark\ (sub_domains, sub_domain)

          Set subdomain markers (uint) for given subdomain number
          
          *Arguments*
              sub_domains (:py:class:`MeshFunction`)
                  The subdomain markers.
              sub_domain (int)
                  The subdomain number.

        * mark\ (sub_domains, sub_domain)

          Set subdomain markers (int) for given subdomain number
          
          *Arguments*
              sub_domains (:py:class:`MeshFunction`)
                  The subdomain markers.
              sub_domain (int)
                  The subdomain number.

        * mark\ (sub_domains, sub_domain)

          Set subdomain markers (double) for given subdomain number
          
          *Arguments*
              sub_domains (:py:class:`MeshFunction`)
                  The subdomain markers.
              sub_domain (float)
                  The subdomain number.

        * mark\ (sub_domains, sub_domain)

          Set subdomain markers (bool) for given subdomain
          
          *Arguments*
              sub_domains (:py:class:`MeshFunction`)
                  The subdomain markers.
              sub_domain (bool)
                  The subdomain number.

        * mark\ (sub_domains, sub_domain, mesh)

          Set subdomain markers (uint) for given subdomain number
          
          *Arguments*
              sub_domains (:py:class:`MeshValueCollection`)
                  The subdomain markers.
              sub_domain (int)
                  The subdomain number.
              mesn (:py:class:`Mesh`)
                  The mesh.

        * mark\ (sub_domains, sub_domain, mesh)

          Set subdomain markers (int) for given subdomain number
          
          *Arguments*
              sub_domains (:py:class:`MeshValueCollection`)
                  The subdomain markers
              sub_domain (int)
                  The subdomain number

        * mark\ (sub_domains, sub_domain, mesh)

          Set subdomain markers (double) for given subdomain number
          
          *Arguments*
              sub_domains (:py:class:`MeshValueCollection`)
                  The subdomain markers.
              sub_domain (float)
                  The subdomain number

        * mark\ (sub_domains, sub_domain, mesh)

          Set subdomain markers (bool) for given subdomain
          
          *Arguments*
              sub_domains (:py:class:`MeshValueCollection`)
                  The subdomain markers
              sub_domain (bool)
                  The subdomain number

        """
        return _cpp.SubDomain_mark(self, *args)

    def geometric_dimension(self, *args):
        """
        Return geometric dimension

        *Returns*
            int
                The geometric dimension.

        """
        return _cpp.SubDomain_geometric_dimension(self, *args)

    def __disown__(self):
        self.this.disown()
        _cpp.disown_SubDomain(self)
        return weakref_proxy(self)
SubDomain.inside = new_instancemethod(_cpp.SubDomain_inside,None,SubDomain)
SubDomain.map = new_instancemethod(_cpp.SubDomain_map,None,SubDomain)
SubDomain.snap = new_instancemethod(_cpp.SubDomain_snap,None,SubDomain)
SubDomain.mark_cells = new_instancemethod(_cpp.SubDomain_mark_cells,None,SubDomain)
SubDomain.mark_facets = new_instancemethod(_cpp.SubDomain_mark_facets,None,SubDomain)
SubDomain.mark = new_instancemethod(_cpp.SubDomain_mark,None,SubDomain)
SubDomain.geometric_dimension = new_instancemethod(_cpp.SubDomain_geometric_dimension,None,SubDomain)
SubDomain_swigregister = _cpp.SubDomain_swigregister
SubDomain_swigregister(SubDomain)

class SubMesh(Mesh):
    """
    A SubMesh is a mesh defined as a subset of a given mesh. It
    provides a convenient way to create matching meshes for
    multiphysics applications by creating meshes for subdomains as
    subsets of a single global mesh. A mapping from the vertices of
    the sub mesh to the vertices of the parent mesh is stored as the
    mesh data named "parent_vertex_indices".

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * SubMesh\ (mesh, sub_domain)

          Create subset of given mesh marked by sub domain

        * SubMesh\ (mesh, sub_domains, sub_domain)

          Create subset of given mesh marked by mesh function

        """
        _cpp.SubMesh_swiginit(self,_cpp.new_SubMesh(*args))
    __swig_destroy__ = _cpp.delete_SubMesh
SubMesh_swigregister = _cpp.SubMesh_swigregister
SubMesh_swigregister(SubMesh)

class DomainBoundary(SubDomain):
    """
    This class provides a SubDomain which picks out the boundary of
    a mesh, and provides a convenient way to specify boundary
    conditions on the entire boundary of a mesh.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.DomainBoundary_swiginit(self,_cpp.new_DomainBoundary(*args))
    __swig_destroy__ = _cpp.delete_DomainBoundary
DomainBoundary_swigregister = _cpp.DomainBoundary_swigregister
DomainBoundary_swigregister(DomainBoundary)

class BoundaryMesh(Mesh):
    """
    A BoundaryMesh is a mesh over the boundary of some given mesh.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * BoundaryMesh\ ()

          Create an empty boundary mesh

        * BoundaryMesh\ (mesh)

          Create (interior) boundary mesh from given mesh

        """
        _cpp.BoundaryMesh_swiginit(self,_cpp.new_BoundaryMesh(*args))
    __swig_destroy__ = _cpp.delete_BoundaryMesh
    def init_exterior_boundary(self, *args):
        """
        Initialize exterior boundary of given mesh

        """
        return _cpp.BoundaryMesh_init_exterior_boundary(self, *args)

    def init_interior_boundary(self, *args):
        """
        Initialize interior boundary of given mesh

        """
        return _cpp.BoundaryMesh_init_interior_boundary(self, *args)

    def cell_map(self, *args):
        """
        Get cell mapping from the boundary mesh to the original full mesh

        """
        return _cpp.BoundaryMesh_cell_map(self, *args)

    def vertex_map(self, *args):
        """
        Get vertex mapping from the boundary mesh to the original full mesh

        """
        return _cpp.BoundaryMesh_vertex_map(self, *args)

BoundaryMesh.init_exterior_boundary = new_instancemethod(_cpp.BoundaryMesh_init_exterior_boundary,None,BoundaryMesh)
BoundaryMesh.init_interior_boundary = new_instancemethod(_cpp.BoundaryMesh_init_interior_boundary,None,BoundaryMesh)
BoundaryMesh.cell_map = new_instancemethod(_cpp.BoundaryMesh_cell_map,None,BoundaryMesh)
BoundaryMesh.vertex_map = new_instancemethod(_cpp.BoundaryMesh_vertex_map,None,BoundaryMesh)
BoundaryMesh_swigregister = _cpp.BoundaryMesh_swigregister
BoundaryMesh_swigregister(BoundaryMesh)

class UnitTetrahedron(Mesh):
    """
    A mesh consisting of a single tetrahedron with vertices at

      (0, 0, 0)
      (1, 0, 0)
      (0, 1, 0)
      (0, 0, 1)

    This class is useful for testing.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create mesh of unit tetrahedron

        """
        _cpp.UnitTetrahedron_swiginit(self,_cpp.new_UnitTetrahedron(*args))
    __swig_destroy__ = _cpp.delete_UnitTetrahedron
UnitTetrahedron_swigregister = _cpp.UnitTetrahedron_swigregister
UnitTetrahedron_swigregister(UnitTetrahedron)

class UnitCube(Mesh):
    """
    Tetrahedral mesh of the 3D unit cube [0,1] x [0,1] x [0,1].
    Given the number of cells (nx, ny, nz) in each direction,
    the total number of tetrahedra will be 6*nx*ny*nz and the
    total number of vertices will be (nx + 1)*(ny + 1)*(nz + 1).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Define a uniform finite element :py:class:`Mesh` over the unit cube
        [0,1] x [0,1] x [0,1].

        *Arguments*
            nx (int)
                Number of cells in :math:`x` direction.
            ny (int)
                Number of cells in :math:`y` direction.
            nz (int)
                Number of cells in :math:`z` direction.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        _cpp.UnitCube_swiginit(self,_cpp.new_UnitCube(*args))
    __swig_destroy__ = _cpp.delete_UnitCube
UnitCube_swigregister = _cpp.UnitCube_swigregister
UnitCube_swigregister(UnitCube)

class UnitInterval(Mesh):
    """
    A mesh of the unit interval (0, 1) with a given number of cells
    (nx) in the axial direction. The total number of intervals will
    be nx and the total number of vertices will be (nx + 1).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create mesh of unit interval

        """
        _cpp.UnitInterval_swiginit(self,_cpp.new_UnitInterval(*args))
    __swig_destroy__ = _cpp.delete_UnitInterval
UnitInterval_swigregister = _cpp.UnitInterval_swigregister
UnitInterval_swigregister(UnitInterval)

class Interval(Mesh):
    """
    Interval mesh of the 1D line [a,b].  Given the number of cells
    (nx) in the axial direction, the total number of intervals will
    be nx and the total number of vertices will be (nx + 1).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        *Arguments*
            nx (int)
                The number of cells.
            a (float)
                The minimum point (inclusive).
            b (float)
                The maximum point (inclusive).

        *Example*
            .. note::
            
                No example code available for this function.

        """
        _cpp.Interval_swiginit(self,_cpp.new_Interval(*args))
    __swig_destroy__ = _cpp.delete_Interval
Interval_swigregister = _cpp.Interval_swigregister
Interval_swigregister(Interval)

class UnitTriangle(Mesh):
    """
    A mesh consisting of a single triangle with vertices at

      (0, 0)
      (1, 0)
      (0, 1)

    This class is useful for testing.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create mesh of unit triangle

        """
        _cpp.UnitTriangle_swiginit(self,_cpp.new_UnitTriangle(*args))
    __swig_destroy__ = _cpp.delete_UnitTriangle
UnitTriangle_swigregister = _cpp.UnitTriangle_swigregister
UnitTriangle_swigregister(UnitTriangle)

class UnitSquare(Mesh):
    """
    Triangular mesh of the 2D unit square [0,1] x [0,1].
    Given the number of cells (nx, ny) in each direction,
    the total number of triangles will be 2*nx*ny and the
    total number of vertices will be (nx + 1)*(ny + 1).

    std::string diagonal ("left", "right", "right/left", "left/right",
    or "crossed") indicates the direction of the diagonals.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Define a uniform finite element :py:class:`Mesh` over the unit square
        [0,1] x [0,1].

        *Arguments*
            nx (int)
                Number of cells in horizontal direction.
            ny (int)
                Number of cells in vertical direction.
            diagonal (str)
                Optional argument: A std::string indicating
                the direction of the diagonals.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        _cpp.UnitSquare_swiginit(self,_cpp.new_UnitSquare(*args))
    __swig_destroy__ = _cpp.delete_UnitSquare
UnitSquare_swigregister = _cpp.UnitSquare_swigregister
UnitSquare_swigregister(UnitSquare)

class UnitCircle(Mesh):
    """
    Triangular mesh of the 2D unit circle.
    Given the number of cells (nx, ny) in each direction,
    the total number of triangles will be 2*nx*ny and the
    total number of vertices will be (nx + 1)*(ny + 1).
    std::string diagonal ("left", "right" or "crossed") indicates the
    direction of the diagonals.
    std:string transformation ("maxn", "sumn" or "rotsumn")

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.UnitCircle_swiginit(self,_cpp.new_UnitCircle(*args))
    __swig_destroy__ = _cpp.delete_UnitCircle
UnitCircle_swigregister = _cpp.UnitCircle_swigregister
UnitCircle_swigregister(UnitCircle)

class Box(Mesh):
    """
    Tetrahedral mesh of the 3D rectangular prism [x0, x1] x [y0, y1]
    x [z0, z1].  Given the number of cells (nx, ny, nz) in each
    direction, the total number of tetrahedra will be 6*nx*ny*nz and
    the total number of vertices will be (nx + 1)*(ny + 1)*(nz + 1).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Define a uniform finite element :py:class:`Mesh` over the rectangular prism
        [x0, x1] x [y0, y1] x [z0, z1].

        *Arguments*
            x0 (float)
                :math:`x`-min.
            y0 (float)
                :math:`y`-min.
            z0 (float)
                :math:`z`-min.
            x1 (float)
                :math:`x`-max.
            y1 (float)
                :math:`y`-max.
            z1 (float)
                :math:`z`-max.
            xn (float)
                Number of cells in :math:`x`-direction.
            yn (float)
                Number of cells in :math:`y`-direction.
            zn (float)
                Number of cells in :math:`z`-direction.

        *Example*
            .. note::
            
                No example code available for this function.

        """
        _cpp.Box_swiginit(self,_cpp.new_Box(*args))
    __swig_destroy__ = _cpp.delete_Box
Box_swigregister = _cpp.Box_swigregister
Box_swigregister(Box)

class Rectangle(Mesh):
    """
    Triangular mesh of the 2D rectangle (x0, y0) x (x1, y1).
    Given the number of cells (nx, ny) in each direction,
    the total number of triangles will be 2*nx*ny and the
    total number of vertices will be (nx + 1)*(ny + 1).

    *Arguments*
        x0 (float)
            :math:`x`-min.
        y0 (float)
            :math:`y`-min.
        x1 (float)
            :math:`x`-max.
        y1 (float)
            :math:`y`-max.
        xn (float)
            Number of cells in :math:`x`-direction.
        yn (float)
            Number of cells in :math:`y`-direction.
        diagonal (str)
            Direction of diagonals: "left", "right", "left/right", "crossed"

    *Example*
        .. note::
        
            No example code available for this function.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.Rectangle_swiginit(self,_cpp.new_Rectangle(*args))
    __swig_destroy__ = _cpp.delete_Rectangle
Rectangle_swigregister = _cpp.Rectangle_swigregister
Rectangle_swigregister(Rectangle)

class UnitSphere(Mesh):
    """
    Triangular mesh of the 3D unit sphere.

    Given the number of cells (nx, ny, nz) in each direction,
    the total number of tetrahedra will be 6*nx*ny*nz and the
    total number of vertices will be (nx + 1)*(ny + 1)*(nz + 1).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.UnitSphere_swiginit(self,_cpp.new_UnitSphere(*args))
    __swig_destroy__ = _cpp.delete_UnitSphere
UnitSphere_swigregister = _cpp.UnitSphere_swigregister
UnitSphere_swigregister(UnitSphere)

class MeshFunctionUInt(Variable,HierarchicalMeshFunctionUInt):
    """
    A MeshFunction is a function that can be evaluated at a set of
    mesh entities. A MeshFunction is discrete and is only defined
    at the set of mesh entities of a fixed topological dimension.
    A MeshFunction may for example be used to store a global
    numbering scheme for the entities of a (parallel) mesh, marking
    sub domains or boolean markers for mesh refinement.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshFunction\ ()

          Create empty mesh function

        * MeshFunction\ (mesh)

          Create empty mesh function on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.

        * MeshFunction\ (mesh, dim)

          Create mesh function of given dimension on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension for the mesh function.

        * MeshFunction\ (mesh, dim, value)

          Create mesh of given dimension on given mesh and initialize
          to a value
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension.
              value (T)
                  The value.

        * MeshFunction\ (mesh, filename)

          Create function from data file
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              filename (str)
                  The filename to create mesh function from.

        * MeshFunction\ (mesh, value_collection)

          Create function from a MeshValueCollecion
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              value_collection (:py:class:`MeshValueCollection`)
                  The mesh value collection for the mesh function data.

        * MeshFunction\ (f)

          Copy constructor
          
          *Arguments*
              f (:py:class:`MeshFunction`)
                  The object to be copied.

        """
        _cpp.MeshFunctionUInt_swiginit(self,_cpp.new_MeshFunctionUInt(*args))
    __swig_destroy__ = _cpp.delete_MeshFunctionUInt
    def mesh(self, *args):
        """
        Return mesh associated with mesh function

        *Returns*
            :py:class:`Mesh`
                The mesh.

        """
        return _cpp.MeshFunctionUInt_mesh(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshFunctionUInt_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshFunctionUInt_size(self, *args)

    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              dim (int)
                  The dimension.

        * init\ (dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              dim (int)
                  The dimension.
              size (int)
                  The size.

        * init\ (mesh, dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.

        * init\ (mesh, dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.
              size (int)
                  The size.

        """
        return _cpp.MeshFunctionUInt_init(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (index, value)

          Set value at given index
          
          *Arguments*
              index (int)
                  The index.
              value (T)
                  The value.

        * set_value\ (index, value, mesh)

          Compatibility function for use in SubDomains

        """
        return _cpp.MeshFunctionUInt_set_value(self, *args)

    def set_values(self, *args):
        """
        Set values

        *Arguments*
            values (std::vector<T>)
                The values.

        """
        return _cpp.MeshFunctionUInt_set_values(self, *args)

    def set_all(self, *args):
        """
        Set all values to given value

        *Arguments*
            value (T)
                The value to set all values to.

        """
        return _cpp.MeshFunctionUInt_set_all(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionUInt___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionUInt___setitem__(self, *args)

MeshFunctionUInt.mesh = new_instancemethod(_cpp.MeshFunctionUInt_mesh,None,MeshFunctionUInt)
MeshFunctionUInt.dim = new_instancemethod(_cpp.MeshFunctionUInt_dim,None,MeshFunctionUInt)
MeshFunctionUInt.size = new_instancemethod(_cpp.MeshFunctionUInt_size,None,MeshFunctionUInt)
MeshFunctionUInt.init = new_instancemethod(_cpp.MeshFunctionUInt_init,None,MeshFunctionUInt)
MeshFunctionUInt.set_value = new_instancemethod(_cpp.MeshFunctionUInt_set_value,None,MeshFunctionUInt)
MeshFunctionUInt.set_values = new_instancemethod(_cpp.MeshFunctionUInt_set_values,None,MeshFunctionUInt)
MeshFunctionUInt.set_all = new_instancemethod(_cpp.MeshFunctionUInt_set_all,None,MeshFunctionUInt)
MeshFunctionUInt.array = new_instancemethod(_cpp.MeshFunctionUInt_array,None,MeshFunctionUInt)
MeshFunctionUInt.__getitem__ = new_instancemethod(_cpp.MeshFunctionUInt___getitem__,None,MeshFunctionUInt)
MeshFunctionUInt.__setitem__ = new_instancemethod(_cpp.MeshFunctionUInt___setitem__,None,MeshFunctionUInt)
MeshFunctionUInt_swigregister = _cpp.MeshFunctionUInt_swigregister
MeshFunctionUInt_swigregister(MeshFunctionUInt)

class CellFunctionUInt(MeshFunctionUInt):
    """
    A CellFunction is a MeshFunction of topological codimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.CellFunctionUInt_swiginit(self,_cpp.new_CellFunctionUInt(*args))
    __swig_destroy__ = _cpp.delete_CellFunctionUInt
CellFunctionUInt_swigregister = _cpp.CellFunctionUInt_swigregister
CellFunctionUInt_swigregister(CellFunctionUInt)

class EdgeFunctionUInt(MeshFunctionUInt):
    """
    An EdgeFunction is a :py:class:`MeshFunction` of topological dimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.EdgeFunctionUInt_swiginit(self,_cpp.new_EdgeFunctionUInt(*args))
    __swig_destroy__ = _cpp.delete_EdgeFunctionUInt
EdgeFunctionUInt_swigregister = _cpp.EdgeFunctionUInt_swigregister
EdgeFunctionUInt_swigregister(EdgeFunctionUInt)

class FaceFunctionUInt(MeshFunctionUInt):
    """
    A FaceFunction is a MeshFunction of topological dimension 2.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FaceFunctionUInt_swiginit(self,_cpp.new_FaceFunctionUInt(*args))
    __swig_destroy__ = _cpp.delete_FaceFunctionUInt
FaceFunctionUInt_swigregister = _cpp.FaceFunctionUInt_swigregister
FaceFunctionUInt_swigregister(FaceFunctionUInt)

class FacetFunctionUInt(MeshFunctionUInt):
    """
    A FacetFunction is a MeshFunction of topological codimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FacetFunctionUInt_swiginit(self,_cpp.new_FacetFunctionUInt(*args))
    __swig_destroy__ = _cpp.delete_FacetFunctionUInt
FacetFunctionUInt_swigregister = _cpp.FacetFunctionUInt_swigregister
FacetFunctionUInt_swigregister(FacetFunctionUInt)

class VertexFunctionUInt(MeshFunctionUInt):
    """
    A VertexFunction is a MeshFunction of topological dimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.VertexFunctionUInt_swiginit(self,_cpp.new_VertexFunctionUInt(*args))
    __swig_destroy__ = _cpp.delete_VertexFunctionUInt
VertexFunctionUInt_swigregister = _cpp.VertexFunctionUInt_swigregister
VertexFunctionUInt_swigregister(VertexFunctionUInt)

class MeshFunctionInt(Variable,HierarchicalMeshFunctionInt):
    """
    A MeshFunction is a function that can be evaluated at a set of
    mesh entities. A MeshFunction is discrete and is only defined
    at the set of mesh entities of a fixed topological dimension.
    A MeshFunction may for example be used to store a global
    numbering scheme for the entities of a (parallel) mesh, marking
    sub domains or boolean markers for mesh refinement.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshFunction\ ()

          Create empty mesh function

        * MeshFunction\ (mesh)

          Create empty mesh function on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.

        * MeshFunction\ (mesh, dim)

          Create mesh function of given dimension on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension for the mesh function.

        * MeshFunction\ (mesh, dim, value)

          Create mesh of given dimension on given mesh and initialize
          to a value
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension.
              value (T)
                  The value.

        * MeshFunction\ (mesh, filename)

          Create function from data file
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              filename (str)
                  The filename to create mesh function from.

        * MeshFunction\ (mesh, value_collection)

          Create function from a MeshValueCollecion
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              value_collection (:py:class:`MeshValueCollection`)
                  The mesh value collection for the mesh function data.

        * MeshFunction\ (f)

          Copy constructor
          
          *Arguments*
              f (:py:class:`MeshFunction`)
                  The object to be copied.

        """
        _cpp.MeshFunctionInt_swiginit(self,_cpp.new_MeshFunctionInt(*args))
    __swig_destroy__ = _cpp.delete_MeshFunctionInt
    def mesh(self, *args):
        """
        Return mesh associated with mesh function

        *Returns*
            :py:class:`Mesh`
                The mesh.

        """
        return _cpp.MeshFunctionInt_mesh(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshFunctionInt_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshFunctionInt_size(self, *args)

    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              dim (int)
                  The dimension.

        * init\ (dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              dim (int)
                  The dimension.
              size (int)
                  The size.

        * init\ (mesh, dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.

        * init\ (mesh, dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.
              size (int)
                  The size.

        """
        return _cpp.MeshFunctionInt_init(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (index, value)

          Set value at given index
          
          *Arguments*
              index (int)
                  The index.
              value (T)
                  The value.

        * set_value\ (index, value, mesh)

          Compatibility function for use in SubDomains

        """
        return _cpp.MeshFunctionInt_set_value(self, *args)

    def set_values(self, *args):
        """
        Set values

        *Arguments*
            values (std::vector<T>)
                The values.

        """
        return _cpp.MeshFunctionInt_set_values(self, *args)

    def set_all(self, *args):
        """
        Set all values to given value

        *Arguments*
            value (T)
                The value to set all values to.

        """
        return _cpp.MeshFunctionInt_set_all(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionInt___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionInt___setitem__(self, *args)

MeshFunctionInt.mesh = new_instancemethod(_cpp.MeshFunctionInt_mesh,None,MeshFunctionInt)
MeshFunctionInt.dim = new_instancemethod(_cpp.MeshFunctionInt_dim,None,MeshFunctionInt)
MeshFunctionInt.size = new_instancemethod(_cpp.MeshFunctionInt_size,None,MeshFunctionInt)
MeshFunctionInt.init = new_instancemethod(_cpp.MeshFunctionInt_init,None,MeshFunctionInt)
MeshFunctionInt.set_value = new_instancemethod(_cpp.MeshFunctionInt_set_value,None,MeshFunctionInt)
MeshFunctionInt.set_values = new_instancemethod(_cpp.MeshFunctionInt_set_values,None,MeshFunctionInt)
MeshFunctionInt.set_all = new_instancemethod(_cpp.MeshFunctionInt_set_all,None,MeshFunctionInt)
MeshFunctionInt.array = new_instancemethod(_cpp.MeshFunctionInt_array,None,MeshFunctionInt)
MeshFunctionInt.__getitem__ = new_instancemethod(_cpp.MeshFunctionInt___getitem__,None,MeshFunctionInt)
MeshFunctionInt.__setitem__ = new_instancemethod(_cpp.MeshFunctionInt___setitem__,None,MeshFunctionInt)
MeshFunctionInt_swigregister = _cpp.MeshFunctionInt_swigregister
MeshFunctionInt_swigregister(MeshFunctionInt)

class CellFunctionInt(MeshFunctionInt):
    """
    A CellFunction is a MeshFunction of topological codimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.CellFunctionInt_swiginit(self,_cpp.new_CellFunctionInt(*args))
    __swig_destroy__ = _cpp.delete_CellFunctionInt
CellFunctionInt_swigregister = _cpp.CellFunctionInt_swigregister
CellFunctionInt_swigregister(CellFunctionInt)

class EdgeFunctionInt(MeshFunctionInt):
    """
    An EdgeFunction is a :py:class:`MeshFunction` of topological dimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.EdgeFunctionInt_swiginit(self,_cpp.new_EdgeFunctionInt(*args))
    __swig_destroy__ = _cpp.delete_EdgeFunctionInt
EdgeFunctionInt_swigregister = _cpp.EdgeFunctionInt_swigregister
EdgeFunctionInt_swigregister(EdgeFunctionInt)

class FaceFunctionInt(MeshFunctionInt):
    """
    A FaceFunction is a MeshFunction of topological dimension 2.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FaceFunctionInt_swiginit(self,_cpp.new_FaceFunctionInt(*args))
    __swig_destroy__ = _cpp.delete_FaceFunctionInt
FaceFunctionInt_swigregister = _cpp.FaceFunctionInt_swigregister
FaceFunctionInt_swigregister(FaceFunctionInt)

class FacetFunctionInt(MeshFunctionInt):
    """
    A FacetFunction is a MeshFunction of topological codimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FacetFunctionInt_swiginit(self,_cpp.new_FacetFunctionInt(*args))
    __swig_destroy__ = _cpp.delete_FacetFunctionInt
FacetFunctionInt_swigregister = _cpp.FacetFunctionInt_swigregister
FacetFunctionInt_swigregister(FacetFunctionInt)

class VertexFunctionInt(MeshFunctionInt):
    """
    A VertexFunction is a MeshFunction of topological dimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.VertexFunctionInt_swiginit(self,_cpp.new_VertexFunctionInt(*args))
    __swig_destroy__ = _cpp.delete_VertexFunctionInt
VertexFunctionInt_swigregister = _cpp.VertexFunctionInt_swigregister
VertexFunctionInt_swigregister(VertexFunctionInt)

class MeshFunctionDouble(Variable,HierarchicalMeshFunctionDouble):
    """
    A MeshFunction is a function that can be evaluated at a set of
    mesh entities. A MeshFunction is discrete and is only defined
    at the set of mesh entities of a fixed topological dimension.
    A MeshFunction may for example be used to store a global
    numbering scheme for the entities of a (parallel) mesh, marking
    sub domains or boolean markers for mesh refinement.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshFunction\ ()

          Create empty mesh function

        * MeshFunction\ (mesh)

          Create empty mesh function on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.

        * MeshFunction\ (mesh, dim)

          Create mesh function of given dimension on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension for the mesh function.

        * MeshFunction\ (mesh, dim, value)

          Create mesh of given dimension on given mesh and initialize
          to a value
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension.
              value (T)
                  The value.

        * MeshFunction\ (mesh, filename)

          Create function from data file
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              filename (str)
                  The filename to create mesh function from.

        * MeshFunction\ (mesh, value_collection)

          Create function from a MeshValueCollecion
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              value_collection (:py:class:`MeshValueCollection`)
                  The mesh value collection for the mesh function data.

        * MeshFunction\ (f)

          Copy constructor
          
          *Arguments*
              f (:py:class:`MeshFunction`)
                  The object to be copied.

        """
        _cpp.MeshFunctionDouble_swiginit(self,_cpp.new_MeshFunctionDouble(*args))
    __swig_destroy__ = _cpp.delete_MeshFunctionDouble
    def mesh(self, *args):
        """
        Return mesh associated with mesh function

        *Returns*
            :py:class:`Mesh`
                The mesh.

        """
        return _cpp.MeshFunctionDouble_mesh(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshFunctionDouble_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshFunctionDouble_size(self, *args)

    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              dim (int)
                  The dimension.

        * init\ (dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              dim (int)
                  The dimension.
              size (int)
                  The size.

        * init\ (mesh, dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.

        * init\ (mesh, dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.
              size (int)
                  The size.

        """
        return _cpp.MeshFunctionDouble_init(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (index, value)

          Set value at given index
          
          *Arguments*
              index (int)
                  The index.
              value (T)
                  The value.

        * set_value\ (index, value, mesh)

          Compatibility function for use in SubDomains

        """
        return _cpp.MeshFunctionDouble_set_value(self, *args)

    def set_values(self, *args):
        """
        Set values

        *Arguments*
            values (std::vector<T>)
                The values.

        """
        return _cpp.MeshFunctionDouble_set_values(self, *args)

    def set_all(self, *args):
        """
        Set all values to given value

        *Arguments*
            value (T)
                The value to set all values to.

        """
        return _cpp.MeshFunctionDouble_set_all(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionDouble___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionDouble___setitem__(self, *args)

MeshFunctionDouble.mesh = new_instancemethod(_cpp.MeshFunctionDouble_mesh,None,MeshFunctionDouble)
MeshFunctionDouble.dim = new_instancemethod(_cpp.MeshFunctionDouble_dim,None,MeshFunctionDouble)
MeshFunctionDouble.size = new_instancemethod(_cpp.MeshFunctionDouble_size,None,MeshFunctionDouble)
MeshFunctionDouble.init = new_instancemethod(_cpp.MeshFunctionDouble_init,None,MeshFunctionDouble)
MeshFunctionDouble.set_value = new_instancemethod(_cpp.MeshFunctionDouble_set_value,None,MeshFunctionDouble)
MeshFunctionDouble.set_values = new_instancemethod(_cpp.MeshFunctionDouble_set_values,None,MeshFunctionDouble)
MeshFunctionDouble.set_all = new_instancemethod(_cpp.MeshFunctionDouble_set_all,None,MeshFunctionDouble)
MeshFunctionDouble.array = new_instancemethod(_cpp.MeshFunctionDouble_array,None,MeshFunctionDouble)
MeshFunctionDouble.__getitem__ = new_instancemethod(_cpp.MeshFunctionDouble___getitem__,None,MeshFunctionDouble)
MeshFunctionDouble.__setitem__ = new_instancemethod(_cpp.MeshFunctionDouble___setitem__,None,MeshFunctionDouble)
MeshFunctionDouble_swigregister = _cpp.MeshFunctionDouble_swigregister
MeshFunctionDouble_swigregister(MeshFunctionDouble)

class CellFunctionDouble(MeshFunctionDouble):
    """
    A CellFunction is a MeshFunction of topological codimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.CellFunctionDouble_swiginit(self,_cpp.new_CellFunctionDouble(*args))
    __swig_destroy__ = _cpp.delete_CellFunctionDouble
CellFunctionDouble_swigregister = _cpp.CellFunctionDouble_swigregister
CellFunctionDouble_swigregister(CellFunctionDouble)

class EdgeFunctionDouble(MeshFunctionDouble):
    """
    An EdgeFunction is a :py:class:`MeshFunction` of topological dimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.EdgeFunctionDouble_swiginit(self,_cpp.new_EdgeFunctionDouble(*args))
    __swig_destroy__ = _cpp.delete_EdgeFunctionDouble
EdgeFunctionDouble_swigregister = _cpp.EdgeFunctionDouble_swigregister
EdgeFunctionDouble_swigregister(EdgeFunctionDouble)

class FaceFunctionDouble(MeshFunctionDouble):
    """
    A FaceFunction is a MeshFunction of topological dimension 2.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FaceFunctionDouble_swiginit(self,_cpp.new_FaceFunctionDouble(*args))
    __swig_destroy__ = _cpp.delete_FaceFunctionDouble
FaceFunctionDouble_swigregister = _cpp.FaceFunctionDouble_swigregister
FaceFunctionDouble_swigregister(FaceFunctionDouble)

class FacetFunctionDouble(MeshFunctionDouble):
    """
    A FacetFunction is a MeshFunction of topological codimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FacetFunctionDouble_swiginit(self,_cpp.new_FacetFunctionDouble(*args))
    __swig_destroy__ = _cpp.delete_FacetFunctionDouble
FacetFunctionDouble_swigregister = _cpp.FacetFunctionDouble_swigregister
FacetFunctionDouble_swigregister(FacetFunctionDouble)

class VertexFunctionDouble(MeshFunctionDouble):
    """
    A VertexFunction is a MeshFunction of topological dimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.VertexFunctionDouble_swiginit(self,_cpp.new_VertexFunctionDouble(*args))
    __swig_destroy__ = _cpp.delete_VertexFunctionDouble
VertexFunctionDouble_swigregister = _cpp.VertexFunctionDouble_swigregister
VertexFunctionDouble_swigregister(VertexFunctionDouble)

class MeshFunctionBool(Variable,HierarchicalMeshFunctionBool):
    """
    A MeshFunction is a function that can be evaluated at a set of
    mesh entities. A MeshFunction is discrete and is only defined
    at the set of mesh entities of a fixed topological dimension.
    A MeshFunction may for example be used to store a global
    numbering scheme for the entities of a (parallel) mesh, marking
    sub domains or boolean markers for mesh refinement.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshFunction\ ()

          Create empty mesh function

        * MeshFunction\ (mesh)

          Create empty mesh function on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.

        * MeshFunction\ (mesh, dim)

          Create mesh function of given dimension on given mesh
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension for the mesh function.

        * MeshFunction\ (mesh, dim, value)

          Create mesh of given dimension on given mesh and initialize
          to a value
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              dim (int)
                  The mesh entity dimension.
              value (T)
                  The value.

        * MeshFunction\ (mesh, filename)

          Create function from data file
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              filename (str)
                  The filename to create mesh function from.

        * MeshFunction\ (mesh, value_collection)

          Create function from a MeshValueCollecion
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to create mesh function on.
              value_collection (:py:class:`MeshValueCollection`)
                  The mesh value collection for the mesh function data.

        * MeshFunction\ (f)

          Copy constructor
          
          *Arguments*
              f (:py:class:`MeshFunction`)
                  The object to be copied.

        """
        _cpp.MeshFunctionBool_swiginit(self,_cpp.new_MeshFunctionBool(*args))
    __swig_destroy__ = _cpp.delete_MeshFunctionBool
    def mesh(self, *args):
        """
        Return mesh associated with mesh function

        *Returns*
            :py:class:`Mesh`
                The mesh.

        """
        return _cpp.MeshFunctionBool_mesh(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshFunctionBool_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshFunctionBool_size(self, *args)

    def init(self, *args):
        """
        **Overloaded versions**

        * init\ (dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              dim (int)
                  The dimension.

        * init\ (dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              dim (int)
                  The dimension.
              size (int)
                  The size.

        * init\ (mesh, dim)

          Initialize mesh function for given topological dimension
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.

        * init\ (mesh, dim, size)

          Initialize mesh function for given topological dimension of
          given size
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              dim (int)
                  The dimension.
              size (int)
                  The size.

        """
        return _cpp.MeshFunctionBool_init(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (index, value)

          Set value at given index
          
          *Arguments*
              index (int)
                  The index.
              value (T)
                  The value.

        * set_value\ (index, value, mesh)

          Compatibility function for use in SubDomains

        """
        return _cpp.MeshFunctionBool_set_value(self, *args)

    def set_values(self, *args):
        """
        Set values

        *Arguments*
            values (std::vector<T>)
                The values.

        """
        return _cpp.MeshFunctionBool_set_values(self, *args)

    def set_all(self, *args):
        """
        Set all values to given value

        *Arguments*
            value (T)
                The value to set all values to.

        """
        return _cpp.MeshFunctionBool_set_all(self, *args)

    def __getitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionBool___getitem__(self, *args)

    def __setitem__(self, *args):
        """Missing docstring"""
        return _cpp.MeshFunctionBool___setitem__(self, *args)

MeshFunctionBool.mesh = new_instancemethod(_cpp.MeshFunctionBool_mesh,None,MeshFunctionBool)
MeshFunctionBool.dim = new_instancemethod(_cpp.MeshFunctionBool_dim,None,MeshFunctionBool)
MeshFunctionBool.size = new_instancemethod(_cpp.MeshFunctionBool_size,None,MeshFunctionBool)
MeshFunctionBool.init = new_instancemethod(_cpp.MeshFunctionBool_init,None,MeshFunctionBool)
MeshFunctionBool.set_value = new_instancemethod(_cpp.MeshFunctionBool_set_value,None,MeshFunctionBool)
MeshFunctionBool.set_values = new_instancemethod(_cpp.MeshFunctionBool_set_values,None,MeshFunctionBool)
MeshFunctionBool.set_all = new_instancemethod(_cpp.MeshFunctionBool_set_all,None,MeshFunctionBool)
MeshFunctionBool.array = new_instancemethod(_cpp.MeshFunctionBool_array,None,MeshFunctionBool)
MeshFunctionBool.__getitem__ = new_instancemethod(_cpp.MeshFunctionBool___getitem__,None,MeshFunctionBool)
MeshFunctionBool.__setitem__ = new_instancemethod(_cpp.MeshFunctionBool___setitem__,None,MeshFunctionBool)
MeshFunctionBool_swigregister = _cpp.MeshFunctionBool_swigregister
MeshFunctionBool_swigregister(MeshFunctionBool)

class CellFunctionBool(MeshFunctionBool):
    """
    A CellFunction is a MeshFunction of topological codimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.CellFunctionBool_swiginit(self,_cpp.new_CellFunctionBool(*args))
    __swig_destroy__ = _cpp.delete_CellFunctionBool
CellFunctionBool_swigregister = _cpp.CellFunctionBool_swigregister
CellFunctionBool_swigregister(CellFunctionBool)

class EdgeFunctionBool(MeshFunctionBool):
    """
    An EdgeFunction is a :py:class:`MeshFunction` of topological dimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.EdgeFunctionBool_swiginit(self,_cpp.new_EdgeFunctionBool(*args))
    __swig_destroy__ = _cpp.delete_EdgeFunctionBool
EdgeFunctionBool_swigregister = _cpp.EdgeFunctionBool_swigregister
EdgeFunctionBool_swigregister(EdgeFunctionBool)

class FaceFunctionBool(MeshFunctionBool):
    """
    A FaceFunction is a MeshFunction of topological dimension 2.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FaceFunctionBool_swiginit(self,_cpp.new_FaceFunctionBool(*args))
    __swig_destroy__ = _cpp.delete_FaceFunctionBool
FaceFunctionBool_swigregister = _cpp.FaceFunctionBool_swigregister
FaceFunctionBool_swigregister(FaceFunctionBool)

class FacetFunctionBool(MeshFunctionBool):
    """
    A FacetFunction is a MeshFunction of topological codimension 1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.FacetFunctionBool_swiginit(self,_cpp.new_FacetFunctionBool(*args))
    __swig_destroy__ = _cpp.delete_FacetFunctionBool
FacetFunctionBool_swigregister = _cpp.FacetFunctionBool_swigregister
FacetFunctionBool_swigregister(FacetFunctionBool)

class VertexFunctionBool(MeshFunctionBool):
    """
    A VertexFunction is a MeshFunction of topological dimension 0.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        _cpp.VertexFunctionBool_swiginit(self,_cpp.new_VertexFunctionBool(*args))
    __swig_destroy__ = _cpp.delete_VertexFunctionBool
VertexFunctionBool_swigregister = _cpp.VertexFunctionBool_swigregister
VertexFunctionBool_swigregister(VertexFunctionBool)

_doc_string = MeshFunctionInt.__doc__
_doc_string += """
  *Arguments*
    tp (str)
      String defining the type of the MeshFunction
      Allowed: 'int', 'uint', 'double', and 'bool'
    mesh (_Mesh_)
      A DOLFIN mesh.
      Optional.
    dim (uint)
      The topological dimension of the MeshFunction.
      Optional.
    filename (str)
      A filename with a stored MeshFunction.
      Optional.

"""
class MeshFunction(object):
    __doc__ = _doc_string
    def __new__(cls, tp, *args):
        if not isinstance(tp, str):
            raise TypeError, "expected a 'str' as first argument"
        if tp == "int":
            return MeshFunctionInt(*args)
        if tp == "uint":
            return MeshFunctionUInt(*args)
        elif tp == "double":
            return MeshFunctionDouble(*args)
        elif tp == "bool":
            return MeshFunctionBool(*args)
        else:
            raise RuntimeError, "Cannot create a MeshFunction of type '%s'." % (tp,)

del _doc_string

def _new_closure(MeshType):
    assert(isinstance(MeshType,str))
    def new(cls, tp, mesh, value=0):
        if not isinstance(tp, str):
            raise TypeError, "expected a 'str' as first argument"
        if tp == "int":
            return eval("%sInt(mesh, value)"%MeshType)
        if tp == "uint":
            return eval("%sUInt(mesh, value)"%MeshType)
        elif tp == "double":
            return eval("%sDouble(mesh, float(value))"%MeshType)
        elif tp == "bool":
            return eval("%sBool(mesh, value)"%MeshType)
        else:
            raise RuntimeError, "Cannot create a %sFunction of type '%s'." % (MeshType, tp)

    return new

# Create the named MeshFunction types
VertexFunction = type("VertexFunction", (), \
		      {"__new__":_new_closure("VertexFunction"),\
                       "__doc__":"Create MeshFunction of topological"\
                       " dimension 0 on given mesh."})
EdgeFunction = type("EdgeFunction", (), \
                    {"__new__":_new_closure("EdgeFunction"),\
                     "__doc__":"Create MeshFunction of topological"\
                     " dimension 1 on given mesh."})
FaceFunction = type("FaceFunction", (),\
                    {"__new__":_new_closure("FaceFunction"),\
                     "__doc__":"Create MeshFunction of topological"\
                     " dimension 2 on given mesh."})
FacetFunction = type("FacetFunction", (),\
                     {"__new__":_new_closure("FacetFunction"),
                      "__doc__":"Create MeshFunction of topological"\
                      " codimension 1 on given mesh."})
CellFunction = type("CellFunction", (),\
                    {"__new__":_new_closure("CellFunction"),\
                     "__doc__":"Create MeshFunction of topological"\
                     " codimension 0 on given mesh."})

class MeshValueCollectionUInt(Variable):
    """
    The MeshValueCollection class can be used to store data
    associated with a subset of the entities of a mesh of a given
    topological dimension. It differs from the MeshFunction class in
    two ways. First, data does not need to be associated with all
    entities (only a subset). Second, data is associated with
    entities through the corresponding cell index and local entity
    number (relative to the cell), not by global entity index, which
    means that data may be stored robustly to file.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshValueCollection\ ()

          Create empty mesh value collection
          

        * MeshValueCollection\ (dim)

          Create empty mesh value collection of given dimension
          
          *Arguments*
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        * MeshValueCollection\ (mesh_function)

          Create a mesh value collection from a MeshFunction
          
          *Arguments*
              mesh_function (:py:class:`MeshFunction`)
                  The mesh function for creating a MeshValueCollection.

        * MeshValueCollection\ (mesh, filename, dim)

          Create a mesh value collection from a file.
          
          *Arguments*
              mesh (Mesh)
                  A mesh associated with the collection. The mesh is used to
                  map collection values to the appropriate process.
              filename (str)
                  The XML file name.
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        """
        _cpp.MeshValueCollectionUInt_swiginit(self,_cpp.new_MeshValueCollectionUInt(*args))
    __swig_destroy__ = _cpp.delete_MeshValueCollectionUInt
    def set_dim(self, *args):
        """
        Set the topological dimension

        *Arguments*
            dim (int)
                The mesh entity dimension for the mesh value collection.

        """
        return _cpp.MeshValueCollectionUInt_set_dim(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshValueCollectionUInt_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities in subset)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshValueCollectionUInt_size(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (cell_index, local_entity, value)

          Set marker value for given entity defined by a cell index and
          a local entity index
          
          *Arguments*
              cell_index (int)
                  The index of the cell.
              local_entity (int)
                  The local index of the entity relative to the cell.
              marker_value (T)
                  The value of the marker.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        * set_value\ (entity_index, value, mesh)

          Set value for given entity index
          
          *Arguments*
              entity_index (int)
                  Index of the entity.
              value (T)
                  The value of the marker.
              mesh (:py:class:`Mesh`)
                  The mesh.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        """
        return _cpp.MeshValueCollectionUInt_set_value(self, *args)

    def get_value(self, *args):
        """
        Get marker value for given entity defined by a cell index and
        a local entity index

        *Arguments*
            cell_index (int)
                The index of the cell.
            local_entity (int)
                The local index of the entity relative to the cell.

        *Returns*
            marker_value (T)
                The value of the marker.

        """
        return _cpp.MeshValueCollectionUInt_get_value(self, *args)

    def values(self, *args):
        """
        **Overloaded versions**

        * values\ ()

          Get all values
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        * values\ ()

          Get all values (const version)
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        """
        return _cpp.MeshValueCollectionUInt_values(self, *args)

    def clear(self, *args):
        """
        Clear all values

        """
        return _cpp.MeshValueCollectionUInt_clear(self, *args)

    def assign(self, *args):
        """Missing docstring"""
        return _cpp.MeshValueCollectionUInt_assign(self, *args)

MeshValueCollectionUInt.set_dim = new_instancemethod(_cpp.MeshValueCollectionUInt_set_dim,None,MeshValueCollectionUInt)
MeshValueCollectionUInt.dim = new_instancemethod(_cpp.MeshValueCollectionUInt_dim,None,MeshValueCollectionUInt)
MeshValueCollectionUInt.size = new_instancemethod(_cpp.MeshValueCollectionUInt_size,None,MeshValueCollectionUInt)
MeshValueCollectionUInt.set_value = new_instancemethod(_cpp.MeshValueCollectionUInt_set_value,None,MeshValueCollectionUInt)
MeshValueCollectionUInt.get_value = new_instancemethod(_cpp.MeshValueCollectionUInt_get_value,None,MeshValueCollectionUInt)
MeshValueCollectionUInt.values = new_instancemethod(_cpp.MeshValueCollectionUInt_values,None,MeshValueCollectionUInt)
MeshValueCollectionUInt.clear = new_instancemethod(_cpp.MeshValueCollectionUInt_clear,None,MeshValueCollectionUInt)
MeshValueCollectionUInt.assign = new_instancemethod(_cpp.MeshValueCollectionUInt_assign,None,MeshValueCollectionUInt)
MeshValueCollectionUInt_swigregister = _cpp.MeshValueCollectionUInt_swigregister
MeshValueCollectionUInt_swigregister(MeshValueCollectionUInt)

class MeshValueCollectionInt(Variable):
    """
    The MeshValueCollection class can be used to store data
    associated with a subset of the entities of a mesh of a given
    topological dimension. It differs from the MeshFunction class in
    two ways. First, data does not need to be associated with all
    entities (only a subset). Second, data is associated with
    entities through the corresponding cell index and local entity
    number (relative to the cell), not by global entity index, which
    means that data may be stored robustly to file.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshValueCollection\ ()

          Create empty mesh value collection
          

        * MeshValueCollection\ (dim)

          Create empty mesh value collection of given dimension
          
          *Arguments*
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        * MeshValueCollection\ (mesh_function)

          Create a mesh value collection from a MeshFunction
          
          *Arguments*
              mesh_function (:py:class:`MeshFunction`)
                  The mesh function for creating a MeshValueCollection.

        * MeshValueCollection\ (mesh, filename, dim)

          Create a mesh value collection from a file.
          
          *Arguments*
              mesh (Mesh)
                  A mesh associated with the collection. The mesh is used to
                  map collection values to the appropriate process.
              filename (str)
                  The XML file name.
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        """
        _cpp.MeshValueCollectionInt_swiginit(self,_cpp.new_MeshValueCollectionInt(*args))
    __swig_destroy__ = _cpp.delete_MeshValueCollectionInt
    def set_dim(self, *args):
        """
        Set the topological dimension

        *Arguments*
            dim (int)
                The mesh entity dimension for the mesh value collection.

        """
        return _cpp.MeshValueCollectionInt_set_dim(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshValueCollectionInt_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities in subset)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshValueCollectionInt_size(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (cell_index, local_entity, value)

          Set marker value for given entity defined by a cell index and
          a local entity index
          
          *Arguments*
              cell_index (int)
                  The index of the cell.
              local_entity (int)
                  The local index of the entity relative to the cell.
              marker_value (T)
                  The value of the marker.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        * set_value\ (entity_index, value, mesh)

          Set value for given entity index
          
          *Arguments*
              entity_index (int)
                  Index of the entity.
              value (T)
                  The value of the marker.
              mesh (:py:class:`Mesh`)
                  The mesh.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        """
        return _cpp.MeshValueCollectionInt_set_value(self, *args)

    def get_value(self, *args):
        """
        Get marker value for given entity defined by a cell index and
        a local entity index

        *Arguments*
            cell_index (int)
                The index of the cell.
            local_entity (int)
                The local index of the entity relative to the cell.

        *Returns*
            marker_value (T)
                The value of the marker.

        """
        return _cpp.MeshValueCollectionInt_get_value(self, *args)

    def values(self, *args):
        """
        **Overloaded versions**

        * values\ ()

          Get all values
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        * values\ ()

          Get all values (const version)
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        """
        return _cpp.MeshValueCollectionInt_values(self, *args)

    def clear(self, *args):
        """
        Clear all values

        """
        return _cpp.MeshValueCollectionInt_clear(self, *args)

    def assign(self, *args):
        """Missing docstring"""
        return _cpp.MeshValueCollectionInt_assign(self, *args)

MeshValueCollectionInt.set_dim = new_instancemethod(_cpp.MeshValueCollectionInt_set_dim,None,MeshValueCollectionInt)
MeshValueCollectionInt.dim = new_instancemethod(_cpp.MeshValueCollectionInt_dim,None,MeshValueCollectionInt)
MeshValueCollectionInt.size = new_instancemethod(_cpp.MeshValueCollectionInt_size,None,MeshValueCollectionInt)
MeshValueCollectionInt.set_value = new_instancemethod(_cpp.MeshValueCollectionInt_set_value,None,MeshValueCollectionInt)
MeshValueCollectionInt.get_value = new_instancemethod(_cpp.MeshValueCollectionInt_get_value,None,MeshValueCollectionInt)
MeshValueCollectionInt.values = new_instancemethod(_cpp.MeshValueCollectionInt_values,None,MeshValueCollectionInt)
MeshValueCollectionInt.clear = new_instancemethod(_cpp.MeshValueCollectionInt_clear,None,MeshValueCollectionInt)
MeshValueCollectionInt.assign = new_instancemethod(_cpp.MeshValueCollectionInt_assign,None,MeshValueCollectionInt)
MeshValueCollectionInt_swigregister = _cpp.MeshValueCollectionInt_swigregister
MeshValueCollectionInt_swigregister(MeshValueCollectionInt)

class MeshValueCollectionDouble(Variable):
    """
    The MeshValueCollection class can be used to store data
    associated with a subset of the entities of a mesh of a given
    topological dimension. It differs from the MeshFunction class in
    two ways. First, data does not need to be associated with all
    entities (only a subset). Second, data is associated with
    entities through the corresponding cell index and local entity
    number (relative to the cell), not by global entity index, which
    means that data may be stored robustly to file.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshValueCollection\ ()

          Create empty mesh value collection
          

        * MeshValueCollection\ (dim)

          Create empty mesh value collection of given dimension
          
          *Arguments*
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        * MeshValueCollection\ (mesh_function)

          Create a mesh value collection from a MeshFunction
          
          *Arguments*
              mesh_function (:py:class:`MeshFunction`)
                  The mesh function for creating a MeshValueCollection.

        * MeshValueCollection\ (mesh, filename, dim)

          Create a mesh value collection from a file.
          
          *Arguments*
              mesh (Mesh)
                  A mesh associated with the collection. The mesh is used to
                  map collection values to the appropriate process.
              filename (str)
                  The XML file name.
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        """
        _cpp.MeshValueCollectionDouble_swiginit(self,_cpp.new_MeshValueCollectionDouble(*args))
    __swig_destroy__ = _cpp.delete_MeshValueCollectionDouble
    def set_dim(self, *args):
        """
        Set the topological dimension

        *Arguments*
            dim (int)
                The mesh entity dimension for the mesh value collection.

        """
        return _cpp.MeshValueCollectionDouble_set_dim(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshValueCollectionDouble_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities in subset)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshValueCollectionDouble_size(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (cell_index, local_entity, value)

          Set marker value for given entity defined by a cell index and
          a local entity index
          
          *Arguments*
              cell_index (int)
                  The index of the cell.
              local_entity (int)
                  The local index of the entity relative to the cell.
              marker_value (T)
                  The value of the marker.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        * set_value\ (entity_index, value, mesh)

          Set value for given entity index
          
          *Arguments*
              entity_index (int)
                  Index of the entity.
              value (T)
                  The value of the marker.
              mesh (:py:class:`Mesh`)
                  The mesh.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        """
        return _cpp.MeshValueCollectionDouble_set_value(self, *args)

    def get_value(self, *args):
        """
        Get marker value for given entity defined by a cell index and
        a local entity index

        *Arguments*
            cell_index (int)
                The index of the cell.
            local_entity (int)
                The local index of the entity relative to the cell.

        *Returns*
            marker_value (T)
                The value of the marker.

        """
        return _cpp.MeshValueCollectionDouble_get_value(self, *args)

    def values(self, *args):
        """
        **Overloaded versions**

        * values\ ()

          Get all values
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        * values\ ()

          Get all values (const version)
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        """
        return _cpp.MeshValueCollectionDouble_values(self, *args)

    def clear(self, *args):
        """
        Clear all values

        """
        return _cpp.MeshValueCollectionDouble_clear(self, *args)

    def assign(self, *args):
        """Missing docstring"""
        return _cpp.MeshValueCollectionDouble_assign(self, *args)

MeshValueCollectionDouble.set_dim = new_instancemethod(_cpp.MeshValueCollectionDouble_set_dim,None,MeshValueCollectionDouble)
MeshValueCollectionDouble.dim = new_instancemethod(_cpp.MeshValueCollectionDouble_dim,None,MeshValueCollectionDouble)
MeshValueCollectionDouble.size = new_instancemethod(_cpp.MeshValueCollectionDouble_size,None,MeshValueCollectionDouble)
MeshValueCollectionDouble.set_value = new_instancemethod(_cpp.MeshValueCollectionDouble_set_value,None,MeshValueCollectionDouble)
MeshValueCollectionDouble.get_value = new_instancemethod(_cpp.MeshValueCollectionDouble_get_value,None,MeshValueCollectionDouble)
MeshValueCollectionDouble.values = new_instancemethod(_cpp.MeshValueCollectionDouble_values,None,MeshValueCollectionDouble)
MeshValueCollectionDouble.clear = new_instancemethod(_cpp.MeshValueCollectionDouble_clear,None,MeshValueCollectionDouble)
MeshValueCollectionDouble.assign = new_instancemethod(_cpp.MeshValueCollectionDouble_assign,None,MeshValueCollectionDouble)
MeshValueCollectionDouble_swigregister = _cpp.MeshValueCollectionDouble_swigregister
MeshValueCollectionDouble_swigregister(MeshValueCollectionDouble)

class MeshValueCollectionBool(Variable):
    """
    The MeshValueCollection class can be used to store data
    associated with a subset of the entities of a mesh of a given
    topological dimension. It differs from the MeshFunction class in
    two ways. First, data does not need to be associated with all
    entities (only a subset). Second, data is associated with
    entities through the corresponding cell index and local entity
    number (relative to the cell), not by global entity index, which
    means that data may be stored robustly to file.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * MeshValueCollection\ ()

          Create empty mesh value collection
          

        * MeshValueCollection\ (dim)

          Create empty mesh value collection of given dimension
          
          *Arguments*
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        * MeshValueCollection\ (mesh_function)

          Create a mesh value collection from a MeshFunction
          
          *Arguments*
              mesh_function (:py:class:`MeshFunction`)
                  The mesh function for creating a MeshValueCollection.

        * MeshValueCollection\ (mesh, filename, dim)

          Create a mesh value collection from a file.
          
          *Arguments*
              mesh (Mesh)
                  A mesh associated with the collection. The mesh is used to
                  map collection values to the appropriate process.
              filename (str)
                  The XML file name.
              dim (int)
                  The mesh entity dimension for the mesh value collection.

        """
        _cpp.MeshValueCollectionBool_swiginit(self,_cpp.new_MeshValueCollectionBool(*args))
    __swig_destroy__ = _cpp.delete_MeshValueCollectionBool
    def set_dim(self, *args):
        """
        Set the topological dimension

        *Arguments*
            dim (int)
                The mesh entity dimension for the mesh value collection.

        """
        return _cpp.MeshValueCollectionBool_set_dim(self, *args)

    def dim(self, *args):
        """
        Return topological dimension

        *Returns*
            int
                The dimension.

        """
        return _cpp.MeshValueCollectionBool_dim(self, *args)

    def size(self, *args):
        """
        Return size (number of entities in subset)

        *Returns*
            int
                The size.

        """
        return _cpp.MeshValueCollectionBool_size(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (cell_index, local_entity, value)

          Set marker value for given entity defined by a cell index and
          a local entity index
          
          *Arguments*
              cell_index (int)
                  The index of the cell.
              local_entity (int)
                  The local index of the entity relative to the cell.
              marker_value (T)
                  The value of the marker.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        * set_value\ (entity_index, value, mesh)

          Set value for given entity index
          
          *Arguments*
              entity_index (int)
                  Index of the entity.
              value (T)
                  The value of the marker.
              mesh (:py:class:`Mesh`)
                  The mesh.
          
          *Returns*
              bool
                  True is a new value is inserted, false if overwriting
                  an existing value.

        """
        return _cpp.MeshValueCollectionBool_set_value(self, *args)

    def get_value(self, *args):
        """
        Get marker value for given entity defined by a cell index and
        a local entity index

        *Arguments*
            cell_index (int)
                The index of the cell.
            local_entity (int)
                The local index of the entity relative to the cell.

        *Returns*
            marker_value (T)
                The value of the marker.

        """
        return _cpp.MeshValueCollectionBool_get_value(self, *args)

    def values(self, *args):
        """
        **Overloaded versions**

        * values\ ()

          Get all values
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        * values\ ()

          Get all values (const version)
          
          *Returns*
              std::map<std::pair<uint, uint>, T>
                  A map from positions to values.

        """
        return _cpp.MeshValueCollectionBool_values(self, *args)

    def clear(self, *args):
        """
        Clear all values

        """
        return _cpp.MeshValueCollectionBool_clear(self, *args)

    def assign(self, *args):
        """Missing docstring"""
        return _cpp.MeshValueCollectionBool_assign(self, *args)

MeshValueCollectionBool.set_dim = new_instancemethod(_cpp.MeshValueCollectionBool_set_dim,None,MeshValueCollectionBool)
MeshValueCollectionBool.dim = new_instancemethod(_cpp.MeshValueCollectionBool_dim,None,MeshValueCollectionBool)
MeshValueCollectionBool.size = new_instancemethod(_cpp.MeshValueCollectionBool_size,None,MeshValueCollectionBool)
MeshValueCollectionBool.set_value = new_instancemethod(_cpp.MeshValueCollectionBool_set_value,None,MeshValueCollectionBool)
MeshValueCollectionBool.get_value = new_instancemethod(_cpp.MeshValueCollectionBool_get_value,None,MeshValueCollectionBool)
MeshValueCollectionBool.values = new_instancemethod(_cpp.MeshValueCollectionBool_values,None,MeshValueCollectionBool)
MeshValueCollectionBool.clear = new_instancemethod(_cpp.MeshValueCollectionBool_clear,None,MeshValueCollectionBool)
MeshValueCollectionBool.assign = new_instancemethod(_cpp.MeshValueCollectionBool_assign,None,MeshValueCollectionBool)
MeshValueCollectionBool_swigregister = _cpp.MeshValueCollectionBool_swigregister
MeshValueCollectionBool_swigregister(MeshValueCollectionBool)

_meshvaluecollection_doc_string = MeshValueCollectionInt.__doc__
_meshvaluecollection_doc_string += """
  *Arguments*
      tp (str)
         String defining the type of the MeshValueCollection
          Allowed: 'int', 'uint', 'double', and 'bool'
      dim (uint)
          The topological dimension of the MeshValueCollection.
          Optional.
      mesh_function (_MeshFunction_)
          The MeshValueCollection will get the values from the mesh_function
          Optional.
       mesh (Mesh)
          A mesh associated with the collection. The mesh is used to
          map collection values to the appropriate process.
          Optional, used when read from file.
      filename (std::string)
          The XML file name.
          Optional, used when read from file.
      dim (uint)
          The mesh entity dimension for the mesh value collection.
          Optional, used when read from file
"""
class MeshValueCollection(object):
    __doc__ = _meshvaluecollection_doc_string
    def __new__(cls, tp, *args):
        if not isinstance(tp, str):
            raise TypeError, "expected a 'str' as first argument"
        if tp == "int":
            return MeshValueCollectionInt(*args)
        if tp == "uint":
            return MeshValueCollectionUInt(*args)
        elif tp == "double":
            return MeshValueCollectionDouble(*args)
        elif tp == "bool":
            return MeshValueCollectionBool(*args)
        else:
            raise RuntimeError, "Cannot create a MeshValueCollection of type '%s'." % (tp,)

del _meshvaluecollection_doc_string

class HierarchicalFunctionSpace(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalFunctionSpace_swiginit(self,_cpp.new_HierarchicalFunctionSpace(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalFunctionSpace
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalFunctionSpace_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalFunctionSpace_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalFunctionSpace_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalFunctionSpace_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalFunctionSpace_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalFunctionSpace_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalFunctionSpace_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalFunctionSpace_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalFunctionSpace_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalFunctionSpace__debug(self, *args)

HierarchicalFunctionSpace.depth = new_instancemethod(_cpp.HierarchicalFunctionSpace_depth,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.has_parent = new_instancemethod(_cpp.HierarchicalFunctionSpace_has_parent,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.has_child = new_instancemethod(_cpp.HierarchicalFunctionSpace_has_child,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.parent = new_instancemethod(_cpp.HierarchicalFunctionSpace_parent,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.child = new_instancemethod(_cpp.HierarchicalFunctionSpace_child,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.root_node = new_instancemethod(_cpp.HierarchicalFunctionSpace_root_node,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.leaf_node = new_instancemethod(_cpp.HierarchicalFunctionSpace_leaf_node,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.set_parent = new_instancemethod(_cpp.HierarchicalFunctionSpace_set_parent,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace.set_child = new_instancemethod(_cpp.HierarchicalFunctionSpace_set_child,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace._debug = new_instancemethod(_cpp.HierarchicalFunctionSpace__debug,None,HierarchicalFunctionSpace)
HierarchicalFunctionSpace_swigregister = _cpp.HierarchicalFunctionSpace_swigregister
HierarchicalFunctionSpace_swigregister(HierarchicalFunctionSpace)

def refine(*args):
  """
    **Overloaded versions**

    * refine\ (mesh)

      Create uniformly refined mesh
      
      *Arguments*
          mesh (:py:class:`Mesh`)
              The mesh to refine.
      
      *Returns*
          :py:class:`Mesh`
              The refined mesh.
      
      *Example*
          .. note::
          
              No example code available for this function.

    * refine\ (refined_mesh, mesh)

      Create uniformly refined mesh
      
      *Arguments*
          refined_mesh (:py:class:`Mesh`)
              The mesh that will be the refined mesh.
          mesh (:py:class:`Mesh`)
              The original mesh.

    * refine\ (mesh, cell_markers)

      Create locally refined mesh
      
      *Arguments*
          mesh (:py:class:`Mesh`)
              The mesh to refine.
          cell_markers (:py:class:`MeshFunction`)
              A mesh function over booleans specifying which cells
              that should be refined (and which should not).
      
      *Returns*
          :py:class:`Mesh`
              The locally refined mesh.
      
      *Example*
          .. note::
          
              No example code available for this function.

    * refine\ (refined_mesh, mesh, cell_markers)

      Create locally refined mesh
      
      *Arguments*
          refined_mesh (:py:class:`Mesh`)
              The mesh that will be the refined mesh.
          mesh (:py:class:`Mesh`)
              The original mesh.
          cell_markers (:py:class:`MeshFunction`)
              A mesh function over booleans specifying which cells
              that should be refined (and which should not).

    """
  return _cpp.refine(*args)

class HierarchicalFunction(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalFunction_swiginit(self,_cpp.new_HierarchicalFunction(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalFunction
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalFunction_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalFunction_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalFunction_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalFunction_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalFunction_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalFunction_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalFunction_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalFunction_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalFunction_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalFunction__debug(self, *args)

HierarchicalFunction.depth = new_instancemethod(_cpp.HierarchicalFunction_depth,None,HierarchicalFunction)
HierarchicalFunction.has_parent = new_instancemethod(_cpp.HierarchicalFunction_has_parent,None,HierarchicalFunction)
HierarchicalFunction.has_child = new_instancemethod(_cpp.HierarchicalFunction_has_child,None,HierarchicalFunction)
HierarchicalFunction.parent = new_instancemethod(_cpp.HierarchicalFunction_parent,None,HierarchicalFunction)
HierarchicalFunction.child = new_instancemethod(_cpp.HierarchicalFunction_child,None,HierarchicalFunction)
HierarchicalFunction.root_node = new_instancemethod(_cpp.HierarchicalFunction_root_node,None,HierarchicalFunction)
HierarchicalFunction.leaf_node = new_instancemethod(_cpp.HierarchicalFunction_leaf_node,None,HierarchicalFunction)
HierarchicalFunction.set_parent = new_instancemethod(_cpp.HierarchicalFunction_set_parent,None,HierarchicalFunction)
HierarchicalFunction.set_child = new_instancemethod(_cpp.HierarchicalFunction_set_child,None,HierarchicalFunction)
HierarchicalFunction._debug = new_instancemethod(_cpp.HierarchicalFunction__debug,None,HierarchicalFunction)
HierarchicalFunction_swigregister = _cpp.HierarchicalFunction_swigregister
HierarchicalFunction_swigregister(HierarchicalFunction)

class GenericFunction(ufc.function,Variable):
    """
    This is a common base class for functions. Functions can be
    evaluated at a given point and they can be restricted to a given
    cell in a finite element mesh. This functionality is implemented
    by sub-classes that implement the eval() and restrict() functions.

    DOLFIN provides two implementations of the GenericFunction
    interface in the form of the classes Function and Expression.

    Sub-classes may optionally implement the gather() function that
    will be called prior to restriction when running in parallel.

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_GenericFunction
    def value_rank(self, *args):
        """
        Return value rank

        """
        return _cpp.GenericFunction_value_rank(self, *args)

    def value_dimension(self, *args):
        """
        Return value dimension for given axis

        """
        return _cpp.GenericFunction_value_dimension(self, *args)

    def eval_cell(self, *args):
        """
        **Overloaded versions**

        * eval\ (values, x, cell)

          Evaluate at given point in given cell

        * eval\ (values, x)

          Evaluate at given point

        """
        return _cpp.GenericFunction_eval_cell(self, *args)

    def eval(self, *args):
        """
        **Overloaded versions**

        * eval\ (values, x, cell)

          Evaluate at given point in given cell

        * eval\ (values, x)

          Evaluate at given point

        """
        return _cpp.GenericFunction_eval(self, *args)

    def restrict(self, *args):
        """
        Restrict function to local cell (compute expansion coefficients w)

        """
        return _cpp.GenericFunction_restrict(self, *args)

    def compute_vertex_values(self, *args):
        """
        Compute values at all mesh vertices

        """
        return _cpp.GenericFunction_compute_vertex_values(self, *args)

    def gather(self, *args):
        """
        Collect off-process coefficients to prepare for interpolation

        """
        return _cpp.GenericFunction_gather(self, *args)

    def value_size(self, *args):
        """
        Evaluation at given point
        Return value size (product of value dimensions)

        """
        return _cpp.GenericFunction_value_size(self, *args)

GenericFunction.value_rank = new_instancemethod(_cpp.GenericFunction_value_rank,None,GenericFunction)
GenericFunction.value_dimension = new_instancemethod(_cpp.GenericFunction_value_dimension,None,GenericFunction)
GenericFunction.eval_cell = new_instancemethod(_cpp.GenericFunction_eval_cell,None,GenericFunction)
GenericFunction.eval = new_instancemethod(_cpp.GenericFunction_eval,None,GenericFunction)
GenericFunction.restrict = new_instancemethod(_cpp.GenericFunction_restrict,None,GenericFunction)
GenericFunction.compute_vertex_values = new_instancemethod(_cpp.GenericFunction_compute_vertex_values,None,GenericFunction)
GenericFunction.gather = new_instancemethod(_cpp.GenericFunction_gather,None,GenericFunction)
GenericFunction.value_size = new_instancemethod(_cpp.GenericFunction_value_size,None,GenericFunction)
GenericFunction_swigregister = _cpp.GenericFunction_swigregister
GenericFunction_swigregister(GenericFunction)

class Expression(GenericFunction):
    """
    This class represents a user-defined expression. Expressions can
    be used as coefficients in variational forms or interpolated
    into finite element spaces.

    An expression is defined by overloading the eval() method. Users
    may choose to overload either a simple version of eval(), in the
    case of expressions only depending on the coordinate x, or an
    optional version for expressions depending on x and mesh data
    like cell indices or facet normals.

    The geometric dimension (the size of x) and the value rank and
    dimensions of an expression must supplied as arguments to the
    constructor.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Expression\ ()

          Create scalar expression.

        * Expression\ (dim)

          Create vector-valued expression with given dimension.
          
          *Arguments*
              dim (int)
                  Dimension of the vector-valued expression.

        * Expression\ (dim0, dim1)

          Create matrix-valued expression with given dimensions.
          
          *Arguments*
              dim0 (int)
                  Dimension (rows).
              dim1 (int)
                  Dimension (columns).

        * Expression\ (value_shape)

          Create tensor-valued expression with given shape.
          
          *Arguments*
              value_shape (numpy.array(int))
                  Shape of expression.

        * Expression\ (expression)

          Copy constructor
          
          *Arguments*
              expression (:py:class:`Expression`)
                  Object to be copied.

        """
        if self.__class__ == Expression:
            _self = None
        else:
            _self = self
        _cpp.Expression_swiginit(self,_cpp.new_Expression(_self, *args))
    __swig_destroy__ = _cpp.delete_Expression
    def eval_cell(self, *args):
        """
        **Overloaded versions**

        * eval\ (values, x, cell)

          Note: The reimplementation of eval is needed for the Python interface.
          Evaluate at given point in given cell.
          
          *Arguments*
              values (numpy.array(float))
                  The values at the point.
              x (numpy.array(float))
                  The coordinates of the point.
              cell (ufc::cell)
                  The cell which contains the given point.

        * eval\ (values, x)

          Evaluate at given point.
          
          *Arguments*
              values (numpy.array(float))
                  The values at the point.
              x (numpy.array(float))
                  The coordinates of the point.

        """
        return _cpp.Expression_eval_cell(self, *args)

    def eval(self, *args):
        """
        **Overloaded versions**

        * eval\ (values, x, cell)

          Note: The reimplementation of eval is needed for the Python interface.
          Evaluate at given point in given cell.
          
          *Arguments*
              values (numpy.array(float))
                  The values at the point.
              x (numpy.array(float))
                  The coordinates of the point.
              cell (ufc::cell)
                  The cell which contains the given point.

        * eval\ (values, x)

          Evaluate at given point.
          
          *Arguments*
              values (numpy.array(float))
                  The values at the point.
              x (numpy.array(float))
                  The coordinates of the point.

        """
        return _cpp.Expression_eval(self, *args)

    def __disown__(self):
        self.this.disown()
        _cpp.disown_Expression(self)
        return weakref_proxy(self)
Expression.eval_cell = new_instancemethod(_cpp.Expression_eval_cell,None,Expression)
Expression.eval = new_instancemethod(_cpp.Expression_eval,None,Expression)
Expression_swigregister = _cpp.Expression_swigregister
Expression_swigregister(Expression)

class Function(GenericFunction,HierarchicalFunction):
    """
    This class represents a function :math:`u_h` in a finite
    element function space :math:`V_h`, given by

    .. math::

        u_h = \sum_{i=1}^{n} U_i \phi_i

    where :math:`\{\phi_i\}_{i=1}^{n}` is a basis for :math:`V_h`,
    and :math:`U` is a vector of expansion coefficients for :math:`u_h`.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Function\ (V)

          Create function on given function space
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * Function\ (V)

          Create function on given function space (shared data)
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.

        * Function\ (V, x)

          Create function on given function space with a given vector
          (shared data)
          
          *Warning: This constructor is intended for internal library use only*
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              x (:py:class:`GenericVector`)
                  The vector.

        * Function\ (V, filename)

          Create function from vector of dofs stored to file
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              filename_vector (str)
                  The name of the file containing the vector.
              filename_dofdata (str)
                  The name of the file containing the dofmap data.

        * Function\ (V, filename)

          Create function from vector of dofs stored to file (shared data)
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              filename_dofdata (str)
                  The name of the file containing the dofmap data.

        * Function\ (v)

          Copy constructor
          
          *Arguments*
              v (:py:class:`Function`)
                  The object to be copied.

        * Function\ (v, i)

          Sub-function constructor with shallow copy of vector (used in Python
          interface)
          
          *Arguments*
              v (:py:class:`Function`)
                  The function to be copied.
              i (int)
                  Index of subfunction.
          

        """
        _cpp.Function_swiginit(self,_cpp.new_Function(*args))
    __swig_destroy__ = _cpp.delete_Function
    def assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (v)

          Assignment from function
          
          *Arguments*
              v (:py:class:`Function`)
                  Another function.

        * operator=\ (v)

          Assignment from expression using interpolation
          
          *Arguments*
              v (:py:class:`Expression`)
                  The expression.

        """
        return _cpp.Function_assign(self, *args)

    def _sub(self, *args):
        """
        Extract subfunction

        *Arguments*
            i (int)
                Index of subfunction.

        """
        return _cpp.Function__sub(self, *args)

    def _function_space(self, *args):
        """
        Return shared pointer to function space

        *Returns*
            :py:class:`FunctionSpace`
                Return the shared pointer.

        """
        return _cpp.Function__function_space(self, *args)

    def vector(self, *args):
        """
        **Overloaded versions**

        * vector\ ()

          Return vector of expansion coefficients (non-const version)
          
          *Returns*
              :py:class:`GenericVector`
                  The vector of expansion coefficients.

        * vector\ ()

          Return vector of expansion coefficients (const version)
          
          *Returns*
              :py:class:`GenericVector`
                  The vector of expansion coefficients (const).

        """
        return _cpp.Function_vector(self, *args)

    def _in(self, *args):
        """
        Check if function is a member of the given function space

        *Arguments*
            V (:py:class:`FunctionSpace`)
                The function space.

        *Returns*
            bool
                True if the function is in the function space.

        """
        return _cpp.Function__in(self, *args)

    def geometric_dimension(self, *args):
        """
        Return geometric dimension

        *Returns*
            int
                The geometric dimension.

        """
        return _cpp.Function_geometric_dimension(self, *args)

    def eval(self, *args):
        """
        **Overloaded versions**

        * eval\ (values, x)

          Evaluate function at given coordinates
          
          *Arguments*
              values (numpy.array(float))
                  The values.
              x (numpy.array(float))
                  The coordinates.

        * eval\ (values, x, dolfin_cell, ufc_cell)

          Evaluate function at given coordinates in given cell
          
          *Arguments*
              values (numpy.array(float))
                  The values.
              x (numpy.array(float))
                  The coordinates.
              dolfin_cell (:py:class:`Cell`)
                  The cell.
              ufc_cell (ufc::cell)
                  The ufc::cell.

        * eval\ (values, x, cell)

          Evaluate at given point in given cell
          
          *Arguments*
              values (numpy.array(float))
                  The values at the point.
              x (numpy.array(float))
                  The coordinates of the point.
              cell (ufc::cell)
                  The cell which contains the given point.

        """
        return _cpp.Function_eval(self, *args)

    def interpolate(self, *args):
        """
        Interpolate function (on possibly non-matching meshes)

        *Arguments*
            v (:py:class:`GenericFunction`)
                The function to be interpolated.

        """
        return _cpp.Function_interpolate(self, *args)

    def extrapolate(self, *args):
        """
        Extrapolate function (from a possibly lower-degree function space)

        *Arguments*
            v (:py:class:`Function`)
                The function to be extrapolated.

        """
        return _cpp.Function_extrapolate(self, *args)

    def non_matching_eval(self, *args):
        """
        Evaluate function for given data (non-matching meshes)

        *Arguments*
            values (numpy.array(float))
                The values at the point.
            x (numpy.array(float))
                The coordinates of the point.
            cell (ufc::cell)
                The cell.

        """
        return _cpp.Function_non_matching_eval(self, *args)

    def function_space(self):
        "Return the FunctionSpace"
        from dolfin.functions.functionspace import FunctionSpaceFromCpp
        return FunctionSpaceFromCpp(self._function_space())

    def copy(self, deepcopy=False):
        "Return a dolfin.Function of itself"
        from dolfin.functions.function import Function
        if deepcopy:
            return Function(self.function_space(), self.vector().copy())
        return Function(self.function_space(), self.vector())

    def leaf_node(self):
        "Return the finest Function in hierarchy"
        f = HierarchicalFunction.leaf_node(self)
        return f.copy()

    def root_node(self):
        "Return the coarsest Function in hierarchy"
        f = HierarchicalFunction.root_node(self)
        return f.copy()

Function.assign = new_instancemethod(_cpp.Function_assign,None,Function)
Function._sub = new_instancemethod(_cpp.Function__sub,None,Function)
Function._function_space = new_instancemethod(_cpp.Function__function_space,None,Function)
Function.vector = new_instancemethod(_cpp.Function_vector,None,Function)
Function._in = new_instancemethod(_cpp.Function__in,None,Function)
Function.geometric_dimension = new_instancemethod(_cpp.Function_geometric_dimension,None,Function)
Function.eval = new_instancemethod(_cpp.Function_eval,None,Function)
Function.interpolate = new_instancemethod(_cpp.Function_interpolate,None,Function)
Function.extrapolate = new_instancemethod(_cpp.Function_extrapolate,None,Function)
Function.non_matching_eval = new_instancemethod(_cpp.Function_non_matching_eval,None,Function)
Function_swigregister = _cpp.Function_swigregister
Function_swigregister(Function)

class FunctionSpace(Variable,HierarchicalFunctionSpace):
    """
    This class represents a finite element function space defined by
    a mesh, a finite element, and a local-to-global mapping of the
    degrees of freedom (dofmap).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * FunctionSpace\ (mesh, element, dofmap)

          Create function space for given mesh, element and dofmap
          (shared data)
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.
              element (:py:class:`FiniteElement`)
                  The element.
              dofmap (:py:class:`GenericDofMap`)
                  The dofmap.

        * FunctionSpace\ (mesh)

          Create empty function space for later initialization. This
          constructor is intended for use by any sub-classes which need
          to construct objects before the initialisation of the base
          class. Data can be attached to the base class using
          FunctionSpace::attach(...).
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh.

        * FunctionSpace\ (V)

          Copy constructor
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The object to be copied.

        """
        _cpp.FunctionSpace_swiginit(self,_cpp.new_FunctionSpace(*args))
    __swig_destroy__ = _cpp.delete_FunctionSpace
    def assign(self, *args):
        """
        Assignment operator

        *Arguments*
            V (:py:class:`FunctionSpace`)
                Another function space.

        """
        return _cpp.FunctionSpace_assign(self, *args)

    def __eq__(self, *args):
        """
        Equality operator

        *Arguments*
            V (:py:class:`FunctionSpace`)
                Another function space.

        """
        return _cpp.FunctionSpace___eq__(self, *args)

    def __ne__(self, *args):
        """
        Unequality operator

        *Arguments*
            V (:py:class:`FunctionSpace`)
                Another function space.

        """
        return _cpp.FunctionSpace___ne__(self, *args)

    def mesh(self, *args):
        """
        Return mesh

        *Returns*
            :py:class:`Mesh`
                The mesh.

        """
        return _cpp.FunctionSpace_mesh(self, *args)

    def element(self, *args):
        """
        Return finite element

        *Returns*
            :py:class:`FiniteElement`
                The finite element.

        """
        return _cpp.FunctionSpace_element(self, *args)

    def dofmap(self, *args):
        """
        Return dofmap

        *Returns*
            :py:class:`GenericDofMap`
                The dofmap.

        """
        return _cpp.FunctionSpace_dofmap(self, *args)

    def dim(self, *args):
        """
        Return dimension of function space

        *Returns*
            int
                The dimension of the function space.

        """
        return _cpp.FunctionSpace_dim(self, *args)

    def interpolate(self, *args):
        """
        Interpolate function v into function space, returning the
        vector of expansion coefficients

        *Arguments*
            expansion_coefficients (:py:class:`GenericVector`)
                The expansion coefficients.
            v (:py:class:`GenericFunction`)
                The function to be interpolated.

        """
        return _cpp.FunctionSpace_interpolate(self, *args)

    def sub(self, *args):
        """
        Extract subspace for component

        *Arguments*
            i (int)
                Index of the subspace.
        *Returns*
            :py:class:`FunctionSpace`
                The subspace.

        """
        return _cpp.FunctionSpace_sub(self, *args)

    def extract_sub_space(self, *args):
        """
        Extract subspace for component

        *Arguments*
            component (numpy.array(int))
                The component.

        *Returns*
            :py:class:`FunctionSpace`
                The subspace.

        """
        return _cpp.FunctionSpace_extract_sub_space(self, *args)

    def collapse(self, *args):
        """
        **Overloaded versions**

        * collapse\ ()

          Collapse a subspace and return a new function space
          
          *Returns*
              :py:class:`FunctionSpace`
                  The new function space.

        * collapse\ (collapsed_dofs)

          Collapse a subspace and return a new function space and a map
          from new to old dofs
          
          *Arguments*
              collapsed_dofs (boost::unordered_map<uint, uint>)
                  The map from new to old dofs.
          
          *Returns*
              :py:class:`FunctionSpace`
                The new function space.

        """
        return _cpp.FunctionSpace_collapse(self, *args)

    def has_cell(self, *args):
        """
        Check if function space has given cell

        *Arguments*
            cell (:py:class:`Cell`)
                The cell.

        *Returns*
            bool
                True if the function space has the given cell.

        """
        return _cpp.FunctionSpace_has_cell(self, *args)

    def has_element(self, *args):
        """
        Check if function space has given element

        *Arguments*
            element (:py:class:`FiniteElement`)
                The finite element.

        *Returns*
            bool
                True if the function space has the given element.

        """
        return _cpp.FunctionSpace_has_element(self, *args)

    def component(self, *args):
        """
        Return component

        *Returns*
            numpy.array(int)
                The component (relative to superspace).

        """
        return _cpp.FunctionSpace_component(self, *args)

    def print_dofmap(self, *args):
        """
        Print dofmap (useful for debugging)

        """
        return _cpp.FunctionSpace_print_dofmap(self, *args)

    def __contains__(self,u):
        "Check whether a function is in the FunctionSpace"
        assert(isinstance(u,Function))
        return u._in(self)

FunctionSpace.assign = new_instancemethod(_cpp.FunctionSpace_assign,None,FunctionSpace)
FunctionSpace.__eq__ = new_instancemethod(_cpp.FunctionSpace___eq__,None,FunctionSpace)
FunctionSpace.__ne__ = new_instancemethod(_cpp.FunctionSpace___ne__,None,FunctionSpace)
FunctionSpace.mesh = new_instancemethod(_cpp.FunctionSpace_mesh,None,FunctionSpace)
FunctionSpace.element = new_instancemethod(_cpp.FunctionSpace_element,None,FunctionSpace)
FunctionSpace.dofmap = new_instancemethod(_cpp.FunctionSpace_dofmap,None,FunctionSpace)
FunctionSpace.dim = new_instancemethod(_cpp.FunctionSpace_dim,None,FunctionSpace)
FunctionSpace.interpolate = new_instancemethod(_cpp.FunctionSpace_interpolate,None,FunctionSpace)
FunctionSpace.sub = new_instancemethod(_cpp.FunctionSpace_sub,None,FunctionSpace)
FunctionSpace.extract_sub_space = new_instancemethod(_cpp.FunctionSpace_extract_sub_space,None,FunctionSpace)
FunctionSpace.collapse = new_instancemethod(_cpp.FunctionSpace_collapse,None,FunctionSpace)
FunctionSpace.has_cell = new_instancemethod(_cpp.FunctionSpace_has_cell,None,FunctionSpace)
FunctionSpace.has_element = new_instancemethod(_cpp.FunctionSpace_has_element,None,FunctionSpace)
FunctionSpace.component = new_instancemethod(_cpp.FunctionSpace_component,None,FunctionSpace)
FunctionSpace.print_dofmap = new_instancemethod(_cpp.FunctionSpace_print_dofmap,None,FunctionSpace)
FunctionSpace_swigregister = _cpp.FunctionSpace_swigregister
FunctionSpace_swigregister(FunctionSpace)

class SubSpace(FunctionSpace):
    """
    This class represents a subspace (component) of a function space.

    The subspace is specified by an array of indices. For example,
    the array [3, 0, 2] specifies subspace 2 of subspace 0 of
    subspace 3.

    A typical example is the function space W = V x P for Stokes.
    Here, V = W[0] is the subspace for the velocity component and
    P = W[1] is the subspace for the pressure component. Furthermore,
    W[0][0] = V[0] is the first component of the velocity space etc.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * SubSpace\ (V, component)

          Create subspace for given component (one level)

        * SubSpace\ (V, component, sub_component)

          Create subspace for given component (two levels)

        * SubSpace\ (V, component)

          Create subspace for given component (n levels)

        """
        _cpp.SubSpace_swiginit(self,_cpp.new_SubSpace(*args))
    __swig_destroy__ = _cpp.delete_SubSpace
SubSpace_swigregister = _cpp.SubSpace_swigregister
SubSpace_swigregister(SubSpace)

class Constant(Expression):
    """
    This class represents a constant-valued expression.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Constant\ (value)

          Create scalar constant
          
          *Arguments*
              value (float)
                  The scalar to create a Constant object from.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * Constant\ (value0, value1)

          Create vector constant (dim = 2)
          
          *Arguments*
              value0 (float)
                  The first vector element.
              value1 (float)
                  The second vector element.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * Constant\ (value0, value1, value2)

          Create vector constant (dim = 3)
          
          *Arguments*
              value0 (float)
                  The first vector element.
              value1 (float)
                  The second vector element.
              value2 (float)
                  The third vector element.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * Constant\ (values)

          Create vector-valued constant
          
          *Arguments*
              values (numpy.array(float))
                  Values to create a vector-valued constant from.

        * Constant\ (value_shape, values)

          Create tensor-valued constant for flattened array of values
          
          *Arguments*
              value_shape (numpy.array(int))
                  Shape of tensor.
              values (numpy.array(float))
                  Values to create tensor-valued constant from.

        * Constant\ (constant)

          Copy constructor
          
          *Arguments*
              constant (:py:class:`Constant`)
                  Object to be copied.

        """
        _cpp.Constant_swiginit(self,_cpp.new_Constant(*args))
    __swig_destroy__ = _cpp.delete_Constant
    def assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (constant)

          Assignment operator
          
          *Arguments*
              constant (:py:class:`Constant`)
                  Another constant.

        * operator=\ (constant)

          Assignment operator
          
          *Arguments*
              constant (float)
                  Another constant.

        """
        return _cpp.Constant_assign(self, *args)

    def __float__(self, *args):
        """
        Cast to double (for scalar constants)

        *Returns*
            float
                The scalar value.

        """
        return _cpp.Constant___float__(self, *args)

Constant.assign = new_instancemethod(_cpp.Constant_assign,None,Constant)
Constant.__float__ = new_instancemethod(_cpp.Constant___float__,None,Constant)
Constant_swigregister = _cpp.Constant_swigregister
Constant_swigregister(Constant)

class MeshCoordinates(Expression):
    """
    This Function represents the mesh coordinates on a given mesh.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.MeshCoordinates_swiginit(self,_cpp.new_MeshCoordinates(*args))
    __swig_destroy__ = _cpp.delete_MeshCoordinates
MeshCoordinates_swigregister = _cpp.MeshCoordinates_swigregister
MeshCoordinates_swigregister(MeshCoordinates)

class FacetArea(Expression):
    """
    This function represents the area/length of a cell facet on a given mesh.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.FacetArea_swiginit(self,_cpp.new_FacetArea(*args))
    __swig_destroy__ = _cpp.delete_FacetArea
FacetArea_swigregister = _cpp.FacetArea_swigregister
FacetArea_swigregister(FacetArea)

class FunctionPlotData(Variable):
    """
    This class is used for communicating plot data for functions
    to and from (XML) files. It is used by DOLFIN for plotting
    Function objects. The data is stored as a mesh and a vector
    of interpolated vertex values.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * FunctionPlotData\ (v, mesh)

          Create plot data for given function

        * FunctionPlotData\ ()

          Create empty data to be read from file

        """
        _cpp.FunctionPlotData_swiginit(self,_cpp.new_FunctionPlotData(*args))
    __swig_destroy__ = _cpp.delete_FunctionPlotData
    def vertex_values(self, *args):
        """
        Return vertex values

        """
        return _cpp.FunctionPlotData_vertex_values(self, *args)

    mesh = _swig_property(_cpp.FunctionPlotData_mesh_get, _cpp.FunctionPlotData_mesh_set)
    rank = _swig_property(_cpp.FunctionPlotData_rank_get, _cpp.FunctionPlotData_rank_set)
FunctionPlotData.vertex_values = new_instancemethod(_cpp.FunctionPlotData_vertex_values,None,FunctionPlotData)
FunctionPlotData_swigregister = _cpp.FunctionPlotData_swigregister
FunctionPlotData_swigregister(FunctionPlotData)


def ipow(*args):
  """
    Return a to the power n

    """
  return _cpp.ipow(*args)

def rand(*args):
  """
    Return a random number, uniformly distributed between [0.0, 1.0)

    """
  return _cpp.rand(*args)

def seed(*args):
  """
    Seed random number generator

    """
  return _cpp.seed(*args)

def near(*args):
  """
    Check whether x is close to x0 (to within DOLFIN_EPS)

    """
  return _cpp.near(*args)

def between(*args):
  """
    Check whether x is between x0 and x1 (inclusive, to within DOLFIN_EPS)

    """
  return _cpp.between(*args)
class Lagrange(Variable):
    """
    Lagrange polynomial (basis) with given degree q determined by n = q + 1 nodal points.

    Example: q = 1 (n = 2)

      Lagrange p(1);
      p.set(0, 0.0);
      p.set(1, 1.0);

    It is the callers reponsibility that the points are distinct.

    This creates a Lagrange polynomial (actually two Lagrange polynomials):

      p(0,x) = 1 - x   (one at x = 0, zero at x = 1)
      p(1,x) = x       (zero at x = 0, one at x = 1)


    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Lagrange\ (q)

          Constructor

        * Lagrange\ (p)

          Copy constructor

        """
        _cpp.Lagrange_swiginit(self,_cpp.new_Lagrange(*args))
    def set(self, *args):
        """
        Specify point

        """
        return _cpp.Lagrange_set(self, *args)

    def size(self, *args):
        """
        Return number of points

        """
        return _cpp.Lagrange_size(self, *args)

    def degree(self, *args):
        """
        Return degree

        """
        return _cpp.Lagrange_degree(self, *args)

    def point(self, *args):
        """
        Return point

        """
        return _cpp.Lagrange_point(self, *args)

    def eval(self, *args):
        """
        Return value of polynomial i at given point x

        """
        return _cpp.Lagrange_eval(self, *args)

    def ddx(self, *args):
        """
        Return derivate of polynomial i at given point x

        """
        return _cpp.Lagrange_ddx(self, *args)

    def dqdx(self, *args):
        """
        Return derivative q (a constant) of polynomial

        """
        return _cpp.Lagrange_dqdx(self, *args)

    __swig_destroy__ = _cpp.delete_Lagrange
Lagrange.set = new_instancemethod(_cpp.Lagrange_set,None,Lagrange)
Lagrange.size = new_instancemethod(_cpp.Lagrange_size,None,Lagrange)
Lagrange.degree = new_instancemethod(_cpp.Lagrange_degree,None,Lagrange)
Lagrange.point = new_instancemethod(_cpp.Lagrange_point,None,Lagrange)
Lagrange.__call__ = new_instancemethod(_cpp.Lagrange___call__,None,Lagrange)
Lagrange.eval = new_instancemethod(_cpp.Lagrange_eval,None,Lagrange)
Lagrange.ddx = new_instancemethod(_cpp.Lagrange_ddx,None,Lagrange)
Lagrange.dqdx = new_instancemethod(_cpp.Lagrange_dqdx,None,Lagrange)
Lagrange_swigregister = _cpp.Lagrange_swigregister
Lagrange_swigregister(Lagrange)

class Legendre(object):
    """
    Interface for computing Legendre polynomials via Boost.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def eval(*args):
        """
        Evaluate polynomial of order n at point x

        """
        return _cpp.Legendre_eval(*args)

    eval = staticmethod(eval)
    def ddx(*args):
        """
        Evaluate first derivative of polynomial of order n at point x

        """
        return _cpp.Legendre_ddx(*args)

    ddx = staticmethod(ddx)
    def d2dx(*args):
        """
        Evaluate second derivative of polynomial of order n at point x

        """
        return _cpp.Legendre_d2dx(*args)

    d2dx = staticmethod(d2dx)
    def __init__(self, *args): 
        _cpp.Legendre_swiginit(self,_cpp.new_Legendre(*args))
    __swig_destroy__ = _cpp.delete_Legendre
Legendre_swigregister = _cpp.Legendre_swigregister
Legendre_swigregister(Legendre)

def Legendre_eval(*args):
  """
    Evaluate polynomial of order n at point x

    """
  return _cpp.Legendre_eval(*args)

def Legendre_ddx(*args):
  """
    Evaluate first derivative of polynomial of order n at point x

    """
  return _cpp.Legendre_ddx(*args)

def Legendre_d2dx(*args):
  """
    Evaluate second derivative of polynomial of order n at point x

    """
  return _cpp.Legendre_d2dx(*args)

class Quadrature(Variable):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.Quadrature_swiginit(self,_cpp.new_Quadrature(*args))
    __swig_destroy__ = _cpp.delete_Quadrature
    def size(self, *args):
        """
        Return number of quadrature points

        """
        return _cpp.Quadrature_size(self, *args)

    def point(self, *args):
        """
        Return quadrature point

        """
        return _cpp.Quadrature_point(self, *args)

    def weight(self, *args):
        """
        Return quadrature weight

        """
        return _cpp.Quadrature_weight(self, *args)

    def measure(self, *args):
        """
        Return sum of weights (length, area, volume)

        """
        return _cpp.Quadrature_measure(self, *args)

Quadrature.size = new_instancemethod(_cpp.Quadrature_size,None,Quadrature)
Quadrature.point = new_instancemethod(_cpp.Quadrature_point,None,Quadrature)
Quadrature.weight = new_instancemethod(_cpp.Quadrature_weight,None,Quadrature)
Quadrature.measure = new_instancemethod(_cpp.Quadrature_measure,None,Quadrature)
Quadrature_swigregister = _cpp.Quadrature_swigregister
Quadrature_swigregister(Quadrature)

class GaussianQuadrature(Quadrature):
    """
    Gaussian-type quadrature rule on the double line,
    including Gauss, Radau, and Lobatto quadrature.

    Points and weights are computed to be exact within a tolerance
    of DOLFIN_EPS. Comparing with known exact values for n <= 3 shows
    that we obtain full precision (16 digits, error less than 2e-16).

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_GaussianQuadrature
GaussianQuadrature_swigregister = _cpp.GaussianQuadrature_swigregister
GaussianQuadrature_swigregister(GaussianQuadrature)

class GaussQuadrature(GaussianQuadrature):
    """
    Gauss (Gauss-Legendre) quadrature on the interval [-1,1].
    The n quadrature points are given by the zeros of the
    n:th Legendre Pn(x).

    The quadrature points are computed using Newton's method, and
    the quadrature weights are computed by solving a linear system
    determined by the condition that Gauss quadrature with n points
    should be exact for polynomials of degree 2n-1.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create Gauss quadrature with n points

        """
        _cpp.GaussQuadrature_swiginit(self,_cpp.new_GaussQuadrature(*args))
    __swig_destroy__ = _cpp.delete_GaussQuadrature
GaussQuadrature_swigregister = _cpp.GaussQuadrature_swigregister
GaussQuadrature_swigregister(GaussQuadrature)

class RadauQuadrature(GaussianQuadrature):
    """
    Radau (Gauss-Radau) quadrature on the interval [-1,1].
    The n quadrature points are given by the zeros of

        ( Pn-1(x) + Pn(x) ) / (1+x)

    where Pn is the n:th Legendre polynomial.

    The quadrature points are computed using Newton's method, and
    the quadrature weights are computed by solving a linear system
    determined by the condition that Radau quadrature with n points
    should be exact for polynomials of degree 2n-2.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create Radau quadrature with n points

        """
        _cpp.RadauQuadrature_swiginit(self,_cpp.new_RadauQuadrature(*args))
    __swig_destroy__ = _cpp.delete_RadauQuadrature
RadauQuadrature_swigregister = _cpp.RadauQuadrature_swigregister
RadauQuadrature_swigregister(RadauQuadrature)

class LobattoQuadrature(GaussianQuadrature):
    """
    Lobatto (Gauss-Lobatto) quadrature on the interval [-1,1].
    The n quadrature points are given by the end-points -1 and 1,
    and the zeros of P{n-1}'(x), where P{n-1}(x) is the (n-1):th
    Legendre polynomial.

    The quadrature points are computed using Newton's method, and
    the quadrature weights are computed by solving a linear system
    determined by the condition that Lobatto quadrature with n points
    should be exact for polynomials of degree 2n-3.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create Lobatto quadrature with n points

        """
        _cpp.LobattoQuadrature_swiginit(self,_cpp.new_LobattoQuadrature(*args))
    __swig_destroy__ = _cpp.delete_LobattoQuadrature
LobattoQuadrature_swigregister = _cpp.LobattoQuadrature_swigregister
LobattoQuadrature_swigregister(LobattoQuadrature)

class ALE(object):
    """
    This class provides functionality useful for implementation of
    ALE (Arbitrary Lagrangian-Eulerian) methods, in particular
    moving the boundary vertices of a mesh and then interpolating
    the new coordinates for the interior vertices accordingly.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def move(*args):
        """
        **Overloaded versions**

        * move\ (mesh, new_boundary)

          Move coordinates of mesh according to new boundary coordinates

        * move\ (mesh0, mesh1)

          Move coordinates of mesh0 according to mesh1 with common global vertices

        * move\ (mesh, displacement)

          Move coordinates of mesh according to displacement function

        """
        return _cpp.ALE_move(*args)

    move = staticmethod(move)
    def __init__(self, *args): 
        _cpp.ALE_swiginit(self,_cpp.new_ALE(*args))
    __swig_destroy__ = _cpp.delete_ALE
ALE_swigregister = _cpp.ALE_swigregister
ALE_swigregister(ALE)

def ALE_move(*args):
  """
    **Overloaded versions**

    * move\ (mesh, new_boundary)

      Move coordinates of mesh according to new boundary coordinates

    * move\ (mesh0, mesh1)

      Move coordinates of mesh0 according to mesh1 with common global vertices

    * move\ (mesh, displacement)

      Move coordinates of mesh according to displacement function

    """
  return _cpp.ALE_move(*args)

class HierarchicalForm(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalForm_swiginit(self,_cpp.new_HierarchicalForm(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalForm
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalForm_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalForm_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalForm_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalForm_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalForm_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalForm_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalForm_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalForm_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalForm_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalForm__debug(self, *args)

HierarchicalForm.depth = new_instancemethod(_cpp.HierarchicalForm_depth,None,HierarchicalForm)
HierarchicalForm.has_parent = new_instancemethod(_cpp.HierarchicalForm_has_parent,None,HierarchicalForm)
HierarchicalForm.has_child = new_instancemethod(_cpp.HierarchicalForm_has_child,None,HierarchicalForm)
HierarchicalForm.parent = new_instancemethod(_cpp.HierarchicalForm_parent,None,HierarchicalForm)
HierarchicalForm.child = new_instancemethod(_cpp.HierarchicalForm_child,None,HierarchicalForm)
HierarchicalForm.root_node = new_instancemethod(_cpp.HierarchicalForm_root_node,None,HierarchicalForm)
HierarchicalForm.leaf_node = new_instancemethod(_cpp.HierarchicalForm_leaf_node,None,HierarchicalForm)
HierarchicalForm.set_parent = new_instancemethod(_cpp.HierarchicalForm_set_parent,None,HierarchicalForm)
HierarchicalForm.set_child = new_instancemethod(_cpp.HierarchicalForm_set_child,None,HierarchicalForm)
HierarchicalForm._debug = new_instancemethod(_cpp.HierarchicalForm__debug,None,HierarchicalForm)
HierarchicalForm_swigregister = _cpp.HierarchicalForm_swigregister
HierarchicalForm_swigregister(HierarchicalForm)

class HierarchicalLinearVariationalProblem(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalLinearVariationalProblem_swiginit(self,_cpp.new_HierarchicalLinearVariationalProblem(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalLinearVariationalProblem
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalLinearVariationalProblem_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalLinearVariationalProblem_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalLinearVariationalProblem_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalLinearVariationalProblem_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalLinearVariationalProblem_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalLinearVariationalProblem_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalLinearVariationalProblem_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalLinearVariationalProblem_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalLinearVariationalProblem_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalLinearVariationalProblem__debug(self, *args)

HierarchicalLinearVariationalProblem.depth = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_depth,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.has_parent = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_has_parent,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.has_child = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_has_child,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.parent = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_parent,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.child = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_child,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.root_node = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_root_node,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.leaf_node = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_leaf_node,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.set_parent = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_set_parent,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem.set_child = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem_set_child,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem._debug = new_instancemethod(_cpp.HierarchicalLinearVariationalProblem__debug,None,HierarchicalLinearVariationalProblem)
HierarchicalLinearVariationalProblem_swigregister = _cpp.HierarchicalLinearVariationalProblem_swigregister
HierarchicalLinearVariationalProblem_swigregister(HierarchicalLinearVariationalProblem)

class HierarchicalNonlinearVariationalProblem(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalNonlinearVariationalProblem_swiginit(self,_cpp.new_HierarchicalNonlinearVariationalProblem(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalNonlinearVariationalProblem
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalNonlinearVariationalProblem_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalNonlinearVariationalProblem__debug(self, *args)

HierarchicalNonlinearVariationalProblem.depth = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_depth,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.has_parent = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_has_parent,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.has_child = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_has_child,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.parent = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_parent,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.child = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_child,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.root_node = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_root_node,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.leaf_node = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_leaf_node,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.set_parent = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_set_parent,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem.set_child = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem_set_child,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem._debug = new_instancemethod(_cpp.HierarchicalNonlinearVariationalProblem__debug,None,HierarchicalNonlinearVariationalProblem)
HierarchicalNonlinearVariationalProblem_swigregister = _cpp.HierarchicalNonlinearVariationalProblem_swigregister
HierarchicalNonlinearVariationalProblem_swigregister(HierarchicalNonlinearVariationalProblem)

class HierarchicalDirichletBC(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalDirichletBC_swiginit(self,_cpp.new_HierarchicalDirichletBC(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalDirichletBC
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalDirichletBC_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalDirichletBC_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalDirichletBC_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalDirichletBC_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalDirichletBC_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalDirichletBC_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalDirichletBC_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalDirichletBC_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalDirichletBC_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalDirichletBC__debug(self, *args)

HierarchicalDirichletBC.depth = new_instancemethod(_cpp.HierarchicalDirichletBC_depth,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.has_parent = new_instancemethod(_cpp.HierarchicalDirichletBC_has_parent,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.has_child = new_instancemethod(_cpp.HierarchicalDirichletBC_has_child,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.parent = new_instancemethod(_cpp.HierarchicalDirichletBC_parent,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.child = new_instancemethod(_cpp.HierarchicalDirichletBC_child,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.root_node = new_instancemethod(_cpp.HierarchicalDirichletBC_root_node,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.leaf_node = new_instancemethod(_cpp.HierarchicalDirichletBC_leaf_node,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.set_parent = new_instancemethod(_cpp.HierarchicalDirichletBC_set_parent,None,HierarchicalDirichletBC)
HierarchicalDirichletBC.set_child = new_instancemethod(_cpp.HierarchicalDirichletBC_set_child,None,HierarchicalDirichletBC)
HierarchicalDirichletBC._debug = new_instancemethod(_cpp.HierarchicalDirichletBC__debug,None,HierarchicalDirichletBC)
HierarchicalDirichletBC_swigregister = _cpp.HierarchicalDirichletBC_swigregister
HierarchicalDirichletBC_swigregister(HierarchicalDirichletBC)

class GenericDofMap(Variable):
    """
    This class provides a generic interface for dof maps

    """
    thisown = _swig_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 is_view(self, *args):
        """
        True if dof map is a view into another map (is a sub-dofmap)

        """
        return _cpp.GenericDofMap_is_view(self, *args)

    def needs_mesh_entities(self, *args):
        """
        Return true iff mesh entities of topological dimension d are needed

        """
        return _cpp.GenericDofMap_needs_mesh_entities(self, *args)

    def global_dimension(self, *args):
        """
        Return the dimension of the global finite element function space

        """
        return _cpp.GenericDofMap_global_dimension(self, *args)

    def cell_dimension(self, *args):
        """
        Return the dimension of the local finite element function space on a
        cell

        """
        return _cpp.GenericDofMap_cell_dimension(self, *args)

    def max_cell_dimension(self, *args):
        """
        Return the maximum dimension of the local finite element function space

        """
        return _cpp.GenericDofMap_max_cell_dimension(self, *args)

    def num_facet_dofs(self, *args):
        """
        Return number of facet dofs

        """
        return _cpp.GenericDofMap_num_facet_dofs(self, *args)

    def ownership_range(self, *args):
        """
        Return the ownership range (dofs in this range are owned by this process)

        """
        return _cpp.GenericDofMap_ownership_range(self, *args)

    def off_process_owner(self, *args):
        """
        Return map from nonlocal-dofs (that appear in local dof map) to owning process

        """
        return _cpp.GenericDofMap_off_process_owner(self, *args)

    def cell_dofs(self, *args):
        """
        Local-to-global mapping of dofs on a cell

        """
        return _cpp.GenericDofMap_cell_dofs(self, *args)

    def tabulate_dofs(self, *args):
        """
        Tabulate the local-to-global mapping of dofs on a cell

        """
        return _cpp.GenericDofMap_tabulate_dofs(self, *args)

    def tabulate_facet_dofs(self, *args):
        """
        Tabulate local-local facet dofs

        """
        return _cpp.GenericDofMap_tabulate_facet_dofs(self, *args)

    def copy(self, *args):
        """
        Create a copy of the dof map

        """
        return _cpp.GenericDofMap_copy(self, *args)

    def extract_sub_dofmap(self, *args):
        """
        Extract sub dofmap component

        """
        return _cpp.GenericDofMap_extract_sub_dofmap(self, *args)

    def collapse(self, *args):
        """
        Create a "collapsed" a dofmap (collapses from a sub-dofmap view)

        """
        return _cpp.GenericDofMap_collapse(self, *args)

    def dofs(self, *args):
        """
        Return the set of dof indices

        """
        return _cpp.GenericDofMap_dofs(self, *args)

    def tabulate_coordinates(self, cell, coordinates=None):
        """ Tabulate the coordinates of all dofs on a cell 
        
        *Arguments*
            cell (_Cell_)
                 The cell.
            coordinates (NumPy array)
                 Optional argument: The coordinates of all dofs on a cell.
        *Returns*
            coordinates
                 The coordinates of all dofs on a cell.
        """
        import numpy as np

        # Check coordinate argument
        shape = (self.max_cell_dimension(), self.geometric_dimension())
        if coordinates is None:
            coordinates = np.zeros(shape, 'd')
        if not isinstance(coordinates, np.ndarray) or \
           not (coordinates.flags.c_contiguous and \
                coordinates.dtype == np.dtype('d') and \
                coordinates.shape==shape):
            raise TypeError, "expected a C-contiguous numpy array " \
                  "of 'double' (dtype='d') with shape %s"%str(shape)

        # Call the extended method
        self._tabulate_coordinates(coordinates, cell)
        return coordinates

    __swig_destroy__ = _cpp.delete_GenericDofMap
GenericDofMap.is_view = new_instancemethod(_cpp.GenericDofMap_is_view,None,GenericDofMap)
GenericDofMap.needs_mesh_entities = new_instancemethod(_cpp.GenericDofMap_needs_mesh_entities,None,GenericDofMap)
GenericDofMap.global_dimension = new_instancemethod(_cpp.GenericDofMap_global_dimension,None,GenericDofMap)
GenericDofMap.cell_dimension = new_instancemethod(_cpp.GenericDofMap_cell_dimension,None,GenericDofMap)
GenericDofMap.max_cell_dimension = new_instancemethod(_cpp.GenericDofMap_max_cell_dimension,None,GenericDofMap)
GenericDofMap.geometric_dimension = new_instancemethod(_cpp.GenericDofMap_geometric_dimension,None,GenericDofMap)
GenericDofMap.num_facet_dofs = new_instancemethod(_cpp.GenericDofMap_num_facet_dofs,None,GenericDofMap)
GenericDofMap.ownership_range = new_instancemethod(_cpp.GenericDofMap_ownership_range,None,GenericDofMap)
GenericDofMap.off_process_owner = new_instancemethod(_cpp.GenericDofMap_off_process_owner,None,GenericDofMap)
GenericDofMap.cell_dofs = new_instancemethod(_cpp.GenericDofMap_cell_dofs,None,GenericDofMap)
GenericDofMap.tabulate_dofs = new_instancemethod(_cpp.GenericDofMap_tabulate_dofs,None,GenericDofMap)
GenericDofMap.tabulate_facet_dofs = new_instancemethod(_cpp.GenericDofMap_tabulate_facet_dofs,None,GenericDofMap)
GenericDofMap.copy = new_instancemethod(_cpp.GenericDofMap_copy,None,GenericDofMap)
GenericDofMap.extract_sub_dofmap = new_instancemethod(_cpp.GenericDofMap_extract_sub_dofmap,None,GenericDofMap)
GenericDofMap.collapse = new_instancemethod(_cpp.GenericDofMap_collapse,None,GenericDofMap)
GenericDofMap.dofs = new_instancemethod(_cpp.GenericDofMap_dofs,None,GenericDofMap)
GenericDofMap.renumber = new_instancemethod(_cpp.GenericDofMap_renumber,None,GenericDofMap)
GenericDofMap._tabulate_coordinates = new_instancemethod(_cpp.GenericDofMap__tabulate_coordinates,None,GenericDofMap)
GenericDofMap_swigregister = _cpp.GenericDofMap_swigregister
GenericDofMap_swigregister(GenericDofMap)

class DofMap(GenericDofMap):
    """
    This class handles the mapping of degrees of freedom. It builds
    a dof map based on a ufc::dofmap on a specific mesh. It will
    reorder the dofs when running in parallel. Sub-dofmaps, both
    views and copies, are supported.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * DofMap\ (ufc_dofmap, mesh)

          Create dof map on mesh (data is not shared)
          
          *Arguments*
              ufc_dofmap (ufc::dofmap)
                  The ufc::dofmap.
              mesh (:py:class:`Mesh`)
                  The mesh.

        * DofMap\ (ufc_dofmap, mesh)

          Create dof map on mesh ((data is not shared), const mesh
          version)
          
          *Arguments*
              ufc_dofmap (ufc::dofmap)
                  The ufc::dofmap.
              mesh (:py:class:`Mesh`)
                  The mesh.

        * DofMap\ (dofmap)

          Copy constructor
          
          *Arguments*
              dofmap (:py:class:`DofMap`)
                  The object to be copied.

        * DofMap\ (parent_dofmap, component, mesh, distributed)

          Create a sub-dofmap (a view) from parent_dofmap

        * DofMap\ (collapsed_map, dofmap_view, mesh, distributed)

          Create a collapsed dofmap from parent_dofmap

        """
        _cpp.DofMap_swiginit(self,_cpp.new_DofMap(*args))
    __swig_destroy__ = _cpp.delete_DofMap
    def copy(self, *args):
        """
        Create a copy of the dof map

        *Arguments*
            mesh (:py:class:`Mesh`)
                The object to be copied.

        """
        return _cpp.DofMap_copy(self, *args)

    def extract_sub_dofmap(self, *args):
        """
        Extract subdofmap component

        *Arguments*
            component (numpy.array(int))
                The component.
            mesh (:py:class:`Mesh`)
                The mesh.

        *Returns*
            DofMap
                The subdofmap component.

        """
        return _cpp.DofMap_extract_sub_dofmap(self, *args)

    def collapse(self, *args):
        """
        Create a "collapsed" dofmap (collapses a sub-dofmap)

        *Arguments*
            collapsed_map (boost::unordered_map<uint, uint>)
                The "collapsed" map.
            mesh (:py:class:`Mesh`)
                The mesh.

        *Returns*
            DofMap
                The collapsed dofmap.

        """
        return _cpp.DofMap_collapse(self, *args)

    def data(self, *args):
        """
        Return the underlying dof map data. Intended for internal library
        use only.

        *Returns*
            std::vector<std::vector<dolfin::uint> >
                The local-to-global map for each cell.

        """
        return _cpp.DofMap_data(self, *args)

DofMap.copy = new_instancemethod(_cpp.DofMap_copy,None,DofMap)
DofMap.extract_sub_dofmap = new_instancemethod(_cpp.DofMap_extract_sub_dofmap,None,DofMap)
DofMap.collapse = new_instancemethod(_cpp.DofMap_collapse,None,DofMap)
DofMap.data = new_instancemethod(_cpp.DofMap_data,None,DofMap)
DofMap_swigregister = _cpp.DofMap_swigregister
DofMap_swigregister(DofMap)

class Equation(object):
    """
    This class represents a variational equation lhs == rhs.
    The equation can be either linear or nonlinear:

    1. Linear (a == L), in which case a must be a bilinear form
       and L must be a linear form.

    2. Nonlinear (F == 0), in which case F must be a linear form.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Equation\ (a, L)

          Create equation a == L

        * Equation\ (F, rhs)

          Create equation F == 0

        """
        _cpp.Equation_swiginit(self,_cpp.new_Equation(*args))
    __swig_destroy__ = _cpp.delete_Equation
    def is_linear(self, *args):
        """
        Check whether equation is linear

        """
        return _cpp.Equation_is_linear(self, *args)

    def lhs(self, *args):
        """
        Return form for left-hand side

        """
        return _cpp.Equation_lhs(self, *args)

    def rhs(self, *args):
        """
        Return form for right-hand side

        """
        return _cpp.Equation_rhs(self, *args)

    def rhs_int(self, *args):
        """
        Return value for right-hand side

        """
        return _cpp.Equation_rhs_int(self, *args)

Equation.is_linear = new_instancemethod(_cpp.Equation_is_linear,None,Equation)
Equation.lhs = new_instancemethod(_cpp.Equation_lhs,None,Equation)
Equation.rhs = new_instancemethod(_cpp.Equation_rhs,None,Equation)
Equation.rhs_int = new_instancemethod(_cpp.Equation_rhs_int,None,Equation)
Equation_swigregister = _cpp.Equation_swigregister
Equation_swigregister(Equation)

class FiniteElement(object):
    """
    This is a wrapper for a UFC finite element (ufc::finite_element).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create finite element from UFC finite element (data may be shared)

        """
        _cpp.FiniteElement_swiginit(self,_cpp.new_FiniteElement(*args))
    __swig_destroy__ = _cpp.delete_FiniteElement
    def signature(self, *args):
        """
        Return a string identifying the finite element

        """
        return _cpp.FiniteElement_signature(self, *args)

    def cell_shape(self, *args):
        """
        Return the cell shape

        """
        return _cpp.FiniteElement_cell_shape(self, *args)

    def space_dimension(self, *args):
        """
        Return the dimension of the finite element function space

        """
        return _cpp.FiniteElement_space_dimension(self, *args)

    def value_rank(self, *args):
        """
        Return the rank of the value space

        """
        return _cpp.FiniteElement_value_rank(self, *args)

    def value_dimension(self, *args):
        """
        Return the dimension of the value space for axis i

        """
        return _cpp.FiniteElement_value_dimension(self, *args)

    def evaluate_basis(self, *args):
        """
        **Overloaded versions**

        * evaluate_basis\ (i, values, x, cell)

          Evaluate basis function i at given point in cell

        * evaluate_basis\ (i, values, x, cell)

          Evaluate basis function i at given point in cell

        """
        return _cpp.FiniteElement_evaluate_basis(self, *args)

    def evaluate_basis_all(self, *args):
        """
        **Overloaded versions**

        * evaluate_basis_all\ (values, coordinates, c)

          Evaluate all basis functions at given point in cell

        * evaluate_basis_all\ (values, coordinates, cell)

          Evaluate all basis functions at given point in cell

        """
        return _cpp.FiniteElement_evaluate_basis_all(self, *args)

    def evaluate_basis_derivatives(self, *args):
        """
        Evaluate order n derivatives of basis function i at given point in cell

        """
        return _cpp.FiniteElement_evaluate_basis_derivatives(self, *args)

    def evaluate_basis_derivatives_all(self, *args):
        """
        Evaluate order n derivatives of all basis functions at given point in cell

        """
        return _cpp.FiniteElement_evaluate_basis_derivatives_all(self, *args)

    def evaluate_dof(self, *args):
        """
        Evaluate linear functional for dof i on the function f

        """
        return _cpp.FiniteElement_evaluate_dof(self, *args)

    def evaluate_dofs(self, *args):
        """
        Evaluate linear functionals for all dofs on the function f

        """
        return _cpp.FiniteElement_evaluate_dofs(self, *args)

    def interpolate_vertex_values(self, *args):
        """
        Interpolate vertex values from dof values

        """
        return _cpp.FiniteElement_interpolate_vertex_values(self, *args)

    def map_from_reference_cell(self, *args):
        """
        Map coordinate xhat from reference cell to coordinate x in cell

        """
        return _cpp.FiniteElement_map_from_reference_cell(self, *args)

    def map_to_reference_cell(self, *args):
        """
        Map from coordinate x in cell to coordinate xhat in reference cell

        """
        return _cpp.FiniteElement_map_to_reference_cell(self, *args)

    def num_sub_elements(self, *args):
        """
        Return the number of sub elements (for a mixed element)

        """
        return _cpp.FiniteElement_num_sub_elements(self, *args)

    def hash(self, *args):
        """
        Return simple hash of the signature string

        """
        return _cpp.FiniteElement_hash(self, *args)

    def create_sub_element(self, *args):
        """
        Create a new finite element for sub element i (for a mixed element)

        """
        return _cpp.FiniteElement_create_sub_element(self, *args)

    def create(self, *args):
        """
        Create a new class instance

        """
        return _cpp.FiniteElement_create(self, *args)

    def extract_sub_element(self, *args):
        """
        Extract sub finite element for component

        """
        return _cpp.FiniteElement_extract_sub_element(self, *args)

FiniteElement.signature = new_instancemethod(_cpp.FiniteElement_signature,None,FiniteElement)
FiniteElement.cell_shape = new_instancemethod(_cpp.FiniteElement_cell_shape,None,FiniteElement)
FiniteElement.topological_dimension = new_instancemethod(_cpp.FiniteElement_topological_dimension,None,FiniteElement)
FiniteElement.geometric_dimension = new_instancemethod(_cpp.FiniteElement_geometric_dimension,None,FiniteElement)
FiniteElement.space_dimension = new_instancemethod(_cpp.FiniteElement_space_dimension,None,FiniteElement)
FiniteElement.value_rank = new_instancemethod(_cpp.FiniteElement_value_rank,None,FiniteElement)
FiniteElement.value_dimension = new_instancemethod(_cpp.FiniteElement_value_dimension,None,FiniteElement)
FiniteElement.evaluate_basis = new_instancemethod(_cpp.FiniteElement_evaluate_basis,None,FiniteElement)
FiniteElement.evaluate_basis_all = new_instancemethod(_cpp.FiniteElement_evaluate_basis_all,None,FiniteElement)
FiniteElement.evaluate_basis_derivatives = new_instancemethod(_cpp.FiniteElement_evaluate_basis_derivatives,None,FiniteElement)
FiniteElement.evaluate_basis_derivatives_all = new_instancemethod(_cpp.FiniteElement_evaluate_basis_derivatives_all,None,FiniteElement)
FiniteElement.evaluate_dof = new_instancemethod(_cpp.FiniteElement_evaluate_dof,None,FiniteElement)
FiniteElement.evaluate_dofs = new_instancemethod(_cpp.FiniteElement_evaluate_dofs,None,FiniteElement)
FiniteElement.interpolate_vertex_values = new_instancemethod(_cpp.FiniteElement_interpolate_vertex_values,None,FiniteElement)
FiniteElement.map_from_reference_cell = new_instancemethod(_cpp.FiniteElement_map_from_reference_cell,None,FiniteElement)
FiniteElement.map_to_reference_cell = new_instancemethod(_cpp.FiniteElement_map_to_reference_cell,None,FiniteElement)
FiniteElement.num_sub_elements = new_instancemethod(_cpp.FiniteElement_num_sub_elements,None,FiniteElement)
FiniteElement.hash = new_instancemethod(_cpp.FiniteElement_hash,None,FiniteElement)
FiniteElement.create_sub_element = new_instancemethod(_cpp.FiniteElement_create_sub_element,None,FiniteElement)
FiniteElement.create = new_instancemethod(_cpp.FiniteElement_create,None,FiniteElement)
FiniteElement.extract_sub_element = new_instancemethod(_cpp.FiniteElement_extract_sub_element,None,FiniteElement)
FiniteElement_swigregister = _cpp.FiniteElement_swigregister
FiniteElement_swigregister(FiniteElement)

class BasisFunction(ufc.function):
    """
    This class represents a finite element basis function. It can be
    used for computation of basis function values and derivatives.

    Evaluation of basis functions is also possible through the use
    of the functions ``evaluate_basis`` and ``evaluate_basis_derivatives``
    available in the :py:class:`FiniteElement` class. The BasisFunction class
    relies on these functions for evaluation but also implements the
    ufc::function interface which allows evaluate_dof to be
    evaluated for a basis function (on a possibly different
    element).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create basis function with given index on element on given cell

        *Arguments*
            index (int)
                The index of the basis function.
            element (:py:class:`FiniteElement`)
                The element to create basis function on.
            cell (ufc::cell)
                The cell.

        """
        _cpp.BasisFunction_swiginit(self,_cpp.new_BasisFunction(*args))
    __swig_destroy__ = _cpp.delete_BasisFunction
    def eval(self, *args):
        """
        Evaluate basis function at given point

        *Arguments*
            values (float)
                The values of the function at the point.
            x (float)
                The coordinates of the point.

        """
        return _cpp.BasisFunction_eval(self, *args)

    def eval_derivatives(self, *args):
        """
        Evaluate all order n derivatives at given point

        *Arguments*
            values (float)
                The values of derivatives at the point.
            x (float)
                The coordinates of the point.
            n (int)
                The order of derivation.

        """
        return _cpp.BasisFunction_eval_derivatives(self, *args)

BasisFunction.eval = new_instancemethod(_cpp.BasisFunction_eval,None,BasisFunction)
BasisFunction.eval_derivatives = new_instancemethod(_cpp.BasisFunction_eval_derivatives,None,BasisFunction)
BasisFunction_swigregister = _cpp.BasisFunction_swigregister
BasisFunction_swigregister(BasisFunction)

class BoundaryCondition(Variable):
    """
    Common base class for boundary conditions

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_BoundaryCondition
    def apply(self, *args):
        """
        **Overloaded versions**

        * apply\ (A)

          Apply boundary condition to a matrix

        * apply\ (b)

          Apply boundary condition to a vector

        * apply\ (A, b)

          Apply boundary condition to a linear system

        * apply\ (b, x)

          Apply boundary condition to a vector for a nonlinear problem

        * apply\ (A, b, x)

          Apply boundary condition to a linear system for a nonlinear problem

        """
        return _cpp.BoundaryCondition_apply(self, *args)

    def _function_space(self, *args):
        """
        Return shared pointer to function space

        """
        return _cpp.BoundaryCondition__function_space(self, *args)

    def function_space(self):
        "Return the FunctionSpace"
        from dolfin.functions.functionspace import FunctionSpaceFromCpp
        return FunctionSpaceFromCpp(self._function_space())

BoundaryCondition.apply = new_instancemethod(_cpp.BoundaryCondition_apply,None,BoundaryCondition)
BoundaryCondition._function_space = new_instancemethod(_cpp.BoundaryCondition__function_space,None,BoundaryCondition)
BoundaryCondition_swigregister = _cpp.BoundaryCondition_swigregister
BoundaryCondition_swigregister(BoundaryCondition)

class DirichletBC(BoundaryCondition,HierarchicalDirichletBC):
    """
    This class specifies the interface for setting (strong)
    Dirichlet boundary conditions for partial differential
    equations,

    .. math::

        u = g \hbox{ on } G,

    where :math:`u` is the solution to be computed, :math:`g` is a function
    and :math:`G` is a sub domain of the mesh.

    A DirichletBC is specified by the function g, the function space
    (trial space) and boundary indicators on (a subset of) the mesh
    boundary.

    The boundary indicators may be specified in a number of
    different ways.

    The simplest approach is to specify the boundary by a :py:class:`SubDomain`
    object, using the inside() function to specify on which facets
    the boundary conditions should be applied.

    Alternatively, the boundary may be specified by a :py:class:`MeshFunction`
    labeling all mesh facets together with a number that specifies
    which facets should be included in the boundary.

    The third option is to attach the boundary information to the
    mesh. This is handled automatically when exporting a mesh from
    for example VMTK.

    The ``method`` variable may be used to specify the type of
    method used to identify degrees of freedom on the
    boundary. Available methods are: topological approach (default),
    geometric approach, and pointwise approach. The topological
    approach is faster, but will only identify degrees of freedom
    that are located on a facet that is entirely on the boundary. In
    particular, the topological approach will not identify degrees
    of freedom for discontinuous elements (which are all internal to
    the cell).  A remedy for this is to use the geometric
    approach. To apply pointwise boundary conditions
    e.g. pointloads, one will have to use the pointwise approach
    which in turn is the slowest of the three possible methods.  The
    three possibilties are "topological", "geometric" and
    "pointwise".
    This class specifies the interface for setting (strong)

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * DirichletBC\ (V, g, sub_domain, method="topological")

          Create boundary condition for subdomain
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              g (:py:class:`GenericFunction`)
                  The value.
              sub_domain (:py:class:`SubDomain`)
                  The subdomain.
              method (str)
                  Optional argument: A string specifying
                  the method to identify dofs.

        * DirichletBC\ (V, g, sub_domain, method="topological")

          Create boundary condition for subdomain
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space
              g (:py:class:`GenericFunction`)
                  The value
              sub_domain (:py:class:`SubDomain`)
                  The subdomain
              method (str)
                  Optional argument: A string specifying
                  the method to identify dofs

        * DirichletBC\ (V, g, sub_domains, sub_domain, method="topological")

          Create boundary condition for subdomain specified by index
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              g (:py:class:`GenericFunction`)
                  The value.
              sub_domains (:py:class:`MeshFunction`)
                  Subdomain markers
              sub_domain (int)
                  The subdomain index (number)
              method (str)
                  Optional argument: A string specifying the
                  method to identify dofs.

        * DirichletBC\ (V, g, sub_domains, sub_domain, method="topological")

          Create boundary condition for subdomain specified by index
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              g (:py:class:`GenericFunction`)
                  The value.
              sub_domains (:py:class:`MeshFunction`)
                  Subdomain markers
              sub_domain (int)
                  The subdomain index (number)
              method (str)
                  Optional argument: A string specifying the
                  method to identify dofs.

        * DirichletBC\ (V, g, sub_domain, method="topological")

          Create boundary condition for boundary data included in the mesh
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              g (:py:class:`GenericFunction`)
                  The value.
              sub_domain (int)
                  The subdomain index (number)
              method (str)
                  Optional argument: A string specifying the
                  method to identify dofs.

        * DirichletBC\ (V, g, sub_domain, method="topological")

          Create boundary condition for boundary data included in the mesh
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              g (:py:class:`GenericFunction`)
                  The value.
              sub_domain (int)
                  The subdomain index (number)
              method (str)
                  Optional argument: A string specifying the
                  method to identify dofs.

        * DirichletBC\ (V, g, markers, method="topological")

          Create boundary condition for subdomain by boundary markers
          (cells, local facet numbers)
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              g (:py:class:`GenericFunction`)
                  The value.
              markers (numpy.array((int, int)))
                  Subdomain markers (cells, local facet number)
              method (str)
                  Optional argument: A string specifying the
                  method to identify dofs.

        * DirichletBC\ (bc)

          Copy constructor
          
          *Arguments*
              bc (:py:class:`DirichletBC`)
                  The object to be copied.

        """
        _cpp.DirichletBC_swiginit(self,_cpp.new_DirichletBC(*args))
    __swig_destroy__ = _cpp.delete_DirichletBC
    def apply(self, *args):
        """
        **Overloaded versions**

        * apply\ (A)

          Apply boundary condition to a matrix
          
          *Arguments*
              A (:py:class:`GenericMatrix`)
                  The matrix to apply boundary condition to.

        * apply\ (b)

          Apply boundary condition to a vector
          
          *Arguments*
              b (:py:class:`GenericVector`)
                  The vector to apply boundary condition to.

        * apply\ (A, b)

          Apply boundary condition to a linear system
          
          *Arguments*
              A (:py:class:`GenericMatrix`)
                  The matrix to apply boundary condition to.
              b (:py:class:`GenericVector`)
                  The vector to apply boundary condition to.

        * apply\ (b, x)

          Apply boundary condition to vectors for a nonlinear problem
          
          *Arguments*
              b (:py:class:`GenericVector`)
                  The vector to apply boundary conditions to.
              x (:py:class:`GenericVector`)
                  Another vector (nonlinear problem).

        * apply\ (A, b, x)

          Apply boundary condition to a linear system for a nonlinear problem
          
          *Arguments*
              A (:py:class:`GenericMatrix`)
                  The matrix to apply boundary conditions to.
              b (:py:class:`GenericVector`)
                  The vector to apply boundary conditions to.
              x (:py:class:`GenericVector`)
                  Another vector (nonlinear problem).

        """
        return _cpp.DirichletBC_apply(self, *args)

    def get_boundary_values(self, *args):
        """
        Get Dirichlet dofs and values

        *Arguments*
            boundary_values (boost::unordered_map<uint, double>)
                Map from dof to boundary value.
            method (str)
                Optional argument: A string specifying which
                method to use.

        """
        return _cpp.DirichletBC_get_boundary_values(self, *args)

    def zero(self, *args):
        """
        Make rows of matrix associated with boundary condition zero,
        useful for non-diagonal matrices in a block matrix.

        *Arguments*
            A (:py:class:`GenericMatrix`)
                The matrix

        """
        return _cpp.DirichletBC_zero(self, *args)

    def zero_columns(self, *args):
        """
        Make columns of matrix associated with boundary condition
        zero, and update a (right-hand side) vector to reflect the
        changes. Useful for non-diagonals.

        *Arguments*
            A (:py:class:`GenericMatrix`)
                The matrix
            b (:py:class:`GenericVector`)
                The vector
            diag_val (float)
                This parameter would normally be -1, 0 or 1.

        """
        return _cpp.DirichletBC_zero_columns(self, *args)

    def markers(self, *args):
        """
        Return boundary markers

        *Returns*
            numpy.array((int, int))
                Boundary markers (facets stored as pairs of cells and
                local facet numbers).

        """
        return _cpp.DirichletBC_markers(self, *args)

    def value(self, *args):
        """
        Return boundary value g

        *Returns*
            :py:class:`GenericFunction`
                The boundary values.

        """
        return _cpp.DirichletBC_value(self, *args)

    def user_sub_domain(self, *args):
        """
        Return shared pointer to subdomain

        *Returns*
            :py:class:`SubDomain`
                Shared pointer to subdomain.

        """
        return _cpp.DirichletBC_user_sub_domain(self, *args)

    def is_compatible(self, *args):
        """
        Check if given function is compatible with boundary condition
        (checking only vertex values)

        *Arguments*
            v (:py:class:`GenericFunction`)
                The function to check for compability
                with boundary condition.

        *Returns*
            bool
                True if compatible.

        """
        return _cpp.DirichletBC_is_compatible(self, *args)

    def set_value(self, *args):
        """
        **Overloaded versions**

        * set_value\ (g)

          Set value g for boundary condition, domain remains unchanged
          
          *Arguments*
              g (:py:class:`GenericFunction`)
                  The value.

        * set_value\ (g)

          Set value g for boundary condition, domain remains unchanged
          
          *Arguments*
              g (:py:class:`GenericFunction`)
                  The value.

        """
        return _cpp.DirichletBC_set_value(self, *args)

    def homogenize(self, *args):
        """
        Set value to 0.0

        """
        return _cpp.DirichletBC_homogenize(self, *args)

    def method(self, *args):
        """
        Return method used for computing Dirichet dofs

        *Returns*
            str
                Method used for computing Dirichet dofs ("topological",
                "geometric" or "pointwise").

        """
        return _cpp.DirichletBC_method(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.DirichletBC_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
DirichletBC.apply = new_instancemethod(_cpp.DirichletBC_apply,None,DirichletBC)
DirichletBC.get_boundary_values = new_instancemethod(_cpp.DirichletBC_get_boundary_values,None,DirichletBC)
DirichletBC.zero = new_instancemethod(_cpp.DirichletBC_zero,None,DirichletBC)
DirichletBC.zero_columns = new_instancemethod(_cpp.DirichletBC_zero_columns,None,DirichletBC)
DirichletBC.markers = new_instancemethod(_cpp.DirichletBC_markers,None,DirichletBC)
DirichletBC.value = new_instancemethod(_cpp.DirichletBC_value,None,DirichletBC)
DirichletBC.user_sub_domain = new_instancemethod(_cpp.DirichletBC_user_sub_domain,None,DirichletBC)
DirichletBC.is_compatible = new_instancemethod(_cpp.DirichletBC_is_compatible,None,DirichletBC)
DirichletBC.set_value = new_instancemethod(_cpp.DirichletBC_set_value,None,DirichletBC)
DirichletBC.homogenize = new_instancemethod(_cpp.DirichletBC_homogenize,None,DirichletBC)
DirichletBC.method = new_instancemethod(_cpp.DirichletBC_method,None,DirichletBC)
DirichletBC_swigregister = _cpp.DirichletBC_swigregister
DirichletBC_swigregister(DirichletBC)

def DirichletBC_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.DirichletBC_default_parameters(*args)

class PeriodicBC(BoundaryCondition):
    """
    This class specifies the interface for setting periodic boundary
    conditions for partial differential equations,

    .. math::

        u(x) &= u(F^{-1}(x)) \hbox { on } G,

        u(x) &= u(F(x))      \hbox{ on } H,

    where F : H --> G is a map from a subdomain H to a subdomain G.

    A periodic boundary condition must be defined by the domain G
    and the map F pulling coordinates back from H to G. The domain
    and the map are both defined by a subclass of :py:class:`SubDomain` which
    must overload both the inside() function, which specifies the
    points of G, and the map() function, which specifies the map
    from the points of H to the points of G.

    The implementation is based on matching degrees of freedom on G
    with degrees of freedom on H and only works when the mapping F
    is bijective between the sets of coordinates associated with the
    two domains. In other words, the nodes (degrees of freedom) must
    be aligned on G and H.

    The matching of degrees of freedom is done at the construction
    of the periodic boundary condition and is reused on subsequent
    applications to a linear system. The matching may be recomputed
    by calling the ``rebuild()`` function.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * PeriodicBC\ (V, sub_domain)

          Create periodic boundary condition for subdomain
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              sub_domain (:py:class:`SubDomain`)
                  The sub domain.

        * PeriodicBC\ (V, sub_domain)

          Create periodic boundary condition for subdomain
          
          *Arguments*
              V (:py:class:`FunctionSpace`)
                  The function space.
              sub_domain (:py:class:`SubDomain`)
                  The subdomain.

        """
        _cpp.PeriodicBC_swiginit(self,_cpp.new_PeriodicBC(*args))
    __swig_destroy__ = _cpp.delete_PeriodicBC
    def apply(self, *args):
        """
        **Overloaded versions**

        * apply\ (A)

          Apply boundary condition to a matrix
          
          *Arguments*
              A (:py:class:`GenericMatrix`)
                  The matrix to apply bc to.

        * apply\ (b)

          Apply boundary condition to a vector
          
          *Arguments*
              b (:py:class:`GenericVector`)
                  The vector to apply bc to.

        * apply\ (A, b)

          Apply boundary condition to a linear system
          
          *Arguments*
              A (:py:class:`GenericMatrix`)
                  The matrix.
              b (:py:class:`GenericVector`)
                  The vector.

        * apply\ (b, x)

          Apply boundary condition to a vector for a nonlinear problem
          
          *Arguments*
              b (:py:class:`GenericVector`)
                  The vector to apply bc to.
              x (:py:class:`GenericVector`)
                  Another vector (nonlinear problem).

        * apply\ (A, b, x)

          Apply boundary condition to a linear system for a nonlinear
          problem
          
          *Arguments*
              A (:py:class:`GenericMatrix`)
                  The matrix to apply bc to.
              b (:py:class:`GenericVector`)
                  The vector to apply bc to.
              x (:py:class:`GenericVector`)
                  Another vector (nonlinear problem).

        """
        return _cpp.PeriodicBC_apply(self, *args)

    def rebuild(self, *args):
        """
        Rebuild mapping between dofs

        """
        return _cpp.PeriodicBC_rebuild(self, *args)

PeriodicBC.apply = new_instancemethod(_cpp.PeriodicBC_apply,None,PeriodicBC)
PeriodicBC.rebuild = new_instancemethod(_cpp.PeriodicBC_rebuild,None,PeriodicBC)
PeriodicBC_swigregister = _cpp.PeriodicBC_swigregister
PeriodicBC_swigregister(PeriodicBC)

class PointSource(object):
    """
    This class provides an easy mechanism for adding a point source
    (Dirac delta function) to the right-hand side vector in a
    variational problem. The associated function space must be
    scalar in order for the inner product with the (scalar) Dirac
    delta function to be well defined.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * PointSource\ (V, p, magnitude=1.0)

          Create point source at given point of given magnitude

        * PointSource\ (V, p, magnitude=1.0)

          Create point source at given point of given magnitude

        """
        _cpp.PointSource_swiginit(self,_cpp.new_PointSource(*args))
    __swig_destroy__ = _cpp.delete_PointSource
    def apply(self, *args):
        """
        Apply (add) point source to right-hand side vector

        """
        return _cpp.PointSource_apply(self, *args)

PointSource.apply = new_instancemethod(_cpp.PointSource_apply,None,PointSource)
PointSource_swigregister = _cpp.PointSource_swigregister
PointSource_swigregister(PointSource)

class Form(HierarchicalForm):
    """
    Base class for UFC code generated by FFC for DOLFIN with option -l.

    A note on the order of trial and test spaces: FEniCS numbers
    argument spaces starting with the leading dimension of the
    corresponding tensor (matrix). In other words, the test space is
    numbered 0 and the trial space is numbered 1. However, in order
    to have a notation that agrees with most existing finite element
    literature, in particular

        a = a(u, v)

    the spaces are numbered from right to

        a: V_1 x V_0 -> R

    .. note::

        Figure out how to write this in math mode without it getting
        messed up in the Python version.

    This is reflected in the ordering of the spaces that should be
    supplied to generated subclasses. In particular, when a bilinear
    form is initialized, it should be initialized as

    .. code-block:: c++

        a(V_1, V_0) = ...

    where ``V_1`` is the trial space and ``V_0`` is the test space.
    However, when a form is initialized by a list of argument spaces
    (the variable ``function_spaces`` in the constructors below, the
    list of spaces should start with space number 0 (the test space)
    and then space number 1 (the trial space).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Form\ (rank, num_coefficients)

          Create form of given rank with given number of coefficients
          
          *Arguments*
              rank (int)
                  The rank.
              num_coefficients (int)
                  The number of coefficients.

        * Form\ (ufc_form, function_spaces, coefficients)

          Create form (shared data)
          
          *Arguments*
              ufc_form (ufc::form)
                  The UFC form.
              function_spaces (list of :py:class:`FunctionSpace`)
                  Vector of function spaces.
              coefficients (list of :py:class:`GenericFunction`)
                  Vector of coefficients.

        """
        _cpp.Form_swiginit(self,_cpp.new_Form(*args))
    __swig_destroy__ = _cpp.delete_Form
    def rank(self, *args):
        """
        Return rank of form (bilinear form = 2, linear form = 1,
        functional = 0, etc)

        *Returns*
            int
                The rank of the form.

        """
        return _cpp.Form_rank(self, *args)

    def num_coefficients(self, *args):
        """
        Return number of coefficients

        *Returns*
            int
                The number of coefficients.

        """
        return _cpp.Form_num_coefficients(self, *args)

    def coloring(self, *args):
        """
        Return coloring type for colored (multi-threaded) assembly of form
        over a mesh entity of a given dimension

        *Arguments*
            entity_dim (int)
                Dimension.

        *Returns*
            numpy.array(int)
                Coloring type.

        """
        return _cpp.Form_coloring(self, *args)

    def set_mesh(self, *args):
        """
        Set mesh, necessary for functionals when there are no function spaces

        *Arguments*
            mesh (:py:class:`Mesh`)
                The mesh.

        """
        return _cpp.Form_set_mesh(self, *args)

    def mesh(self, *args):
        """
        Extract common mesh from form

        *Returns*
            :py:class:`Mesh`
                The mesh.

        """
        return _cpp.Form_mesh(self, *args)

    def mesh_shared_ptr(self, *args):
        """
        Return mesh shared pointer (if any)

        *Returns*
            :py:class:`Mesh`
                The mesh shared pointer.

        """
        return _cpp.Form_mesh_shared_ptr(self, *args)

    def function_space(self, *args):
        """
        Return function space for given argument

        *Arguments*
            i (int)
                Index

        *Returns*
            :py:class:`FunctionSpace`
                Function space shared pointer.

        """
        return _cpp.Form_function_space(self, *args)

    def function_spaces(self, *args):
        """
        Return function spaces for arguments

        *Returns*
            list of :py:class:`FunctionSpace`
                Vector of function space shared pointers.

        """
        return _cpp.Form_function_spaces(self, *args)

    def set_coefficient(self, *args):
        """
        **Overloaded versions**

        * set_coefficient\ (i, coefficient)

          Set coefficient with given number (shared pointer version)
          
          *Arguments*
              i (int)
                  The given number.
              coefficient (:py:class:`GenericFunction`)
                  The coefficient.

        * set_coefficient\ (name, coefficient)

          Set coefficient with given name (shared pointer version)
          
          *Arguments*
              name (str)
                  The name.
              coefficient (:py:class:`GenericFunction`)
                  The coefficient.

        """
        return _cpp.Form_set_coefficient(self, *args)

    def set_coefficients(self, *args):
        """
        Set all coefficients in given map, possibly a subset (shared
        pointer version)

        *Arguments*
            coefficients (:py:class:`GenericFunction`)
                The map of coefficients.

        """
        return _cpp.Form_set_coefficients(self, *args)

    def coefficient(self, *args):
        """
        **Overloaded versions**

        * coefficient\ (i)

          Return coefficient with given number
          
          *Arguments*
              i (int)
                  Index
          
          *Returns*
              :py:class:`GenericFunction`
                  The coefficient.

        * coefficient\ (name)

          Return coefficient with given name
          
          *Arguments*
              name (str)
                  The name.
          
          *Returns*
              :py:class:`GenericFunction`
                  The coefficient.

        """
        return _cpp.Form_coefficient(self, *args)

    def coefficients(self, *args):
        """
        Return all coefficients

        *Returns*
            list of :py:class:`GenericFunction`
                All coefficients.

        """
        return _cpp.Form_coefficients(self, *args)

    def coefficient_number(self, *args):
        """
        Return the number of the coefficient with this name

        *Arguments*
            name (str)
                The name.

        *Returns*
            int
                The number of the coefficient with the given name.

        """
        return _cpp.Form_coefficient_number(self, *args)

    def coefficient_name(self, *args):
        """
        Return the name of the coefficient with this number

        *Arguments*
            i (int)
                The number

        *Returns*
            str
                The name of the coefficient with the given number.

        """
        return _cpp.Form_coefficient_name(self, *args)

    def cell_domains_shared_ptr(self, *args):
        """
        Return cell domains (zero pointer if no domains have been
        specified)

        *Returns*
            :py:class:`MeshFunction`
                The cell domains.

        """
        return _cpp.Form_cell_domains_shared_ptr(self, *args)

    def exterior_facet_domains_shared_ptr(self, *args):
        """
        Return exterior facet domains (zero pointer if no domains have
        been specified)

        *Returns*
            :py:class:`MeshFunction`
                The exterior facet domains.

        """
        return _cpp.Form_exterior_facet_domains_shared_ptr(self, *args)

    def interior_facet_domains_shared_ptr(self, *args):
        """
        Return interior facet domains (zero pointer if no domains have
        been specified)

        *Returns*
            :py:class:`MeshFunction`
                The interior facet domains.

        """
        return _cpp.Form_interior_facet_domains_shared_ptr(self, *args)

    def set_cell_domains(self, *args):
        """
        Set cell domains

        *Arguments*
            cell_domains (:py:class:`MeshFunction`)
                The cell domains.

        """
        return _cpp.Form_set_cell_domains(self, *args)

    def set_exterior_facet_domains(self, *args):
        """
        Set exterior facet domains

        *Arguments*
            exterior_facet_domains (:py:class:`MeshFunction`)
                The exterior facet domains.

        """
        return _cpp.Form_set_exterior_facet_domains(self, *args)

    def set_interior_facet_domains(self, *args):
        """
        Set interior facet domains

        *Arguments*
            interior_facet_domains (:py:class:`MeshFunction`)
                The interior facet domains.

        """
        return _cpp.Form_set_interior_facet_domains(self, *args)

    def ufc_form(self, *args):
        """
        Return UFC form shared pointer

        *Returns*
            ufc::form
                The UFC form.

        """
        return _cpp.Form_ufc_form(self, *args)

    def check(self, *args):
        """
        Check function spaces and coefficients

        """
        return _cpp.Form_check(self, *args)

Form.rank = new_instancemethod(_cpp.Form_rank,None,Form)
Form.num_coefficients = new_instancemethod(_cpp.Form_num_coefficients,None,Form)
Form.coloring = new_instancemethod(_cpp.Form_coloring,None,Form)
Form.set_mesh = new_instancemethod(_cpp.Form_set_mesh,None,Form)
Form.mesh = new_instancemethod(_cpp.Form_mesh,None,Form)
Form.mesh_shared_ptr = new_instancemethod(_cpp.Form_mesh_shared_ptr,None,Form)
Form.function_space = new_instancemethod(_cpp.Form_function_space,None,Form)
Form.function_spaces = new_instancemethod(_cpp.Form_function_spaces,None,Form)
Form.set_coefficient = new_instancemethod(_cpp.Form_set_coefficient,None,Form)
Form.set_coefficients = new_instancemethod(_cpp.Form_set_coefficients,None,Form)
Form.coefficient = new_instancemethod(_cpp.Form_coefficient,None,Form)
Form.coefficients = new_instancemethod(_cpp.Form_coefficients,None,Form)
Form.coefficient_number = new_instancemethod(_cpp.Form_coefficient_number,None,Form)
Form.coefficient_name = new_instancemethod(_cpp.Form_coefficient_name,None,Form)
Form.cell_domains_shared_ptr = new_instancemethod(_cpp.Form_cell_domains_shared_ptr,None,Form)
Form.exterior_facet_domains_shared_ptr = new_instancemethod(_cpp.Form_exterior_facet_domains_shared_ptr,None,Form)
Form.interior_facet_domains_shared_ptr = new_instancemethod(_cpp.Form_interior_facet_domains_shared_ptr,None,Form)
Form.set_cell_domains = new_instancemethod(_cpp.Form_set_cell_domains,None,Form)
Form.set_exterior_facet_domains = new_instancemethod(_cpp.Form_set_exterior_facet_domains,None,Form)
Form.set_interior_facet_domains = new_instancemethod(_cpp.Form_set_interior_facet_domains,None,Form)
Form.ufc_form = new_instancemethod(_cpp.Form_ufc_form,None,Form)
Form.check = new_instancemethod(_cpp.Form_check,None,Form)
Form_swigregister = _cpp.Form_swigregister
Form_swigregister(Form)

def assemble_system(*args):
  """
    **Overloaded versions**

    * assemble_system\ (A, b, a, L, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble system (A, b)

    * assemble_system\ (A, b, a, L, bc, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble system (A, b) and apply Dirichlet boundary condition

    * assemble_system\ (A, b, a, L, bcs, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble system (A, b) and apply Dirichlet boundary conditions

    * assemble_system\ (A, b, a, L, bcs, cell_domains, exterior_facet_domains, interior_facet_domains, x0, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble system (A, b) on sub domains and apply Dirichlet boundary conditions

    """
  return _cpp.assemble_system(*args)

def assemble(*args):
  """
    **Overloaded versions**

    * assemble\ (A, a, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor

    * assemble\ (A, a, sub_domain, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor on sub domain

    * assemble\ (A, a, cell_domains, exterior_facet_domains, interior_facet_domains, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor on sub domains

    * assemble\ (a, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble scalar

    * assemble\ (a, sub_domain, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble scalar on sub domain

    * assemble\ (a, cell_domains, exterior_facet_domains, interior_facet_domains, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble scalar on sub domains

    """
  return _cpp.assemble(*args)

class Assembler(object):
    """
    This class provides automated assembly of linear systems, or
    more generally, assembly of a sparse tensor from a given
    variational form.

    Subdomains for cells and facets may be specified in a number of
    different ways:

    1. By explicitly passing :py:class:`MeshFunction` (as pointers) to the
       assemble functions

    2. By assigning subdomain indicators specified by :py:class:`MeshFunction`
       to the :py:class:`Form` being assembled:

       .. code-block:: c++

           form.dx = cell_domains
           form.ds = exterior_facet_domains
           form.dS = interior_facet_domains

    3. By markers stored as part of the :py:class:`Mesh` (in :py:class:`MeshDomains`)

    4. By specifying a :py:class:`SubDomain` which specifies the domain numbered
       as 0 (with the rest treated as domain number 1)

    Note that (1) overrides (2), which overrides (3).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def assemble(*args):
        """
        **Overloaded versions**

        * assemble\ (A, a, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble tensor from given form
          
          *Arguments*
              A (:py:class:`GenericTensor`)
                  The tensor to assemble.
              a (:py:class:`Form`)
                  The form to assemble the tensor from.
              reset_sparsity (bool)
                  Optional argument: Default value is true.
                  This controls whether the sparsity pattern of the
                  given tensor is reset prior to assembly.
              add_values (bool)
                  Optional argument: Default value is false.
                  This controls whether values are added to the given
                  tensor or if it is zeroed prior to assembly.
              finalize_tensor (bool)
                  Optional argument: Default value is true.
                  This controls whether the assembler finalizes the
                  given tensor after assembly is completed by calling
                  A.apply().

        * assemble\ (A, a, sub_domain, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble tensor from given form on subdomain
          
          *Arguments*
              A (:py:class:`GenericTensor`)
                  The tensor to assemble.
              a (:py:class:`Form`)
                  The form to assemble the tensor from.
              sub_domain (:py:class:`SubDomain`)
                  The subdomain to assemble on.
              reset_sparsity (bool)
                  Optional argument: Default value is true.
                  This controls whether the sparsity pattern of the
                  given tensor is reset prior to assembly.
              add_values (bool)
                  Optional argument: Default value is false.
                  This controls whether values are added to the given
                  tensor or if it is zeroed prior to assembly.
              finalize_tensor (bool)
                  Optional argument: Default value is true.
                  This controls whether the assembler finalizes the
                  given tensor after assembly is completed by calling
                  A.apply().

        * assemble\ (A, a, cell_domains, exterior_facet_domains, interior_facet_domains, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble tensor from given form on subdomains
          
          *Arguments*
              A (:py:class:`GenericTensor`)
                  The tensor to assemble.
              a (:py:class:`Form`)
                  The form to assemble the tensor from.
              cell_domains (:py:class:`MeshFunction`)
                  Cell domains.
              exterior_facet_domains (:py:class:`MeshFunction`)
                  The exterior facet domains.
              interior_facet_domains (:py:class:`MeshFunction`)
                  The interior facet domains.
              reset_sparsity (bool)
                  Optional argument: Default value is true.
                  This controls whether the sparsity pattern of the
                  given tensor is reset prior to assembly.
              add_values (bool)
                  Optional argument: Default value is false.
                  This controls whether values are added to the given
                  tensor or if it is zeroed prior to assembly.
              finalize_tensor (bool)
                  Optional argument: Default value is true.
                  This controls whether the assembler finalizes the
                  given tensor after assembly is completed by calling
                  A.apply().

        """
        return _cpp.Assembler_assemble(*args)

    assemble = staticmethod(assemble)
    def assemble_cells(*args):
        """
        Assemble tensor from given form over cells. This function is
        provided for users who wish to build a customized assembler.

        """
        return _cpp.Assembler_assemble_cells(*args)

    assemble_cells = staticmethod(assemble_cells)
    def assemble_exterior_facets(*args):
        """
        Assemble tensor from given form over exterior facets. This
        function is provided for users who wish to build a customized
        assembler.

        """
        return _cpp.Assembler_assemble_exterior_facets(*args)

    assemble_exterior_facets = staticmethod(assemble_exterior_facets)
    def assemble_interior_facets(*args):
        """
        Assemble tensor from given form over interior facets. This
        function is provided for users who wish to build a customized
        assembler.

        """
        return _cpp.Assembler_assemble_interior_facets(*args)

    assemble_interior_facets = staticmethod(assemble_interior_facets)
    def __init__(self, *args): 
        _cpp.Assembler_swiginit(self,_cpp.new_Assembler(*args))
    __swig_destroy__ = _cpp.delete_Assembler
Assembler_swigregister = _cpp.Assembler_swigregister
Assembler_swigregister(Assembler)

def Assembler_assemble(*args):
  """
    **Overloaded versions**

    * assemble\ (A, a, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor from given form
      
      *Arguments*
          A (:py:class:`GenericTensor`)
              The tensor to assemble.
          a (:py:class:`Form`)
              The form to assemble the tensor from.
          reset_sparsity (bool)
              Optional argument: Default value is true.
              This controls whether the sparsity pattern of the
              given tensor is reset prior to assembly.
          add_values (bool)
              Optional argument: Default value is false.
              This controls whether values are added to the given
              tensor or if it is zeroed prior to assembly.
          finalize_tensor (bool)
              Optional argument: Default value is true.
              This controls whether the assembler finalizes the
              given tensor after assembly is completed by calling
              A.apply().

    * assemble\ (A, a, sub_domain, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor from given form on subdomain
      
      *Arguments*
          A (:py:class:`GenericTensor`)
              The tensor to assemble.
          a (:py:class:`Form`)
              The form to assemble the tensor from.
          sub_domain (:py:class:`SubDomain`)
              The subdomain to assemble on.
          reset_sparsity (bool)
              Optional argument: Default value is true.
              This controls whether the sparsity pattern of the
              given tensor is reset prior to assembly.
          add_values (bool)
              Optional argument: Default value is false.
              This controls whether values are added to the given
              tensor or if it is zeroed prior to assembly.
          finalize_tensor (bool)
              Optional argument: Default value is true.
              This controls whether the assembler finalizes the
              given tensor after assembly is completed by calling
              A.apply().

    * assemble\ (A, a, cell_domains, exterior_facet_domains, interior_facet_domains, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor from given form on subdomains
      
      *Arguments*
          A (:py:class:`GenericTensor`)
              The tensor to assemble.
          a (:py:class:`Form`)
              The form to assemble the tensor from.
          cell_domains (:py:class:`MeshFunction`)
              Cell domains.
          exterior_facet_domains (:py:class:`MeshFunction`)
              The exterior facet domains.
          interior_facet_domains (:py:class:`MeshFunction`)
              The interior facet domains.
          reset_sparsity (bool)
              Optional argument: Default value is true.
              This controls whether the sparsity pattern of the
              given tensor is reset prior to assembly.
          add_values (bool)
              Optional argument: Default value is false.
              This controls whether values are added to the given
              tensor or if it is zeroed prior to assembly.
          finalize_tensor (bool)
              Optional argument: Default value is true.
              This controls whether the assembler finalizes the
              given tensor after assembly is completed by calling
              A.apply().

    """
  return _cpp.Assembler_assemble(*args)

def Assembler_assemble_cells(*args):
  """
    Assemble tensor from given form over cells. This function is
    provided for users who wish to build a customized assembler.

    """
  return _cpp.Assembler_assemble_cells(*args)

def Assembler_assemble_exterior_facets(*args):
  """
    Assemble tensor from given form over exterior facets. This
    function is provided for users who wish to build a customized
    assembler.

    """
  return _cpp.Assembler_assemble_exterior_facets(*args)

def Assembler_assemble_interior_facets(*args):
  """
    Assemble tensor from given form over interior facets. This
    function is provided for users who wish to build a customized
    assembler.

    """
  return _cpp.Assembler_assemble_interior_facets(*args)

class SparsityPatternBuilder(object):
    """
    This class provides functions to compute the sparsity pattern.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def build(*args):
        """
        Build sparsity pattern for assembly of given form

        """
        return _cpp.SparsityPatternBuilder_build(*args)

    build = staticmethod(build)
    def __init__(self, *args): 
        _cpp.SparsityPatternBuilder_swiginit(self,_cpp.new_SparsityPatternBuilder(*args))
    __swig_destroy__ = _cpp.delete_SparsityPatternBuilder
SparsityPatternBuilder_swigregister = _cpp.SparsityPatternBuilder_swigregister
SparsityPatternBuilder_swigregister(SparsityPatternBuilder)

def SparsityPatternBuilder_build(*args):
  """
    Build sparsity pattern for assembly of given form

    """
  return _cpp.SparsityPatternBuilder_build(*args)

class SystemAssembler(object):
    """
    This class provides implements an assembler for systems
    of the form Ax = b. It differs from the default DOLFIN
    assembler in that it assembles both A and b and the same
    time (leading to better performance) and in that it applies
    boundary conditions at the time of assembly.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def assemble(*args):
        """
        **Overloaded versions**

        * assemble\ (A, b, a, L, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble system (A, b)

        * assemble\ (A, b, a, L, bc, reset_sparsity=true, add_values=true, finalize_tensor=true)

          Assemble system (A, b) and apply Dirichlet boundary condition

        * assemble\ (A, b, a, L, bcs, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble system (A, b) and apply Dirichlet boundary conditions

        * assemble\ (A, b, a, L, bcs, cell_domains, exterior_facet_domains, interior_facet_domains, x0, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble system (A, b) and apply Dirichlet boundary conditions

        """
        return _cpp.SystemAssembler_assemble(*args)

    assemble = staticmethod(assemble)
    def __init__(self, *args): 
        _cpp.SystemAssembler_swiginit(self,_cpp.new_SystemAssembler(*args))
    __swig_destroy__ = _cpp.delete_SystemAssembler
SystemAssembler_swigregister = _cpp.SystemAssembler_swigregister
SystemAssembler_swigregister(SystemAssembler)

def SystemAssembler_assemble(*args):
  """
    **Overloaded versions**

    * assemble\ (A, b, a, L, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble system (A, b)

    * assemble\ (A, b, a, L, bc, reset_sparsity=true, add_values=true, finalize_tensor=true)

      Assemble system (A, b) and apply Dirichlet boundary condition

    * assemble\ (A, b, a, L, bcs, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble system (A, b) and apply Dirichlet boundary conditions

    * assemble\ (A, b, a, L, bcs, cell_domains, exterior_facet_domains, interior_facet_domains, x0, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble system (A, b) and apply Dirichlet boundary conditions

    """
  return _cpp.SystemAssembler_assemble(*args)

class LinearVariationalProblem(HierarchicalLinearVariationalProblem):
    """
    This class represents a linear variational problem:

    Find u in V such that

        a(u, v) = L(v)  for all v in V^,

    where V is the trial space and V^ is the test space.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * LinearVariationalProblem\ (a, L, u)

          Create linear variational problem without boundary conditions

        * LinearVariationalProblem\ (a, L, u, bc)

          Create linear variational problem with a single boundary condition

        * LinearVariationalProblem\ (a, L, u, bcs)

          Create linear variational problem with a list of boundary conditions

        * LinearVariationalProblem\ (a, L, u, bcs)

          Create linear variational problem with a list of boundary conditions
          (shared pointer version)

        """
        _cpp.LinearVariationalProblem_swiginit(self,_cpp.new_LinearVariationalProblem(*args))
    def bilinear_form(self, *args):
        """
        Return bilinear form

        """
        return _cpp.LinearVariationalProblem_bilinear_form(self, *args)

    def linear_form(self, *args):
        """
        Return linear form

        """
        return _cpp.LinearVariationalProblem_linear_form(self, *args)

    def solution(self, *args):
        """
        **Overloaded versions**

        * solution\ ()

          Return solution variable

        * solution\ ()

          Return solution variable (const version)

        """
        return _cpp.LinearVariationalProblem_solution(self, *args)

    def bcs(self, *args):
        """
        Return boundary conditions

        """
        return _cpp.LinearVariationalProblem_bcs(self, *args)

    def trial_space(self, *args):
        """
        Return trial space

        """
        return _cpp.LinearVariationalProblem_trial_space(self, *args)

    def test_space(self, *args):
        """
        Return test space

        """
        return _cpp.LinearVariationalProblem_test_space(self, *args)

    __swig_destroy__ = _cpp.delete_LinearVariationalProblem
LinearVariationalProblem.bilinear_form = new_instancemethod(_cpp.LinearVariationalProblem_bilinear_form,None,LinearVariationalProblem)
LinearVariationalProblem.linear_form = new_instancemethod(_cpp.LinearVariationalProblem_linear_form,None,LinearVariationalProblem)
LinearVariationalProblem.solution = new_instancemethod(_cpp.LinearVariationalProblem_solution,None,LinearVariationalProblem)
LinearVariationalProblem.bcs = new_instancemethod(_cpp.LinearVariationalProblem_bcs,None,LinearVariationalProblem)
LinearVariationalProblem.trial_space = new_instancemethod(_cpp.LinearVariationalProblem_trial_space,None,LinearVariationalProblem)
LinearVariationalProblem.test_space = new_instancemethod(_cpp.LinearVariationalProblem_test_space,None,LinearVariationalProblem)
LinearVariationalProblem_swigregister = _cpp.LinearVariationalProblem_swigregister
LinearVariationalProblem_swigregister(LinearVariationalProblem)

class LinearVariationalSolver(Variable):
    """
    This class implements a solver for linear variational problems.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * LinearVariationalSolver\ (problem)

          Create linear variational solver for given problem

        * LinearVariationalSolver\ (problem)

          Create linear variational solver for given problem (shared pointer version)

        """
        _cpp.LinearVariationalSolver_swiginit(self,_cpp.new_LinearVariationalSolver(*args))
    def solve(self, *args):
        """
        Solve variational problem

        """
        return _cpp.LinearVariationalSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.LinearVariationalSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
    __swig_destroy__ = _cpp.delete_LinearVariationalSolver
LinearVariationalSolver.solve = new_instancemethod(_cpp.LinearVariationalSolver_solve,None,LinearVariationalSolver)
LinearVariationalSolver_swigregister = _cpp.LinearVariationalSolver_swigregister
LinearVariationalSolver_swigregister(LinearVariationalSolver)

def LinearVariationalSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.LinearVariationalSolver_default_parameters(*args)

class NonlinearVariationalProblem(HierarchicalNonlinearVariationalProblem):
    """
    This class represents a nonlinear variational problem:

    Find u in V such that

        F(u; v) = 0  for all v in V^,

    where V is the trial space and V^ is the test space.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * NonlinearVariationalProblem\ (F, u)

          Create nonlinear variational problem without boundary conditions.
          The Jacobian form is not specified which requires the use of a
          nonlinear solver that does not rely on the Jacobian.

        * NonlinearVariationalProblem\ (F, u, J)

          Create nonlinear variational problem without boundary conditions.
          The Jacobian form is specified which allows the use of a nonlinear
          solver that relies on the Jacobian (using Newton's method).

        * NonlinearVariationalProblem\ (F, u, bc)

          Create nonlinear variational problem with a single boundary condition.
          The Jacobian form is not specified which requires the use of a
          nonlinear solver that does not rely on the Jacobian.

        * NonlinearVariationalProblem\ (F, u, bc, J)

          Create nonlinear variational problem with a single boundary condition.
          The Jacobian form is specified which allows the use of a nonlinear
          solver that relies on the Jacobian (using Newton's method).

        * NonlinearVariationalProblem\ (F, u, bcs)

          Create nonlinear variational problem with a list of boundary conditions.
          The Jacobian form is not specified which requires the use of a
          nonlinear solver that does not rely on the Jacobian.

        * NonlinearVariationalProblem\ (F, u, bcs, J)

          Create nonlinear variational problem with a list of boundary conditions.
          The Jacobian form is specified which allows the use of a nonlinear
          solver that relies on the Jacobian (using Newton's method).

        * NonlinearVariationalProblem\ (F, u, bcs)

          Create nonlinear variational problem, shared pointer version.
          The Jacobian form is not specified which requires the use of a
          nonlinear solver that does not rely on the Jacobian.

        * NonlinearVariationalProblem\ (F, u, bcs, J)

          Create nonlinear variational problem, shared pointer version.
          The Jacobian form is specified which allows the use of a nonlinear
          solver that relies on the Jacobian (using Newton's method).

        """
        _cpp.NonlinearVariationalProblem_swiginit(self,_cpp.new_NonlinearVariationalProblem(*args))
    def residual_form(self, *args):
        """
        Return residual form

        """
        return _cpp.NonlinearVariationalProblem_residual_form(self, *args)

    def jacobian_form(self, *args):
        """
        Return Jacobian form

        """
        return _cpp.NonlinearVariationalProblem_jacobian_form(self, *args)

    def solution(self, *args):
        """
        **Overloaded versions**

        * solution\ ()

          Return solution variable

        * solution\ ()

          Return solution variable (const version)

        """
        return _cpp.NonlinearVariationalProblem_solution(self, *args)

    def bcs(self, *args):
        """
        Return boundary conditions

        """
        return _cpp.NonlinearVariationalProblem_bcs(self, *args)

    def trial_space(self, *args):
        """
        Return trial space

        """
        return _cpp.NonlinearVariationalProblem_trial_space(self, *args)

    def test_space(self, *args):
        """
        Return test space

        """
        return _cpp.NonlinearVariationalProblem_test_space(self, *args)

    def has_jacobian(self, *args):
        """
        Check whether Jacobian has been defined

        """
        return _cpp.NonlinearVariationalProblem_has_jacobian(self, *args)

    __swig_destroy__ = _cpp.delete_NonlinearVariationalProblem
NonlinearVariationalProblem.residual_form = new_instancemethod(_cpp.NonlinearVariationalProblem_residual_form,None,NonlinearVariationalProblem)
NonlinearVariationalProblem.jacobian_form = new_instancemethod(_cpp.NonlinearVariationalProblem_jacobian_form,None,NonlinearVariationalProblem)
NonlinearVariationalProblem.solution = new_instancemethod(_cpp.NonlinearVariationalProblem_solution,None,NonlinearVariationalProblem)
NonlinearVariationalProblem.bcs = new_instancemethod(_cpp.NonlinearVariationalProblem_bcs,None,NonlinearVariationalProblem)
NonlinearVariationalProblem.trial_space = new_instancemethod(_cpp.NonlinearVariationalProblem_trial_space,None,NonlinearVariationalProblem)
NonlinearVariationalProblem.test_space = new_instancemethod(_cpp.NonlinearVariationalProblem_test_space,None,NonlinearVariationalProblem)
NonlinearVariationalProblem.has_jacobian = new_instancemethod(_cpp.NonlinearVariationalProblem_has_jacobian,None,NonlinearVariationalProblem)
NonlinearVariationalProblem_swigregister = _cpp.NonlinearVariationalProblem_swigregister
NonlinearVariationalProblem_swigregister(NonlinearVariationalProblem)

class NonlinearVariationalSolver(Variable):
    """
    This class implements a solver for nonlinear variational problems.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * NonlinearVariationalSolver\ (problem)

          Create nonlinear variational solver for given problem

        * NonlinearVariationalSolver\ (problem)

          Create nonlinear variational solver for given problem (shared pointer version)

        """
        _cpp.NonlinearVariationalSolver_swiginit(self,_cpp.new_NonlinearVariationalSolver(*args))
    def solve(self, *args):
        """
        Solve variational problem

        *Returns*
            (int, bool)
                Pair of number of Newton iterations, and whether
                iteration converged)

        """
        return _cpp.NonlinearVariationalSolver_solve(self, *args)

    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.NonlinearVariationalSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
    __swig_destroy__ = _cpp.delete_NonlinearVariationalSolver
NonlinearVariationalSolver.solve = new_instancemethod(_cpp.NonlinearVariationalSolver_solve,None,NonlinearVariationalSolver)
NonlinearVariationalSolver_swigregister = _cpp.NonlinearVariationalSolver_swigregister
NonlinearVariationalSolver_swigregister(NonlinearVariationalSolver)

def NonlinearVariationalSolver_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.NonlinearVariationalSolver_default_parameters(*args)

class OpenMpAssembler(object):
    """
    This class provides automated assembly of linear systems, or
    more generally, assembly of a sparse tensor from a given
    variational form.

    The MeshFunction arguments can be used to specify assembly over
    subdomains of the mesh cells, exterior facets or interior
    facets. Either a null pointer or an empty MeshFunction may be
    used to specify that the tensor should be assembled over the
    entire set of cells or facets.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def assemble(*args):
        """
        **Overloaded versions**

        * assemble\ (A, a, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble tensor from given form

        * assemble\ (A, a, cell_domains, exterior_facet_domains, interior_facet_domains, reset_sparsity=true, add_values=false, finalize_tensor=true)

          Assemble tensor from given form on sub domains

        """
        return _cpp.OpenMpAssembler_assemble(*args)

    assemble = staticmethod(assemble)
    def __init__(self, *args): 
        _cpp.OpenMpAssembler_swiginit(self,_cpp.new_OpenMpAssembler(*args))
    __swig_destroy__ = _cpp.delete_OpenMpAssembler
OpenMpAssembler_swigregister = _cpp.OpenMpAssembler_swigregister
OpenMpAssembler_swigregister(OpenMpAssembler)

def OpenMpAssembler_assemble(*args):
  """
    **Overloaded versions**

    * assemble\ (A, a, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor from given form

    * assemble\ (A, a, cell_domains, exterior_facet_domains, interior_facet_domains, reset_sparsity=true, add_values=false, finalize_tensor=true)

      Assemble tensor from given form on sub domains

    """
  return _cpp.OpenMpAssembler_assemble(*args)

class VariationalProblem(object):
    """
    This class is deprecated and is only here to give an informative error
    message to users about the new interface.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * VariationalProblem\ (form_0, form_1)

          Deprecated

        * VariationalProblem\ (form_0, form_1, bc)

          Deprecated

        * VariationalProblem\ (form_0, form_1, bcs)

          Deprecated

        * VariationalProblem\ (form_0, form_1, bcs)

          Deprecated

        """
        _cpp.VariationalProblem_swiginit(self,_cpp.new_VariationalProblem(*args))
    __swig_destroy__ = _cpp.delete_VariationalProblem
    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (u)

          Deprecated

        * solve\ (u0, u1)

          Deprecated

        * solve\ (u0, u1, u2)

          Deprecated

        * solve\ (u, tol, M)

          Deprecated

        * solve\ (u, tol, M, ec)

          Deprecated

        """
        return _cpp.VariationalProblem_solve(self, *args)

VariationalProblem.solve = new_instancemethod(_cpp.VariationalProblem_solve,None,VariationalProblem)
VariationalProblem_swigregister = _cpp.VariationalProblem_swigregister
VariationalProblem_swigregister(VariationalProblem)

class HierarchicalErrorControl(object):
    """
    This class provides storage and data access for hierarchical
    classes; that is, classes where an object may have a child
    and a parent.

    Note to developers: each subclass of Hierarchical that
    implements an assignment operator must call the base class
    assignment operator at the *end* of the subclass assignment
    operator. See the Mesh class for an example.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Constructor

        """
        _cpp.HierarchicalErrorControl_swiginit(self,_cpp.new_HierarchicalErrorControl(*args))
    __swig_destroy__ = _cpp.delete_HierarchicalErrorControl
    def depth(self, *args):
        """
        Return depth of the hierarchy; that is, the total number of
        objects in the hierarchy linked to the current object via
        child-parent relationships, including the object itself.

        *Returns*
            int
                The depth of the hierarchy.

        """
        return _cpp.HierarchicalErrorControl_depth(self, *args)

    def has_parent(self, *args):
        """
        Check if the object has a parent.

        *Returns*
            bool
                The return value is true iff the object has a parent.

        """
        return _cpp.HierarchicalErrorControl_has_parent(self, *args)

    def has_child(self, *args):
        """
        Check if the object has a child.

        *Returns*
            bool
                The return value is true iff the object has a child.

        """
        return _cpp.HierarchicalErrorControl_has_child(self, *args)

    def parent(self, *args):
        """
        **Overloaded versions**

        * parent_shared_ptr\ ()

          Return shared pointer to parent. A zero pointer is returned if
          the object has no parent.
          
          *Returns*
              shared_ptr<T>
                  The parent object.

        * parent_shared_ptr\ ()

          Return shared pointer to parent (const version).

        """
        return _cpp.HierarchicalErrorControl_parent(self, *args)

    def child(self, *args):
        """
        **Overloaded versions**

        * child_shared_ptr\ ()

          Return shared pointer to child. A zero pointer is returned if
          the object has no child.
          
          *Returns*
              shared_ptr<T>
                  The child object.

        * child_shared_ptr\ ()

          Return shared pointer to child (const version).

        """
        return _cpp.HierarchicalErrorControl_child(self, *args)

    def root_node(self, *args):
        """
        **Overloaded versions**

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy.
          
          *Returns*
              _T_
                  The root node object.

        * root_node_shared_ptr\ ()

          Return shared pointer to root node object in hierarchy (const version).

        """
        return _cpp.HierarchicalErrorControl_root_node(self, *args)

    def leaf_node(self, *args):
        """
        **Overloaded versions**

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy.
          
          *Returns*
              _T_
                  The leaf node object.

        * leaf_node_shared_ptr\ ()

          Return shared pointer to leaf node object in hierarchy (const version).

        """
        return _cpp.HierarchicalErrorControl_leaf_node(self, *args)

    def set_parent(self, *args):
        """
        Set parent

        """
        return _cpp.HierarchicalErrorControl_set_parent(self, *args)

    def set_child(self, *args):
        """
        Set child

        """
        return _cpp.HierarchicalErrorControl_set_child(self, *args)

    def _debug(self, *args):
        """
        Function useful for debugging the hierarchy

        """
        return _cpp.HierarchicalErrorControl__debug(self, *args)

HierarchicalErrorControl.depth = new_instancemethod(_cpp.HierarchicalErrorControl_depth,None,HierarchicalErrorControl)
HierarchicalErrorControl.has_parent = new_instancemethod(_cpp.HierarchicalErrorControl_has_parent,None,HierarchicalErrorControl)
HierarchicalErrorControl.has_child = new_instancemethod(_cpp.HierarchicalErrorControl_has_child,None,HierarchicalErrorControl)
HierarchicalErrorControl.parent = new_instancemethod(_cpp.HierarchicalErrorControl_parent,None,HierarchicalErrorControl)
HierarchicalErrorControl.child = new_instancemethod(_cpp.HierarchicalErrorControl_child,None,HierarchicalErrorControl)
HierarchicalErrorControl.root_node = new_instancemethod(_cpp.HierarchicalErrorControl_root_node,None,HierarchicalErrorControl)
HierarchicalErrorControl.leaf_node = new_instancemethod(_cpp.HierarchicalErrorControl_leaf_node,None,HierarchicalErrorControl)
HierarchicalErrorControl.set_parent = new_instancemethod(_cpp.HierarchicalErrorControl_set_parent,None,HierarchicalErrorControl)
HierarchicalErrorControl.set_child = new_instancemethod(_cpp.HierarchicalErrorControl_set_child,None,HierarchicalErrorControl)
HierarchicalErrorControl._debug = new_instancemethod(_cpp.HierarchicalErrorControl__debug,None,HierarchicalErrorControl)
HierarchicalErrorControl_swigregister = _cpp.HierarchicalErrorControl_swigregister
HierarchicalErrorControl_swigregister(HierarchicalErrorControl)

class GenericAdaptiveVariationalSolver(Variable):
    """
    An abstract class for goal-oriented adaptive solution of
    variational problems.

    """
    thisown = _swig_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
    __swig_destroy__ = _cpp.delete_GenericAdaptiveVariationalSolver
    def solve(self, *args):
        """
        **Overloaded versions**

        * solve\ (tol, goal, control)

          Solve such that the error measured in the functional 'goal' is
          less than the given tolerance using the ErrorControl object
          'control'
          
          *Arguments*
              tol (float)
                  The error tolerance
              goal (:py:class:`Form`)
                  The goal functional
              control (:py:class:`ErrorControl`)
                  The error controller

        * solve\ (tol, M)

          Solve such that the error measured in the goal functional 'M'
          is less than the given tolerance using the GoalFunctional's
          ErrorControl object. Must be overloaded in subclass.
          
          *Arguments*
              tol (float)
                  The error tolerance
              goal (:py:class:`GoalFunctional`)
                  The goal functional

        """
        return _cpp.GenericAdaptiveVariationalSolver_solve(self, *args)

    def solve_primal(self, *args):
        """
        Solve the primal problem. Must be overloaded in subclass.

        *Returns*
            :py:class:`Function`
                The solution to the primal problem

        """
        return _cpp.GenericAdaptiveVariationalSolver_solve_primal(self, *args)

    def extract_bcs(self, *args):
        """
        Extract the boundary conditions for the primal problem. Must
        be overloaded in subclass.

        *Returns*
            list of :py:class:`BoundaryCondition`
                The primal boundary conditions

        """
        return _cpp.GenericAdaptiveVariationalSolver_extract_bcs(self, *args)

    def evaluate_goal(self, *args):
        """
        Evaluate the goal functional. Must be overloaded in subclass.

        *Arguments*
           M (:py:class:`Form`)
               The functional to be evaluated
           u (:py:class:`Function`)
               The function of which to evaluate the functional

        *Returns*
            float
                The value of M evaluated at u

        """
        return _cpp.GenericAdaptiveVariationalSolver_evaluate_goal(self, *args)

    def adapt_problem(self, *args):
        """
        Adapt the problem to other mesh. Must be overloaded in subclass.

        *Arguments*
           mesh (:py:class:`Mesh`)
               The other mesh

        """
        return _cpp.GenericAdaptiveVariationalSolver_adapt_problem(self, *args)

    def adaptive_data(self, *args):
        """
        Return stored adaptive data

        *Returns*
           list of :py:class:`Parameters`
               The data stored in the adaptive loop

        """
        return _cpp.GenericAdaptiveVariationalSolver_adaptive_data(self, *args)

    def default_parameters(*args):
        """
        Default parameter values:

            "max_iterations"     (int)
            "max_dimension"      (int)
            "plot_mesh"          (bool)
            "save_data"          (bool)
            "data_label"         (std::string)
            "reference"          (double)
            "marking_strategy"   (std::string)
            "marking_fraction"   (double)

        """
        return _cpp.GenericAdaptiveVariationalSolver_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
GenericAdaptiveVariationalSolver.solve = new_instancemethod(_cpp.GenericAdaptiveVariationalSolver_solve,None,GenericAdaptiveVariationalSolver)
GenericAdaptiveVariationalSolver.solve_primal = new_instancemethod(_cpp.GenericAdaptiveVariationalSolver_solve_primal,None,GenericAdaptiveVariationalSolver)
GenericAdaptiveVariationalSolver.extract_bcs = new_instancemethod(_cpp.GenericAdaptiveVariationalSolver_extract_bcs,None,GenericAdaptiveVariationalSolver)
GenericAdaptiveVariationalSolver.evaluate_goal = new_instancemethod(_cpp.GenericAdaptiveVariationalSolver_evaluate_goal,None,GenericAdaptiveVariationalSolver)
GenericAdaptiveVariationalSolver.adapt_problem = new_instancemethod(_cpp.GenericAdaptiveVariationalSolver_adapt_problem,None,GenericAdaptiveVariationalSolver)
GenericAdaptiveVariationalSolver.adaptive_data = new_instancemethod(_cpp.GenericAdaptiveVariationalSolver_adaptive_data,None,GenericAdaptiveVariationalSolver)
GenericAdaptiveVariationalSolver_swigregister = _cpp.GenericAdaptiveVariationalSolver_swigregister
GenericAdaptiveVariationalSolver_swigregister(GenericAdaptiveVariationalSolver)

def GenericAdaptiveVariationalSolver_default_parameters(*args):
  """
    Default parameter values:

        "max_iterations"     (int)
        "max_dimension"      (int)
        "plot_mesh"          (bool)
        "save_data"          (bool)
        "data_label"         (std::string)
        "reference"          (double)
        "marking_strategy"   (std::string)
        "marking_fraction"   (double)

    """
  return _cpp.GenericAdaptiveVariationalSolver_default_parameters(*args)

class AdaptiveLinearVariationalSolver(GenericAdaptiveVariationalSolver):
    """
    A class for goal-oriented adaptive solution of linear
    variational problems.

    For a linear variational problem of the form: find u in V
    satisfying

        a(u, v) = L(v) for all v in :math:`\hat V`

    and a corresponding conforming discrete problem: find u_h in V_h
    satisfying

        a(u_h, v) = L(v) for all v in :math:`\hat V_h`

    and a given goal functional M and tolerance tol, the aim is to
    find a V_H and a u_H in V_H satisfying the discrete problem such
    that

        \|M(u) - M(u_H)\| < tol

    This strategy is based on dual-weighted residual error
    estimators designed and automatically generated for the primal
    problem and subsequent h-adaptivity.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * AdaptiveLinearVariationalSolver\ (problem)

          Create AdaptiveLinearVariationalSolver
          
          *Arguments*
              problem (:py:class:`LinearVariationalProblem`)
                  The primal problem

        * AdaptiveLinearVariationalSolver\ (problem)

          Create AdaptiveLinearVariationalSolver
          
          *Arguments*
              problem (:py:class:`LinearVariationalProblem`)
                  The primal problem

        """
        _cpp.AdaptiveLinearVariationalSolver_swiginit(self,_cpp.new_AdaptiveLinearVariationalSolver(*args))
    __swig_destroy__ = _cpp.delete_AdaptiveLinearVariationalSolver
AdaptiveLinearVariationalSolver_swigregister = _cpp.AdaptiveLinearVariationalSolver_swigregister
AdaptiveLinearVariationalSolver_swigregister(AdaptiveLinearVariationalSolver)

class AdaptiveNonlinearVariationalSolver(GenericAdaptiveVariationalSolver):
    """
    A class for goal-oriented adaptive solution of nonlinear
    variational problems.

    For a nonlinear variational problem of the form: find u in V
    satisfying

        F(u; v) = 0 for all v in :math:`\hat V`

    and a corresponding conforming discrete problem: find u_h in V_h
    satisfying (at least approximately)

        F(u_h; v) = 0 for all v in :math:`\hat V_h`

    and a given goal functional M and tolerance tol, the aim is to
    find a V_H and a u_H in V_H satisfying the discrete problem such
    that

        \|M(u) - M(u_H)\| < tol

    This strategy is based on dual-weighted residual error
    estimators designed and automatically generated for the primal
    problem and subsequent h-adaptivity.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * AdaptiveNonlinearVariationalSolver\ (problem)

          Create AdaptiveNonlinearVariationalSolver
          
          *Arguments*
              problem (:py:class:`NonlinearVariationalProblem`)
                  The primal problem

        * AdaptiveNonlinearVariationalSolver\ (problem)

          Create AdaptiveNonlinearVariationalSolver
          
          *Arguments*
              problem (:py:class:`NonlinearVariationalProblem`)
                  The primal problem

        """
        _cpp.AdaptiveNonlinearVariationalSolver_swiginit(self,_cpp.new_AdaptiveNonlinearVariationalSolver(*args))
    __swig_destroy__ = _cpp.delete_AdaptiveNonlinearVariationalSolver
AdaptiveNonlinearVariationalSolver_swigregister = _cpp.AdaptiveNonlinearVariationalSolver_swigregister
AdaptiveNonlinearVariationalSolver_swigregister(AdaptiveNonlinearVariationalSolver)

class ErrorControl(HierarchicalErrorControl,Variable):
    """
    (Goal-oriented) Error Control class.
    The notation used here follows the notation in "Automated
    goal-oriented error control I: stationary variational problems",
    ME Rognes and A Logg, 2010-2011.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create error control object

        *Arguments*
            a_star (:py:class:`Form`)
               the bilinear form for the dual problem
            L_star (:py:class:`Form`)
               the linear form for the dual problem
            residual (:py:class:`Form`)
               a functional for the residual (error estimate)
            a_R_T (:py:class:`Form`)
               the bilinear form for the strong cell residual problem
            L_R_T (:py:class:`Form`)
               the linear form for the strong cell residual problem
            a_R_dT (:py:class:`Form`)
               the bilinear form for the strong facet residual problem
            L_R_dT (:py:class:`Form`)
               the linear form for the strong facet residual problem
            eta_T (:py:class:`Form`)
               a linear form over DG_0 for error indicators
            is_linear (bool)
               true iff primal problem is linear

        """
        _cpp.ErrorControl_swiginit(self,_cpp.new_ErrorControl(*args))
    __swig_destroy__ = _cpp.delete_ErrorControl
    def default_parameters(*args):
        """
        Default parameter values:

        """
        return _cpp.ErrorControl_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
    def estimate_error(self, *args):
        """
        Estimate the error relative to the goal M of the discrete
        approximation 'u' relative to the variational formulation by
        evaluating the weak residual at an approximation to the dual
        solution.

        *Arguments*
            u (:py:class:`Function`)
               the primal approximation

            bcs (list of :py:class:`BoundaryCondition`)
                the primal boundary conditions

        *Returns*
            float
                error estimate

        """
        return _cpp.ErrorControl_estimate_error(self, *args)

    def compute_indicators(self, *args):
        """
        Compute error indicators

        *Arguments*
            indicators (:py:class:`Vector`)
                the error indicators (to be computed)

            u (:py:class:`Function`)
                the primal approximation

        """
        return _cpp.ErrorControl_compute_indicators(self, *args)

    def residual_representation(self, *args):
        """
        Compute strong representation (strong cell and facet
        residuals) of the weak residual.

        *Arguments*
            R_T (:py:class:`Function`)
                the strong cell residual (to be computed)

            R_dT (:py:class:`SpecialFacetFunction`)
                the strong facet residual (to be computed)

            u (:py:class:`Function`)
                the primal approximation

        """
        return _cpp.ErrorControl_residual_representation(self, *args)

    def compute_cell_residual(self, *args):
        """
        Compute representation for the strong cell residual
        from the weak residual

        *Arguments*
            R_T (:py:class:`Function`)
                the strong cell residual (to be computed)

            u (:py:class:`Function`)
                the primal approximation

        """
        return _cpp.ErrorControl_compute_cell_residual(self, *args)

    def compute_facet_residual(self, *args):
        """
        Compute representation for the strong facet residual from the
        weak residual and the strong cell residual

        *Arguments*
            R_dT (:py:class:`SpecialFacetFunction`)
                the strong facet residual (to be computed)

            u (:py:class:`Function`)
                the primal approximation

            R_T (:py:class:`Function`)
                the strong cell residual

        """
        return _cpp.ErrorControl_compute_facet_residual(self, *args)

    def compute_dual(self, *args):
        """
        Compute dual approximation defined by dual variational
        problem and dual boundary conditions given by homogenized primal
        boundary conditions.

        *Arguments*
            z (:py:class:`Function`)
                the dual approximation (to be computed)

            bcs (list of :py:class:`BoundaryCondition`)
                the primal boundary conditions

        """
        return _cpp.ErrorControl_compute_dual(self, *args)

    def compute_extrapolation(self, *args):
        """
        Compute extrapolation with boundary conditions

        *Arguments*
            z (:py:class:`Function`)
                the extrapolated function (to be computed)

            bcs (list of :py:class:`BoundaryCondition`)
                the dual boundary conditions

        """
        return _cpp.ErrorControl_compute_extrapolation(self, *args)

ErrorControl.estimate_error = new_instancemethod(_cpp.ErrorControl_estimate_error,None,ErrorControl)
ErrorControl.compute_indicators = new_instancemethod(_cpp.ErrorControl_compute_indicators,None,ErrorControl)
ErrorControl.residual_representation = new_instancemethod(_cpp.ErrorControl_residual_representation,None,ErrorControl)
ErrorControl.compute_cell_residual = new_instancemethod(_cpp.ErrorControl_compute_cell_residual,None,ErrorControl)
ErrorControl.compute_facet_residual = new_instancemethod(_cpp.ErrorControl_compute_facet_residual,None,ErrorControl)
ErrorControl.compute_dual = new_instancemethod(_cpp.ErrorControl_compute_dual,None,ErrorControl)
ErrorControl.compute_extrapolation = new_instancemethod(_cpp.ErrorControl_compute_extrapolation,None,ErrorControl)
ErrorControl_swigregister = _cpp.ErrorControl_swigregister
ErrorControl_swigregister(ErrorControl)

def ErrorControl_default_parameters(*args):
  """
    Default parameter values:

    """
  return _cpp.ErrorControl_default_parameters(*args)

class Extrapolation(object):
    """
    This class implements an algorithm for extrapolating a function
    on a given function space from an approximation of that function
    on a possibly lower-order function space.

    This can be used to obtain a higher-order approximation of a
    computed dual solution, which is necessary when the computed
    dual approximation is in the test space of the primal problem,
    thereby being orthogonal to the residual.

    It is assumed that the extrapolation is computed on the same
    mesh as the original function.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def extrapolate(*args):
        """
        Compute extrapolation w from v

        """
        return _cpp.Extrapolation_extrapolate(*args)

    extrapolate = staticmethod(extrapolate)
    def __init__(self, *args): 
        _cpp.Extrapolation_swiginit(self,_cpp.new_Extrapolation(*args))
    __swig_destroy__ = _cpp.delete_Extrapolation
Extrapolation_swigregister = _cpp.Extrapolation_swigregister
Extrapolation_swigregister(Extrapolation)

def Extrapolation_extrapolate(*args):
  """
    Compute extrapolation w from v

    """
  return _cpp.Extrapolation_extrapolate(*args)

class LocalAssembler(object):
    """
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def assemble(*args):
        """
        """
        return _cpp.LocalAssembler_assemble(*args)

    assemble = staticmethod(assemble)
    def assemble_cell(*args):
        """
        """
        return _cpp.LocalAssembler_assemble_cell(*args)

    assemble_cell = staticmethod(assemble_cell)
    def assemble_exterior_facet(*args):
        """
        """
        return _cpp.LocalAssembler_assemble_exterior_facet(*args)

    assemble_exterior_facet = staticmethod(assemble_exterior_facet)
    def assemble_interior_facet(*args):
        """
        """
        return _cpp.LocalAssembler_assemble_interior_facet(*args)

    assemble_interior_facet = staticmethod(assemble_interior_facet)
    def __init__(self, *args): 
        _cpp.LocalAssembler_swiginit(self,_cpp.new_LocalAssembler(*args))
    __swig_destroy__ = _cpp.delete_LocalAssembler
LocalAssembler_swigregister = _cpp.LocalAssembler_swigregister
LocalAssembler_swigregister(LocalAssembler)

def LocalAssembler_assemble(*args):
  """
    """
  return _cpp.LocalAssembler_assemble(*args)

def LocalAssembler_assemble_cell(*args):
  """
    """
  return _cpp.LocalAssembler_assemble_cell(*args)

def LocalAssembler_assemble_exterior_facet(*args):
  """
    """
  return _cpp.LocalAssembler_assemble_exterior_facet(*args)

def LocalAssembler_assemble_interior_facet(*args):
  """
    """
  return _cpp.LocalAssembler_assemble_interior_facet(*args)

class SpecialFacetFunction(Expression):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * SpecialFacetFunction\ (f_e)

          Create (scalar-valued) SpecialFacetFunction
          
          *Arguments*
              f_e (list of :py:class:`Function`)
                 Separate _Function_s for each facet

        * SpecialFacetFunction\ (f_e, dim)

          Create (vector-valued) SpecialFacetFunction
          
          *Arguments*
              f_e (list of :py:class:`Function`)
                 Separate _Function_s for each facet
          
              dim (int)
                  The value-dimension of the Functions

        """
        _cpp.SpecialFacetFunction_swiginit(self,_cpp.new_SpecialFacetFunction(*args))
    def _sub(self, *args):
        """
        Extract sub-function i

        *Arguments*
            i (int)
               component

        *Returns*
            :py:class:`Function`

        """
        return _cpp.SpecialFacetFunction__sub(self, *args)

    __swig_destroy__ = _cpp.delete_SpecialFacetFunction
SpecialFacetFunction._sub = new_instancemethod(_cpp.SpecialFacetFunction__sub,None,SpecialFacetFunction)
SpecialFacetFunction_swigregister = _cpp.SpecialFacetFunction_swigregister
SpecialFacetFunction_swigregister(SpecialFacetFunction)

class TimeSeries(Variable):
    """
    This class stores a time series of objects to file(s) in a
    binary format which is efficient for reading and writing.

    When objects are retrieved, the object stored at the time
    closest to the given time will be used.

    A new time series will check if values have been stored to
    file before (for a series with the same name) and in that
    case reuse those values. If new values are stored, old
    values will be cleared.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Create empty time series

        *Arguments*
            name (str)
                The time series name
            compressed (bool)
                Use compressed file format (default false)
            store_connectivity (bool)
                Store all computed connectivity (default false)

        """
        _cpp.TimeSeries_swiginit(self,_cpp.new_TimeSeries(*args))
    __swig_destroy__ = _cpp.delete_TimeSeries
    def store(self, *args):
        """
        **Overloaded versions**

        * store\ (vector, t)

          Store vector at given time
          
          *Arguments*
              vector (:py:class:`GenericVector`)
                  The vector to be stored.
              t (float)
                  The time.

        * store\ (mesh, t)

          Store mesh at given time
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh to be stored.
              t (float)
                  The time.

        """
        return _cpp.TimeSeries_store(self, *args)

    def retrieve(self, *args):
        """
        **Overloaded versions**

        * retrieve\ (vector, t, interpolate=true)

          Retrieve vector at given time
          
          *Arguments*
              vector (:py:class:`GenericVector`)
                  The vector (values to be retrieved).
              t (float)
                  The time.
              interpolate (bool)
                  Optional argument: If true (default), interpolate
                  time samples closest to t if t is not present.

        * retrieve\ (mesh, t)

          Retrieve mesh at given time
          
          *Arguments*
              mesh (:py:class:`Mesh`)
                  The mesh (values to be retrieved).
              t (float)
                  The time.

        """
        return _cpp.TimeSeries_retrieve(self, *args)

    def vector_times(self, *args):
        """
        Return array of sample times for vectors

        *Returns*
            numpy.array(float)
                The times.

        """
        return _cpp.TimeSeries_vector_times(self, *args)

    def mesh_times(self, *args):
        """
        Return array of sample times for meshes

        *Returns*
            numpy.array(float)
                The times.

        """
        return _cpp.TimeSeries_mesh_times(self, *args)

    def clear(self, *args):
        """
        Clear time series

        """
        return _cpp.TimeSeries_clear(self, *args)

    def filename_data(*args):
        """
        Return filename for data

        *Arguments*
            series_name (str)
                The time series name
            type_name (str)
                The type of data
            index (int)
                The index
            compressed (bool)
                True if compressed file format

        *Returns*
            str
                The filename

        """
        return _cpp.TimeSeries_filename_data(*args)

    filename_data = staticmethod(filename_data)
    def filename_times(*args):
        """
        Return filename for times

        *Arguments*
            series_name (str)
                The time series name
            type_name (str)
                The type of data
            compressed (bool)
                True if compressed file format

        *Returns*
            str
                The filename

        """
        return _cpp.TimeSeries_filename_times(*args)

    filename_times = staticmethod(filename_times)
    def default_parameters(*args):
        """
        Default parameter values

        """
        return _cpp.TimeSeries_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
TimeSeries.store = new_instancemethod(_cpp.TimeSeries_store,None,TimeSeries)
TimeSeries.retrieve = new_instancemethod(_cpp.TimeSeries_retrieve,None,TimeSeries)
TimeSeries.vector_times = new_instancemethod(_cpp.TimeSeries_vector_times,None,TimeSeries)
TimeSeries.mesh_times = new_instancemethod(_cpp.TimeSeries_mesh_times,None,TimeSeries)
TimeSeries.clear = new_instancemethod(_cpp.TimeSeries_clear,None,TimeSeries)
TimeSeries_swigregister = _cpp.TimeSeries_swigregister
TimeSeries_swigregister(TimeSeries)

def TimeSeries_filename_data(*args):
  """
    Return filename for data

    *Arguments*
        series_name (str)
            The time series name
        type_name (str)
            The type of data
        index (int)
            The index
        compressed (bool)
            True if compressed file format

    *Returns*
        str
            The filename

    """
  return _cpp.TimeSeries_filename_data(*args)

def TimeSeries_filename_times(*args):
  """
    Return filename for times

    *Arguments*
        series_name (str)
            The time series name
        type_name (str)
            The type of data
        compressed (bool)
            True if compressed file format

    *Returns*
        str
            The filename

    """
  return _cpp.TimeSeries_filename_times(*args)

def TimeSeries_default_parameters(*args):
  """
    Default parameter values

    """
  return _cpp.TimeSeries_default_parameters(*args)


def adapt_markers(*args):
  """
    Helper function for refinement of boundary conditions

    """
  return _cpp.adapt_markers(*args)

def mark(*args):
  """
    Mark cells based on indicators and given marking strategy

    *Arguments*
        markers (:py:class:`MeshFunction`)
            the cell markers (to be computed)

        indicators (:py:class:`Vector`)
            error indicators (one per cell)

        strategy (str)
            the marking strategy

        fraction (float)
            the marking fraction

    """
  return _cpp.mark(*args)

def dorfler_mark(*args):
  """
    Mark cells using Dorfler marking

    *Arguments*
        markers (:py:class:`MeshFunction`)
            the cell markers (to be computed)

        indicators (:py:class:`Vector`)
            error indicators (one per cell)

        fraction (float)
            the marking fraction

    """
  return _cpp.dorfler_mark(*args)
class File(object):
    """
    A File represents a data file for reading and writing objects.
    Unless specified explicitly, the format is determined by the
    file name suffix.
    A list of objects that can be read/written to file can be found in
    GenericFile.h. Compatible file formats include:
        * XML (.xml)
        * VTK (.pvd)
        * RAW (.raw)
        * XYZ (.xyz)
        * Binary (.bin)

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    xml = _cpp.File_xml
    vtk = _cpp.File_vtk
    raw = _cpp.File_raw
    xyz = _cpp.File_xyz
    binary = _cpp.File_binary
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * File\ (filename, encoding="ascii")

          Create a file with given name
          
          *Arguments*
              filename (str)
                  Name of file.
              encoding (str)
                  Optional argument specifying encoding, ascii is default.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * File\ (filename, type, encoding="ascii")

          Create a file with given name and type (format)
          
          *Arguments*
              filename (str)
                  Name of file.
              type (Type)
                  File format.
              encoding (str)
                  Optional argument specifying encoding, ascii is default.
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * File\ (outstream)

          Create an outfile object writing to stream
          
          *Arguments*
              outstream (std::ostream)
                  The stream.

        """
        _cpp.File_swiginit(self,_cpp.new_File(*args))
    __swig_destroy__ = _cpp.delete_File
    def exists(*args):
        """
        Check if file exists

        *Arguments*
            filename (str)
                Name of file.

        *Returns*
            bool
                True if the file exists.

        """
        return _cpp.File_exists(*args)

    exists = staticmethod(exists)
    def create_parent_path(*args):
        """
        *Arguments*
            filename (str)
                Name of file / path.

        """
        return _cpp.File_create_parent_path(*args)

    create_parent_path = staticmethod(create_parent_path)
    def __rshift__(self, *args):
        """
        Read from file

        """
        return _cpp.File___rshift__(self, *args)

    def __lshift__(self, *args):
        """
        **Overloaded versions**

        * operator<<\ (Function*, u)

          Write Function to file with time
          
          *Example*
              .. note::
              
                  No example code available for this function.

        * operator<<\ (t)

          Write object to file

        """
        return _cpp.File___lshift__(self, *args)

File.__rshift__ = new_instancemethod(_cpp.File___rshift__,None,File)
File.__lshift__ = new_instancemethod(_cpp.File___lshift__,None,File)
File_swigregister = _cpp.File_swigregister
File_swigregister(File)

def adapt(*args):
  """
    **Overloaded versions**

    * adapt\ (mesh)

      Refine mesh uniformly

    * adapt\ (mesh, cell_markers)

      Refine mesh based on cell markers

    * adapt\ (space)

      Refine function space uniformly

    * adapt\ (space, cell_markers)

      Refine function space based on cell markers

    * adapt\ (space, adapted_mesh)

      Refine function space based on refined mesh

    * adapt\ (function, adapted_mesh, interpolate=true)

      Adapt Function based on adapted mesh
      
      *Arguments*
          function (:py:class:`Function`)
              The function that should be adapted
          adapted_mesh (:py:class:`Mesh`)
              The new mesh
          interpolate (bool)
              Optional argument, default is true. If false, the
              function's function space is adapted, but the values are
              not interpolated.
      
      *Returns*
          :py:class:`Function`
              The adapted function

    * adapt\ (function, adapted_mesh)

      Refine GenericFunction based on refined mesh

    * adapt\ (mesh_function, adapted_mesh)

      Refine mesh function<uint> based on mesh

    * adapt\ (bc, adapted_mesh, S)

      Refine Dirichlet bc based on refined mesh

    * adapt\ (form, adapted_mesh, adapt_coefficients=true)

      Adapt form based on adapted mesh
      
      *Arguments*
          form (:py:class:`Form`)
              The form that should be adapted
          adapted_mesh (:py:class:`Mesh`)
              The new mesh
          adapt_coefficients (bool)
              Optional argument, default is true. If false, the form
              coefficients are not explictly adapted, but pre-adapted
              coefficients will be transferred.
      
      *Returns*
          :py:class:`Form`
              The adapted form

    * adapt\ (problem, adapted_mesh)

      Refine linear variational problem based on mesh

    * adapt\ (problem, adapted_mesh)

      Refine nonlinear variational problem based on mesh

    * adapt\ (ec, adapted_mesh, adapt_coefficients=true)

      Adapt error control object based on adapted mesh
      
      *Arguments*
          ec (:py:class:`ErrorControl`)
              The error control object to be adapted
          adapted_mesh (:py:class:`Mesh`)
              The new mesh
          adapt_coefficients (bool)
              Optional argument, default is true. If false, any form
              coefficients are not explictly adapted, but pre-adapted
              coefficients will be transferred.
      
      *Returns*
          :py:class:`ErrorControl`
              The adapted error control object

    """
  return _cpp.adapt(*args)

def solve(*args):
  """
    **Overloaded versions**

    * solve\ (equation, u, tol, M)

      Solve linear variational problem a(u, v) == L(v) without
      essential boundary conditions

    * solve\ (equation, u, bc, tol, M)

      Solve linear variational problem a(u, v) == L(v) with single
      boundary condition

    * solve\ (equation, u, bcs, tol, M)

      Solve linear variational problem a(u, v) == L(v) with list of
      boundary conditions

    * solve\ (equation, u, J, tol, M)

      Solve nonlinear variational problem F(u; v) = 0 without
      essential boundary conditions

    * solve\ (equation, u, bc, J, tol, M)

      Solve linear variational problem F(u; v) = 0 with single
      boundary condition

    * solve\ (equation, u, bcs, J, tol, M)

      Solve linear variational problem F(u; v) = 0 with list of
      boundary conditions

    """
  return _cpp.solve(*args)

def File_exists(*args):
  """
    Check if file exists

    *Arguments*
        filename (str)
            Name of file.

    *Returns*
        bool
            True if the file exists.

    """
  return _cpp.File_exists(*args)

def File_create_parent_path(*args):
  """
    *Arguments*
        filename (str)
            Name of file / path.

    """
  return _cpp.File_create_parent_path(*args)


def dolfin_swigversion(*args):
  return _cpp.dolfin_swigversion(*args)
dolfin_swigversion = _cpp.dolfin_swigversion

def dolfin_version(*args):
  return _cpp.dolfin_version(*args)
dolfin_version = _cpp.dolfin_version
tmp = hex(dolfin_swigversion())
__swigversion__ = "%d.%d.%d"%(tuple(map(int, [tmp[-5], tmp[-3], tmp[-2:]])))
__dolfinversion__ = dolfin_version()
del tmp, dolfin_swigversion, dolfin_version