NAME
       FFC - the FEniCS Form Compiler


SYNOPSIS
       ffc  [-h]  [-v]  [-d debuglevel] [-s] [-l language] [-r representation]
       [-f option] [-O] ... input.form ...


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,   -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_points=n
              Will  generate  n quadrature  points  in  each spatial direction
              regardless of the  polynomial order of the  form. 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 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  ver-
              sions.

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

       -O, --optimize
              Generate optimized code using FErari optimizations. This  option
              is  currently  ignored,  but can be used to reduce the operation
              count for assembly  (run-time  for  the  generated  code).  This
              option  requires FErari and should be used with caution since it
              may be very costly  (at  compile-time)  for  other  than  simple
              forms.



       BUGS

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


AUTHOR
       Anders Logg (logg@simula.no)



                                                                        FFC(1)
