[feature] python layer for limiter operators.

python/CMakeLists.txt

+add_subdirectory(dune)
+
+configure_file(setup.py.in setup.py)

python/dune/CMakeLists.txt

+add_subdirectory(alugrid)
+
+add_python_targets(dune
+  __init__
+)

python/dune/fem-dg/CMakeLists.txt

+add_python_targets(fem-dg
+  __init__
+  _operators
+)

python/dune/fem-dg/__init__.py

+from ._grids import *
+
+registry = dict()
+registry["grid"] = grid_registry

python/dune/fem-dg/_operators.py

+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sys
+import logging
+logger = logging.getLogger(__name__)
+
+from dune.common.checkconfiguration import assertHave, preprocessorAssert, ConfigurationError
+
+from dune.generator import Constructor, Method
+from dune.generator.generator import SimpleGenerator
+from dune.generator.generator import SimpleGenerator
+from dune.fem.operator import load
+
+generator = SimpleGenerator("Operator", "Dune::FemPy")
+
+# limiter can be ScalingLimiter or FV based limiter with FV type reconstructions for troubled cells
+def createLimiter(domainSpace, rangeSpace=None, bounds = [1e-12,1.], limiter='scaling'):
+    if rangeSpace is None:
+        rangeSpace = domainSpace
+
+    domainSpaceType = domainSpace._typeName
+    rangeSpaceType = rangeSpace._typeName
+
+    _, domainFunctionIncludes, domainFunctionType, _, _ = domainSpace.storage
+    _, rangeFunctionIncludes, rangeFunctionType, _, _ = rangeSpace.storage
+
+    includes = ["dune/fem-dg/operator/limiter/limiter.hh"]
+    includes += domainSpace._includes + domainFunctionIncludes
+    includes += rangeSpace._includes + rangeFunctionIncludes
+
+    typeName = 'Dune::Fem::ScalingLimiter< ' + domainFunctionType + ', ' + rangeFunctionType + ' >'
+    # FV type limiter where FV based reconstructions are done
+    if limiter is 'fv':
+        typeName = 'Dune::Fem::Limiter< ' + domainFunctionType + ', ' + rangeFunctionType + ' >'
+
+    constructor = Constructor(['const '+domainSpaceType + ' &dSpace, const '+rangeSpaceType + ' &rSpace, double lower,double upper'],
+                              ['return new ' + typeName + '(dSpace,rSpace,lower,upper );'],
+                              ['"dSpace"_a', '"rSpace"_a', '"lower"_a', '"upper"_a',
+                               'pybind11::keep_alive< 1, 2 >()', 'pybind11::keep_alive< 1, 3 >()'])
+
+    # add method activated to inspect limited cells.
+    activated = Method('activated', '&'+typeName+'::activated')
+
+    return load(includes, typeName, constructor, activated).Operator( domainSpace, rangeSpace, bounds[0], bounds[1] )
+
+# new method name, only is kept for convenience
+def limiter(domainSpace, rangeSpace=None, bounds = [1e-12,1.], limiter='scaling'):
+    return createLimiter( domainSpace, rangeSpace, bounds, limiter )
+
+def createOrderRedcution(domainSpace):
+
+    domainSpaceType = domainSpace._typeName
+
+    _, domainFunctionIncludes, domainFunctionType, _, _ = domainSpace.storage
+
+    includes = ["dune/fem/operator/common/orderreduction.hh"]
+    includes += domainSpace._includes + domainFunctionIncludes
+
+    typeName = 'Dune::Fem::OrderReduction< ' + domainFunctionType + ' >'
+
+    constructor = Constructor(['const '+domainSpaceType + ' &dSpace'],
+                              ['return new ' + typeName + '(dSpace);'],
+                              ['"dSpace"_a','pybind11::keep_alive< 1, 2 >()'])
+
+    # add method maxRelevantOrder to get max order that is relevant per cell
+    # maxRelevantOrder = Method('maxRelevantOrder', '&'+typeName+'::maxRelevantOrder')
+
+    # return load(includes, typeName, constructor, maxRelevantOrder).Operator( domainSpace )
+    return load(includes, typeName, constructor).Operator( domainSpace )

python/setup.py.in

+from setuptools import setup, find_packages
+
+setup(name="dune.fem-dg",
+    namespace_packages=['dune'],
+    description="Python lib for dune: dune-fem-dg header library",
+    version="${DUNE_PYTHON_VERSION}",
+    author="Robert Kloefkorn, Andreas Dedner, Tobias Malkmus, Stefan Wierling (geb. Girke)",
+    packages = find_packages(),
+    zip_safe = 0,
+    package_data = {'': ['*.so']}
+  )