.TH "FFC" 1

.SH NAME
FFC - the FEniCS Form Compiler

.SH SYNOPSIS
.B ffc
[-h]
[-V]
[-S]
[-v]
[-s]
[-e]
[-l language]
[-r representation]
[-f option]
[-O]
[-q quadrature-rule] ... input.ufl ...

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

.SH OPTIONS
.TP
\fB\-h\fR, \fB\-\-help\fR
Display help text and exit.
.TP
\fB\-V\fR, \fB\-\-version\fR
Display version number and exit.
.TP
\fB\-S\fR, \fB\-\-signature\fR
Display UFC signature and exit.
.TP
\fB\-v\fR, \fB\-\-verbose\fR
Verbose mode, more output is printed. Conflicts with -s.
.TP
\fB\-s\fR, \fB\-\-silent\fR
Silent mode, no output is printed. Conflicts with -v.
.TP
\fB\-e\fR, \fB\-\-error-control\fR
Error control mode, a set of additional forms useful for goal-oriented
error control is generated and compiled.
.TP
\fB\-l\fR language, \fB\-\-language\fR language
Specify output language, one of 'ufc' (default) or 'dolfin' (UFC with
a small layer of DOLFIN-specific bindings).
.TP
\fB\-r\fR representation, \fB\-\-representation\fR representation
Specify representation for precomputation and code generation,
one of 'quadrature' (default) or 'tensor'.
.TP
\fB\-f\fR option
Specify code generation options. The list of options available depends on
the specified language (format). Current options include
\fB-fblas\fR,
\fB-fno-foo\fR,
\fB-fprecision=n\fR,
\fB-fprecompute_basis_const\fR,
\fB-fprecompute_ip_const\fR,
\fB-fsimplify_expressions\fR,
\fB-feliminate_zeros\fR,
\fB-fquadrature_degree=n\fR and,
\fB-fsplit\fR,
\fB-fno_ferari\fR,
described in detail below.
.TP
\fB-f\fR 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.
.TP
\fB-f\fR no-foo
Don't generate code for UFC function with name 'foo'. Typical
options include \fB-fno-evaluate_basis\fR and \fB-fno-evaluate_basis_derivatives\fR
to reduce the size of the generated code when these functions are
not needed.
.TP
\fB-f\fR precision=n
Set the number of significant digits to n in the generated code.
The default value of n is 15.
.TP
\fB-f\fR precompute_basis_const
Optimisation option for quadrature representation. This option is ignored if
optimisation is not used (see \fB-O\fR option), and it also implies
the \fB-fprecompute_ip_const option\fR. 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.
.TP
\fB-f\fR precompute_ip_const
Like the \fB-fprecompute_basis_const\fR option with the only difference that
code will be generated to compute terms which are constant in the loops
involving the integration points only.
.TP
\fB-f\fR simplify_expressions
Optimisation option for quadrature representation. This option is ignored if
optimisation is not used (see \fB-O\fR 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.
.TP
\fB-f\fR eliminate_zeros
Optimisation option for quadrature representation. This option is ignored if
optimisation is not used (see \fB-O\fR 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.
.TP
\fB-f\fR 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.
.TP
\fB-f\fR split
Generate separate files for declarations and the implementation.
.TP
\fB-f\fR 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.
.TP
\fB\-O\fR, \fB\-\-optimize\fR
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 \fB-r\fR 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 \fB-O\fR
option for quadrature representation turns on the following optimisation flags:

\fB-fsimplify_expressions -feliminate_zeros\fR

.TP
\fB\-o\fR directory, \fB\-\-output-directory\fR directory
Specify the directory where the generated files should be written to. The
default output directory is the current ('.') directory.
.TP
\fB\-q\fR rule, \fB\-\-quadrature-rule\fR 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
\fB-fquadrature_degree\fR can be used.
.TP

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

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