initial commit

3 files changed, 2071 insertions, 0 deletions

diff --git a/.SRCINFO b/.SRCINFO
new file mode 100644
index 000000000000..65b326492d30
--- /dev/null
+++ b/.SRCINFO
@@ -0,0 +1,13 @@
+pkgbase = mfem
+	pkgdesc = Lightweight, general, scalable C++ library for finite element methods
+	pkgver = 4.3
+	pkgrel = 1
+	url = https://mfem.org
+	changelog = CHANGELOG
+	arch = x86_64
+	license = BSD
+	makedepends = cmake
+	source = mfem-4.3.tar.gz::https://github.com/mfem/mfem/archive/v4.3.tar.gz
+	sha256sums = b5f2b33997caeed653c0fadd353cdce596754f2883b5860ef7e5a370e33eeafd
+
+pkgname = mfem
diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 000000000000..f1f865fdebc7
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,2029 @@
+                    Finite Element Discretization Library
+                                   __
+                       _ __ ___   / _|  ___  _ __ ___
+                      | '_ ` _ \ | |_  / _ \| '_ ` _ \
+                      | | | | | ||  _||  __/| | | | | |
+                      |_| |_| |_||_|   \___||_| |_| |_|
+
+                               https://mfem.org
+
+
+Version 4.3, released on July 29, 2021
+======================================
+
+Discretization improvements
+---------------------------
+- Variable order spaces, p- and hp-refinement. This is the initial (serial)
+  support for variable-order FiniteElementCollection and FiniteElementSpace.
+  The new method FiniteElementSpace::SetElementOrder can be called to set an
+  arbitrary order for each mesh element. The conforming interpolation matrix
+  will now automatically constrain p- and hp- interfaces, enabling general
+  hp-refinement in both 2D and 3D, on uniform or mixed NC meshes. Support for
+  parallel variable-order spaces will follow shortly.
+
+- Extended the support for field transfer between high-order and low-order
+  refined finite element spaces to include: dual fields and H1 fields (both
+  primary and dual). These are illustrated in the lor-transfer miniapp.
+
+- Improved libCEED integration, including support for VectorCoefficient,
+  ConvectionIntegrator, and VectorConvectionNLFIntegrator with libCEED backends.
+
+- Extending support for L2 basis functions using MapTypes VALUE and INTEGRAL in
+  linear interpolators and GridFunction "GetValue" methods.
+
+- Changed the interface for the error estimator and implemented the Kelly error
+  indicator for scalar-valued problems, supported in serial and parallel builds.
+
+- Added support for the "BR2" discontinuous Galerkin discretization for
+  diffusion via DGDiffusionBR2Integrator (see Example 14/14p).
+
+- Added convective and skew-symmetric integrators for the nonlinear term in the
+  Navier-Stokes equations.
+
+- Added new classes DenseSymmetricMatrix and SymmetricMatrixCoefficient for
+  efficient evaluation of symmetric matrix coefficients. This replaces the now
+  deprecated EvalSymmetric in MatrixCoefficient. Added DiagonalMatrixCoefficient
+  for clarity, which is a typedef of VectorCoefficient.
+
+- Added support for nonscalar coefficient with VectorDiffusionIntegrator.
+
+Linear and nonlinear solvers
+----------------------------
+- Added support for AMG preconditioners on GPUs based on the hypre library
+  (version 2.22.0 or later). These include BoomerAMG, AMS and ADS and most
+  MFEM examples that use hypre have been ported to support this functionality.
+  The GPU preconditioners require that both hypre and MFEM are built with CUDA
+  support. Hypre builds with CUDA and unified memory are also supported and
+  can be used with `-d cuda:uvm` as a command-line option.
+
+- Added support for AMG preconditioners for non-symmetric systems (e.g.
+  advection-dominated problems) using hypre's approximate ideal restriction
+  (AIR) AMG. Requires hypre version 2.14.0 or newer. Usage is illustrated in
+  example 9/9p.
+
+- Added new functionality for constructing low-order refined discretizations and
+  solvers, see the LORDiscretization and LORSolver classes. A new basis type for
+  H(curl) and H(div) spaces is introduced to give spectral equivalence. This
+  functionality is illustrated in the LOR solvers miniapp in miniapps/solvers.
+
+- Generalized the Multigrid class to support non-geometric multigrid. Previous
+  functionality, based on FiniteElementSpaceHierarchy, is now available in the
+  derived class GeometricMultigrid.
+
+- Introduced solver interface for linear problems with constraints, a few
+  concrete solvers that implement the interface, and a demonstration of their
+  use in Example 28(p), which solves an elasticity problem with zero normal
+  displacement (but allowed tangential displacement) on two boundaries.
+
+- Added high-order matrix-free auxiliary Maxwell solver for H(curl) problems,
+  as described in Barker and Kolev 2020 (https://doi.org/10.1002/nla.2348). See
+  Example 3p and linalg/auxiliary.?pp.
+
+- Improved interface for using the Ginkgo library, including: support for matrix-
+  free operators in Ginkgo solvers, new wrappers for Ginkgo preconditioners, HIP
+  support, and reduction of unnecessary data copies.
+
+- Added initial support for hypre's mixed integer (mixedint) capability, which
+  uses different data types for local and global indices in order to save memory
+  in large problems. This capability requires that hypre was configured with the
+  --enable-mixedint option. Note that this option is currently tested only in
+  ex1p, ex3p, and ex4p, and may not work in more general settings.
+
+- Added AlgebraicCeedSolver that does matrix-free algebraic p-multigrid for
+  diffusion problems with the Ceed backend.
+
+- Added interface to MUMPS direct solver. Its usage is demonstrated in ex25p.
+  See http://mumps.enseeiht.fr/ for more details. Supported versions >= 5.1.1.
+
+- Added three ESDIRK time integrators: implicit trapezoid rule, L-stable
+  ESDIRK-32, and A-stable ESDIRK-33.
+
+- Implemented a variable step-size IMEX (VSSIMEX) method for the Navier miniapp.
+
+- Implemented an adaptive linear solver tolerance option for NewtonSolver based
+  on the algorithm of Eisenstat and Walker.
+
+Meshing improvements
+--------------------
+- Added support for reading high-order Lagrange meshes in VTK format. Arbitrary-
+  orders and all element types are supported. See the VTK blog for more info:
+  https://blog.kitware.com/wp-content/uploads/2018/09/Source_Issue_43.pdf.
+
+- Introduced a new non-conforming mesh format that fixes known inconsistencies
+  of legacy "MFEM mesh v1.1" NC format and works consistently in both serial and
+  parallel. ParMesh::ParPrint can now print non-conforming AMR meshes that can
+  be used to restart a parallel AMR computation. Example 6p has been extended to
+  demonstrate restarting from a previously saved checkpoint. Note that parallel
+  NC data files are compatible with serial code, e.g., can be viewed with serial
+  GLVis. Loading of legacy NC mesh files is still supported.
+
+- Added FMS support (https://github.com/CEED/FMS) to mfem. FMS can represent
+  unstructured high-order meshes with general high-order finite element fields
+  on them. When enabled, mfem can convert data collections to/from FMS data
+  collections in memory. In addition, an FMS data collection class was added so
+  the convert-dc miniapp can read and generate data files in FMS format.
+
+- Added new mesh quality metrics and improved the untangling capabilities of the
+  TMOP-based mesh optimization algorithms.
+
+- The TMOP mesh optimization algorithms were extended to GPU:
+  * QualityMetric 1, 2, 7, 77 are available in 2D, 302, 303, 315, 321 in 3D
+  * Both AnalyticAdaptTC and DiscreteAdaptTC TargetConstructor are available
+  * Kernels for normalization and limiting have been added
+  * The AdvectorCG now also supports AssemblyLevel::PARTIAL
+
+- Added support for creating refined meshes for all element types (e.g. by
+  splitting high-order elements into low-order refined elements), including
+  mixed meshes. The LOR Transfer miniapp (miniapps/tools/lor-transfer.cpp) now
+  supports meshes with any element geometry.
+
+- Meshes consisting of any type of elements (including mixed meshes) can be
+  converted to all-simplex meshes using Mesh::MakeSimplicial.
+
+- Several of the mesh constructors (creating Cartesian meshes, refined (LOR)
+  meshes, simplex meshes, etc.) are now available as "named constructors", e.g.
+  Mesh::MakeCartesian2D or Mesh::MakeRefined. The legacy constructors are marked
+  as deprecated.
+
+- Added support for creating periodic meshes with Mesh::MakePeriodic. The
+  requisite periodic vertex mappings can be created with
+  Mesh::CreatePeriodicVertexMapping.
+
+- Added support for 1D non-conforming meshes (which can be useful for parallel
+  load balancing and derefinement).
+
+- Added sample meshes in the `data` subdirectory showing the reference elements
+  of the six currently supported element types; ref-segment.mesh,
+  ref-triangle.mesh, ref-square.mesh, ref-tetrahedron.mesh, ref-cube.mesh, and
+  ref-prism.mesh.
+
+High-performance computing
+--------------------------
+- Added initial support for GPU-accelerated versions of PETSc that works with
+  MFEM_USE_CUDA if PETSc has been configured with CUDA support. Examples 1 and 9
+  in the examples/petsc directory have been modified to work with --device cuda.
+  Examples with GAMG (ex1p) and SLEPc (ex11p) are also provided.
+
+- Added support for explicit vectorization in the high-performance templated
+  code for Fujitsu's A64FX ARM microprocessor architecture.
+
+- Added support for different modes of QuadratureInterpolator on GPU.
+  The layout (QVectorLayout::byNODES|byVDIM) and the tensor products modes can
+  be enabled before calling the Mult, Values, Derivatives, PhysDerivatives and
+  Determinants methods.
+
+- Added method Device::SetMemoryTypes that can be used to change the default
+  host and device MemoryTypes before Device setup.
+
+- In class MemoryManager, added methods GetDualMemoryType and SetDualMemoryType;
+  dual MemoryTypes are used to determine the second MemoryType (host or device)
+  when only one MemoryType is specified in methods of class Memory.
+
+- Added Memory constructor for setting both the host and device MemoryTypes.
+
+- Switched the default behavior of device memory allocations so that they are
+  deferred until the device pointer is needed.
+
+- Added a second Umpire device MemoryType, DEVICE_UMPIRE_2, with corresponding
+  allocator that can be set with the method SetUmpireDevice2AllocatorName.
+
+- Added HOST_PINNED MemoryType and a pinned host allocator for CUDA and HIP.
+
+- Added matrix-free GPU-enabled implementations of GradientInterpolator and
+  IdentityInterpolator.
+
+New and updated examples and miniapps
+-------------------------------------
+- Added a new, very simple example (ex0 and parallel version ex0p). This example
+  solves a simple Poisson problem using H1 elements (the same problem as ex1),
+  but is intended to be extremely simple and approachable for new users.
+
+- Added new miniapps demonstrating: 1) the use of GSLIB for overlapping grids,
+  see gslib/schwarz_ex1, and 2) coupling different physics in different domains,
+  see navier/cht. Note that gslib v1.0.7 is require (see INSTALL for details).
+
+- Added a new miniapp for computing (signed) distance functions to a point
+  source or zero level set. See miniapps/shifted/distance.cpp.
+
+- Added a high-order extension of the shifted boundary method to solve PDEs on
+  non body-fitted meshes. This is illustrated in the new Shifted Diffusion
+  miniapp, see miniapps/shifted/diffusion.cpp.
+
+- Added new miniapp directory mtop/ with optimization-oriented block parametric
+  non-linear form and abstract integrators. Two new miniapps, ParHeat and
+  SeqHeat, demonstrate parallel and sequential implementation of gradients
+  evaluation for linear diffusion with discrete density.
+
+- Added a new miniapp block-solvers that compares the performance of various
+  solvers for mixed finite element discretization of the second order scalar
+  elliptic equations. Currently available solvers in the miniapp include a
+  block-diagonal preconditioner that is based on approximate Schur complement
+  (implemented in ex5p), and a newly implemented solver DivFreeSolver, which
+  exploits a multilevel decomposition of the Raviart-Thomas space and its
+  divergence-free subspace. See the miniapps/solvers directory for more details.
+
+- Introduced new options for the mesh-explorer miniapp to visualize the actual
+  element attributes in parallel meshes while retaining the visualization of the
+  domain decomposition.
+
+- Added partial assembly and device support to Example 25/25p, with diagonal
+  preconditioning.
+
+- Implemented a filter method for the Navier miniapp to stabilize highly
+  turbulent flows in direct numerical simulation.
+
+Improved testing
+----------------
+- Transitioned from Travis to GitHub Action for testing/CI on GitHub.
+
+- Use Spack (and Uberenv) to automate TPL building in LLNL GitLab tests.
+
+- Extended `make test` to include GPU tests when MFEM is built with CUDA or HIP
+  support.
+
+- Added a set of suggested git hooks for developers in config/githooks.
+
+- Added support for Caliper: a library to integrate performance profiling
+  capabilities into applications. See examples/caliper for more details.
+
+- Added a new command line boolean option (`--all`) to the unit tests to launch
+  *all* non-regression tests.
+
+- Upgraded the Catch unit test framework from version 2.13.0 to version 2.13.2.
+
+Miscellaneous
+-------------
+- The following integrations have updated minimum version requirements:
+  * CUDA >= 10.1.168
+  * Ginkgo >= 1.4.0
+  * GSLIB >= 1.0.7
+  * HIOP >= 0.4
+  * HYPRE >= 2.20.0 for mixedint support
+  * HYPRE >= 2.22.0 for CUDA support
+  * libCEED >= 0.8
+  * PETSc >= 3.15.0 for CUDA support
+  * RAJA >= 0.13.0
+  see INSTALL for more details.
+
+- Added a "scaled Jacobian" visualization option in the Mesh Explorer miniapp to
+  help identify elements with poor mesh quality.
+
+- Added support for reading VTK meshes in XML format.
+
+- Added makefile rule to generate TAGS table for vi or Emacs users.
+
+- Added HIP support to the CMake build system.
+
+- Various other simplifications, extensions, and bugfixes in the code.
+
+API changes
+-----------
+- Added an abstract interface `mfem::FaceRestriction` for `H1FaceRestriction`
+  and `L2FaceRestriction`.
+  In order to conform with the semantic of `MultTranspose` in `mfem::Operator`,
+  `mfem::FaceRestriction::MultTranspose` now sets instead of adding values, and
+  `mfem::FaceRestriction::AddMultTranspose` should replace previous calls to
+  `mfem::FaceRestriction::MultTranspose`.
+
+
+Version 4.2, released on October 30, 2020
+=========================================
+
+High-performance computing
+--------------------------
+- Added support for explicit vectorization in the high-performance templated
+  code, which can now take advantage of specific classes on the following
+  architectures:
+  * x86 (SSE/AVX/AVX2/AVX512),
+  * Power8 & Power9 (VSX),
+  * BG/Q (QPX).
+  These are disabled by default, but can be enabled with MFEM_USE_SIMD=YES.
+  See the new file linalg/simd.hpp and the new directory linalg/simd.
+
+- Added an Element Assembly mode compatible with GPU device execution for H1 and
+  L2 spaces in the mass, convection, diffusion, transpose, and the face DG trace
+  integrators. See option '-ea' in Example 9. When enabled, this assembly level
+  stores independent dense matrices for the elements, and independent dense
+  matrices for the faces in the DG case.
+
+- Added a Full Assembly mode compatible with GPU device execution. This assembly
+  level builds on top of the Element Assembly kernels to compute a global sparse
+  matrix. All integrators supported by element assembly are also supported by
+  full assembly. See the '-fa' option in Example 9.
+
+- Optimized the AMD/HIP kernel support and enabled HIP support in the libCEED
+  integration. This is now available via the "ceed-hip" device backend.
+
+- Improved the libCEED integration to support:
+  * AssemblyLevel::NONE for Mass, Diffusion, VectorMass, and VectorDiffusion
+    Integrators. This level computes the full operator evaluation "on the fly".
+  * VectorMassIntegrator and VectorDiffusionIntegrator.
+  * All types of (scalar) Coefficients.
+
+- Added partial assembly / device support for:
+  * H(div) bilinear forms and VectorFEDivergenceIntegrator.
+  * BlockOperator, see the updated Example 5.
+  * Complex operators, see the updated Example 22.
+  * Chebyshev accelerated polynomial smoother.
+  * Convergent diagonal preconditioning on non-conforming adaptively refined
+    meshes, see Example 6/6p.
+
+- Added CUDA support for:
+  * Sparse matrix-vector multiplication with cuSPARSE,
+  * SUNDIALS ODE integrators, see updated SUNDIALS modification of Example 9/9p.
+
+Linear and nonlinear solvers
+----------------------------
+- Added a new solver class for simple integration with NVIDIA's multigrid
+  library, AmgX. The AmgX class is designed to work as a standalone solver or
+  preconditioner for existing MFEM solvers. It uses MFEM's sparse matrix format
+  for serial runs and the HypreParMatrix format for parallel runs. The new
+  solver may be configured to run with one GPU per MPI rank or with more MPI
+  ranks than GPUs. In the latter case, matrices and vectors are consolidated to
+  ranks communicating with the GPUs and the solution is then broadcasted.
+
+  Although CUDA is required to build, the AmgX support is compatible with the
+  MFEM CPU device configuration. The examples/amgx folder illustrates how to
+  integrate AmgX in existing MFEM applications. The AmgX solver class is
+  partially based on: "AmgXWrapper: An interface between PETSc and the NVIDIA
+  AmgX library", by Pi-Yueh Chuang and Lorena A. Barba, doi:10.21105/joss.00280.
+
+- Added initial support for geometric h- and p-multigrid preconditioners for
+  matrix-based and matrix-free discretizations with basic GPU capability, see
+  Example 26/26p.
+
+- Added support for the CVODES package in SUNDIALS which provides ODE solvers
+  with sensitivity analysis capabilities. See the CVODESSolver class and the new
+  adjoint miniapps in the miniapps/adjoint directory.
+
+- Added an interface to the MKL CPardiso solver, an MPI-parallel sparse direct
+  solver developed by Intel. See Example 11p for an illustration of its usage.
+
+- Added support for the SLEPc eigensolver package, https://slepc.upv.es.
+
+- Upgraded SuperLU interface to use SuperLU_DIST 6.3.1. Added a simple SuperLU
+  example in the new directory examples/superlu.
+
+- Extended the KINSOL (SUNDIALS) nonlinear solver interface to support the
+  Jacobian-free Newton-Krylov method. A usage example is shown in Example 10p.
+
+- Block arrays of parallel matrices can now be merged into a single parallel
+  matrix with the function HypreParMatrixFromBlocks. This could be useful for
+  solving block systems with parallel direct solvers such as STRUMPACK.
+
+- Added wrappers for hypre's flexible GMRES solver and the new parallel ILU
+  preconditioner. The latter requires hypre version 2.19.0 or later.
+
+Discretization improvements
+---------------------------
+- Extended GSLIB-FindPoints integration to support simplices and interpolation
+  of functions from L2, H(div) and H(curl) spaces.
+
+- Added support for computing asymptotic error estimates and convergence rates
+  for the whole de Rham sequence based on the new class ConvergenceStudy and new
+  member methods in GridFunction and ParGridFunction. See the rates.cpp file in
+  the tests/convergence directory for sample usage.
+
+- Extended the GetValue and GetVectorValue methods of GridFunction to support
+  evaluation on boundary elements and, in the continuous field case, arbitrary
+  mesh edges and faces. This requires passing an ElementTransformation argument.
+
+- Added support for matrix-free interpolation and restriction operators between
+  continuous H1 finite element spaces of different order on the same mesh or
+  with the same order on uniformly refined meshes.
+
+- The Coefficient classes based on a C-function pointer (FunctionCoefficient,
+  VectorFunctionCoefficient and MatrixFunctionCoefficient) now use the more
+  general std::function class template. This allows the classes to be backward
+  compatible (i.e. they can still work with C-functions) and, in addition,
+  support any "callable", e.g. lambda functions.
+
+- Non-conforming meshes are now supported with block nonlinear forms. See the
+  updated Example 19/19p.
+
+Meshing improvements
+--------------------
+- The graph linear ordering library Gecko, previously an external dependency, is
+  now included directly in MFEM. As a result, Mesh::GetGeckoElementOrdering is
+  always available. The interface has also been improved, see for example the
+  Mesh Explorer miniapp.
+
+- Added support for finite difference-based gradient and Hessian approximation
+  in the TMOP mesh optimization algorithms. This improves the accuracy of the
+  Hessian for r-adaptivity using discrete fields, and allows use of skewness
+  and orientation based metrics.
+
+- Improved Gmsh reader (version 2.2), which now supports both high-order and
+  periodic meshes. Segments, triangles, quadrilaterals, and tetrahedra are
+  supported up to order 10. Wedges and hexahedra are supported up to order 9.
+  For sample periodic meshes, see the periodic*.msh files in the data directory.
+
+- Added support for construction of (serial) non-conforming meshes. Hanging
+  nodes can be marked with Mesh::AddVertexParents when building the mesh with
+  the "init" constructor. The usage is demonstrated in a new meshing miniapp,
+  Polar NC, which generates meshes that are non-conforming from the start.
+
+- Added support for r-adaptivity with more than one discrete field. This allows
+  the user to specify different discrete functions for controlling the size,
+  aspect-ratio, orientation, and skew of elements in the mesh.
+
+- Additional TMOP improvements:
+  * Capability for approximate tangential mesh relaxation.
+  * Support and examples for using TMOP on mixed meshes.
+  * Complete integrator action accounting for spatial derivatives of discrete
+    and analytic targets.
+
+New and updated examples and miniapps
+-------------------------------------
+- Added a new miniapp, Navier, that solves the time-dependent Navier-Stokes
+  equations of incompressible fluid dynamics. See the miniapps/navier directory
+  for more details.
+
+- Added 10 new example codes:
+  * Example 25/25p demonstrates the use of a Perfectly Matched Layer (PML) for
+    electromagnetic wave propagation (indefinite Maxwell).
+  * Example 26/26p shows how to construct matrix-free geometric and p-multigrid
+    preconditioner for the Laplace problem.
+  * Example 27/27p demonstrates the enforcement of Dirichlet, Neumann, Robin,
+    and periodic boundary conditions with either H1 or DG Laplace problems.
+  * Versions of Example 1/1p in examples/amgx demonstrating the use of AmgX,
+    to solve the Laplace problem with AMG preconditioning on GPUs.
+  * A version of Example 11p in examples/petsc demonstrating the use of SLEPc,
+    to solve the Laplace eigenproblem with shift-and-invert transformation.
+  * A version of Example 1 in examples/superlu demonstrating the use of SuperLU
+    to solve the Laplace problem.
+
+- Added a new Field Interpolation miniapp in miniapps/gslib that demonstrates
+  transfer of grid functions between different meshes using GSLIB-FindPoints.
+
+- Added 2 miniapps in the new miniapps/adjoint directory demonstrating how to
+  solve adjoint problems in MFEM using the CVODES package in SUNDIALS. Both of
+  these miniapps require the MFEM_USE_SUNDIALS configuration option.
+  * The cvsRoberts_ASAi_dns miniapp solves a backward adjoint problem for a
+    system of ODEs, evaluating both forward and adjoint quadratures in serial.
+  * The adjoint_advection_diffusion miniapp solves a backward adjoint problem
+    for an advection diffusion PDE, evaluating adjoint quadratures in parallel.
+
+- Added 4 additional meshing miniapps:
+  * The Minimal Surface miniapp solves Plateau's problem: the Dirichlet problem
+    for the minimal surface equation.
+  * The Twist miniapp demonstrates how to stitch together opposite surfaces of a
+    mesh to create a topologically periodic mesh.
+  * The Trimmer miniapp trims away parts of a mesh based on element attributes.
+  * Polar NC shows the construction of polar non-conforming meshes.
+
+- Several examples and miniapps were updated to include:
+  * Full and element assembly support in Example 9/9p.
+  * Partial assembly with diagonal preconditioning in Examples 4/4p/5/5p/22/22p.
+  * Diagonal preconditioner in Example 6/6p for partial assembly with AMR.
+  * The option to plot a function in Mesh Explorer.
+  * A new test problem showing a mixed bilinear form for H1, H(curl), H(div) and
+    L2, with partial assembly support in Example 24/24p.
+  * Weak Dirichlet boundary conditions (Nitsche) to the NURBS miniapp.
+
+Data management and visualization
+---------------------------------
+- Added support for ADIOS2 for parallel I/O with ParaView visualization. See
+  Examples 5, 9, 12, 16. The classes adios2stream and ADIOS2DataCollection
+  provide the interface to generate ADIOS2 Binary Pack (BP4) directory datasets.
+
+- Added VTU output of boundary elements and attributes and parallel VTU (PVTU)
+  output of parallel meshes for visualization using ParaView.
+
+Improved testing
+----------------
+- Added a GitLab pipeline that automates PR testing on supercomputing systems
+  and Linux clusters at Lawrence Livermore National Lab (LLNL). This can be
+  triggered only by LLNL developers, see .gitlab-ci.yml, the .gitlab directory
+  and the updated CONTRIBUTING.md file.
+
+- Added additional testing for convergence, the parallel mesh I/O, and for the
+  libCEED integration in MFEM in the tests/ directory.
+
+- Upgraded the Catch unit test framework from version 1.6.1 to version 2.13.0.
+
+Miscellaneous
+-------------
+- Renamed "Backend::DEBUG" to "Backend::DEBUG_DEVICE" to avoid conflicts,
+  as DEBUG is sometimes used as a macro.
+
+- Added a new IterativeSolverMonitor class that allows to monitor the residual
+  and solution with an IterativeSolver after every iteration.
+
+- Added power method to iteratively estimate the largest eigenvalue and the
+  corresponding eigenvector of an operator.
+
+- Added support for face integrals on the boundaries of NURBS meshes.
+
+- In SLISolver, changed the residual inner product from (Br,r) to (Br,Br) so the
+  solver can work with non-SPD preconditioner B.
+
+- Added new coefficient and vector coefficient classes for QuadratureFunctions,
+  with new LinearForm integrators which use them.
+
+- The integration order used in the ComputeLpError and ComputeElementLpError
+  methods of class GridFunction has been increased.
+
+- Change the IntegrationRule inside VectorDiffusionIntegrator to use the same
+  quadrature as DiffusionIntegrator.
+
+- The README.html files previously included in several source directories have
+  been removed. Use the corresponding pages at mfem.org instead.
+
+- Various other simplifications, extensions, and bugfixes in the code.
+
+
+Version 4.1, released on March 10, 2020
+=======================================
+
+Starting with this version, the MFEM open source license is changed to BSD-3.
+
+Improved GPU capabilities
+-------------------------
+- Added initial support for AMD GPUs based on HIP: a C++ runtime API and kernel
+  language that can run on both AMD and NVIDIA hardware.
+
+- Added support for Umpire, a resource management library that allows the
+  discovery, provision, and management of memory on machines with multiple
+  memory devices like NUMA and GPUs, see https://github.com/LLNL/Umpire.
+
+- GPU acceleration is now available in 3 additional examples: 3, 9 and 24.
+
+- Improved RAJA backend and multi-GPU MPI communications.
+
+- Added a "debug" device designed specifically to aid in debugging GPU code by
+  following the "device" code path (using separate host/device memory spaces and
+  host <-> device transfers) without any GPU hardware.
+
+- Added support for matrix-free diagonal smoothers on GPUs.
+
+- The current list of available device backends is: "ceed-cuda", "occa-cuda",
+  "raja-cuda", "cuda", "hip", "debug", "occa-omp", "raja-omp", "omp",
+  "ceed-cpu", "occa-cpu", "raja-cpu", and "cpu".
+
+- The MFEM memory manager now supports different memory types, associated with
+  the following memory backends:
+  * Default host memory, using standard C++ new and delete,
+  * CUDA pointers, using cudaMalloc and HIP pointers, using hipMalloc,
+  * Managed CUDA/HIP memory (UVM), using cudaMallocManaged/hipMallocManaged,
+  * Umpire-managed memory, including memory pools,
+  * 32- or 64-byte aligned memory, using posix_memalign (WIN32 also supported),
+  * Debug memory with mmap/mprotect protection used by the new "debug" device.
+
+libCEED support
+---------------
+- Added support for libCEED, the portable library for high-order operator
+  evaluation developed by the Center for Efficient Exascale Discretizations in
+  the Exascale Computing Project, https://github.com/CEED/libCEED.
+
+- This initial integration includes Mass and Diffusion integrators. libCEED GPU
+  backends can be used without specific MFEM configuration, however it is highly
+  recommended to use the "cuda" build option to minimize memory transfers.
+
+- Both CPU and GPU modes are available as MFEM device backends (ceed-cpu and
+  ceed-cuda), using some of the best performing CPU and GPU backends from
+  libCEED, see the sample runs in examples 1 and 6.
+
+- NOTE: The current default libCEED GPU backend (ceed-cuda) uses atomics and
+  therefore is non-deterministic.
+
+Partial assembly and matrix-free discretizations
+------------------------------------------------
+- The support for matrix-free methods on both CPU and GPU devices based on a
+  partially assembled operator decomposition was extended to include:
+  * DG integrators, (for now only in the Gauss-Lobatto basis), see Example 9,
+  * H(curl) bilinear forms, see Example 3,
+  * vector mass and vector diffusion bilinear integrators,
+  * convection integrator with improved performance,
+  * gradient and vector divergence integrators for Stokes problems,
+  * initial partial assembly mode for NonlinearForms.
+
+- Diagonals of partially assembled operators can now be computed efficiently.
+  See the new methods AssembleDiagonal in BilinearForm, AssembleDiagonalPA in
+  BilinearFormIntegrator and the implementations in fem/bilininteg_*.cpp.
+
+- In many examples, the partial assembly algorithms provide significantly
+  improved performance, particularly in high-order 3D runs on GPUs.
+
+Meshing improvements
+--------------------
+- The algorithms for mesh element numbering were changed to have significantly
+  better caching and parallel partitioning properties. Both initial (see e.g.
+  Mesh::GetHilbertElementOrdering) and ordering after uniform refinement were
+  improved. NOTE: new ordering can have a round-off effect on solver results.
+
+- Added support for non-conforming AMR on both prisms and tetrahedra, including
+  coarsening and parallel load balancing. Anisotropic prism refinement is only
+  available in the serial version at the moment.
+
+- The TMOP mesh optimization algorithms were extended to support r-adaptivity.
+  Target matrices can now be constructed either via a given analytical function
+  (e.g. spatial dependence of size, aspect ratio, etc., for each element) or via
+  a (Par)GridFunction specified on the original mesh.
+
+- The TMOP algorithms were also improved to support non-conforming AMR meshes.
+
+- Added support for creating refined versions of periodic meshes, making use of
+  the new L2ElementRestriction class. This class also allows for computing
+  geometric factors on periodic meshes using partial assembly.
+
+Discretization improvements
+---------------------------
+- Added support for GSLIB-FindPoints, a general high-order interpolation utility
+  that can robustly evaluate a GridFunction in an arbitrary collection of points
+  in physical space. See INSTALL for details on building MFEM with GSLIB, and
+  miniapps/gslib for examples of how to use this feature.
+
+- Added support for complex-valued finite element operators and fields using a
+  2x2 block structured linear system to mimic complex arithmetic. New classes
+  include: ComplexGridFunction, SesquilinearForm, ComplexLinearForm, and their
+  parallel counterparts.
+
+- Added second order derivatives of NURBS shape functions.
+
+- Added support for serendipity elements of arbitrary order on affinely-mapped
+  square elements. Basis functions for these elements can be visualized using
+  an option in the display-basis miniapp.
+
+- Two integrators related to Stokes problems, (Q grad u, v) and (Q div v, u),
+  where u and the components of v are in H1, were added/modified to support full
+  and partial assembly modes. See the new GradientIntegrator and the updated
+  VectorDivergenceIntegrator classes in fem/bilininteg.hpp, as well as the PA
+  kernels in fem/bilininteg_gradient.cpp and fem/bilininteg_divergence.cpp.
+
+- Added a nonlinear vector valued convection integrator (Q u \cdot grad u, v)
+  where u_i and v_i are in H1. This form occurs e.g. in the Navier-Stokes
+  equations. The integrator supports the partial assembly mode for its
+  action. In full assembly mode we also provide the GetGradient method that
+  computes the linearized version of the integrator.
+
+- Added a new method, MixedBilinearForm::FormRectangularLinearSystem, that can
+  be used to impose boundary conditions on the non-square off-diagonal blocks of
+  a block operator (similar to FormLinearSystem in the square case).
+
+Linear and nonlinear solvers
+----------------------------
+- Added support for Ginkgo, a high-performance linear algebra library for GPU
+  and manycore nodes, with a focus on sparse solution of linear systems. For
+  more details see linalg/ginkgo.hpp and the example code in examples/gingko.
+
+- Added support for HiOp, a lightweight HPC solver for nonlinear optimization
+  problems, see class HiOpNLPOptimizer and the example codes in examples/hiop.
+
+- Added a general interface for specifying and solving nonlinear constrained
+  optimization problems through the new classes OptimizationProblem and
+  OptimizationSolver, see linalg/solver.hpp.
+
+- Added a block ILU(0) preconditioner for DG-type discretizations. Example 9
+  (DG advection) now takes advantage of this for implicit time integration.
+
+- New time integrators: Adams-Bashforth, Adams-Moulton and several integrators
+  for 2nd order ODEs, see the new Example 23.
+
+- Added a LinearSolve(A,X) convenience method to solve dense linear systems. In
+  the trivial cases, i.e., square matrices of size 1 or 2, the system is solved
+  directly, otherwise, LU factorization is employed.
+
+New and updated examples and miniapps
+-------------------------------------
+- Added a collection of 7 playful miniapps in miniapps/toys that illustrate the
+  meshing and visualization features of the library in more relaxed settings.
+  The toys include simulations of cellular automata, Rubik's cube, Mandelbrot
+  set, a tool to convert any image to mfem mesh, and more.
+
+- Added 8 new example codes:
+  * Example 22/22p demonstrates the use of the new complex-valued finite element
+    operators by defining and solving a family of time-harmonic PDEs related to
+    damped harmonic oscillators.
+  * Example 23 solves a simple 2D/3D wave equation with the new second order
+    time integrators.
+  * Example 24/24p demonstrates usage of mixed finite element spaces in bilinear
+    forms. Partial assembly is supported in this example.
+  * A version of Example 1 in examples/ginkgo demonstrating the use of the
+    Gingko interface to solve a linear system.
+  * A version of Example 9/9p in examples/hiop demonstrating the nonlinear
+    constrained optimization interface and use of the SLBQP and HiOp solvers.
+
+- Added two new miniapps: Find Points and Field Diff in miniapps/gslib that show
+  how GSLIB-FindPoints can be used to interpolate a (Par) GridFunction in an
+  arbitrary number of physical space points in 2D and 3D. The GridFunction must
+  be in H1 and in the same space as the mesh that is used to find the points.
+
+- Added a simple miniapp, Get Values, that extracts field values at a set of
+  points, from previously saved data via DataCollection classes.
+
+- Several examples and miniapps were updated:
+  * Added device support in Example 3/3p and Example 9/9p.
+  * Example 1/1p and Example 3/3p now use diagonal preconditioning in partial
+    assembly mode.
+  * Example 9/9p now supports implicit time integration, using the new block
+    ILU(0) solvers as preconditioners for the linear system.
+  * The mesh-optimizer and pmesh-optimizer miniapps now include the new
+    r-adaptivity capabilities of TMOP. They were also updated to support mesh
+    optimization on non-conforming AMR meshes.
+  * New options to reorder and partition the mesh and boundary attribute
+    visualization (key 'b') are now available in the mesh-explorer miniapp.
+
+- Collected object files from the miniapps/common directory into a new library,
+  libmfem-common for the convenience of application developers. The new library
+  is now used in several miniapps in the electromagnetic and tools directories.
+
+Improved testing
+----------------
+- Added a large number of unit tests in the tests/unit directory, including
+  several parallel unit tests.
+
+- Added a new directory, tests/scripts, with several shell scripts that perform
+  simple checks on the code including: code styling, documentation formatting,
+  proper use of .gitignore, and preventing the accidental commit of large files.
+
+- It is recommended that developers run the above tests scripts (via the runtest
+  script) before pushing to GitHub. See the README file in tests/scripts.
+
+- The Travis CI settings have been updated to include an initial Checks stage
+  which currently runs the code-style, documentation and gitignore test scripts,
+  as well as a final stage for optional checks/tests which currently runs the
+  branch-history script.
+
+Miscellaneous
+-------------
+- Added support for output in the ParaView XML format. Both low-order and
+  high-order Lagrange elements are supported. Output can be in ASCII or binary
+  format. The binary output can be compressed if MFEM is compiled with zlib
+  support (MFEM_USE_ZLIB). See the new ParaViewDataCollection class and the
+  updated Examples 5/5p and 9/9p.
+
+- Upgraded the SUNDIALS interface to utilize SUNDIALS 5.0. This necessitated a
+  complete rework of the interface and requires changes at the application
+  level. Example usage of the new interface can be found in examples/sundials.
+
+- Switched from gzstream to zstr for the implementation of zlib-compressed C++
+  output stream. The build system definition now uses MFEM_USE_ZLIB instead of
+  MFEM_USE_GZSTREAM, but the code interface (e.g. ofgzstream) remains the same.
+
+- Various other simplifications, extensions, and bugfixes in the code.
+
+API changes
+-----------
+- In the enum classes MemoryType and MemoryClass, "CUDA" was renamed to "DEVICE"
+  which now denotes either "CUDA" or "HIP" depending on the build configuration.
+  In the same enum classes, "CUDA_UVM" was renamed to "MANAGED".
+
+
+Version 4.0, released on May 24, 2019
+=====================================
+
+Unlike previous MFEM releases, this version requires a C++11 compiler.
+
+GPU support
+-----------
+- Added initial support for hardware devices, such as GPUs, and programming
+  models, such as CUDA, OCCA, RAJA and OpenMP.
+
+- The GPU/device support is based on MFEM's new backends and kernels working
+  seamlessly with a new lightweight device/host memory manager. The kernels can
+  be implemented either in OCCA, or as a simple wrapper around for-loops, which
+  can then be dispatched to RAJA and native backends. See the files forall.hpp
+  and mem_manager.hpp in the general/ directory for more details.
+
+- Several of the MFEM example codes (ex1, ex1p, ex6, and ex6p) can now take
+  advantage of GPU acceleration with the backend selectable at runtime. Many of
+  the linear algebra and finite element operations (e.g. partially assembled
+  bilinear forms) have been extended to take advantage of kernel acceleration by
+  simply replacing loops with the MFEM_FORALL() macro.
+
+- In addition to native CUDA kernels, the library currently supports OCCA, RAJA
+  and OpenMP kernels, which could be mixed and matched in different parts of the
+  same application. We plan on adding support for more programming models and
+  devices in the future, without the need for significant modifications in user
+  code. The list of current backends is: "occa-cuda", "raja-cuda", "cuda",
+  "occa-omp", "raja-omp", "omp", "occa-cpu", "raja-cpu", and "cpu".
+
+- GPU-related limitations:
+  * Hypre preconditioners are not yet available in GPU mode, and in particular
+    hypre must be built in CPU mode.
+  * Only constant coefficients are currently supported on GPUs.
+  * Optimized element assembly, and matrix-free bilinear forms are not
+    implemented yet. Element batching is currently ignored.
+  * In device mode, full assembly is performed on the host (but the matvec
+    action is performed on the device).
+  * Partial assembly kernels are not implemented yet for simplices.
+
+Discretization improvements
+---------------------------
+- Partial assembled finite element operators are now available in the core
+  library, based on the new classes PABilinearFormExtension, ElementRestriction,
+  DofToQuad and GeometricFactors (associated with the classes BilinearForm,
+  FiniteElementSpace, FiniteElement and Mesh, respectively). The kernels for
+  partial assembled Setup/Assembly and Action/Mult are implemented in the
+  BilinearFormIntegrator methods AssemblePA and AddMultPA.
+
+- Added support for a general "low-order refined"-to-"high-order" transfer of
+  GridFunction data from a "low-order refined" (LOR) space defined on a refined
+  mesh to a "high-order" (HO) finite element space defined on a coarse mesh. See
+  the new classes InterpolationGridTransfer and L2ProjectionGridTransfer and the
+  new LOR Transfer miniapp: miniapps/tools/lor-transfer.cpp.
+
+- Added element flux, and flux energy computation in class ElasticityIntegrator,
+  allowing for the use of Zienkiewicz-Zhu type error estimators with the
+  integrator. For an illustration of this addition, see the new Example 21.
+
+- Added support for derefinement of vector (RT + ND) spaces.
+
+- Added a variety of coefficients which are sums or products of existing
+  coefficients as well as grid function coefficients which return the
+  divergence, gradient, or curl of their GridFunctions.
+
+Support for wedge elements and meshes with mixed element types
+--------------------------------------------------------------
+- Added support for wedge-shaped mesh elements of arbitrary order (with Geometry
+  type PRISM) which have two triangular faces and three quadrilateral faces.
+  Several examples of such meshes can be found in the data/ directory.
+
+- Added support for mixed meshes containing triangles and quadrilaterals in 2D
+  or tetrahedra, wedges, and hexahedra in 3D. This includes support for uniform
+  refinement of such meshes. Several examples of such meshes can be found in the
+  data/ directory.
+
+- Added H1 and L2 finite elements of arbitrary order for Wedge elements.
+
+- Added support for reading and writing linear and quadratic meshes containing
+  wedge elements in VTK mesh format. Several examples of such meshes can be
+  found in the data/ directory.
+
+Other meshing improvements
+--------------------------
+- Improved the uniform refinement of tetrahedral meshes (also part of the
+  uniform refinement of mixed 3D meshes). The previous refinement algorithm is
+  still available as an option in Mesh::UniformRefinement. Both can be used in
+  the updated Mesh Explorer miniapp.
+
+- The local tetrahedral mesh refinement algorithm in serial and in parallel now
+  follows precisely the paper:
+
+     D. Arnold, A. Mukherjee, and L. Pouly, "Locally Adapted Tetrahedral Meshes
+     Using Bisection", SIAM J. Sci. Comput. 22 (2000), 431-448.
+
+  This guarantees that the shape regularity of the elements will be preserved
+  under refinement.
+
+- The TMOP mesh optimization algorithms were extended to support user-defined
+  space-dependent limiting terms. Improved the TMOP objective functions by more
+  accurate normalization of the different terms.
+
+- Added support for parallel communication groups on non-conforming meshes.
+
+- Improved parallel partitioning of non-conforming meshes. If the coarse mesh
+  elements are ordered as a sequence of face-neighbors, the parallel partitions
+  are now guaranteed to be continuous. To that end, inline quadrilateral and
+  hexahedral meshes are now by default ordered along a space-filling curve.
+
+- A boundary in a NURBS mesh can now be connected with another boundary. Such a
+  periodic NURBS mesh is a simple way to impose periodic boundary conditions.
+
+- Added support for reading linear and quadratic 2D quadrilateral and triangular
+  Cubit meshes.
+
+New and updated examples and miniapps
+-------------------------------------
+- Added a new meshing miniapp, Toroid, which can produce a variety of torus
+  shaped meshes by twisting a stack of wedges or hexahedra.
+
+- Added a new meshing miniapp, Extruder, that demonstrates the capability to
+  produce 3D meshes by extruding 2D meshes.
+
+- Added a simple miniapp, LOR Transfer, for visualizing the actions of the
+  transfer operators between a high-order and a low-order refined spaces.
+
+- Added a new example, Example 20/20p, that solves a system of 1D ODEs derived
+  from a Hamiltonian. The example demonstrates the use of the variable order,
+  symplectic integration algorithm implemented in class SIAVSolver.
+
+- Added a new example, Example 21/21p, that illustrates the use of AMR to solve
+  a linear elasticity problem. This is an extension of Example 2/2p.
+
+New and improved solvers and preconditioners
+--------------------------------------------
+- Added support for parallel ILU preconditioning via hypre's Euclid solver.
+
+- Added support for STRUMPACK v3 with a small API change in the class
+  STRUMPACKSolver, see "API changes" below.
+
+Miscellaneous
+-------------
+- Added unit tests based on the Catch++ library in the test/ directory.
+
+- Renamed the option MFEM_USE_OPENMP to MFEM_USE_LEGACY_OPENMP. This legacy
+  option is deprecated and planned for removal in a future release. The original
+  option name, MFEM_USE_OPENMP, is now used to enable the new OpenMP backends in
+  the new kernels.
+
+- In SparseMatrix added the option to perform MultTranspose() by matvec with
+  computed and stored transpose matrix. This is required for deterministic
+  results when using devices such as CUDA and OpenMP.
+
+- Altered the way FGMRES counts its iterations so that it matches GMRES.
+
+- Various other simplifications, extensions, and bugfixes in the code.
+
+- Construct abstract parallel rectangular truedof-to-truedof operators via
+  Operator::FormDiscreteOperator().
+
+API changes
+-----------
+- In multiple places, use Geometry::Type instead of int, where appropriate.
+- In multiple places, use Element::Type instead of int, where appropriate.
+- The Mesh methods GetElementBaseGeometry and GetBdrElementBaseGeometry no
+  longer have a default value for their parameter, they only work with an
+  explicitly given index.
+- In class Mesh, added methods useful for queries regarding the types of
+  elements present in the mesh: HasGeometry, GetNumGeometries, GetGeometries,
+  and class Mesh::GeometryList.
+- The struct CoarseFineTransformations (returned by the Mesh method
+  GetRefinementTransforms) now stores the embedding matrices separately for each
+  Geometry::Type.
+- In class ParMesh, replaced the method GroupNFaces with two new methods:
+  GroupNTriangles and GroupNQuadrilaterals. Also, replaced GroupFace with two
+  methods: GroupTriangle and GroupQuadrilateral.
+- In class ParMesh, made the two RefineGroups methods protected.
+- Removed the virtual method Element::GetRefinementFlag, it is only used by the
+  derived class Tetrahedron.
+- Added new methods: Array::CopyTo, Tetrahedron::Init.
+- In class STRUMPACKSolver, the method SetMC64Job() was replaced by the new
+  methods: DisableMatching(), EnableMatching(), and EnableParallelMatching().
+
+
+Version 3.4, released on May 29, 2018
+=====================================
+
+More general and efficient mesh adaptivity
+------------------------------------------
+- Added support for PUMI, the Parallel Unstructured Mesh Infrastructure from
+  https://scorec.rpi.edu/pumi. PUMI is an unstructured, distributed mesh data
+  management system that is capable of handling general non-manifold models and
+  effectively supports automated adaptive analysis. PUMI enables for the first
+  time support for parallel unstructured modifications of MFEM meshes.
+
+- Significantly reduced MPI communication in the construction of the parallel
+  prolongation matrix in ParFiniteElementSpace, for much improved parallel
+  scaling of non-conforming AMR on hundreds of thousands of MPI tasks. The
+  memory footprint of the ParNCMesh class has also been reduced.
+
+- In FiniteElementSpace, the fully assembled refinement matrix is now replaced
+  by default by a specialized refinement operator. The operator option is both
+  faster and more memory efficient than using the fully assembled matrix. The
+  old approach is still available and can be enabled, if needed, using the new
+  method FiniteElementSpace::SetUpdateOperatorType().
+
+Discretization improvements
+---------------------------
+- Added support for a general "high-order"-to-"low-order refined" transfer of
+  GridFunction and true-dof data from a "high-order" finite element space
+  defined on a coarse mesh, to a "low-order refined" space defined on a refined
+  mesh. The new methods, GetTransferOperator and GetTrueTransferOperator in the
+  FiniteElementSpace classes, work in both serial and parallel and support
+  matrix-based as well as matrix-free transfer operator representations. They
+  use a new method, GetTransferMatrix, in the FiniteElement class similar to
+  GetLocalInterpolation, that allows the coarse FiniteElement to be different
+  from the fine FiniteElement.
+
+- Added class ComplexOperator, that implements the action of a complex operator
+  through the equivalent 2x2 real formulation. Both symmetric and antisymmetric
+  block structures are supported.
+
+- Added classes for general block nonlinear finite element operators (deriving
+  from BlockNonlinearForm and ParBlockNonlinearForm) enabling solution of
+  nonlinear systems with multiple unknowns in different function spaces. Such
+  operators have assemble-based action and also support assembly of the gradient
+  operator to enable inversion with Newton iteration.
+
+- Added variable order NURBS: for each space each knot vector in the mesh can
+  have a different order. The order information is now part of the finite
+  element space header in the NURBS mesh output, so NURBS meshes in the old
+  format need to be updated.
+
+- In the classes NonlinearForm and ParNonlinearForm, added support for
+  non-conforming AMR meshes; see also the "API changes" section.
+
+- New specialized time integrators: symplectic integrators of orders 1-4 for
+  systems of first order ODEs derived from a Hamiltonian and generalized-alpha
+  ODE solver for the filtered Navier-Stokes equations with stabilization. See
+  classes SIASolver and GeneralizedAlphaSolver in linalg/ode.hpp.
+
+- Inherit finite element classes from the new base class TensorBasisElement,
+  whenever the basis can be represented by a tensor product of 1D bases.
+
+- Added support for elimination of boundary conditions in block matrices.
+
+New and updated examples and miniapps
+-------------------------------------
+- Added a new serial and parallel example (ex19) that solves the quasi-static
+  incompressible hyperelastic equations. The example demonstrates the use of
+  block nonlinear forms as well as custom block preconditioners.
+
+- Added a new serial example (ex23) to demonstrate the use of second order
+  time integration to solve the wave equation.
+
+- Added a new electromagnetics miniapp, Maxwell, for simulating time-domain
+  electromagnetics phenomena as a coupled first order system of equations.
+
+- A simple local refinement option has been added to the mesh-explorer miniapp
+  (menu option 'r', sub-option 'l') that selects elements for refinement based
+  on their spatial location - see the function 'region()' in the source file.
+
+- Added a set of miniapps specifically focused on Isogeometric Analysis (IGA) on
+  NURBS meshes in the miniapps/nurbs directory. Currently the directory contains
+  variable order NURBS versions of examples 1, 1p and 11p.
+
+- Added PUMI versions of examples ex1, ex1p, ex2 and ex6p in a new examples/pumi
+  directory. The new examples demonstrate the PUMI APIs for parallel and serial
+  mesh loading (ex1 and ex1p), applying BCs using classification (ex2), and
+  performing parallel mesh adaptation (ex6p).
+
+- Added two new miniapps related to DataCollection I/O in miniapps/tools:
+  load-dc.cpp can be used to visualize fields saved via DataCollection classes;
+  convert-dc.cpp demonstrates how to convert between MFEM's different concrete
+  DataCollection options.
+
+- Example 10p with its SUNDIALS and PETSc versions have been updated to reflect
+  the change in the behavior of the method ParNonlinearForm::GetLocalGradient()
+  (see the "API changes" section) and now works correctly on non-conforming AMR
+  meshes. Example 10 and its SUNDIALS version have also been updated to support
+  non-conforming ARM meshes.
+
+Miscellaneous
+-------------
+- Documented project workflow and provided contribution guidelines in the new
+  top-level file, CONTRIBUTING.md.
+
+- Added (optional) Conduit Mesh Blueprint support of MFEM data for both in-core
+  and I/O use cases. This includes a new ConduitDataCollection that provides
+  json, simple binary, and HDF5-based I/O. Support requires Conduit >= v0.3.1
+  and VisIt >= v2.13.1 will read the new Data Collection outputs.
+
+- Added a new developer tool, config/sample-runs.sh, that extracts the sample
+  runs from all examples and miniapps and runs them. Optionally, it can save the
+  output from the execution to files, allowing comparison between different
+  versions and builds of the library.
+
+- Support for building a shared version of the MFEM library with GNU make.
+
+- Added a build option, MFEM_USE_EXCEPTIONS=YES, to throw an exception instead
+  of calling abort on mfem errors.
+
+- When building with the GnuTLS library, switch to using X.509 certificates for
+  secure socket authentication. Support for the previously used OpenPGP keys has
+  been deprecated in GnuTLS 3.5.x and removed in 3.6.0. For secure communication
+  with the visualization tool GLVis, a new set of certificates can be generated
+  using the latest version of the script 'glvis-keygen.sh' from GLVis.
+
+- Upgraded MFEM to support Axom 0.2.8. Prior versions are no longer supported.
+
+API changes
+-----------
+- Introduced a new enum, Matrix::DiagonalPolicy, that replaces the integer
+  parameters in many methods that perform elimination of rows and/or columns in
+  matrices. Some examples of such methods are:
+  * class SparseMatrix: EliminateRow(), EliminateCol(), EliminateRowCol(), ...
+  * class BilinearForm: EliminateEssentialBC(), EliminateVDofs(), ...
+  * class StaticCondensation: EliminateReducedTrueDofs()
+  * class BlockMatrix: EliminateRowCol()
+  Calling these methods with an explicitly given (integer) constants, will now
+  generate compilation errors, please use one of the new enum constants instead.
+
+- Modified the virtual method AbstractSparseMatrix::EliminateZeroRows() and its
+  implementations in derived classes, to accept an optional 'threshold'
+  parameter, replacing previously hard-coded threshold values.
+
+- In the classes NonlinearForm and ParNonlinearForm:
+  * The method GetLocalGradient() no longer imposes boundary conditions. The
+    motivation for the change is that, in the case of non-conforming AMR,
+    performing the elimination at the local level is incorrect - it must be
+    applied at the true-dof level.
+  * The method SetEssentialVDofs() is now deprecated.
+
+
+Version 3.3.2, released on Nov 10, 2017
+=======================================
+
+High-order mesh optimization
+----------------------------
+- Added support for mesh optimization via node-movement based on the Target-
+  Matrix Optimization Paradigm (TMOP) developed by P.Knupp et al. A variety of
+  mesh quality metrics, with their first and second derivatives have been
+  implemented. The combination of targets & quality metrics is used to optimize
+  the physical node positions, i.e., they must be as close as possible to the
+  shape, size and/or alignment of their targets. The optimization of arbitrary
+  high-order meshes in 2D, 3D, serial and parallel is supported.
+
+- The new Mesh Optimizer miniapp can be used to perform mesh optimization with
+  TMOP in serial and parallel versions. The miniapp also demonstrates the use of
+  nonlinear operators and their coupling to Newton methods for solving
+  minimization problems.
+
+New and improved solvers and preconditioners
+--------------------------------------------
+- MFEM is now included in the xSDK project, the Extreme-scale Scientific
+  Software Development Kit, as of xSDK-0.3.0. Various changes were made to
+  comply with xSDK's community policies, https://xsdk.info/policies, including:
+  xSDK-specific options in CMake, support for user-provided MPI communicators,
+  runtime API for version number, and the ability to disable/redirect output.
+  For more details, see general/globals.hpp and in particular the mfem::err and
+  mfem::out streams replacing std::err and std::out respectively.
+
+- Added (optional) support for the STRUMPACK parallel sparse direct solver and
+  preconditioner. STRUMPACK uses Hierarchically Semi-Separable (HSS) compression
+  in a fully algebraic manner, with interface similar to SuperLU_DIST. See
+  http://portal.nersc.gov/project/sparse/strumpack for more details.
+
+- Added a block lower triangular preconditioner based (only) on the actions of
+  each block, see class BlockLowerTriangularPreconditioner.
+
+- Added an optional operator in LOBPCG to projects vectors onto a desired
+  subspace (e.g. divergence-free). Other small changes in LOBPCG include the
+  ability to set the starting vectors and support for relative tolerance.
+
+- The Newton solver supports an optional scaling factor, that can limit the
+  increment in the Newton step, see e.g. the Mesh Optimizer miniapp.
+
+- Updated MFEM integration to support the new SUNDIALS 3.0.0 interface.
+
+New and updated examples and miniapps
+-------------------------------------
+- Added a new serial and parallel example (ex18) that solves the transient Euler
+  equations on a periodic domain with explicit time integrators. In the process
+  extended the NonlinearForm class to allow for integrals over faces and
+  exchanging face-neighbor data in parallel.
+
+- Added a new meshing miniapp, Shaper, that can be used to resolve complicated
+  material interfaces by mesh refinement, e.g. as a tool for initial mesh
+  generation from prescribed "material()" function. Both conforming and
+  non-conforming (isotropic and anisotropic) refinements are supported.
+
+- Added a new meshing miniapp, Mesh Optimizer, that demonstrates the use of TMOP
+  for mesh optimization (serial and parallel version.)
+
+- Added SUNDIALS version of Example 16/16p.
+
+Discretization improvements
+---------------------------
+- Added a FindPoints method of the Mesh and ParMesh classes that returns the
+  elements that contain a given set of points, together with the coordinates of
+  the points in the reference space of the corresponding element. In parallel,
+  if a point is shared by multiple processors, only one of them will mark that
+  point as found. Note that the current implementation of this method is not
+  optimal and/or 100% reliable. See the mesh-explorer miniapp for an example.
+
+- Added a new class InverseElementTransformation, that supports a number of
+  algorithms for inversion of general ElementTransformations. This class can be
+  used as a more flexible and extensible alternative to ElementTransformation's
+  TransformBack method. It is also used in the FindPoints methods as a tunable
+  and customizable inversion algorithm.
+
+- Memory optimizations in the NCMesh class, which now uses 50% less memory than
+  before. The average cost of an element in a uniformly refined mesh (including
+  the refinement hierarchy, but excluding the temporary face_list and edge_list)
+  is now only about 290 bytes. This also makes the class faster.
+
+- Added the ability to integrate delta functions on the right-hand side (by
+  sampling the test function at the center of the delta coefficient). Currently
+  this is supported in the DomainLFIntegrator, VectorDomainLFIntegrator and
+  VectorFEDomainLFIntegrator classes.
+
+- Added five new linear interpolators in fem/bilininteg.cpp to compute products
+  of scalar and vector fields or products with arbitrary coefficients.
+
+- Added matrix coefficient support to CurlCurlIntegrator.
+
+- Extend the method NodalFiniteElement::Project for VectorCoefficient to work
+  with arbitrary number of vector components.
+
+Miscellaneous
+-------------
+- Added a .gitignore file that ignores all files erased by "make distclean",
+  i.e. the files that can be generated from the source but we don't want to
+  track in the repository, as well as a few platform-specific files.
+
+- Added Linux, Mac and Windows CI testing on GitHub with Travis CI and Appveyor.
+
+- Added a new macro, MFEM_VERSION, defined as a single integer of the form
+  (major*100 + minor)*100 + patch. The convention is that an even number
+  (i.e. even patch number) denotes a "release" version, while an odd number
+  denotes a "development" version. See config/config.hpp.in.
+
+- Added an option for building in parallel without a METIS dependency. This is
+  used for example the Laghos miniapp, https://github.com/CEED/Laghos.
+
+- Modified the installation layout: all headers, except the master headers
+  (mfem.hpp and mfem-performance.hpp), are installed in <PREFIX>/include/mfem;
+  the master headers are installed in both <PREFIX>/include/mfem and in
+  <PREFIX>/include. The mfem configuration and testing makefiles (config.mk and
+  test.mk) are installed in <PREFIX>/share/mfem, instead of <PREFIX>.
+
+- Add three more options for MFEM_TIMER_TYPE.
+
+- Support independent number of digits for cycle and rank in DataCollection.
+
+- Converted Sidre usage from "asctoolkit" to "axom" namespace.
+
+- Various small fixes and styling updates.
+
+API changes
+-----------
+- The methods GetCoeff of VectorArrayCoefficient and MatrixArrayCoefficient now
+  return a pointer to Coefficient (instead of reference). Note that NULL pointer
+  is a valid entry for these two classes - it is treated as the zero function.
+
+- When building with PETSc, the required PETSc version is now 3.8.0. Newer
+  versions may work too, as long as there are no interface changes in PETSc.
+
+- The class GeometryRefiner now uses the enum in Quadrature1D for its type
+  specification. In particular, this will affect older versions of GLVis. A
+  simple upgrade to the latest version of GLVis should resolve this issue.
+
+
+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 axom project (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://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.
diff --git a/PKGBUILD b/PKGBUILD
new file mode 100644
index 000000000000..3596dcb21aa6
--- /dev/null
+++ b/PKGBUILD
@@ -0,0 +1,29 @@
+# Maintainer: Luis Martinez <luis dot martinez at disroot dot org>
+
+pkgname=mfem
+pkgver=4.3
+pkgrel=1
+pkgdesc="Lightweight, general, scalable C++ library for finite element methods"
+arch=('x86_64')
+url="https://mfem.org"
+license=('BSD')
+makedepends=('cmake')
+changelog=CHANGELOG
+source=("$pkgname-$pkgver.tar.gz::https://github.com/mfem/mfem/archive/v$pkgver.tar.gz")
+sha256sums=('b5f2b33997caeed653c0fadd353cdce596754f2883b5860ef7e5a370e33eeafd')
+
+build() {
+	cmake \
+		-DCMAKE_INSTALL_PREFIX=/usr \
+		-Wno-dev \
+		-B build \
+		-S "$pkgname-$pkgver"
+	make -C build
+}
+
+package() {
+	make -C build install DESTDIR="$pkgdir/"
+	cd "$pkgname-$pkgver"
+	install -Dm 644 LICENSE -t "$pkgdir/usr/share/licenses/$pkgname/"
+	install -Dm 644 README NOTICE -t "$pkgdir/usr/share/doc/$pkgname/"
+}