Promising implementation of GridFunctions

python/dune/perftool/pdelab/__init__.py

@@ -12,7 +12,7 @@ from dune.perftool.pdelab.argument import (pymbolic_apply_function,
                                            )
 from dune.perftool.pdelab.basis import (pymbolic_basis,
                                         pymbolic_reference_gradient,
-                                        pymbolic_evaluate_gridfunction,
+                                        pymbolic_gridfunction,
                                         )
 from dune.perftool.pdelab.geometry import (component_iname,
                                            pymbolic_cell_volume,
@@ -99,8 +99,8 @@ class PDELabInterface(object):
     def pymbolic_apply_function(self, element, restriction, index):
         return pymbolic_apply_function(self.visitor, element, restriction, index)
 
-    def pymbolic_evaluate_gridfunction(self, coeff, restriction, grad):
-        return pymbolic_evaluate_gridfunction(self.visitor, coeff, restriction, grad)
+    def pymbolic_gridfunction(self, coeff, restriction, grad):
+        return pymbolic_gridfunction(coeff, restriction, grad)
 
     #
     # Tensor expression related generator functions

python/dune/perftool/pdelab/basis.py

@@ -231,20 +231,53 @@ def evaluate_coefficient_gradient(visitor, element, name, container, restriction
                 )
 
 
+def local_gridfunction(coeff, restriction, diffOrder):
+    from dune.perftool.pdelab.localoperator import name_gridfunction_member
+    gf = name_gridfunction_member(coeff, diffOrder)
+    name = "{}_local".format(gf)
+    define_local_gridfunction(name, gf)
+    bind_gridfunction_to_element(name, restriction)
+    return name
+
+
+@preamble
+def define_local_gridfunction(name, gf):
+    return "auto {} = localFunction({});".format(name, gf)
+
+
 @preamble
 def bind_gridfunction_to_element(gf, restriction):
     element = name_cell(restriction)
-    return "localFunction({}).bind({});".format(gf, element)
+    return "{}.bind({});".format(gf, element)
+
+
+def declare_grid_function_range(gridfunction):
+    def _decl(name, *args):
+        return "typename decltype({})::Range {};".format(gridfunction, name)
 
+    return _decl
 
-def pymbolic_evaluate_gridfunction(visitor, coeff, restriction, grad):
+@kernel_cached
+def pymbolic_evaluate_gridfunction(name, coeff, restriction, grad):
     diffOrder = 1 if grad else 0
 
-    from dune.perftool.pdelab.localoperator import name_gridfunction_member
-    gridfunction = name_gridfunction_member(coeff, diffOrder)
+    gridfunction = local_gridfunction(coeff, restriction, diffOrder)
+
+    temporary_variable(name,
+                       shape=(1,) + (world_dimension(),) * diffOrder,
+                       decl_method=declare_grid_function_range(gridfunction),
+                       managed=False,
+                       )
+
+    quadpos = get_backend(interface="qp_in_cell")(restriction)
+    instruction(code="{} = {}({});".format(name, gridfunction, quadpos),
+                assignees=frozenset({name}),
+                within_inames=frozenset(get_backend(interface="quad_inames")()),
+                within_inames_is_final=True,
+                )
 
-    bind_gridfunction_to_element(gridfunction, restriction)
 
-    # Foobar!
-    visitor.indices = None
-    return 1
+def pymbolic_gridfunction(coeff, restriction, grad):
+    name = "coeff{}{}".format(coeff.count(), "_grad" if grad else "")
+    pymbolic_evaluate_gridfunction(name, coeff, restriction, grad)
+    return Subscript(Variable(name), (0,))

python/dune/perftool/pdelab/localoperator.py

@@ -179,7 +179,7 @@ def define_gridfunction_member(name, coeff, diffOrder):
         newtype = "Dune::PDELab::DiscreteGridViewFunction<typename {0}::GridFunctionSpace, typename {0}::Vector, {1}>".format(_type, diffOrder)
         params = ["{}.gridFunctionSpace()".format(param), "{}.dofs()".format(param)]
         initializer_list(name, params, classtag="operator")
-        return "{} {};".format(_type, name)
+        return "{} {};".format(newtype, name)
     else:
         initializer_list(name, [param], classtag="operator")
         return "const {}& {};".format(_type, name)

python/dune/perftool/ufl/visitor.py

@@ -164,7 +164,7 @@ class UFL2LoopyVisitor(ModifiedTerminalTracker):
             # and exports it through a getter method 'getTime'
             return prim.Call(prim.Variable("getTime"), ())
         else:
-            return self.interface.pymbolic_evaluate_gridfunction(o, restriction, self.reference_grad)
+            return self.interface.pymbolic_gridfunction(o, restriction, self.reference_grad)
 
     #
     # Handlers for all indexing related stuff

test/coeffeval/CMakeLists.txt

@@ -8,3 +8,5 @@ add_generated_executable(UFLFILE poisson.ufl
 dune_add_test(TARGET coeffeval_poisson
               CMD_ARGS coeffeval_poisson.ini
               )
+
+dune_symlink_to_source_files(FILES coeffeval_poisson.ini)