-
Notifications
You must be signed in to change notification settings - Fork 0
/
CHANGELOG
1728 lines (1330 loc) · 82.8 KB
/
CHANGELOG
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
Finite Element Discretization Library
__
_ __ ___ / _| ___ _ __ ___
| '_ ` _ \ | |_ / _ \| '_ ` _ \
| | | | | || _|| __/| | | | | |
|_| |_| |_||_| \___||_| |_| |_|
http://mfem.org
Version 4.1.1 (development)
===========================
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.
- 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 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.
- 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.
- Added TMOP capability for approximate tangential mesh relaxation. Added
support and examples for using TMOP on mixed meshes.
- Added complete action of the TMOP Integrator to account for the spatial
derivatives of discrete and analytic targets.
- Added support for initialization 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.
Performance improvements
------------------------
- Added support for explicit vectorization in the high-performance templated
code, which can now take advantage of specific intrinsics classes on the
following architectures:
- x86 (SSE/AVX/AVX2/AVX512),
- Power8 & Power9 (VSX),
- BG/Q (QPX).
These are disabled by default, and can be enabled with MFEM_USE_SIMD=YES.
See the new file linalg/simd.hpp and the new directory linalg/simd.
Improved GPU capabilities
-------------------------
- Added support for Chebyshev accelerated polynomial smoother on GPU.
- Optimized AMD/HIP kernel support.
- Added a Full Assembly mode compatible with Device kernel execution. This
assembly level builds on top of the current 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.
- Added CUDA support for sparse matrix-vector multiplication with cuSPARSE.
- Added support for BlockOperator on GPU. See the updated Example 5.
- Added partial assembly and GPU support for complex operators, including the
classes ComplexOperator, [Par]ComplexGridFunction, [Par]ComplexLinearForm, and
[Par]SesquilinearForm. See the updated Example 22.
Discretization improvements
---------------------------
- 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.
- Added support for simplices in GSLIB-FindPoints.
- Added support for H1 and L2 element matrix assembly in the mass, convection,
diffusion, transpose, and the face DG trace integrators. This is compatible
with GPU device execution and is illustrated in Example 9/9p, see the option
'-ea'. When enabled, this level of assembly stores independent dense matrices
for the elements, and independent dense matrices for the faces in the DG case.
- Added new partial assembly kernels for H(div) bilinear forms, as well as
VectorFEDivergenceIntegrator.
- Improved the documentation of the GridFunction GetValue and GetVectorValue
methods. Expanded the GetValue and GetVectorValue methods which accept an
ElementTransformation argument to support evaluation on boundary elements
and, in the continuous field case, arbitrary mesh edges and faces.
- Added new coefficient and vector coefficient classes for QuadratureFunctions.
Additionally, new LinearForm integrators were also added which make use of
these new QuadratureFunction coefficient classes.
- Added support face integrals on the boundaries of NURBS meshes.
- Added support for interpolation of functions in L2, H(div) and H(curl)
spaces using GSLIB-FindPoints.
- 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.
Linear and nonlinear solvers
----------------------------
- Added power method to iteratively estimate the largest eigenvalue and the
corresponding eigenvector of an operator.
- Added initial support for h- and p-multigrid solvers and preconditioners for
matrix-based and matrix-free discretizations with basic GPU capability.
- Added a new IterativeSolverMonitor class that allows to monitor the residual
and solution during the solving process of an IterativeSolver after every
iteration.
- 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 below.
- 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.
- In SLISolver, changed the residual inner product from (Br,r) to (Br,Br) so the
solver can work with non-SPD preconditioner B.
- Added support for the SLEPc eigensolver package.
- Added partially assembled convergent diagonal preconditioner for adaptively
refined meshes (i.e. non-conforming finite element spaces), see Example 6/6p.
New and updated examples and miniapps
-------------------------------------
- Added a new example, Example 25/25p, to demonstrate the use of a Perfectly
Matched Layer (PML) for the simulation of electromagnetic wave propagation.
The example defines and solves several indefinite Maxwell problems.
- Added a new Example 26/26p to demonstrate the construction of a matrix-free
geometric and p-multigrid preconditioner for the Laplace problem.
- Added a new example, Example 27/27p, to demonstrate the enforcement of various
boundary conditions with the Laplace operator. The example shows the procedure
for applying Dirichlet, Neumann (both homogeneous and inhomogeneous), Robin,
and periodic boundary conditions with either H1 or DG discretizations.
- 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 a new miniapps/adjoint directory with two miniapps 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.
- Ported Example 11p to SLEPc, to demonstrate solving the Laplace eigenvalue
equation with the shift-and-invert spectral transformation method.
- Added a simple meshing miniapp, Twist, which demonstrates MFEM's strategy of
stitching together opposite surfaces of a mesh to create a topologically
periodic mesh.
- Added a new meshing miniapp, Minimal Surface, which solves Plateau's problem:
the Dirichlet problem for the minimal surface equation.
- Added a new meshing miniapp, Polar NC, which demonstrates the construction of
polar non-conforming meshes.
- Added partial assembly support to Example 4/4p and Example 5/5p, with diagonal
preconditioning.
- Added full assembly support in Example 9/9p.
- Added a new test problem in Example 24/24p, demonstrating a mixed bilinear
form for H1, H(curl), H(div) and L_2, with partial assembly support.
- Added weak Dirichlet boundary conditions (Nitsche) to the NURBS miniapp.
- Added a simple mesh editing miniapp, Trimmer, which trims away portions of a
mesh based on element attributes. Any newly exposed boundary elements are
assigned attribute numbers related to the trimmed element attributes.
- Added a new miniapp (field-interp) that demonstrates transfer of grid function
between different meshes using GSLIB-FindPoints.
- Added diagonal preconditioner in Example 6/6p for partial assembly with AMR.
- Added device support in Example 5/5p.
- Added partial assembly and device support to Example 22/22p, with diagonal
preconditioning.
- Added the option to plot a function in Mesh Explorer.
Improved testing
----------------
- Upgraded the Catch unit test framework from version 1.6.1 to version 2.13.0.
- 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 testing of the parallel mesh format in tests/par-mesh-format.
Miscellaneous
-------------
- Added support for ADIOS2 for parallel I/O with ParaView visualization. The
classes adios2stream and ADIOS2DataCollection are introduced in mfem as the
interfaces to generate ADIOS2 Binary Pack (BP4) directory datasets for the
entire spatial and temporal node data. Cell centered data is accessible by
ADIOS2 data readers (e.g. Python), but currently not yet implement as of
ParaView v5.8.1. In addition, ADIOS2 allows for setting a user-defined number
of data substreams/subfiles at scale. See examples 5, 9, 12, 16.
- The integration order used in the ComputeLpError and ComputeElementLpError
methods of class GridFunction has been increased.
- Various other simplifications, extensions, and bugfixes in the code.
- Renamed "Backend::DEBUG" to "Backend::DEBUG_DEVICE" to avoid conflicts,
as DEBUG is sometimes used as a macro.
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