diff options
| author | Luis Martinez | 2021-08-09 12:24:38 -0500 |
|---|---|---|
| committer | Luis Martinez | 2021-08-09 12:50:42 -0500 |
| commit | 098606feff49a3128323c5d827ce73e6dcaf7747 (patch) | |
| tree | 0ca9b4c9b32257c52b9c4cc1be81fede1764ed4f | |
| download | aur-098606feff49a3128323c5d827ce73e6dcaf7747.tar.gz | |
initial commit
| -rw-r--r-- | .SRCINFO | 13 | ||||
| -rw-r--r-- | CHANGELOG | 2029 | ||||
| -rw-r--r-- | PKGBUILD | 29 |
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/" +} |