Some infrastructure update

python/dune/perftool/compile.py

@@ -4,9 +4,7 @@ The methods to run the parts of the form compiler
 Should also contain the entrypoint methods.
 """
 
-def read_ufl(uflfile=None):
-    assert uflfile
-    
+def read_ufl(uflfile):
     from ufl.algorithms.formfiles import read_ufl_file, interpret_ufl_namespace
     from ufl.algorithms import compute_form_data
 
@@ -19,13 +17,10 @@ def read_ufl(uflfile=None):
     return formdata
 
 
-def write_driver(formdata=None, filename=None):
-    assert formdata
-    assert filename
-    
+def generate_driver(formdata, filename):
     # The driver module uses a global variable for ease of use
-    import dune.perftool.driver
-    dune.perftool.driver._formdata = formdata
+    from dune.perftool.driver import set_formdata
+    set_formdata(formdata)
 
     # The vtkoutput is the generating method that triggers all others.
     # Alternatively, one could use the `solve` method.
@@ -53,10 +48,23 @@ def write_driver(formdata=None, filename=None):
     f.write("\nvoid driver(int argc, char** argv)\n")
     f.write("\n".join(driver.generate()))
 
+    # Reset the caching data structure
+    from dune.perftool.generation import delete_cache
+    delete_cache()
 
-def write_localoperator():
+
+def generate_localoperator():
     pass
 
 
 def compile_form():
-    pass    
+    from dune.perftool.options import get_option
+    ufldata = read_ufl(get_option("uflfile"))
+
+    generate_localoperator()
+
+    if get_option("driver_file"):
+        generate_driver(ufldata, get_option("driver_file"))
+
+    if get_option("operator_file"):
+        generate_localoperator(ufldata, get_option("operator_file"))

python/dune/perftool/driver.py

@@ -14,6 +14,11 @@ from dune.perftool.generation import dune_include, dune_preamble, dune_symbol
 # through the entire generator chain.
 _formdata = None
 
+# Have a function access this global data structure
+def set_formdata(fd):
+    global _formdata
+    _formdata = fd
+
 
 def isLagrange(fem):
     return fem._short_name is 'CG'

python/dune/perftool/generation.py

@@ -66,12 +66,18 @@ class LoopDomainCacheItem(UFL2LoopyCacheItem):
 class IncludeCacheItem(NoReturnCacheItem):
     def __init__(self, content):
         NoReturnCacheItem.__init__(self, content)
+        from cgen import Include
         self.content = "#include<{}>".format(content)
 
 
 # have one cache the module level. It is easier than handing around an instance of it.
 _cache = {}
 
+# Have an easy button to delete the cache from other modules
+def delete_cache():
+    global _cache
+    _cache = {}
+
 
 def freeze(data):
     """ A function that deterministically generates an

python/dune/perftool/options.py

@@ -4,18 +4,27 @@ from pytools import memoize
 
 @memoize
 def get_form_compiler_arguments():
+    # define an argument parser.
     from argparse import ArgumentParser
     parser = ArgumentParser(description="Compile UFL files to PDELab C++ code", epilog="Please report bugs to dominic.kempf@iwr.uni-heidelberg.de")
     parser.add_argument("uflfile", type=str, nargs=1, help="the UFL file to compile")
+    parser.add_argument("--driver-file", type=str, help="The filename for the generated driver header")
+    parser.add_argument("--operator-file", type=str, help="The filename for the generated local operator header")
+    parser.add_argument('--version', action='version', version='%(prog)s 0.1')
+
+    # These are the options that I deemed necessary in uflpdelab
 #     parser.add_argument("--numerical-jacobian", action="store_true", help="use numerical jacobians (only makes sense, if uflpdelab for some reason fails to generate analytic jacobians)")
-#     parser.add_argument('--version', action='version', version='%(prog)s 0.0')
-#     parser.add_argument("--operator-file", type=str, help="The filename for the generated local operator header")
-#     parser.add_argument("--driver-file", type=str, help="The filename for the generated driver header")
 #     parser.add_argument("--param-class-file", type=str, help="The filename for the generated parameter class header")
 #     parser.add_argument("--export-trafo-graphs", action="store_true", help="export expression graphs after the application of each single transformation")
 #     parser.add_argument("--parameter-tree", action="store_true", help="have the generated local operate take a Dune::ParameterTree as constructor argument")
 #     parser.add_argument("--inifile", type=str, help="The inifile that this program's driver should be hardcoded to. Omit to use a commandline argument ini file")
-    return vars(parser.parse_args)
+
+    # Modify the positional argument to not be a list
+    args = vars(parser.parse_args())
+    args["uflfile"] = args["uflfile"][0]
+
+    # Return the argument dict. This result is memoized to turn all get_option calls into simple dict lookups.
+    return args
 
 def get_option(key):
-    return get_form_compiler_arguments()(key)
\ No newline at end of file
+    return get_form_compiler_arguments().get(key, None)
\ No newline at end of file

python/setup.py

@@ -35,6 +35,6 @@ setup(name='dune.perftool',
       cmdclass={'test': PyTest},
       entry_points = {
         "console_scripts": [
-            "ufl2pdelab = dune.perftool.compiler:compile_form",
+            "ufl2pdelab = dune.perftool.compile:compile_form",
         ]
     })