dolfin team mailing list archive

[Johan Hake <hake@xxxxxxxxx>]

On Monday 30 June 2008 13:28:11 Martin Sandve Alnæs wrote:
> 2008/6/30 Anders Logg <logg@xxxxxxxxx>:
> > On Mon, Jun 30, 2008 at 12:50:39PM +0200, Martin Sandve Alnæs wrote:
> >> 2008/6/28 Anders Logg <logg@xxxxxxxxx>:
> >> > On Sat, Jun 28, 2008 at 08:55:44PM +0200, Johan Hake wrote:
> >> >> Hello!
> >> >>
> >> >> I tried to compile an advection diffusion form using Streamline
> >> >> Upwind Petrow Galerkin stabilazing method, similar to the one
> >> >> introduced in DOLFIN 0.6.4. Using 3 dimensional and first degree
> >> >> Lagrange elements, FFC/g++ chokes when the produced code is
> >> >> compiling. It wont finish compile... Is this a known problem and a
> >> >> limitation of FFC/g++?
> >> >
> >> > Try compiling with the -r quadrature option. I guess this is not
> >> > supported in the JIT compiler yet, but could easily be added. There
> >> > should be an option
> >> >
> >> >  dolfin_set("form representation", "quadrature");
> >> >
> >> > in the same way as there is an option "optimize". See if you can
> >> > figure it out and send a patch, or else file a bug report.
> >> >
> >> > Options are added in DefaultParameters.h in DOLFIN and the JIT
> >> > compiler is in jit.py in FFC.

The jit compiler allready a kwarg for the representation. The only thin I had 
to add was a dolfin_set("form representation",value). The value of this 
parameter is checked if an uncompiled form is sent to the assemble function. 
The value is then just passed to jit, without checkes. I also added a 
dolfin_set("quadrature points",value) which is also just passed to the jit 
compiler. 

The changes is only done in the python interface, i.e., in assemble.py. Maybee 
you freek on this Anders? I thought the changes would not have any meaning 
for the c++ interface and therefore I did not add the parameters in 
DefaultParameters.h.

> >> > Possible options for "form representation" are "tensor", "quadrature"
> >> > and (unsupported at the moment) "symbolic" (for SyFi).

As it is now ffc check if the string is "tensor" if not it assume it is 
quadrature. A more thorough check would be nice.

> >> > The quadrature representation generates much less code than the tensor
> >> > representation.

It did, and it compiled nicely!

> >> SFC also does quadrature (in fact most users (me) mainly use that),
> >> and there are many possible compilation options. I don't think it's a
> >> good idea to mix form compiler details into dolfin. We should talk about
> >> this to find a solution that doesn't discriminate form compilers :-)
> >
> > I think we need have to. It is DOLFIN that sends the form to the form
> > compiler so DOLFIN needs to make a choice which form compiler to use.
> >
> > But I agree we should not discriminate form compilers. Any form
> > compiler that handles UFL/UFC should be possible to use.
>
> Then we should at least have an options system that doesn't
> need every possible form compiler option pre-registered.
>
> And setting form compiler options globally for all jit calls may not
> be enough, different forms may call for different compilation options.
>
> As I see it, dolfin doesn't need to know more than the option "form
> compiler". Compiler-specific options should be applied to the particular
> compiler.
>
> Like:
> dolfin_set("form compiler", "ffc")
> ffc_set("form representation", "quadrature")
> A = assemble(ufl_form, ...)
>
> or:
> dolfin_set("form compiler", "sfc")
> A = assemble(ufl_form, ..., options=sfc_options_dict)

I like this. 

For now one could just get around all this parameter settings by just send a 
precompiled form to assemble. I assume that this is what you do Martin?

Johan

> --
> Martin
> _______________________________________________
> DOLFIN-dev mailing list
> DOLFIN-dev@xxxxxxxxxx
> http://www.fenics.org/mailman/listinfo/dolfin-dev


# HG changeset patch
# User "Johan Hake <hake@xxxxxxxxx>"
# Date 1214813815 -7200
# Node ID dc59b16c6b0174f1a59ca7a4102169e21cb5c32d
# Parent  6f19d6b94b9ffc0391f42453cdcb4439c26a73e9
Added functionality to assemble forms using quadrature representation in pyDOLFIN.

Usage:
  dolfin_set("form representation", "quadrature")
  dolfin_set("quadrature points",2)

  A = assemble(A_form, mesh)

diff -r 6f19d6b94b9f -r dc59b16c6b01 site-packages/dolfin/assemble.py
--- a/site-packages/dolfin/assemble.py	Sun Jun 29 19:47:59 2008 +0100
+++ b/site-packages/dolfin/assemble.py	Mon Jun 30 10:16:55 2008 +0200
@@ -35,6 +35,11 @@ _dof_map_cache = {}
 # Cache for tensors
 _tensor_cache = {}
 
+# Add parameters for form representation.
+# Used when the jit compiler is called in assemble
+dolfin_add("form representation",common.constants.FFC_REPRESENTATION)
+dolfin_add("quadrature points",0)
+
 # JIT assembler
 def assemble(form, mesh, coefficients=None, dof_maps=None,
     cell_domains=None, exterior_facet_domains=None, interior_facet_domains=None, reset_tensor=None,
@@ -44,6 +49,8 @@ def assemble(form, mesh, coefficients=No
     # Create empty list of coefficients, filled below
     _coefficients = ArrayFunctionPtr()
 
+    # FIXME: We need to check the rank and dimension of any provided coeffisient function,
+    # so they corresponds with the one in the form, see bug #45.
     # Extract coefficients
     if not coefficients is None: 
         # Compile all strings as dolfin::Function
@@ -69,8 +76,15 @@ def assemble(form, mesh, coefficients=No
     # Check if we need to compile the form (JIT)
     if not hasattr(form, "create_cell_integral"):
         # FFC form, call JIT compile
-        optimize = dolfin_get("optimize form") or dolfin_get("optimize")
-        (compiled_form, module, form_data) = jit(form, optimize=optimize)
+        
+        # Collect parameters that will be passed to the jit compiler
+        optimize       = dolfin_get("optimize form") or dolfin_get("optimize")
+        representation = dolfin_get("form representation")
+        options        = common.constants.FFC_OPTIONS.copy()
+        options["quadrature_points="] = int(dolfin_get("quadrature points"))
+
+        (compiled_form, module, form_data) = jit(form, representation = representation,\
+                                                 optimize=optimize, options=options)
         
         # Extract coefficients from form if no coefficients are provided
         if coefficients is None: