NAME

       FFC - the FEniCS Form Compiler

SYNOPSIS

       ffc [-h] [-V] [-S] [-v] [-s] [-e] [-l language] [-r representation] [-f option] [-O] [-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 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 system.

       By default, FFC generates code according to the UFC  specification  version  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.

       -S, --signature
              Display UFC signature and exit.

       -v, --verbose
              Verbose mode, more output is printed. Conflicts with -s.

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

       -e, --error-control
              Error  control mode, a set of additional forms useful for goal-oriented error control is generated
              and compiled.

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

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

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

       -f no_ferari
              Skip FErari optimizations, even if the -O flag is set.  This  only  has  effect  when  the  tensor
              representation  is  used.  This  option  can  be  used  in  combination  with the -O flag to avoid
              potentially very long compilation times by instructing FFC to only optimize  when  the  quadrature
              representation is used.

       -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 ('.') 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, available options are 'default' and 'canonical'.
              The 'default' option covers hand implemented quadrature rules for triangles and tetrahedra with  a
              degree  of  precision less than or equal to six.  The 'canonical' option relies on FIAT to compute
              the quadrature rule which is based on the Gauss--Legendre--Jacobi rule mapped onto simplices.   By
              default,  FFC  will  try  to  use  the  'default' option as this will typically result in the most
              efficient code being generated. If this is not possible (if the polynomial degree of the integrand
              is  larger  than  six,  or  if  the  cell  is  not  one  of 'triangle' or 'tetrahedron'), FFC will
              automatically apply the 'canonical' rule.  If  the  number  of  integration  points  used  by  the
              'canonical' rule is too big for efficient computation, the option -fquadrature_degree can be used.

       BUGS

       See https://fenicsproject.org/support/ for channels to send comments,
              questions, bug reports etc.

AUTHOR

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

                                                                                                          FFC(1)