NAME
       FFC - the FEniCS Form Compiler


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


DESCRIPTION
       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 efficent low-level code for automatic assembly of the tensors rep-
       resenting  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 system.

       By  default, FFC generates code according to the UFC specification ver-
       sion 1.0 (Unified Form-assembly Code, see  http://www.fenics.org/)  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: http://www.fenics.org/


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

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

       -d debuglevel, --debug debuglevel
              Specify debug level (default is 0).

       -s, --silent
              Silent mode, no output is printed (same as --debuglevel -1).

       -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 'tensor' (default) or 'quadrature' (experimental).

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

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

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

       -f quadrature_points=n
              Will generate n quadrature points in each spatial direction
              regardless of the polynomial order of the form. This option is
              only valid for the standard FFC forms i.e., *.form files, not
              UFL forms. The specified number of points will apply to ALL terms
              of the given form! As default FFC will determine the number of
              quadrature points needed for exact representation of the form.

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

       -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 versions.

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

       -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. However, this option is  currently
              ignored. 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.

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

       -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.


       BUGS

       Send comments, questions, bug reports etc. to ffc-dev@fenics.org.

AUTHOR
       Written by Anders Logg (logg@simula.no) with help from Kristian {\O}lgaard,
       Marie Rognes, Garth N. Wells and many others.


                                                                        FFC(1)
