                    Finite Element Discretization Library
                                   __
                       _ __ ___   / _|  ___  _ __ ___
                      | '_ ` _ \ | |_  / _ \| '_ ` _ \
                      | | | | | ||  _||  __/| | | | | |
                      |_| |_| |_||_|   \___||_| |_| |_|

                               http://mfem.org


Version 3.3, released on Jan 28, 2017
=====================================

FEM <-> linear system interface for action-only linear operators
----------------------------------------------------------------
- Added a new class, ConstrainedOperator, which can impose essential boundary
  conditions using only the action, Mult(), of a given square linear Operator.

- Added a FormLinearSystem + RecoverFEMSolution functionality for square linear
  Operators that are available only through their action. This includes all
  necessary transformations, such as: parallel assembly, conforming constraints
  for non-conforming AMR and eliminating boundary conditions. (Hybridization and
  static condensation are not supported.) See examples in miniapps/performance.

Matrix-free preconditioning and low-order-refined spaces
--------------------------------------------------------
- The HPC examples in miniapps/performance now support efficient preconditioning
  in matrix-free mode based on applying a standard (e.g. AMG) preconditioner to
  a sparsified version of the operator. The sparsification is obtained by
  rediscretizing with a low-order refined spaces, currently at the high-order
  degrees of freedom.

- New mesh constructors support the creation of low-order-refined version of a
  given mesh, both in serial and in parallel. These are illustrated in the HPC
  examples in miniapp/performance (option -pc lor), as well as in mesh-explorer
  miniapp, which now supports Gauss-Lobatto refinement and uniform refinement,
  both for any factor > 1.

Comprehensive PETSc and SUNDIALS interfaces
-------------------------------------------
- Added support for many linear and nonlinear solvers, preconditioners, time
  integrators and other features from the PETSc suite (version 3.8 or higher of
  the PETSc dev branch is required). The new features include:
  * support for PETSc matrices in MATAIJ, MATIS, MATSHELL and MATNEST formats.
  * PETSc linear solvers can take any mfem Operator and support user-defined
    monitoring routines (see examples/petsc/ex1p).
  * BDDC preconditioners for H1, H(curl) and H(div), including with static
    condensation/hybridization, FieldSplit preconditioner for BlockOperators.
  * PETSc non-linear solvers can take any mfem Operator that implements the
    GetGradient() method.
  * PETSc ODE solvers are supported for mfem's TimeDependentOperators.
  The use of these features is illustrated in the new examples/petsc directory.

- Added a new class, OperarorHandle, that provides a common interface for
  global, matrix-type operators to be used in bilinear forms, gradients of
  nonlinear forms, static condensation, hybridization, etc.
  The following backends are currently supported:
  * HYPRE parallel sparse matrix (HYPRE_PARCSR)
  * PETSC globally assembled parallel sparse matrix (PETSC_MATAIJ)
  * PETSC parallel matrix assembled on each processor (PETSC_MATIS)

- Added support for the time integrators and non-linear solvers from the CVODE,
  ARKODE and KINSOL libraries of the SUNDIALS suite (version 2.7 or higher of
  SUNDIALS is required). The use of these features is illustrated in the new
  examples/sundials directory.

Scalable parallel mesh support
------------------------------
- Introduced a new mesh format (v1.2) that can describe/recover MFEM parallel
  meshes. This way, computations can start directly in parallel without serial
  refinement and splitting. Non-conforming meshes are currently supported only
  in serial.

General quadrature and nodal finite element basis types
-------------------------------------------------------
- Added support for different numerical quadrature schemes and finite element
  basis points. Different basis points can be selected via optional integer
  argument(s) to the finite element collection constructor of type BasisType:
  * H1 elements can use GaussLobatto (default), Positive, or ClosedUniform;
  * L2 elements can use GaussLegendre (default), GaussLobatto, Positive,
       ClosedUniform, OpenUniform or OpenHalfUniform;
  * RT can now use open basis that is GaussLegendre (default), GaussLobatto,
       ClosedUniform, OpenUniform, or OpenHalfUniform, and closed basis that is
       GaussLobatto (default) or ClosedUniform;
  * ND elements can use the same BasisType's as RT elements.

- GaussLegendre, GaussLobatto, ClosedUniform, OpenUniform, and OpenHalfUniform
  integration rules can be directly constructed with an optional parameter of
  type Quadrature1D:
     IntegrationRules gl(0, Quadrature1D::GaussLobatto);
     const IntegrationRule *ir = gl(Geometry::SEGMENT, 5); // 4pt 1D rule
  The global IntRules object continues to use GaussLegendre.

New integrators for common families of operators
------------------------------------------------
- Added MixedScalarIntegrator and 7 derived classes for integrating products of
  two scalar basis functions and optional scalar coefficients.

- Added MixedVectorIntegrator and 16 derived classes for integrating the inner
  product of two vector basis functions with optional scalar, vector, or matrix
  coefficients.

- Added MixedScalarVectorIntegrator and 13 derived classes for integrating the
  product of a scalar basis function with the inner product of a vector basis
  function with a vector coefficient. In 2D the inner product can optionally be
  replaced with a cross product.

- Added a new class DGElasticityIntegrator that supports a few types of DG
  formulations for linear elasticity and a new linear form integrator,
  DGElasticityDirichletLFIntegrator, that implements non-homogeneous BCs.

- Added support for DG spaces in class VectorBoundaryLFIntegrator.

- In classes BilinearForm and LinearForm, added support for boundary face
  integrators applied to a subset of the boundary, see AddBdrFaceIntegrator.

New and updated examples and miniapps
-------------------------------------
- Sixteen new serial and parallel example codes that demonstrate:
  * solution of a time-dependent nonlinear heat equation (Example 16/16p)
  * DG formulations of static linear elasticity (Example 17/17p)
  * the use of PETSc solvers and preconditioners (Examples 1p, 2p, 3p, 4p, 5p,
    6p, 9p and 10p in examples/petsc)
  * the use of SUNDIALS time integrators and nonlinear solvers (Examples 9/9p
    and 10/10p in examples/sundials)

- The HPC examples in miniapps/performance now have a -mf/--matrix-free option
  illustrating optimized "partial assembly" operator evaluation. This is now the
  default in these examples, to switch to optimized matrix assembly instead use
  the -asm/--assembly option.

- Added a new electromagnetic miniapp, Joule, illustrating the simulation of
  transient magnetics and joule heating. This is a comprehensive miniapp that
  uses finite element spaces and solvers for the whole de Rham sequence.

- Added a simple miniapp, display-basis, for displaying the various types
  of finite element basis functions within single elements. This is part of
  the new miniapps/tools directory.

- Rewrote the Volta and Tesla solver classes to avoid using linear algebra
  objects when possible. This greatly simplifies the code, reduces memory
  requirements, and eliminates unnecessary computation. It also fixed a bug
  with divergence cleaning in the Tesla miniapp.

- Added an option to Example 9/9p to save a binary visualization file using the
  Conduit mesh blueprint/hdf5 format.

Improved building options
-------------------------
- Added a new CMake build system, that can be used as an alternative to the GNU
  make-based build system (e.g. for out-of-source building). For more details,
  see the INSTALL file and the config/cmake directory.

- Added support for out-of-source builds with GNU make, see the INSTALL file.

Improved file output
--------------------
- Added on-the-fly compression of file streams input and output via gzstream,
  see the MFEM_USE_GZSTREAM option.

- Added experimental support for an HDF5-based output file format following the
  Conduit (https://github.com/LLNL/conduit) mesh blueprint specification for
  visualization and/or restart capability. This functionality is aimed primarily
  at user of LLNL's ASC Toolkit (Sidre component) that run problems at extreme
  scales. Users desiring a small scale binary format may want to look at the
  gzstream functionality instead.

Miscellaneous
-------------
- Added optional support for software-based higher-precision arithmetic with
  the MPFR library. When MFEM_USE_MPFR is enabled, the 1D quadrature rules will
  be computed precisely, at least for rules with up to 65-points.

- Better support for METIS version 5 and above.

- Provide an informative backtrace in mfem_error based on the cross-platform
  libunwind library (requires MFEM_USE_LIBUNWIND=YES).

- In class SparseMatrix, added methods PrintInfo and CheckFinite.

- GMRESSolver and MINRESSolver now support the same print levels as CGSolver.

- Added method MemoryUsage to the classes Stack and MemAlloc.

- Improved Doxygen formatting of code comments.

- Various other simplifications, extensions, and bugfixes in the code.


Version 3.2, released on Jun 30, 2016
=====================================

Dynamic AMR with parallel load balancing, derefinement of non-conforming meshes
-------------------------------------------------------------------------------
- Parallel non-conforming meshes can now be load balanced at any time by calling
  ParMesh::Rebalance(). Elements of the mesh are redistributed in such a way
  that each processor gets approximately the same number of elements (plus minus
  one element). Partitioning is done by splitting a sequence of space-filling
  (Hilbert) curves defined on the refinement octrees.

- Isotropically refined non-conforming meshes can now be derefined, both in
  serial and in parallel, based on a per-element error measure and a
  derefinement threshold. See the class ThresholdDerefiner.

- Following an arbitrary mesh change (uniform/general conforming/non-conforming
  refinement, derefinement, load balancing), the FiniteElementSpace and
  associated GridFunctions can be updated by interpolating or redistributing the
  previous function values based on the new state of the mesh. (Internally this
  is implemented through a transformation matrix that is constructed in the
  FiniteElementSpace.) The user interface is quite simple:

     pmesh.Rebalance();  // or GeneralRefinement, or GeneralDerefinement
     fespace.Update();   // calculate a transformation matrix (by default)
     x.Update();         // apply the transformation to the GridFunction
     z.Update();         // apply it again

- New abstractions are available for error estimation and general mesh
  operations such as refinement and derefinement. See the base classes
  ErrorEstimator and MeshOperator and their descendants.

- The above features are illustrated in the new Example 15 (see also Example 6).

Tensor-based high-performance FEM operator assembly and evaluation
------------------------------------------------------------------
- Added support for high-performance, tensor-based efficient assembly and
  evaluation of high-order operators.

- A number of new header files have been added to the fem/, linalg/ and mesh/
  directories. They start with the prefix "t" to indicate the (heavy) use of C++
  templating, similar to how the prefix "p" denotes "parallel". All the code for
  the new HPC FE assembly/evaluation algorithms is fully implemented in these
  header files. Note that the new interface is optional and only enabled if the
  mfem-performance.hpp header is included instead of mfem.hpp. This is an
  initial, reference implementation.

- Similarly to the serial-to-parallel (ex1.cpp-to-ex1p.cpp) transition, an
  existing MFEM-based applications has to be transitioned to the new HPC
  interface. This is illustrated in two new example codes which are the
  high-performance versions of Example 1/1p. See miniapps/performance.

- The new interface reduces local operator assembly/evaluation to batched small
  dense tensor contraction operations. For high performance, the sizes of these
  contractions should be known at compile time, so the BilinearForm object needs
  to have detailed knowledge about the mesh, the finite element space, the
  quadrature rule and the integrator to be assembled. This required a new
  interface, that supports a subset of the current (general) coefficients and
  bilinear form integrators, including variable coefficients and mass and
  diffusion integrators. It is possible to use the old and the new HPC interface
  side-by-side, see the HPC version of Example 1/1p in miniapps/performance.

Advanced FEM on parallel non-conforming meshes
----------------------------------------------
- Added support for discontinuous Galerkin methods on parallel non-conforming
  meshes, see Examples 9p and 14p.

- Added support for hybridization on parallel non-conforming meshes, see
  Example 4p.

New and improved linear solvers
-------------------------------
- Added a wrapper for the real-valued, double precision solver in SuperLU_DIST
  which is a sparse direct solver for distributed memory architectures. As such
  it can only be enabled along with MFEM_USE_MPI. When MFEM is configured with
  MFEM_USE_SUPERLU, one also needs to alter the version of METIS, since SuperLU
  requires ParMETIS (which comes packaged with a serial version of METIS).  See
  http://http://crd-legacy.lbl.gov/~xiaoye/SuperLU for SuperLU_DIST details.

- Added a wrapper for the KLU solver in SuiteSparse see
  http://faculty.cse.tamu.edu/davis/suitesparse.html for details of KLU.
  If MFEM was configured with MFEM_USE_SUITESPARSE, one must now also link
  against the klu and btf libraries in SuiteSparse, see config/defaults.mk.

New and updated examples and miniapps
-------------------------------------
- Four new serial and parallel example codes that demonstrate:
  * high-performance finite element operator assembly/evaluation (Example 1/1p
    in miniapps/performance)
  * adaptive refinement, derefinement and load balancing (in parallel) on
    non-conforming meshes (Example 15/15p)

- Examples 4p now supports hybridization on non-conforming meshes.

- Examples 9p and 14p now work on non-conforming meshes.

- Example 11p now has optional support for the SuperLU parallel direct solver.

- Added several new options and example runs in the Volta and Tesla miniapps,
  including support for Halbach arrays of permanent magnets.

Miscellaneous
-------------
- Added "check" and "test" targets to the top-level makefile. The former does a
  quick check by running Example 1/1p, while the latter does a more thorough
  verification of the build by running all example codes and miniapps.

- Added support for 2D and 3D meshes generated by Gmsh (http://gmsh.info), both
  in ASCII and binary formats.

- Added a reader for Cubit meshes in the Genesis (NetCDF) format. Currently
  supported are linear and quadratic tet and hex meshes.

- Added support for boundary bilinear form integrators when using hybridization.

- Added support for Robin boundary conditions for DG in BoundaryMassIntegrator.

- Moved all reference element connectivity descriptions, such as element-edge,
  element-face, etc. to the template class Geometry::Constants<Geometry::Type>.

- Added support for secure socket communications in class socketstream based on
  the GnuTLS library, see INSTALL for more details.

- Renamed config/user.mk.in to config/defaults.mk and moved all the default
  build settings from the makefile there.

- Added configurable variables AR, ARFLAGS, and RANLIB in the build system. The
  defaults for Mac OS X will suppress the "has no symbols" warnings.

- Various other simplifications, extensions, and bugfixes in the code.

API changes
-----------
- Changes in class Mesh
  * Two-level state functionality was removed, including: UseTwoLevelState(int),
    SetState(int), GetState(), GetNumFineElems(int), GetRefinementType(int),
    GetFineElem(int, int) and GetFineElemTrans(int, int).

- Changes in class FiniteElementSpace
  * BuildElementToDofTable() is now protected, and it is always called.
  * GlobalRestrictionMatrix(FiniteElementSpace*, int) was removed, but the
    prolongation operator can still be accessed via GetUpdateOperator() after
    mesh refinement and a call to Update(true).

- Changes in methods related to non-conforming meshes and spaces
  * The methods LinearForm::ConformingAssemble, BilinearForm::ConformingAssemble
    and GridFunction::ConformingProlongate/ConformingProject are now hidden
    inside (Par)BilinearForm::FormLinearSystem and RecoverFEMSolution.
  * The conforming prolongation/restriction matrices can still be accessed via
    FiniteElementSpace::GetConformingProlongation()/GetConformingRestriction().

- Changes in classes GridFunction and ParGridFunction
  * Renamed Update((Par)FiniteElementSpace*, Vector&, int) to MakeRef.
  * Renamed Update((Par)FiniteElementSpace*) to SetSpace.


Version 3.1, released on Feb 16, 2016
=====================================

Substantially improved non-conforming adaptive mesh refinement
--------------------------------------------------------------
- Added support for parallel non-conforming mesh refinement, including a new
  example code with adaptive mesh refinement for the Laplace problem (Example
  6p). Most of the example codes can now work on non-conforming meshes in serial
  and in parallel.

- Added simple ZZ-type error estimators, including an anisotropic one in serial,
  and one based on Raviart-Thomas flux projection in parallel, to the AMR
  examples 6 and 6p. These seem to perform quite reasonably, even for
  higher-order discretizations on 2D, 3D and surface meshes.

- The MFEM mesh format has a new version(1.1) that supports non-conforming
  meshes. The format is an extension of 1.0 that includes a vertex_parents and
  an optional coarse_elements section. See the example meshes amr-quad.mesh,
  amr-hex.mesh and fichera-amr.mesh in the data/ directory.

- Added support for DG discretizations on non-conforming meshes in serial. See
  the sample runs in Example 14.

- A new function, ParGridFunction::ParallelProject() directly returns a hypre
  vector restricted to the true degrees of freedom (and supports non-conforming
  meshes). In most cases, this should be preferred to the ParallelAverage()
  function.

- When using non-conforming meshes, the essential boundary condition elimination
  has to be applied at the end of the (parallel) assembly. Furthermore, in
  serial, the bilinear form needs to call ConformingAssemble() after assembly
  and the solution should call ConformingProlongate() after the solve (these are
  not necessary in parallel). Note that these could also be handled
  automatically by the new FEM <-> linear system interface, see below.

General finite element spaces and solvers on surfaces/skeletons
---------------------------------------------------------------
- Added support for arbitrary high-order finite element spaces on the mesh
  skeleton (the faces, edges, and vertices between mesh elements) that are the
  traces of the H1 and H(curl) spaces defined on the mesh. With the previously
  existing H(div) trace space, the full de Rham sequence on the skeleton is now
  supported.

- Updated integrators and discrete interpolators to work correctly for H(curl)
  and H(div) spaces defined on surface meshes, or the mesh skeleton.

Hybridization, static condensation and a new FEM <-> linear system interface
----------------------------------------------------------------------------
- The BilinearForm/ParBilinearForm classes now support static condensation, as
  well as hybridization (based on given constraint space and trace integrator).
  These are illustrated in Examples 1-4.

- Added a new interface for transitioning between the finite element objects and
  their corresponding linear algebra objects, which supports abstracts
  transformations such as: parallel assembly, eliminating boundary conditions,
  applying conforming constraints for non-conforming AMR, hybridization, static
  condensation, back substitution, etc. Changed several of the example codes
  accordingly.

New eigensolvers and improved solvers
-------------------------------------
- Added support for the scalable Locally Optimal Block Preconditioned Conjugate
  Gradient (LOBPCG) eigenvalue solver and the Auxiliary-space Maxwell
  Eigensolver (AME) from hypre.

- Added 3 new example codes to demonstrate the LOBPCG and AME applications to
  the Laplace (Example 11p), Elasticity (Example 12p) and Maxwell (Example 13p)
  eigenproblems.

- Updated the HypreAMS and HypreADS solvers to work for H(curl) and H(div)
  problems defined on surface meshes, or the mesh skeleton.

- Added support for a discretization-enhanced version of hypre's BoomerAMG
  designed specifically for linear elasticity problems, see Example 2p.

- The HypreAMS solver can now be used to solve singular curl-curl problems.

New and updated examples
------------------------
- Six new serial and parallel example codes that demonstrate:
  * parallel conforming and non-conforming adaptive mesh refinement (Example 6p)
  * hypre's LOBPCG eigensolver for the Laplace eigenproblem (Example 11p)
  * hypre's LOBPCG eigensolver for the elasticity eigenproblem (Example 12p)
  * hypre's AME eigensolver for the Maxwell eigenproblem (Example 13p)
  * DG diffusion discretizations for the Laplace equation (Example 14/14p)

- Examples 1-4 now support static condensation, and Example 4/4p supports H(div)
  hybridization, leading to much improved solve times. These examples also
  illustrate the new interface for linear system assembly (see also Examples 6
  and 7).

- Significantly improved the DPG preconditioner in Example 8p, which is now
  scalable in parallel and uses the HypreADS solver to precondition the
  interfacial block as an H(div) problem reduced to the mesh skeleton.

- Example 7/7p has a new option, -amr, showcasing simple local conforming and
  non-conforming mesh refinements.

- Example 3/3p now works in both 2D and 3D.

New miniapps
------------
- Electromagnetic miniapps:
  * Volta - simple electrostatics simulation code.
  * Tesla - simple magnetostatics simulation code.
  See also the README file in miniapps/electromagnetics.

- Meshing miniapps:
  * Mobius Strip  - generate various Mobius strip-like meshes.
  * Klein Bottle  - generate three types of Klein bottle surfaces.
  * Mesh Explorer - visualize and manipulate meshes.
  See also the README file in miniapps/meshing.

Miscellaneous
-------------
- Moved MFEM from Google Code to GitHub. New website: http://mfem.org.

- Formatted the code with Artistic Style, see the "make style" target.

- Added support for 64-bit integers in global size variables, enabling
  simulations with >2B unknowns. (This requires that hypre is configured with
  the --enable-bigint option.)

- Added optional support for the Gecko graph reordering library.

- Updated the implementation of some operations in DenseMatrix for better
  auto-vectorization. Added a new class LUFactors that computes LU factorization
  (with pivoting) and perform various operations with the factored data.

- Various other simplifications, extensions, and bugfixes in the code.


Version 3.0, released on Jan 26, 2015
=====================================

Improved documentation and build system
---------------------------------------
- Added interactive example documentation in examples/README.html. This should
  be the starting point for new users interested in MFEM's features.

- New Doxygen-based code documentation. Due to its size, users are expected to
  build this documentation themselves by typing make in the doc/ directory.
  (Alternatively, the pre-build documentation can be browsed online).

- New build system, based on GNU make which consists of configuration and build
  steps: "make config; make". The MFEM build options are exported, and can be
  included in external makefiles. Library installation is also supported. See
  "make help" and the INSTALL file for details.

- To build the examples use 'make' or 'make -j <np>' in the examples/ directory.
  Based on the current MFEM configuration this will build the serial or the
  parallel examples using the same config options as the library.

New and updated examples
------------------------
- Six new serial/parallel example codes that demonstrate:
  * mixed pressure-velocity FEM for Darcy (Example 5)
  * non-conforming adaptive mesh refinement for Laplace (Example 6)
  * Laplace problem on a surface (Example 7)
  * Discontinuous Petrov-Galerkin (DPG) for Laplace (Example 8)
  * Discontinuous Galerkin (DG) time-dependent advection (Example 9)
  * time-dependent implicit nonlinear elasticity (Example 10)

- Added command line options to all examples and modified several of the serial
  ones to optionally use the serial direct solver UMFPACK.

- Simplified the elimination of Dirichlet boundary conditions in parallel.

- Grouped and documented the example code features in examples/README.html

Serial non-conforming adaptive mesh refinement
----------------------------------------------
- Added support for general, isotropic and anisotropic, local non-conforming
  mesh refinement (using hanging nodes) in 2D and 3D, on quadrilateral,
  triangular and hexahedral meshes. High-order curved and surface meshes are
  also supported.

- The current implementation supports serial meshes (see example 6). Extension
  to parallel meshes is in active development.

- The mesh is refined with Mesh::GeneralRefinement. The non-conforming mesh is
  represented as a mesh that is "cut" along non-conforming edges and faces in
  the internal NCMesh class. The only thing the user has to do to obtain a
  continuous solution is to call BilinearForm::ConformingAssemble and
  GridFunction::ConformingProlongate before and after solving the linear system.
  The finite element space and grid functions are then updated with
  FiniteElementSpace::UpdateAndInterpolate().

Time-dependent problems, non-linear operators and ODE integrators
-----------------------------------------------------------------
- Added new abstract base class TimeDependentOperator and a set of explicit
  Runge-Kutta time integration classes in linalg/ode.?pp.

- Added classes for diagonally implicit Runge-Kutta (DIRK) time integrators
  based on the ImplicitSolve() method of TimeDependentOperator.

- Extended all coefficient classes to be optionally time-dependent.

- Added classes for general nonlinear finite element operators (deriving from
  NonlinearForm/ParNonlinearForm). Such operators have assemble-based action and
  also support assembly of the gradient operator to enable inversion with Newton
  iteration.

Discontinuous Galerkin and Discontinuous Petrov-Galerkin methods
----------------------------------------------------------------
- Added support Discontinuous Galerkin (DG) face integrators in parallel by
  extending ParMesh with information for face-neighboring processors. Added DG
  support in ParFiniteElementSpace, ParBilinearForm and ParGridFunction.

- Introduced a new class of integrators for forms defined on the faces of the
  mesh (including interior and boundary faces), mainly intended for hybrid
  methods like HDG and DPG that employ facet (numerical trace) spaces.

Block systems and rectangular operators
---------------------------------------
- Added classes BlockOperator, BlockVector and BlockMatrix for handling block
  systems with different components (e.g., pressure and velocity).

- New abstract class AbstractSparseMatrix, between Matrix and SparseMatrix

- Modified class Operator to have two separate sizes: "height" and "width" for
  the output and input sizes, respectively. The Size method was removed.

- For backward compatibility, the method Size is still present in the classes
  DenseMatrix (returns width as before), SparseMatrix (returns height as
  before), DenseMatrixInverse (square matrix) and BilinearForm (square matrix).

Linear and non-linear solvers
-----------------------------
- New abstract class Solver, with sub-classes for sparse smoothers, dense matrix
  inverse, iterative solvers (Krylov methods and Newton) and the hypre solvers.
  All Krylov methods were consolidated in linalg/solver.cpp and extended to work
  in parallel.

- Added several new classes of solvers and smoothers:
  * serial sparse direct solvers from the SuiteSparse library (UMFPACK)
  * HypreSmoother, giving access to the parallel ParCSR smoothers in hypre
  * polynomial smoothers: Chebyshev, Taubin and FIR
  * stationary linear iteration (SLI)
  * quadratic single linearly-constrained optimization problems with bounds

Miscellaneous
-------------
- Wrapped all classes/functions/objects in a namespace called "mfem".

- Automated the creation of quadrature rules to enable on-demand generation of
  arbitrary order rules for all geometries 1D/2D/3D geometries.

- Added support for saving collections of grid functions in format suitable for
  visualization with VisIt (visit.llnl.gov). See examples 5 and 9.

- Added support for 1D, surface and topologically periodic meshes, as well as a
  simple inline mesh format. See the data/ directory for examples.

- Added support for serial mesh optimization using the Mesquite mesh quality
  improvement toolkit (see mesh/mesquite.?pp and INSTALL for details).

- Made sure that MFEM can work in parallel with empty processors and with any
  MPI communicator.

- Improved high-order Bernstein basis support.

- Support for high-resolution timers (e.g. POSIX clocks).

- Improved error messages with several macros, such as MFEM_ABORT, MFEM_VERIFY,
  MFEM_ASSERT, MFEM_WARNING, etc.

- Improved portability for Windows (Visual Studio) and Mac OS X.

- Various simplifications, extensions, and bugfixes in the code.


Version 2.0, released on Nov 18, 2011
=====================================

Arbitrary order finite element spaces
-------------------------------------
- Added support for arbitrary high-order finite element spaces through the new
  classes H1_FECollection, L2_FECollection, RT_FECollection and ND_FECollection.
  These are based on a number of new FiniteElement sub-classes H1_*, L2_*, RT_*
  and ND_* elements of arbitrary order on all types of reference elements.

- The classes implement H1-conforming, L2-discontinuous, H(div)-conforming
  Raviart-Thomas and H(curl)-conforming Nedelec elements on triangular,
  quadrilateral, tetrahedral and hexahedral meshes. The only restriction on the
  order of the spaces is the availability of the required quadrature rules.

NURBS meshes and discretization spaces
--------------------------------------
- Added a collection of classes for serial and parallel meshes and
  discretization spaces using Non-uniform rational B-splines (NURBS) basis
  functions (files mesh/nurbs.?pp).

- The Mesh class supports the NURBS-specific refinement functions: KnotInsert
  and DegreeElevate. Example NURBS meshes can found in the 'data' directory with
  file names *-nurbs.mesh including an exact non-degenerate disc
  (disc-nurbs.mesh) and exact non-degenerate ball (ball-nurbs.mesh).

- We can handle arbitrary NURBS or standard, non-NURBS, finite element spaces on
  NURBS meshes. However, a NURBS finite element space requires an underlying
  NURBS mesh. Refinement of parallel NURBS meshes is not supported yet.

Discrete gradient, curl, etc. matrices
--------------------------------------
- Added a new class, DiscreteLinearOperator, that facilitates the construction
  of matrix representations for linear operators like gradient, curl, embedding,
  projection, etc. The corresponding local "interpolators" are similar to
  bilinear form integrators and derive from base class DiscreteInterpolator.
  Current interpolators include GradientInterpolator, IdentityInterpolator,
  CurlInterpolator and DivergenceInterpolator.

- Also available is a parallel version of DiscreteLinearOperator, which
  assembles parallel topological matrices (such as the discrete gradient, curl,
  etc.) in hypre's ParCSR format.

New integrators
---------------
- New linear (r.h.s.) integrator VectorFEBoundaryFluxLFIntegrator for
  assembling (u, v.n) on the boundary for scalar u and v in an RT space.

- New bilinear integrator VectorFECurlIntegrator for assembling (curl u, v) for
  u in a ND space and v in an RT space.

New and updated examples
------------------------
- Added a new serial/parallel Example code 4/4p, which solves a 2D or 3D H(Div)
  diffusion problem using the Raviart-Thomas finite elements. In parallel, the
  linear system is solved with the brand-new Auxiliary-space Divergence Solver
  (ADS) in hypre.

- Modified Example 1 to use isoparametric discretization (use the FE space from
  the mesh) including NURBS meshes and spaces.  Updated Example 2 to support
  arbitrary order spaces. Updated all examples to work with NURBS meshes and
  spaces, as well as to not use projection onto discontinuous polynomial spaces
  for visualization (this is now handled directly in GLVis when necessary).

- In all examples, switched to a uniform "solution" socket data type instead of
  the various previous "*_gf_data" data types.

- In the parallel examples, switched to parallel mesh and solution output, as
  well as to the new parallel socket format in place of PrintAsOne/SaveAsOne.

New hypre solvers
-----------------
- The parallel MFEM build now requires hypre 2.8.0b or newer.

- Extended HypreAMS and HypreADS to support (arbitrary) high-order ND/RT spaces,
  by internally constructing the high-order ParDiscreteLinearOperator gradient,
  curl and interpolation matrices. This makes the linear solve in Example 3p and
  4p significantly faster than before. Extended the HypreAMS object to also work
  for 2D H(div) problems.

Miscellaneous
-------------
- Added new class socketstream implementing two-way tcp/ip socket communications
  in the framework of C++ streams. Added new class socketserver implementing
  tcp/ip server functionality: listen on a given port for incoming connections,
  and accept them by assigning the new connection to a socketstream. These new
  classes are meant to replace the classes isockstream and osockstream. They
  allow MFEM code to update the mesh and solution via a single socket connection
  to a GLVis window.

- Added new Mesh and GridFunction constructors that combine multiple Mesh and
  GridFunction objects into one object. These are used in GLVis to visualize
  data saved in parallel. Removed obsolete code related to reading of parallel
  disjoint meshes.

- Added more quadrature rules on triangles and tetrahedra.

- Basic experimental OpenMP support (disabled by default). When enabled, OpenMP
  code is used for local matrix assembly, sparse matrix-vector product, and some
  vector operations.

- Added support for METIS 5.0 (not the default, see INSTALL).

- Various simplifications, extensions, and bugfixes in the code.


Version 1.2, released on Apr 08, 2011
=====================================

Parallel MPI-based version of the library based on hypre
--------------------------------------------------------
- New MPI parallel version of the library based on the ParCSR parallel matrix
  format from hypre and the metis graph partitioning library. This version
  supports parallel local refinement and parallel curved meshes, as well as
  several solvers from hypre.

New serial and parallel examples
--------------------------------
- Added a new example code describing an electromagnetic diffusion problem
  discretized with lowest order Nedelec finite elements (Example 3).

- Added parallel versions of all examples codes (files ex1p.cpp, ex2p.cpp and
  ex3p.cpp) based on hypre's BoomerAMG and AMS preconditioners.

Miscellaneous
-------------
- Added support for saving and reading linear and curved quadratic meshes in VTK
  format. The format is automatically recognized when opening a mesh file, and
  the boundary is reconstructed based on the actual domain boundary.

- The 'data' directory now contains a collection of various mesh files in the
  MFEM and VTK formats, including curved meshes and the mesh files that were
  previously in the 'examples' directory.

- Updated the default integration rule order for most of the linear form
  integrators.

- Added support for cubic hex elements.

- Bugfixes in the face orientation of 3D RT0 elements and in the VectorFEDomain
  linear form integrator.

- Various small fixes and styling updates.


Version 1.1, released on Sep 13, 2010
=====================================

New MFEM format for general meshes
----------------------------------
- New MFEM mesh v1.0 format with uniform structure for any dimension and support
  for curved meshes including in 3D.  Class Mesh will recognize and read the new
  format (in addition to all previously used formats) and Mesh::Print uses the
  new format by default. The old print function was renamed to Mesh::PrintXG.

New elasticity example
----------------------
- Added an example code for linear elasticity with (high-order) vector finite
  elements (Example 2).

Miscellaneous
-------------
- Added Mesh::PrintVTK and GridFunction::SaveVTK methods for output in VTK
  format.

- Implemented GeometryRefiner::Refine for CUBE and TETRAHEDRON geometries. This
  allows for saving curved meshes in the VTK format.

- Added SConstruct file for mfem/examples.

- Various small fixes and styling updates.


Version 1.0, released on Jul 21, 2010
=====================================

- Uploaded to http://mfem.googlecode.com.

- Initial release.
