A bit more polishing

python/dune/perftool/cgen/clazz.py

@@ -50,10 +50,11 @@ class Constructor(Generable):
     def generate(self):
         assert self.clsname
 
+        yield '\n'
         yield "{}:\n".format(access_modifier_string(self.access))
-        yield self.classname + "("
+        yield self.clsname + "("
         for ad in self.arg_decls:
-            for content in ad.generate():
+            for content in ad.generate(with_semicolon=False):
                 yield content
         yield ")"
 
@@ -72,7 +73,6 @@ class Class(Generable):
         self.tparam_decls = tparam_decls
         self.constructors = constructors
 
-        assert isinstance(name, str)
         for bc in base_classes:
             assert isinstance(bc, BaseClass)
         for mem in members:
@@ -99,7 +99,11 @@ class Class(Generable):
         yield '\n'
 
         # add base class inheritance
-        yield ",\n".join("    : {} {}\n".format(access_modifier_string(bc.inheritance), bc.name) for bc in self.base_classes)
+        for i, bc in enumerate(self.base_classes):
+            yield "    : {} {}".format(access_modifier_string(bc.inheritance), bc.name)
+            if i+1 != len(self.base_classes):
+                yield ','
+            yield '\n'
 
         # Now yield the entire block
         block = Block(contents=self.constructors + self.members)

python/dune/perftool/file.py

@@ -44,4 +44,4 @@ def generate_file(filename, tag, content, headerguard=True):
                 f.write(line)
 
         if headerguard:
-            f.write("\n\n#endif //{}".format(macro))
+            f.write("\n\n#endif //{}\n".format(macro))

python/dune/perftool/pdelab/localoperator.py

@@ -14,12 +14,10 @@ from dune.perftool.cgen.clazz import BaseClass
 public_base_class = generator_factory(item_tags=("baseclass", "operator"), on_store=lambda n: BaseClass(n), counted=True, no_deco=True)
 initializer_list = generator_factory(item_tags=("pdelab", "initializer", "operator"), counted=True, no_deco=True)
 
-# TODO definition
-#private_member = generator_factory(item_tags=("pdelab", "member", "privatemember"))
-
-@generator_factory(item_tags=("pdelab", "constructor"), counted=True)
+@generator_factory(item_tags=("operator", "constructor_param"), counted=True)
 def constructor_parameter(_type, name):
-    return "{} {}".format(_type, name)
+    from cgen import Value
+    return Value(_type, name)
 
 @dune_symbol
 def name_initree_constructor():
@@ -27,6 +25,11 @@ def name_initree_constructor():
     constructor_parameter("const Dune::ParameterTree&", "iniParams")
     return "iniParams"
 
+@dune_symbol
+def localoperator_type():
+    #TODO use something from the form here to make it unique
+    return "LocalOperator"
+
 @memoize
 def measure_specific_details(measure):
     # The return dictionary that this memoized method will grant direct access to.
@@ -77,8 +80,6 @@ def measure_specific_details(measure):
 def generate_kernel(integrand=None, measure=None):
     assert integrand and measure
 
-    # Delete all non-include parts of the cache.
-    # TODO: add things such as base classes as cache items.
     from dune.perftool.generation import delete_cache
     delete_cache()
 
@@ -101,17 +102,19 @@ def generate_kernel(integrand=None, measure=None):
     domains = [i for i in retrieve_cache_items("domain")]
     instructions = [i for i in retrieve_cache_items("instruction")]
     temporaries = {i.name:i for i in retrieve_cache_items("temporary")}
-    preambles = [i for i in retrieve_cache_items("preamble")]
+    #preambles = [i for i in retrieve_cache_items("preamble")]
     arguments = [i for i in retrieve_cache_items("argument")]
 
     # Create the kernel
     from loopy import make_kernel, preprocess_kernel
-    kernel = make_kernel(domains, instructions, arguments, temporary_variables=temporaries, preambles=preambles, target=DuneTarget())
+    #kernel = make_kernel(domains, instructions, arguments, temporary_variables=temporaries, preambles=preambles, target=DuneTarget())
+    kernel = make_kernel(domains, instructions, arguments, temporary_variables=temporaries, target=DuneTarget())
     kernel = preprocess_kernel(kernel)
 
     # Return the actual code (might instead return kernels...)
     return kernel
 
+
 from dune.perftool.cgen.clazz import ClassMember
 class AssemblyMethod(ClassMember):
     def __init__(self, signature, kernel):
@@ -120,13 +123,18 @@ class AssemblyMethod(ClassMember):
         content = LiteralLines('\n'+'\n'.join(signature) + '\n' + generate_code(kernel)[0])
         ClassMember.__init__(self, content)
 
-def cgen_class_from_cache(name, tag, members=[]):
+
+def cgen_class_from_cache(tag, members=[]):
     from dune.perftool.generation import retrieve_cache_items
 
     base_classes = [bc for bc in retrieve_cache_items(tags=(tag, "baseclass"), union=False)]
+    constructor_params = [bc for bc in retrieve_cache_items(tags=(tag, "constructor_param"), union=False)]
+
+    from dune.perftool.cgen.clazz import Constructor
+    constructor = Constructor(arg_decls=constructor_params, clsname=localoperator_type())
 
     from dune.perftool.cgen import Class
-    return Class(name, base_classes=base_classes, members=members)
+    return Class(localoperator_type, base_classes=base_classes, members=members, constructors=[constructor])
 
 
 def generate_localoperator(form):
@@ -185,5 +193,5 @@ def generate_localoperator_file(kernels):
     from dune.perftool.file import generate_file
 
     # TODO take the name of this thing from the UFL file
-    lop = cgen_class_from_cache("LocalOperator", "operator", members=operator_methods)
+    lop = cgen_class_from_cache("operator", members=operator_methods)
     generate_file(get_option("operator_file"), "operator", [lop])