Man Linux: Main Page and Category List


       FFC - the FEniCS Form Compiler


       ffc  [-h]  [-v] [-d] [-s] [-l language] [-r representation] [-f option]
       [-O] [-q quadrature-rule] ... input.ufl ...


       Compile multilinear forms into efficient low-level code.

       The FEniCS Form Compiler FFC accepts as input one or more  files,  each
       specifying  one or more multilinear forms, and compiles the given forms
       into efficient low-level code for automatic  assembly  of  the  tensors
       representing  the multilinear forms. In particular, FFC compiles a pair
       of bilinear and linear forms defining a variational problem  into  code
       that  can  be  used  to  efficiently  assemble the corresponding linear

       By default, FFC generates  code  according  to  the  UFC  specification
       version  1.0  (Unified  Form-assembly Code, see
       but this can be controlled by specifying a  different  output  language
       (option -l). It is also possible to add new output languages to FFC.

       For  a  full  description of FFC, including a specification of the form
       language used to define the multilinear forms, see the FFC user  manual
       available on the FEniCS web page:


       -h, --help
              Display help text and exit.

       -v, --version
              Display version number and exit.

       -d, --debug
              Debug mode, more output is printed. Conflicts with -s.

       -s, --silent
              Silent mode, no output is printed. Conflicts with -d.

       -l language, --language language
              Specify output language, one of ’ufc’ (default) or ’dolfin’ (UFC
              with a small layer of DOLFIN-specific bindings).

       -r representation, --representation representation
              Specify representation for precomputation and  code  generation,
              one of ’quadrature’ (default) or ’tensor’.

       -f option
              Specify  code  generation options. The list of options available
              depends on the  specified  language  (format).  Current  options
              include         -fblas,         -fno-foo,         -fprecision=n,
              -fprecompute_basis_const,                 -fprecompute_ip_const,
              -fsimplify_expressions, -feliminate_zeros, -fquadrature_degree=n
              and, -fsplit, described in detail below.

       -f blas
              Generate code that uses BLAS to compute tensor  products.   This
              option  is currently ignored, but can be used to reduce the code
              size  when  the  BLAS  option  is  (re-)implemented  in   future

       -f no-foo
              Don’t  generate  code  for UFC function with name ’foo’. Typical
              options     include      -fno-evaluate_basis      and      -fno-
              evaluate_basis_derivatives  to  reduce the size of the generated
              code when these functions are not needed.

       -f precision=n
              Set the number of significant digits to n in the generated code.
              The default value of n is 15.

       -f precompute_basis_const
              Optimisation  option  for quadrature representation. This option
              is ignored if optimisation is not used (see -O option),  and  it
              also  implies the -fprecompute_ip_const option. This option will
              generate code that precompute terms which are  constant  in  the
              loops  involving  basis indices.  This can result in a reduction
              of  the  operation  count  and  thereby  improve   the   runtime
              efficiency  of  the  generated  code.  However, the improvements
              depends  on  the  GCC  compiler   options   as   well   as   the
              characteristics of the variational form.

       -f precompute_ip_const
              Like   the   -fprecompute_basis_const   option   with  the  only
              difference that code will be generated to  compute  terms  which
              are constant in the loops involving the integration points only.

       -f simplify_expressions
              Optimisation option for quadrature representation.  This  option
              is  ignored  if optimisation is not used (see -O option). Before
              simplifying the expressions to compute the local element tensor,
              they  are  expanded  in  order  to identify and precompute terms
              which are constant with  respect  to  geometry  and  integration
              points.  This  operation can be very expensive since it involves
              creating many new terms  which  might  result  in  memory  being

       -f eliminate_zeros
              Optimisation  option  for quadrature representation. This option
              is ignored if optimisation is not used (see -O  option).  Tables
              containing  basis  function  values will be compressed such that
              they only contain non zero values.  This will  reduce  the  loop
              ranges and thereby the number of operations, but since a mapping
              is introduced, in order to  insert  values  correctly  into  the
              element  matrix,  some overhead is introduced. This optimisation
              option is usually most effective in combination with one of  the
              other optimisation options.

       -f quadrature_degree=n
              Will  generate  a  quadrature  rule  accurate  up  to  degree  n
              regardless of the polynomial degree of the form. This option  is
              only  valid for UFL forms and the specified degree will apply to
              ALL terms of the  given  form  for  which  no  degree  has  been
              specified  through  metadata!  As default FFC will determine the
              degree automatically from the form.

       -f split
              Generate separate files for declarations and the implementation.

       -O, --optimize
              Generate optimized code with a lower operation count compared to
              non-optimized code for the assembly of the local element tensor.
              This  will  in  general increase the run-time performance of the
              code. If the representation (see -r option) is ’tensor’ then FFC
              will  use FErari optimizations.  This option requires FErari and
              should be used with caution since it  may  be  very  costly  (at
              compile-time)   for   other   than   simple   forms.    If   the
              representation is ’quadrature’ the compile-time  increase  tends
              to  be  much  less  drastic  compared to FErari for very complex
              forms. The -O option for quadrature representation turns on  the
              following optimisation flags:

              -fsimplify_expressions -feliminate_zeros

       -o directory, --output-directory directory
              Specify  the  directory  where  the  generated  files  should be
              written to. The default output directory is  the  current  (’.’)

       -q rule, --quadrature-rule rule
              Specify the quadrature rule that should be used when integrating
              the  forms.   This  will  affect  both  tensor  and   quadrature
              representation.   Currently,   no   quadrature  rules  has  been
              implemented so the default from FIAT will be used.


       Send comments, questions, bug reports etc. to


       Written  by  Anders  Logg  (  with  help  from  Kristian
       Ølgaard, Marie Rognes, Garth N. Wells and many others.