Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev

# Conflicts: # fem/bilininteg.hpp # fem/coefficient.cpp # fem/coefficient.hpp # linalg/hypre.cpp # linalg/hypre.hpp # linalg/solvers.cpp # makefile # miniapps/common/pfem_extras.hpp # miniapps/electromagnetics/tesla_solver.hpp
2025-03-13 17:43:24 -07:00 · 2019-04-01 11:27:41 -07:00 · 2018-11-08 18:00:03 -08:00 · 2018-10-20 12:18:07 -07:00 · 2018-10-20 12:17:00 -07:00 · 2018-10-18 13:07:44 -07:00
471 changed files with 18227 additions and 53312 deletions
@@ -1,154 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: Sanitizer Config
-description: Sets up environment variables for MFEM sanitizer workflow
-
-inputs:
-  DEBUG:
-    description: If true, use intermediate caches to speed up the workflow
-                 by reusing previous builds.
-    default: false
-
-  REPOSITORY:
-    description: Repository to checkout
-    default: mfem/mfem
-
-  BRANCH:
-    description: Branch to checkout
-    default: ubsan
-
-  CLANG_VER:
-    description: CLANG version to use
-    default: 18
-
-  # https://github.com/llvm/llvm-project/releases
-  LLVM_VER:
-    description: LLVM version to use
-    default: 19.1.7
-
-  # https://github.com/hypre-space/hypre/releases
-  HYPRE_VER:
-    description: HYPRE version to use
-    default: 2.19.0
-
-  METIS_VER:
-    description: METIS version to use
-    default: 4.0.3
-
-  CTEST:
-    description: CTest command to use
-    default: ctest -j --test-load $(nproc)
-                      --schedule-random
-                      --stop-on-failure --output-on-failure
-                      --test-dir
-
-  # https://clang.llvm.org/docs/AddressSanitizer.html
-  ASAN_OPTIONS:
-    default: detect_leaks=1,
-             strict_init_order=1,
-             strict_string_checks=1,
-             check_initialization_order=1,
-             detect_stack_use_after_return=1
-  ASAN_CXXFLAGS:
-    default: -fsanitize=address
-             -fsanitize-address-use-after-scope
-  ASAN_LDFLAGS:
-    default: -fsanitize=address
-
-  # https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
-  UBSAN_OPTIONS:
-    default: halt_on_error=1, print_stacktrace=1
-  UBSAN_CXXFLAGS:
-    default: -fsanitize=undefined
-  UBSAN_LDFLAGS:
-    default: -fsanitize=undefined
-
-  # https://clang.llvm.org/docs/MemorySanitizer.html
-  MSAN_OPTIONS:
-    default: "poison_in_dtor=1"
-  MSAN_CXXFLAGS:
-    default: -fsanitize=memory
-             -fsanitize-memory-track-origins
-             -fsanitize-memory-use-after-dtor
-  MSAN_LDFLAGS:
-    default: -fsanitize=memory
-
-  LSAN_DIR:
-    description: LSAN suppression directory
-    default: lsan
-
-  LSAN_FILE:
-    description: LSAN suppression file
-    default: lsan.supp
-
-  NO_FLAGS:
-    description: If true, do not set any CXXFLAGS or LDFLAGS.
-    default: false
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Env (Inputs)
-      run: |
-        echo DEBUG=${{inputs.DEBUG}} >> $GITHUB_ENV
-        echo REPOSITORY=${{inputs.REPOSITORY}} >> $GITHUB_ENV
-        echo BRANCH=${{inputs.BRANCH}} >> $GITHUB_ENV
-        echo CLANG_VER=${{inputs.CLANG_VER}} >> $GITHUB_ENV
-        echo LLVM_VER=${{inputs.LLVM_VER}} >> $GITHUB_ENV
-        echo HYPRE_VER=${{inputs.HYPRE_VER}} >> $GITHUB_ENV
-        echo METIS_VER=${{inputs.METIS_VER}} >> $GITHUB_ENV
-        echo CTEST=${{inputs.CTEST}} >> $GITHUB_ENV
-        echo ASAN_OPTIONS=${{inputs.ASAN_OPTIONS}} >> $GITHUB_ENV
-        echo UBSAN_OPTIONS=${{inputs.UBSAN_OPTIONS}} >> $GITHUB_ENV
-        echo MSAN_OPTIONS=${{inputs.MSAN_OPTIONS}} >> $GITHUB_ENV
-        echo LSAN_DIR=${{inputs.LSAN_DIR}} >> $GITHUB_ENV
-        echo LSAN_FILE=${{inputs.LSAN_FILE}} >> $GITHUB_ENV
-        echo ASAN_CXXFLAGS=${{inputs.ASAN_CXXFLAGS}} >> $GITHUB_ENV
-        echo ASAN_LDFLAGS=${{inputs.ASAN_LDFLAGS}} >> $GITHUB_ENV
-        echo UBSAN_CXXFLAGS=${{inputs.UBSAN_CXXFLAGS}} >> $GITHUB_ENV
-        echo UBSAN_LDFLAGS=${{inputs.UBSAN_LDFLAGS}} >> $GITHUB_ENV
-        echo MSAN_CXXFLAGS=${{inputs.MSAN_CXXFLAGS}} >> $GITHUB_ENV
-        echo MSAN_LDFLAGS=${{inputs.MSAN_LDFLAGS}} >> $GITHUB_ENV
-      shell: bash
-
-    - name: Env (dir)
-      run: |
-        echo LLVM_DIR=${{github.workspace}}/llvm >> $GITHUB_ENV
-        echo HYPRE_DIR=hypre-${{inputs.HYPRE_VER}} >> $GITHUB_ENV
-        echo METIS_DIR=metis-${{inputs.METIS_VER}} >> $GITHUB_ENV
-      shell: bash
-
-    - name: Env (bis)
-      run: |
-        echo CC=clang-${{inputs.CLANG_VER}} >> $GITHUB_ENV
-        echo CXX=clang++-${{inputs.CLANG_VER}} >> $GITHUB_ENV
-        echo LLVM_INC=${{env.LLVM_DIR}}/include/c++/v1 >> $GITHUB_ENV
-        echo LLVM_LIB=${{env.LLVM_DIR}}/lib >> $GITHUB_ENV
-        echo HYPRE_TGZ=v${{inputs.HYPRE_VER}}.tar.gz >> $GITHUB_ENV
-        echo METIS_TGZ=metis-${{inputs.METIS_VER}}.tar.gz >> $GITHUB_ENV
-        LSAN_SUPPRESSIONS="${{github.workspace}}/${{inputs.LSAN_DIR}}/${{inputs.LSAN_FILE}}"
-        echo "LSAN_OPTIONS=suppressions=$LSAN_SUPPRESSIONS" >> $GITHUB_ENV
-      shell: bash
-
-    - name: Env (ter)
-      if: ${{ inputs.NO_FLAGS != 'true' }}
-      run: |
-        echo LLVM_CXXFLAGS=-stdlib=libc++ -I${{env.LLVM_INC}} -Isystem${{env.LLVM_INC}} >> $GITHUB_ENV
-        echo LLVM_LDFLAGS=-L${{env.LLVM_LIB}} -lc++abi -Wl,-rpath,${{env.LLVM_LIB}} >> $GITHUB_ENV
-      shell: bash
-
-    - name: Env (quater)
-      if: ${{ inputs.NO_FLAGS != 'true' }}
-      run: |
-        echo CXXFLAGS=${{env.LLVM_CXXFLAGS}} >> $GITHUB_ENV
-        echo LDFLAGS=${{env.LLVM_LDFLAGS}} >> $GITHUB_ENV
-      shell: bash
@@ -1,91 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: 'MFEM Compilation'
-description: 'MFEM Compilation'
-
-inputs:
-  par:
-    description: 'Whether to build for parallel (true/false)'
-    default: false
-  sanitizer:
-    description: 'Sanitizer to use (asan, msan, ubsan)'
-    default: asan
-
-runs:
-  using: 'composite'
-  steps:
-    - uses: ./.github/actions/sanitize/config
-
-    - uses: actions/cache@v4
-      if: ${{env.DEBUG == 'true'}}
-      id: debug
-      with:
-        path: mfem/build
-        key: build-${{inputs.par}}-${{inputs.sanitizer}}
-
-    - uses: ./.github/actions/sanitize/setup
-      if: ${{steps.debug.outputs.cache-hit != 'true'}}
-      with:
-        par: ${{inputs.par}}
-        sanitizer: ${{inputs.sanitizer}}
-
-    - name: Build with ASAN
-      if: inputs.sanitizer == 'asan'
-      run: echo CXXFLAGS=${{env.CXXFLAGS}} ${{env.ASAN_CXXFLAGS}} >> $GITHUB_ENV
-      shell: bash
-
-    - name: Build with MSAN
-      if: inputs.sanitizer == 'msan'
-      run: echo CXXFLAGS=${{env.CXXFLAGS}} ${{env.MSAN_CXXFLAGS}} >> $GITHUB_ENV
-      shell: bash
-
-    - name: Build with UBSAN
-      if: inputs.sanitizer == 'ubsan'
-      run: echo CXXFLAGS=${{env.CXXFLAGS}} ${{env.UBSAN_CXXFLAGS}} >> $GITHUB_ENV
-      shell: bash
-
-    - uses: mfem/github-actions/build-mfem@v2.5
-      if: ${{steps.debug.outputs.cache-hit != 'true'}}
-      env:
-        CXXFLAGS: ${{env.CXXFLAGS}}
-        LDFLAGS: ${{env.LDFLAGS}}
-      with:
-        mpi: ${{inputs.par == 'false' && 'seq' || 'par'}}
-        mfem-dir: mfem
-        os: ${{runner.os}}
-        library-only: true
-        build-system: cmake
-        hypre-dir: ${{env.HYPRE_DIR}}
-        metis-dir: ${{env.METIS_DIR}}
-        config-options: >-
-          -GNinja
-          -DMPICXX=${{env.CXX}}
-          -DCMAKE_CXX_STANDARD=17
-          -DMFEM_USE_MEMALLOC=OFF
-          -DCMAKE_BUILD_TYPE=Release
-          -DCMAKE_VERBOSE_MAKEFILE=ON
-          -DCMAKE_CXX_COMPILER=${{env.CXX}}
-          -DCMAKE_CXX_FLAGS_RELEASE='-g -O1 -fno-omit-frame-pointer'
-
-    - name: Delete object files
-      if: ${{steps.debug.outputs.cache-hit != 'true'}}
-      working-directory: mfem/build
-      run: find . -type f -name '*.o' -delete
-      shell: bash
-
-    - uses: actions/upload-artifact@v4
-      with:
-        name: build-${{inputs.par}}-${{inputs.sanitizer}}
-        path: mfem/build
-        if-no-files-found: error
-        retention-days: 1
-        overwrite: false
@@ -1,33 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: 'Install MPI'
-description: 'Installs MPI and set up its environment variables'
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Install
-      run: sudo apt-get install openmpi-bin libopenmpi-dev
-      shell: bash
-
-    - name: Env
-      run: |
-        echo PRTE_MCA_rmaps_default_mapping_policy=:oversubscribe >> $GITHUB_ENV
-        echo MPI_INC=$(mpicxx --showme:compile) >> $GITHUB_ENV
-        echo MPI_LIB=$(mpicxx --showme:link) >> $GITHUB_ENV
-      shell: bash
-
-    - name: Env (bis)
-      run: |
-        echo CXXFLAGS=${{env.CXXFLAGS}} ${{env.MPI_INC}} >> $GITHUB_ENV
-        echo LDFLAGS=${{env.LDFLAGS}} ${{env.MPI_LIB}} >> $GITHUB_ENV
-      shell: bash
@@ -1,71 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: 'Restore state'
-description: 'Restore state to be able to run checks, tests'
-
-inputs:
-  par:
-    description: 'Whether to build for parallel (true/false)'
-    default: false
-  sanitizer:
-    description: 'Sanitizer to use (asan, msan, ubsan)'
-    default: asan
-  cache-path:
-    description: 'path to what needs to be restored'
-    default: none
-  cache-skip:
-    description: 'Skip cache restoration'
-    default: false
-
-outputs:
-  cache-hit:
-    description: 'Output from a specific step'
-    value: ${{steps.debug.outputs.cache-hit}}
-
-runs:
-  using: 'composite'
-  steps:
-    - uses: ./.github/actions/sanitize/config
-
-    - uses: actions/cache@v4
-      if: ${{env.DEBUG == 'true' && inputs.cache-skip != 'true'}}
-      id: debug
-      with:
-        path: ${{inputs.cache-path}}
-        key: ${{github.job}}-${{inputs.par}}-${{inputs.sanitizer}}
-
-    - uses: ./.github/actions/sanitize/setup
-      if: ${{steps.debug.outputs.cache-hit != 'true'}}
-      with:
-        par: ${{inputs.par}}
-        sanitizer: ${{inputs.sanitizer}}
-
-    - uses: actions/download-artifact@v4
-      with:
-        name: build-${{inputs.par}}-${{inputs.sanitizer}}
-        path: mfem/build
-
-    - name: Ninja Patch
-      working-directory: mfem/build
-      run: |
-        sed -i -e 's/CXX_STATIC_LIBRARY_LINKER__mfem_Release.*/CUSTOM_COMMAND/' build.ninja
-        sed -i -e '/build tests\/unit\/all:/ s/tests\/unit\/[^ ]*unit_tests[^ ]*//g' build.ninja
-        sed -i -e '/^add_test(\[=\[\(unit_tests\|punit_tests\)\]=\]/ s/)/ "--input-file .\/list-test-names-${{matrix.tag}}" "--min-duration 1")/' tests/unit/CTestTestfile.cmake
-      shell: bash
-
-    - name: Copy Data
-      if: ${{steps.debug.outputs.cache-hit != 'true'}}
-      working-directory: mfem/build
-      run: |
-        ninja cmake_object_order_depends_target_unit_tests
-        cp -pR ../tests/unit/data tests/unit
-      shell: bash
@@ -1,64 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: 'Setup state'
-description: 'Sets up the state to be able to run build & run'
-
-inputs:
-  par:
-    description: 'Whether to build for parallel (true/false)'
-    default: false
-  sanitizer:
-    description: 'Sanitizer to use (asan, msan, ubsan)'
-    default: asan
-
-runs:
-  using: 'composite'
-  steps:
-    - uses: actions/cache/restore@v4  # Cache for LLVM libcxx
-      with:
-        path: ${{env.LLVM_DIR}}
-        fail-on-cache-miss: true
-        key: build-libcxx-${{env.LLVM_VER}}-${{inputs.sanitizer}}
-
-    - uses: ./.github/actions/sanitize/mpi
-      if: ${{inputs.par == 'true'}}
-
-    - uses: actions/cache/restore@v4  # Cache for Hypre
-      if: ${{inputs.par == 'true'}}
-      with:
-        path: ${{env.HYPRE_DIR}}
-        fail-on-cache-miss: true
-        key: ${{runner.os}}-ompi-build-${{env.HYPRE_DIR}}-int32-fp64-v2.5
-
-    - uses: actions/cache/restore@v4  # Cache for Metis
-      if: ${{inputs.par == 'true'}}
-      with:
-        path: ${{env.METIS_DIR}}
-        fail-on-cache-miss: true
-        key: ${{runner.os}}-build-${{env.METIS_DIR}}-v2.5
-
-    - name: Hypre/Metis links
-      if: ${{inputs.par == 'true'}}
-      run: ln -s -f ${{env.HYPRE_DIR}} hypre && ln -s -f ${{env.METIS_DIR}} metis-4.0
-      shell: bash
-
-    - uses: actions/cache/restore@v4  # Cache for LSAN suppression file
-      with:
-        path: ${{env.LSAN_DIR}}
-        fail-on-cache-miss: true
-        key: build-lsan-suppression-file
-
-    - uses: actions/checkout@v4  # Checkout the repository
-      with:
-        path: mfem
-        # ref: ${{env.BRANCH}}
-        # repository: ${{env.REPOSITORY}}
@@ -7,17 +7,18 @@

                               https://mfem.org

+
 This directory contains the GitHub CI scripts for MFEM.

 Note that some of these scripts use the shared MFEM GitHub Actions from the external mfem/github-actions repository:

-  <https://github.com/mfem/github-actions>
+  https://github.com/mfem/github-actions

-For a particular action, e.g. `mfem/github-actions/build-mfem@v2.5`, the `v2.5` suffix denotes the branch in the above from which the action is taken.
+For a particular action, e.g. `mfem/github-actions/build-mfem@v2.1`, the `v2.1` suffix denotes the branch in the above from which the action is taken.

 The current CI workflows are:

-## `repo-check.yml`
+### `repo-check.yml`

 Runs a number of static repository-level sanity checks.

@@ -29,39 +30,19 @@ Runs a number of static repository-level sanity checks.

 - `branch-history` guards against accidental commits of large files using the `--history` option of the `config/githooks/pre-push` script.

-## `mfem-analysis.yml` (`build-analysis`)
+### `mfem-analysis.yml` (`build-analysis`)

 Checks if the code builds and satisfies minimal requirements.

 - `gitignore` builds hypre, METIS, and MFEM using `mfem/github-actions/build-hypre`, `mfem/github-actions/build-metis`, and `mfem/github-actions/build-mfem` and checks for correct `.gitignore` settings by running the `tests/scripts/gitignore` script.

-## `builds-and-tests.yml`
+### `builds-and-tests.yml`

 Runs a matrix of builds and tests runs with different compilers, OS, mfem/hypre settings, etc. Also processes and upload Codecov reports.

-Uses the following GitHub Actions from <https://github.com/mfem/github-actions>:
+Uses the following GitHub Actions from https://github.com/mfem/github-actions:

 - `mfem/github-actions/build-hypre`
 - `mfem/github-actions/build-metis`
 - `mfem/github-actions/build-mfem`
 - `mfem/github-actions/upload-coverage`
-
-## Sanitizer Workflow for MFEM Verification
-
-This workflow validates MFEM unit tests, examples, and miniapps using sanitizer tools.
-
- `sanitizers.yml` orchestrates:
-  - Building and caching dependencies: HYPRE, METIS, LSAN suppression file, and LLVM libcxx.
-  - Launching fine-grained jobs for serial (ASAN, MSAN, UBSAN) and parallel (ASAN, UBSAN) sanitizers.
- `sanitize-tests.yml` is a reusable workflow accepting `par` mode (`true` for parallel) and `sanitizer` (ASAN, MSAN, or UBSAN) as inputs. It executes the following jobs:
-  - **Build**: Compiles the MFEM library with specified parallel and sanitizer settings.
-  - **Check**: Runs verification checks.
-  - Parallel jobs to test the following: **Examples**, **Miniapps** and **Unit tests**
-
-The workflow leverages composite actions in `.github/actions/sanitize/`:
-
- `config`: Centralizes settings for the sanitizer workflow.
- `mfem`: Manages the MFEM library build process.
- `mpi`: Installs MPI and applies additional compilation flags.
- `restore`: Restores the testing environment state.
- `setup`: Builds or restores cached dependencies.
@@ -58,7 +58,6 @@ jobs:
        build-system: [make, cmake]
        hypre-target: [int32]
        precision: [fp64]
-        enzyme: [false]
        exclude:
          - os: ubuntu-latest
            build-system: cmake
@@ -81,17 +80,15 @@ jobs:
            codecov: YES
          - os: ubuntu-latest
            target: dbg
-            config-opts: "CPPFLAGS+=-Og"
+            config-opts: 'CPPFLAGS+=-Og'
          - os: macos-latest
            codecov: NO
          - os: windows-latest
            codecov: NO
-            # config-opts: '-G "Ninja Multi-Config"'
          - os: windows-latest
            target: opt
            mpi: par
-            config-opts: "-DBUILD_SHARED_LIBS=ON"
-            # config-opts: '-DBUILD_SHARED_LIBS=ON -G "Ninja Multi-Config"'
+            config-opts: '-DBUILD_SHARED_LIBS=ON'
          - os: ubuntu-latest
            target: opt
            codecov: NO
@@ -99,7 +96,7 @@ jobs:
            build-system: cmake
            hypre-target: int32
            precision: fp64
-            config-opts: "-DCMAKE_INSTALL_PREFIX=../cmake-install"
+            config-opts: '-DCMAKE_INSTALL_PREFIX=../cmake-install'
            # This option can be set to pass additional configuration options to
            # the MFEM configuration command.
            # config-opts: '-DCMAKE_VERBOSE_MAKEFILE=ON'
@@ -117,24 +114,7 @@ jobs:
            build-system: make
            hypre-target: int32
            precision: fp32
-          - os: macos-latest
-            target: opt
-            codecov: NO
-            mpi: par
-            build-system: make
-            hypre-target: int32
-            precision: fp32
-          - os: macos-latest
-            target: opt
-            codecov: NO
-            mpi: par
-            build-system: make
-            hypre-target: int32
-            precision: fp64
-            enzyme: true
-            config-opts: MFEM_USE_ENZYME=YES ENZYME_DIR=$(brew --prefix enzyme)
-
-    name: ${{ matrix.os }}-${{ matrix.build-system }}-${{ matrix.target }}-${{ matrix.mpi }}-${{ matrix.hypre-target }}-${{ matrix.precision }}${{ matrix.enzyme && '-enzyme' || '' }}
+    name: ${{ matrix.os }}-${{ matrix.build-system }}-${{ matrix.target }}-${{ matrix.mpi }}-${{ matrix.hypre-target }}-${{ matrix.precision }}

    runs-on: ${{ matrix.os }}

@@ -144,8 +124,8 @@ jobs:
        if: matrix.os == 'ubuntu-latest'
        uses: easimon/maximize-build-space@v8
        with:
-          overprovision-lvm: "true"
-          remove-android: "true"
+          overprovision-lvm: 'true'
+          remove-android: 'true'

      # Checkout MFEM in "mfem" subdirectory. Final path:
      # /home/runner/work/mfem/mfem/mfem
@@ -157,17 +137,6 @@ jobs:
          # Fetch the complete history for codecov to access commits ID
          fetch-depth: 0

-      - name: Windows environment - PowerShell [debug]
-        if: matrix.os == 'windows-latest'
-        run: |
-          ls env: | fl
-
-      - name: Windows environment - Bash [debug]
-        if: matrix.os == 'windows-latest'
-        run: |
-          env
-        shell: bash
-
      - name: Xcode version setup (MacOS)
        if: matrix.os == 'macos-latest'
        run: |
@@ -185,8 +154,7 @@ jobs:
      - name: get MPI (Linux)
        if: matrix.mpi == 'par' && matrix.os == 'ubuntu-latest'
        run: |
-          sudo apt-get install openmpi-bin libopenmpi-dev
-          export OMPI_MCA_rmaps_base_oversubscribe=1
+          sudo apt-get install mpich libmpich-dev

      - name: get lcov (Linux)
        if: matrix.codecov == 'YES' && matrix.os == 'ubuntu-latest'
@@ -223,7 +191,7 @@ jobs:
        uses: actions/cache@v4
        with:
          path: ${{ env.HYPRE_TOP_DIR }}
-          key: ${{ runner.os }}-ompi-build-${{ env.HYPRE_TOP_DIR }}-${{ matrix.hypre-target }}-${{ matrix.precision }}-v2.5
+          key: ${{ runner.os }}-build-${{ env.HYPRE_TOP_DIR }}-${{ matrix.hypre-target }}-${{ matrix.precision }}-v2.5

      - name: get hypre
        if: matrix.mpi == 'par' && steps.hypre-cache.outputs.cache-hit != 'true' && matrix.os != 'windows-latest'
@@ -282,18 +250,6 @@ jobs:
        run: |
          vcpkg install metis-mfem --triplet=x64-windows-static --overlay-ports=${{ env.MFEM_TOP_DIR }}/config/vcpkg/ports

-      # It's usually fine to build the above TPLs with a different compiler.
-      #
-      - name: install Enzyme (macOS w/ Enzyme)
-        if: matrix.enzyme && matrix.os == 'macos-latest'
-        run: |
-          export HOMEBREW_NO_INSTALL_CLEANUP=1
-          brew update
-          brew install llvm@19 enzyme
-          echo "LLVM_PREFIX=$(brew --prefix llvm@19)" >> $GITHUB_ENV
-          echo "OMPI_CC=$(brew --prefix llvm@19)/bin/clang" >> $GITHUB_ENV
-          echo "OMPI_CXX=$(brew --prefix llvm@19)/bin/clang++" >> $GITHUB_ENV
-
      # MFEM build and test
      - name: build
        uses: mfem/github-actions/build-mfem@v2.5
@@ -45,15 +45,14 @@ jobs:

      - name: Get MPI (Linux)
        run: |
-          sudo apt-get install openmpi-bin libopenmpi-dev
-          export OMPI_MCA_rmaps_base_oversubscribe=1
+          sudo apt-get install mpich libmpich-dev

      - name: Cache Hypre Install
        id: hypre-cache
        uses: actions/cache@v4
        with:
          path: ${{ env.HYPRE_TOP_DIR }}
-          key: ${{ runner.os }}-ompi-build-${{ env.HYPRE_TOP_DIR }}-v2.5
+          key: ${{ runner.os }}-build-${{ env.HYPRE_TOP_DIR }}-v2.5

      - name: Get Hypre
        if: steps.hypre-cache.outputs.cache-hit != 'true'
@@ -0,0 +1,69 @@
+# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
+# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
+# LICENSE and NOTICE for details. LLNL-CODE-806117.
+#
+# This file is part of the MFEM library. For more information and source code
+# availability visit https://mfem.org.
+#
+# MFEM is free software; you can redistribute it and/or modify it under the
+# terms of the BSD-3 license. We welcome feedback and contributions, see file
+# CONTRIBUTING.md for details.
+
+name: "Sanitizer"
+
+permissions:
+  actions: write
+
+on:
+  push:
+    branches:
+      - master
+      - next
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  Serial:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: MFEM Checkout
+        uses: actions/checkout@v4
+        with:
+          path: mfem
+
+      - name: MFEM Build
+        uses: mfem/github-actions/build-mfem@v2.5
+        with:
+          os: ${{ runner.os }}
+          target: opt
+          mpi: seq
+          hypre-dir: unused-hypre-dir
+          metis-dir: unused-metis-dir
+          mfem-dir: mfem
+          build-system: make
+          library-only: false
+          config-options:
+            CXX="clang++-18"
+            CXXFLAGS="-g -O1 -std=c++11
+                      -fsanitize=address
+                      -fno-omit-frame-pointer
+                      -fsanitize-address-use-after-scope"
+
+      - name: MFEM Info
+        working-directory: mfem
+        run: make info
+
+      - name: MFEM Sanitize
+        working-directory: mfem
+        run:
+          ASAN_OPTIONS="detect_leaks=1,
+                        strict_init_order=1,
+                        strict_string_checks=1,
+                        check_initialization_order=1,
+                        detect_stack_use_after_return=1"
+          make test
@@ -1,39 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: build-hypre
-on:
-  workflow_call:
-jobs:
-  build-hypre:
-    runs-on: ubuntu-latest
-    name: 2.19.0
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/config
-      - name: Cache
-        id: cache
-        uses: actions/cache@v4
-        with:
-          path: ${{env.HYPRE_DIR}}
-          key: ${{runner.os}}-ompi-build-${{env.HYPRE_DIR}}-int32-fp64-v2.5
-      - name: Setup
-        if: steps.cache.outputs.cache-hit != 'true'
-        uses: ./.github/actions/sanitize/mpi
-      - name: Build
-        if: steps.cache.outputs.cache-hit != 'true'
-        uses: mfem/github-actions/build-hypre@v2.5
-        with:
-          archive: ${{env.HYPRE_TGZ}}
-          dir: ${{env.HYPRE_DIR}}
-          target: int32
-          precision: fp64
-          build-system: make
@@ -1,76 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: build-libcxx
-on:
-  workflow_call:
-jobs:
-  build-llvm-libcxx:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        sanitizer: [asan, msan, ubsan]
-        include:
-          - sanitizer: asan
-            llvm_use_sanitizer: "Address"
-          - sanitizer: msan
-            llvm_use_sanitizer: "MemoryWithOrigins"
-          - sanitizer: ubsan
-            llvm_use_sanitizer: "Undefined"
-    name: ${{matrix.sanitizer}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/config
-        with:
-          NO_FLAGS: true
-      - name: Cache
-        id: cache
-        uses: actions/cache@v4
-        with:
-          path: ${{env.LLVM_DIR}}
-          key: build-libcxx-${{env.LLVM_VER}}-${{matrix.sanitizer}}
-      - name: Clone
-        if: ${{ steps.cache.outputs.cache-hit != 'true' }}
-        run: >
-          git clone --filter=blob:none --depth=1
-          --branch llvmorg-${{env.LLVM_VER}}
-          --no-checkout https://github.com/llvm/llvm-project.git llvm-project
-      - name: Checkout
-        if: ${{ steps.cache.outputs.cache-hit != 'true' }}
-        working-directory: llvm-project
-        run: |
-          git sparse-checkout set --cone
-          git checkout llvmorg-${{env.LLVM_VER}}
-          git sparse-checkout set cmake llvm/cmake runtimes libcxx libcxxabi
-      - name: Mkdir
-        if: ${{ steps.cache.outputs.cache-hit != 'true' }}
-        run: mkdir ${{env.LLVM_DIR}}
-      - name: CMake
-        if: ${{ steps.cache.outputs.cache-hit != 'true' }}
-        working-directory: ${{env.LLVM_DIR}}
-        run: >
-          VERBOSE=1
-          cmake -GNinja ../llvm-project/runtimes/
-          -DCMAKE_C_COMPILER=${{env.CC}}
-          -DCMAKE_CXX_COMPILER=${{env.CXX}}
-          -DCMAKE_BUILD_TYPE=RelWithDebInfo
-          -DCMAKE_INSTALL_PREFIX=/usr
-          -DLLVM_USE_SANITIZER=${{matrix.llvm_use_sanitizer}}
-          -DLLVM_BUILD_32_BITS=OFF
-          -DLIBCXXABI_USE_LLVM_UNWINDER=OFF
-          -DLLVM_INCLUDE_TESTS=OFF
-          -DLIBCXX_INCLUDE_TESTS=OFF
-          -DLIBCXX_INCLUDE_BENCHMARKS=OFF
-          -DLLVM_ENABLE_RUNTIMES='libcxx;libcxxabi'
-      - name: Build
-        if: ${{ steps.cache.outputs.cache-hit != 'true' }}
-        working-directory: ${{env.LLVM_DIR}}
-        run: cmake --build . -- cxx cxxabi
@@ -1,38 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: build-file-lsan
-on:
-  workflow_call:
-jobs:
-  build-file-lsan:
-    runs-on: ubuntu-latest
-    name: lsan.supp
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/config
-      - name: Cache
-        id: cache
-        uses: actions/cache@v4
-        with:
-          path: ${{env.LSAN_DIR}}
-          key: build-lsan-suppression-file
-      - name: Setup
-        if: steps.cache.outputs.cache-hit != 'true'
-        run: |
-          mkdir -p ${{env.LSAN_DIR}}
-          cat << EOF > ${{env.LSAN_DIR}}/${{env.LSAN_FILE}}
-          leak:libevent_core-2.1.so
-          leak:ompi_mpi_finalize
-          leak:ompi_mpi_init
-          leak:PMPI_Init
-          leak:strdup
-          EOF
@@ -1,36 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: build-metis
-on:
-  workflow_call:
-jobs:
-  build-metis:
-    runs-on: ubuntu-latest
-    name: 4.0.3
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/config
-      - name: Cache
-        id: cache
-        uses: actions/cache@v4
-        with:
-          path: ${{env.METIS_DIR}}
-          key: ${{runner.os}}-build-${{env.METIS_DIR}}-v2.5
-      - name: Setup
-        if: steps.cache.outputs.cache-hit != 'true'
-        uses: ./.github/actions/sanitize/mpi
-      - name: Build
-        if: steps.cache.outputs.cache-hit != 'true'
-        uses: mfem/github-actions/build-metis@v2.5
-        with:
-          archive: ${{env.METIS_TGZ}}
-          dir: ${{env.METIS_DIR}}
@@ -1,197 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: Sanitize
-on:
-  workflow_call:
-    inputs:
-      par:
-        description: 'Whether to build for parallel (true/false)'
-        required: false
-        default: false
-        type: boolean
-      sanitizer:
-        description: 'Sanitizer to use (asan, msan, ubsan)'
-        required: true
-        default: asan
-        type: string
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/mfem
-        with:
-          par: ${{inputs.par}}
-          sanitizer: ${{inputs.sanitizer}}
-
-  check:
-    needs: [build]
-    runs-on: ubuntu-latest
-    env:
-      ex: ${{inputs.par && 'ex1p' || 'ex1'}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/restore
-        id: restore
-        with:
-          par: ${{inputs.par}}
-          sanitizer: ${{inputs.sanitizer}}
-          cache-path: mfem/build/examples/${{env.ex}}
-      - name: MFEM Check
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: ninja -v check
-
-  examples:
-    needs: [check]
-    runs-on: ubuntu-latest
-    env:
-      exclude: ${{inputs.par && '-E "_ser"' || ''}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/restore
-        id: restore
-        with:
-          par: ${{inputs.par}}
-          sanitizer: ${{inputs.sanitizer}}
-          cache-path: mfem/build/examples/ex1
-      - name: Build Examples
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: ninja -v examples
-      - name: Test Examples
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: |
-          ${{env.CTEST}} examples ${{env.exclude}} --show-only
-          ${{env.CTEST}} examples ${{env.exclude}}
-
-  miniapps:
-    needs: [check]
-    runs-on: ubuntu-latest
-    env:
-      exclude: ${{inputs.par && '-E "_ser"' || ''}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/restore
-        id: restore
-        with:
-          par: ${{inputs.par}}
-          sanitizer: ${{inputs.sanitizer}}
-          cache-path: mfem/build/miniapps/meshing/minimal-surface
-      - name: Build Miniapps
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: ninja -v miniapps
-      - name: Test Miniapps
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: |
-          ${{env.CTEST}} miniapps ${{env.exclude}} --show-only
-          ${{env.CTEST}} miniapps ${{env.exclude}}
-
-  tests-miniapps:
-    needs: [check]
-    runs-on: ubuntu-latest
-    env:
-      run: ${{inputs.par && '-R "_cpu_np"' || ''}}
-      exclude: ${{inputs.par && '"unit_tests|debug"' || '"^unit_tests$|debug"'}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/restore
-        id: restore
-        with:
-          par: ${{inputs.par}}
-          sanitizer: ${{inputs.sanitizer}}
-          cache-path: mfem/build/tests/unit/sedov_tests_cpu
-      - name: Build Tests Unit Miniapps
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: ninja -v tests/unit/all
-      - name: Run Tests Unit Miniapps
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: |
-          ${{env.CTEST}} tests/unit -E ${{env.exclude}} ${{env.run}} --show-only
-          ${{env.CTEST}} tests/unit -E ${{env.exclude}} ${{env.run}}
-
-  tests-unit-build:
-    needs: [check]
-    runs-on: ubuntu-latest
-    env:
-      unit_tests: ${{inputs.par && 'punit_tests' || 'unit_tests'}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/restore
-        id: restore
-        with:
-          par: ${{inputs.par}}
-          sanitizer: ${{inputs.sanitizer}}
-          cache-path: mfem/build/tests/unit/${{env.unit_tests}}
-      - name: Build Unit Tests
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: ninja -v ${{env.unit_tests}}
-      - name: Delete object files
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build/tests/unit
-        run: find . -type f -name '*.o' -delete
-      - uses: actions/upload-artifact@v4
-        with:
-          name: tests-${{inputs.par}}-${{inputs.sanitizer}}
-          path: mfem/build/tests/unit/${{env.unit_tests}}
-          if-no-files-found: error
-          retention-days: 1
-          overwrite: false
-
-  tests-unit-run:
-    needs: [tests-unit-build]
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        tag: [0, 1, 2, 3]
-    name: tests-unit-run-${{matrix.tag}}
-    env:
-      unit_tests: ${{inputs.par && 'punit_tests' || 'unit_tests'}}
-      np: ${{inputs.par && '_np=2' || ''}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./.github/actions/sanitize/restore
-        id: restore
-        with:
-          par: ${{inputs.par}}
-          sanitizer: ${{inputs.sanitizer}}
-          cache-path: mfem/build/tests/unit/${{env.unit_tests}}
-      - uses: actions/download-artifact@v4
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        with:
-          name: tests-${{inputs.par}}-${{inputs.sanitizer}}
-          path: mfem/build/tests/unit
-      - name: Split Unit Tests
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build/tests/unit
-        run: |
-          chmod 755 ${{env.unit_tests}}
-          ./${{env.unit_tests}} --list-test-names-only | tail -n +2 > list-test-names
-          shuf list-test-names -o list-test-names
-          split --verbose -n l/4 -d -a 1 list-test-names list-test-names-
-      - name: Cat Unit Tests ${{matrix.tag}}
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build/tests/unit
-        run: cat list-test-names-${{matrix.tag}}
-      - name: Run Unit Tests ${{matrix.tag}}
-        if: ${{steps.restore.outputs.cache-hit != 'true'}}
-        working-directory: mfem/build
-        run: |
-          ${{env.CTEST}} tests/unit -R "${{env.unit_tests}}${{env.np}}" --show-only
-          ${{env.CTEST}} tests/unit -R "${{env.unit_tests}}${{env.np}}"
@@ -1,73 +0,0 @@
-# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-# LICENSE and NOTICE for details. LLNL-CODE-806117.
-#
-# This file is part of the MFEM library. For more information and source code
-# availability visit https://mfem.org.
-#
-# MFEM is free software; you can redistribute it and/or modify it under the
-# terms of the BSD-3 license. We welcome feedback and contributions, see file
-# CONTRIBUTING.md for details.
---
-name: Sanitizers
-
-permissions:
-  actions: write
-
-on:
-  push:
-    branches: ["master", "next"]
-  pull_request:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{github.workflow}}-${{github.ref}}
-  cancel-in-progress: true
-
-jobs:
-
-  # Build steps for dependencies
-  build-hypre:
-    uses: ./.github/workflows/sanitize-build-hypre.yml
-
-  build-metis:
-    uses: ./.github/workflows/sanitize-build-metis.yml
-
-  build-lsan:
-    uses: ./.github/workflows/sanitize-build-lsan.yml
-
-  build-libcxx:
-    uses: ./.github/workflows/sanitize-build-libcxx.yml
-
-  # Serial sanitizers: asan, msan, ubsan
-  seq-asan:
-    needs: [build-libcxx]
-    uses: ./.github/workflows/sanitize-tests.yml
-    with:
-      sanitizer: asan
-
-  seq-msan:
-    needs: [build-libcxx]
-    uses: ./.github/workflows/sanitize-tests.yml
-    with:
-      sanitizer: msan
-
-  seq-ubsan:
-    needs: [build-libcxx]
-    uses: ./.github/workflows/sanitize-tests.yml
-    with:
-      sanitizer: ubsan
-
-  # Parallel sanitizers: asan, ubsan
-  par-asan:
-    needs: [build-libcxx, build-hypre, build-metis]
-    uses: ./.github/workflows/sanitize-tests.yml
-    with:
-      par: true
-      sanitizer: asan
-  par-ubsan:
-    needs: [build-libcxx, build-hypre, build-metis]
-    uses: ./.github/workflows/sanitize-tests.yml
-    with:
-      par: true
-      sanitizer: ubsan
@@ -80,7 +80,6 @@ examples/sol_p.*
 examples/sol_r.*
 examples/sol_i.*
 examples/ex6p-checkpoint.*
-examples/order.*
 examples/ex9.mesh
 examples/ex9-mesh.*
 examples/ex9-init.*
@@ -201,9 +200,6 @@ examples/superlu/sol.*
 miniapps/adjoint/cvsRoberts_ASAi_dns
 miniapps/adjoint/adjoint_advection_diffusion

-miniapps/dfem/dfem-minimal-surface
-miniapps/dfem/dfem-minimal-surface-output
-
 miniapps/electromagnetics/volta
 miniapps/electromagnetics/tesla
 miniapps/electromagnetics/maxwell
@@ -232,7 +228,6 @@ miniapps/meshing/fit-node-position
 miniapps/meshing/trimmer
 miniapps/meshing/reflector
 miniapps/meshing/ref321
-miniapps/meshing/mesh-bounding-boxes
 miniapps/meshing/mesh-optimizer
 miniapps/meshing/pmesh-optimizer
 miniapps/meshing/pmesh-fitting
@@ -240,8 +235,6 @@ miniapps/meshing/minimal-surface
 miniapps/meshing/pminimal-surface
 miniapps/meshing/polar-nc
 miniapps/meshing/mesh-quality
-miniapps/meshing/hpref
-miniapps/meshing/phpref
 miniapps/meshing/mobius-strip.mesh
 miniapps/meshing/klein-bottle.mesh
 miniapps/meshing/toroid-*.mesh
@@ -259,12 +252,6 @@ miniapps/meshing/sol.gf
 miniapps/meshing/optimized*
 miniapps/meshing/perturbed*
 miniapps/meshing/polar-nc.mesh
-miniapps/meshing/mesh.*
-miniapps/meshing/order.*
-miniapps/meshing/sol.*
-miniapps/meshing/refined.mesh
-miniapps/meshing/bounding-box*
-miniapps/meshing/jacobian-determinant*

 miniapps/mtop/parheat
 miniapps/mtop/ParHeat*
@@ -300,7 +287,6 @@ miniapps/nurbs/nurbs_solenoidal
 miniapps/nurbs/nurbs_printfunc
 miniapps/nurbs/nurbs_patch_ex1
 miniapps/nurbs/nurbs_curveint
-miniapps/nurbs/nurbs_surface
 miniapps/nurbs/refined.mesh
 miniapps/nurbs/mesh.*
 miniapps/nurbs/sol_?.gf
@@ -319,7 +305,6 @@ miniapps/nurbs/nurbs_naca_cmesh
 miniapps/nurbs/naca-cmesh.mesh
 miniapps/nurbs/glvis_naca-cmesh.mesh
 miniapps/nurbs/Naca_cmesh
-miniapps/nurbs/*-Surface.mesh

 miniapps/performance/ex1
 miniapps/performance/ex1p
@@ -341,7 +326,6 @@ miniapps/shifted/lsf_integral
 miniapps/tools/display-basis
 miniapps/tools/load-dc
 miniapps/tools/convert-dc
-miniapps/tools/gridfunction-bounds
 miniapps/tools/lor-transfer
 miniapps/tools/plor-transfer
 miniapps/tools/get-values
@@ -408,15 +392,12 @@ miniapps/spde/ParaView

 miniapps/tribol/contact-patch-test

-miniapps/diag-smoothers/abs-l1-jacobi
-miniapps/diag-smoothers/mg-abs-l1-jacobi
-
 # Unit test binary and outputs
 tests/unit/output_meshes
 tests/unit/unit_tests
 tests/unit/punit_tests
-tests/unit/gpu_unit_tests
-tests/unit/pgpu_unit_tests
+tests/unit/cunit_tests
+tests/unit/pcunit_tests
 tests/unit/sedov_tests_*
 tests/unit/psedov_tests_*
 tests/unit/tmop_pa_tests_*
@@ -8,282 +8,159 @@
                               https://mfem.org


-Version 4.8.1 (development)
+Version 4.7.1 (development)
 ===========================
-
-Starting with this version, MFEM requires a C++17 compiler.
-
-Discretization improvements
---------------------------
- Introduced dFEM: a new MFEM capability for Automatic Differentiation (AD) of
-  nonlinear finite element operators, based on Enzyme or dual numbers AD at
-  quadrature points. These features are part of the new mfem::future namespace
-  and some of the API can change in the future. See the new dFEM minimal surface
-  miniapp in the miniapps/dfem/ directory for illustration of dFEM's use.
-
- Using Enzyme for AD in MFEM is tested with clang v19 and requires clang/LLVM
-  built with plugin support. See INSTALL for more details.
-
- In the ParMoonolith integration, added support for variational resampling of
-  H1 vector fields.
-
-Meshing improvements
--------------------
-
- Added support for higher order meshes in Mesh::MakeSimplicial and
-  ParMesh::MakeSimplicial.
-
- Added a new miniapp for interpolating a surface grid of points in 3D using a
-  smooth NURBS surface, that can then be sampled at arbitrary resolution while
-  staying close to the original geometry. See miniapps/nurbs/nurbs_surface.
-
-GPU computing
-------------
- The function Vector::SetSubVector(const Array<int> &, const real_t) now
-  executes on device if either the vector or the array have the device flag
-  set. This is most often used for setting constant essential boundary
-  conditions. A new function Vector::SetSubVectorHost has been added in cases
-  where host execution is always needed (e.g. when the DOFs array is small).
- Introduced MFEM_FOREACH_THREAD_DIRECT, which directly maps loop tasks to GPU
-  threads, assigning one task per thread.
-
-New and updated examples and miniapps
-------------------------------------
- Added miniapps to demonstrate an implementation of the absolute-value
-  L(1)-Jacobi preconditioners in partially assembled operators. This includes
-  Multigrid wrapper to demonstrate the effectiveness of these Jacobi-type
-  operators as smoothers.
-  These miniapps can be found in `miniapps/diag-smoothers`.
-
-API changes
-----------
- mfem::internal::tensor and mfem::internal::dual have been moved to
-  mfem::future::tensor and mfem::future::dual.
- API addition: in class `Operator`, added virtual functions: `AbsMult`, and
-  `AbsMultTranspose`; in class `Vector`, added `Abs` and `Pow`.
-
-Miscellaneous
-------------
- Added the "gpu", "raja-gpu", and "ceed-gpu" backend aliases/shortcuts which
-  automatically select between CUDA or HIP.
- The CUDA-specific names used by some of the unit tests like 'cunit_tests' and
-  'pcunit_tests' were replaced by names using 'gpu' instead of 'c' (short for
-  CUDA) or 'cuda'. These tests automatically run the CUDA/HIP tests based on the
-  MFEM build configuration.
- Added the option to enable GPU-aware MPI in MFEM using the environment
-  variable 'MFEM_GPU_AWARE_MPI' set to any value. Setting this environment
-  variable is an alternative to calling 'Device::SetGPUAwareMPI(true)'.
- Added parallel Address Sanitizer, serial and parallel Undefined Behavior
-  Sanitizer and serial Memory Sanitizer GitHub actions tests on Ubuntu.
-
-Version 4.8, released on Apr 9, 2025
-====================================
-
-Discretization improvements
---------------------------
- Added high-order basis functions on pyramid-shaped elements for all spaces in
-  the de Rham complex based on the paper "Orientation embedded high order shape
-  functions for the exact sequence elements of all shapes" by Fuentes, Keith,
-  Demkowicz and Nagaraj (doi.org/10.1016/j.camwa.2015.04.027). Positive basis
-  functions (Bernstein basis) for H1 and L2 on pyramids were also added.
-
- Added support for parallel p- and hp-refinement on quad/hex meshes. For hp, we
-  currently support only isotropic refinement with L2 or H1 spaces. See the new
-  miniapps hpref and phpref in the miniapps/meshing/ directory.
-
- Added several improvements for hyperbolic problems:
-  * Assembly of Jacobians in HyperbolicFormIntegrator
-  * Component-wise upwinded flux (ComponentwiseUpwindFlux)
-  * Average fluxes in NumericalFlux (formerly RiemannSolver) and FluxFunction
-
- Added convenience methods to class FiniteElementSpace to directly identify all
-  degrees of freedom on the exterior faces of the domain, without referencing
-  boundary element attributes (GetExteriorVDofs and GetExteriorTrueDofs).
-
+- Refactored ALGOIM cut integration rules. The interface is unified with
+  the interface for moment based cut integration rules.
 - Altered (Par)GridFunction::Compute*Error functions to ensure they return
  non-negative values and therefore behave as "norms".

- SubMesh and ParSubMesh have been extended to work on nonconforming meshes.
-  Extracting volume and exterior surface submeshes are both supported.
+Discretization improvements
+---------------------------
+- Added NURBS-based H(div) and H(curl) elements in 2D and 3D. Only on single
+  patch meshes. Only implemented for serial computations.

- LinearFormIntegrator, BilinearFormIntegrator and NonlinearFormIntegrator now
-  inherit from a base class Integrator that centralizes the logic for selecting
-  quadrature rules. This includes a virtual method GetDefaultIntegrationRule,
-  which should be favored over directly defining a default integration rule in
-  the element-level assembly routines. The latter is still possible, by leaving
-  the new virtual method as its default base implementation of returning NULL.
+- Added support for boundary constraints to the hybridization class.

- Added NURBS-based H(div) and H(curl) elements in 2D and 3D. Currently only for
-  single patch meshes in serial.
+- Added support for external boundary submeshes with nonconformal mesh adaptation.

- Refactored ALGOIM cut integration rules. The interface is unified with the
-  interface for moment based cut integration rules.
+- Added assembly of Jacobians to `HyperbolicFormIntegrator`.

- FiniteElementSpace has new methods to directly set the prolongation and
-  restriction operators to user-specified sparse matrices.
+- Added average fluxes to `NumericalFlux` (formerly `RiemannSolver`)
+  and `FluxFunction`.

- Added support for H(div) spaces in class QuadratureInterpolator. Currently only
+- Added component-wise upwinded flux (`ComponentwiseUpwindFlux`).
+
+- Added support for H(div) spaces in class QuadratureInterpolator. For now, only
  (vector) VALUES, (vector) PHYSICAL_VALUES, and PHYSICAL_MAGNITUDES evaluations
-  are implemented.
-
- Added support for boundary constraints to class Hybridization.
-
- Added support for custom interpolation procedure in FindPointsGSLIB.
-
- Added GSLIB-based gather-scatter operator.
+  are implemented. [PR #4669]

 Meshing improvements
 --------------------
- Added support for nonuniform anisotropic mesh refinement on serial quad/hex
-  meshes with arbitrary spacing in each direction. This enables in particular
-  3:1 refinement, as demonstrated in the new meshing miniapp ref321.
+- Added native AD support for numerous TMOP metrics that didn't have first or
+  second derivative implementations.

- Added capabilities for optimization and adaptation of periodic meshes with
-  TMOP. The internals of TMOP were modified so that the optimization problem is
-  always solved with respect to mesh displacements.
+- The ExodusII reader now handles pyramid and wedge element types. Mixed meshes
+  are also supported.

- New convenience methods for manipulating boundary attribute markers in class
-  Mesh: MarkExternalBoundaries, MarkNamedBoundaries, UnmarkInternalBoundaries
-  and UnmarkNamedBoundaries. See Examples 1/1p and 11p for basic usage.
+- Added support for nonuniform anisotropic (nonconforming) mesh refinement with
+  arbitrary spacing in each direction, for quadrilateral (2D) and hexahedral
+  (3D) meshes. This enables in particular 3:1 refinement, as demonstrated in the
+  new meshing miniapp ref321.

- Added a new method, GetExteriorFaceMarker, to the serial and parallel mesh
-  classes for identifying faces on the exterior of the mesh irrespective of
-  their presence in the list of "boundary elements".
+New and updated examples and miniapps
+-------------------------------------
+- Added miniapps to demonstrate the H(div) and H(curl) NURBS elements.

- Added native AD support for computing the derivatives of numerous TMOP metrics
-  that didn't have first or second derivative implementations.
+- Added an MFEM example for the eikonal equation. This new solver is based on
+  the proximal Galerkin method introduced by Keith and Surowiec.

- Added ExodusII output capability which can handle in particular pyramid and
-  wedge element types. Mixed meshes are also supported.
+- Added a new toy miniapp that animates an interesting fidget spiral cone toy.
+  See miniapps/toys/spiral.cpp.

- Added InverseElementTransformation::InitGuessType::EdgeScan as an alternative
-  initial guess type. This guess type tries solving with multiple initial guesses
-  along the r/s/t=0 edges of the element until a valid solution is found or all
-  initial guess points are exhausted.
-
- Added new convenience constructors for NURBS patches and knot vectors.
+- Added a command line option to all miniapps (`-p` or `--send-port`) for
+  specifying the GLVis server socket port (19916 by default).

 GPU computing
 -------------
- Extended FindPointsGSLIB to support general field interpolation on GPUs. Note
-  that this requires that switch from gslib v1.0.7 to v1.0.9.
-
 - Added support for GPU-accelerated batched linear algebra (using cuBLAS,
  hipBLAS, MAGMA, or native MFEM functionality) through the BatchedLinAlg class.

 - A new GPU kernel dispatch mechanism was introduced. Users can instantiate
  specialized kernels for specific combinations of (for example) polynomial
-  degree and number of quadrature points using method AddSpecialization in
-  classes DiffusionIntegrator and MassIntegrator (this functionality may be
-  added to more integrators in the future).
+  degree and number of quadrature points using
+  `DiffusionIntegrator::AddSpecialization` and
+  `MassIntegrator::AddSpecialization` (this functionality may be added to more
+  integrators in the future).

- Added BatchInverseElementTransformation to batch InverseElementTransformation
-  searches. Batch searches are currently limited to meshes with a single element
-  geometry type of SEGMENT, SQUARE, or CUBE. Additional element geometry types
-  may be added in the future. Mixed element order meshes are supported. Batch
-  searches can be performed on the CPU (serial per MPI rank) or GPU. Embedded
-  elements (SEGMENT in 2D/3D space or SQUARE in 3D space) are supported, however
-  the existing solvers may struggle to find a valid solution.
+- Calls to slower fallback kernels can be reported to `mfem::err` by setting
+  the environment variable `MFEM_REPORT_KERNELS` to any value other than `NO`
+  or by explicitly calling `KernelReporter::Enable`. Users can then add
+  specializations for these kernels to achieve higher performance.

- Calls to slower fallback kernels can be reported to mfem::err by setting the
-  environment variable MFEM_REPORT_KERNELS to any value other than NO or by
-  explicitly calling KernelReporter::Enable. For higher performance, users can
-  then add specializations for these kernels.
+- Element assembly kernels have been added for low-order refined to
+  high-order transfer operators. New kernels can be offloaded as device
+  kernels. Example usage may be found in lor-transfer.cpp under miniapps/tools.

- Element assembly kernels have been added for low-order refined -> high-order
-  transfer operators. New kernels can be offloaded as device kernels. Example
-  usage may be found in lor-transfer.cpp in the miniapps/tools/ directory.
-
- Added GPU acceleration and element assembly for DivDivIntegrator and
-  NormalTraceJumpIntegrator.
+- Added support for GPU accelerated FindPointsGSLIB. Note that this will require
+  the users to switch from gslib v1.0.7 to v1.0.9.

 - Allow BlockLowerTriangularPreconditioner to run on GPU.

 - Use device vectors in GMRES, FGMRES and other iterative methods.

-Linear and nonlinear solvers
----------------------------
- Added GPU acceleration of the algebraic hybridization solver for grad-div
-  problems in H(div). See Example 4.
-
- Added a self-contained implementation of the Method of Moving Asymptotes (MMA)
-  for solving optimization problems.
-
+Miscellaneous
+-------------
 - Added support for SUNDIALS v7. See the section "API changes" for some small
  changes related to this new version.

- Changed the name of class IterativeSolverMonitor to IterativeSolverController,
-  which now allows for specifying convergence by a user defined criterion. For
-  backward compatibility, the old name is still available.
+- Refactored the `ARKStepSolver` class (ARKODE interface) to use
+  `TimeDependentOperator::Mult` only when the associated ODE operator is
+  expressed in explicit form (i.e., `TimeDependentOperator::isExplicit()`),
+  otherwise `TimeDependentOperator::ExplicitMult` is used. A check has been
+  added to `ARKStepSolver` to verify that the associated ODE operator is not in
+  explicit form when a mass matrix solver is enabled via a call to either the
+  `UseMFEMMassLinearSolver` or `UseSundialsMassLinearSolver` methods. This is
+  because enabling a mass matrix solver assumes that F(u,k,t) = M k in the
+  associated ODE operator.

- Refactored the ARKStepSolver class (ARKODE interface) to use the Mult() method
-  of TimeDependentOperator only when the associated ODE operator is expressed in
-  explicit form (i.e., TimeDependentOperator::isExplicit()), otherwise the
-  method ExplicitMult() is used. A check has been added to ARKStepSolver to
-  verify that the associated ODE operator is not in explicit form when a mass
-  matrix solver is enabled via a call to either the UseMFEMMassLinearSolver or
-  UseSundialsMassLinearSolver methods. This is because enabling a mass matrix
-  solver assumes that F(u,k,t) = M k in the associated ODE operator.
+- Added support for custom interpolation procedure in FindPointsGSLIB.

- Added ODE solvers selection routines. This creates a uniformity across
-  examples, miniapps and other executables in regard to ODE (time-integrator)
-  selection.
+- `FiniteElementSpace` has new methods to directly set prolongation and
+  restriction operators to arbitrary sparse matrices.

- Added new mechanism for retrieving and setting state vectors in ODE solvers.
-  This is relevant for AB/AM and gen-alpha solvers.
+- There are new convenience constructors for NURBS patches and knot vectors.

- Added ODEsolver/ODEsolver2 unit tests to verify order of convergence and
-  read/write functionality.
+- Added convenience methods for manipulating boundary attribute marker arrays;
+  `(Par)Mesh::MarkExternalBoundaries`, `(Par)Mesh::UnmarkInternalBoundaries`,
+  `(Par)Mesh::MarkNamedBoundaries`, and `(Par)Mesh::UnmarkNamedBoundaries`.
+  See examples `ex1.cpp`, `ex1p.cpp`, and `ex11p.cpp` for basic usage.

-New and updated examples and miniapps
-------------------------------------
- Added an MFEM example for the eikonal equation (examples/ex40) based on the
-  proximal Galerkin method introduced by Keith and Surowiec.
+- Added `(Par)Mesh::GetExteriorFaceMarker` for identifying faces on the
+  exterior of the mesh irrespective of their presence in the list of "boundary
+  elements".

- Added miniapps to demonstrate the H(div) and H(curl) NURBS elements.
+- Added methods to `(Par)FiniteElementSpace` to identify all degrees of freedom
+  located on the exterior of the domain without reference to the list of
+  "boundary elements"; `GetExteriorVDofs` and `GetExteriorTrueDofs`.

- Fixed element visualization in the Mesh explorer miniapp.
+- `LinearFormIntegrator` and `NonlinearFormIntegrator` (including
+  `BilinearFormIntegrator`) now all inherit from a base class `Integrator`
+  that combines some logic related to selecting quadrature rules. This includes
+  a virtual method `Integrator::GetDefaultIntegrationRule`, which should be
+  favored over directly defining a default integration rule in the element-level
+  assembly routines (although the latter is still possible, by leaving the new
+  virtual method as its default base implementation of returning `NULL`).

- Added a command line option to all miniapps (-p or --send-port) for
-  specifying the GLVis server socket port (19916 by default).
-
- Added a new toy miniapp that animates an interesting fidget spiral cone toy.
-  See miniapps/toys/spiral.cpp.
-
-Miscellaneous
-------------
 - Updated the benchmarks (in tests/benchmarks) to work with the latest Google
  Benchmarks classes (version 1.9.1). Renamed the MFEM_ENABLE_GOOGLE_BENCHMARKS
  CMake option to just MFEM_ENABLE_BENCHMARKS.

- Updated the minimum CMake version requirements:
-  * CMake >= 3.12 for CPU builds,
-  * CMake >= 3.17 for CUDA builds, and
-  * CMake >= 3.14 for HIP builds (CMake >= 3.12 may work as well, not tested).
-
- Various other simplifications, extensions, and bugfixes in the code.
+- Changed the name of `IterativeSolverMonitor` to `IterativeSolverController`
+  which now allows for declaring convergence by a user defined criterion. For
+  backward compatibility, the old name is still available.

 API changes
 -----------
- In class GridFunction, fec was renamed to fec_owned.
+- API change: 'TMOP_Metric_skew2D' has been marked as deprecated.

- RiemannSolver was renamed to NumericalFlux (the old name has been deprecated
-  through typedef).
+- API change: in class GridFunction, 'fec' was renamed to 'fec_owned'.

- API changes due to SUNDIALS v7:
-  * the SUNDIALS types realtype and booleantype are no longer defined by v7
-    and therefore MFEM now uses the new type names sunrealtype and
-    sunbooleantype, respectively, which MFEM defines when using SUNDIALS < v6
+- API change: `RiemannSolver` was renamed to `NumericalFlux` (the old name has
+  been been deprecated through typedef)
+
+- API change: support for SUNDIALS v7:
+  * the SUNDIALS types `realtype` and `booleantype` are no longer defined by v7
+    and therefore MFEM now uses the new type names `sunrealtype` and
+    `sunbooleantype`, respectively, which MFEM defines when using SUNDIALS < v6
    where these types were not defined.
-  * The SUNDIALS macro SUNLS_SUCCESS and some other *_SUCCESS macros were
-    removed and replaced by SUN_SUCCESS in v7, so to avoid tedious checks for
-    SUNDIALS versions, MFEM now defines and uses the constant SUN_SUCCESS when
+  * The SUNDIALS macro `SUNLS_SUCCESS` and some other `*_SUCCESS` macros were
+    removed and replaced by `SUN_SUCCESS` in v7, so to avoid tedious checks for
+    SUNDIALS versions, MFEM now defines and uses the constant `SUN_SUCCESS` when
    using SUNDIALS < v7.
-  * The constants SUN_PREC_*, introduced by SUNDIALS v6 are now introduced by
+  * The constants `SUN_PREC_*`, introduced by SUNDIALS v6 are now introduced by
    MFEM when using SUNDIALS < v6 to avoid tedious version checks.

- TMOP_Metric_skew2D has been marked as deprecated.
-

 Version 4.7, released on May 7, 2024
 ====================================
@@ -308,6 +185,9 @@ Meshing improvements

 - Added support for internal boundary elements in nonconforming meshes.

+- Added ExodusII output capability. The writer can handle first-order (Pyramid5,
+  Wedge6, Hex8, Tet4) and second-order FE types (Pyramid14, Wedge18, Hex27, Tet10).
+
 - The ReadCubit Genesis mesh importer has been rewritten to improve readability.

 Discretization improvements
@@ -367,6 +247,15 @@ New and updated examples and miniapps
 - Added two new example codes: 38 and 39/39p described above. Substantially
  updated Example 18/18p.

+- Added ODE solvers selection routines. This creates a uniformity across examples,
+  miniapps and other executables in regard to ODE(time-integrator) selection.
+
+- Added new mechanism for retrieving and setting state vectors in ODE solvers.
+  This is relevant for AB/AM and gen-alpha solvers.
+
+- Added ODEsolver/ODEsolver2 unit tests to verify order of convergence and
+  read/write functionality.
+
 Miscellaneous
 -------------
 - Updated the Doxygen documentation style, which now requires Doxygen version
@@ -380,6 +269,8 @@ Miscellaneous

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

+- Added GSLIB-based gather-scatter operator.
+

 Version 4.6, released on September 27, 2023
 ===========================================
@@ -12,14 +12,13 @@
 # The variable CMAKE_CXX_STANDARD and related were introduced in CMake v3.1
 # Version 3.8 fixes the handling of CMAKE_CXX_STANDARD for try_compile.
 # Version 3.8 or newer is required for direct CUDA support.
-# Version 3.12 or newer is required for setting maximum policy version.
-cmake_minimum_required(VERSION 3.12.0...4.0.0)
+cmake_minimum_required(VERSION 3.8)
 message(STATUS "CMake version: ${CMAKE_VERSION}")
 set(USER_CONFIG "${CMAKE_CURRENT_SOURCE_DIR}/config/user.cmake" CACHE PATH
  "Path to optional user configuration file.")

-# Require C++17 and disable compiler-specific extensions
-set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ standard to use.")
+# Require C++11 and disable compiler-specific extensions
+set(CMAKE_CXX_STANDARD 11 CACHE STRING "C++ standard to use.")
 set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL
  "Force the use of the chosen C++ standard.")
 set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Enable C++ standard extensions.")
@@ -59,7 +58,7 @@ project(mfem NONE)
 # Current version of MFEM, see also `makefile`.
 #   mfem_VERSION = (string)
 #   MFEM_VERSION = (int)   [automatically derived from mfem_VERSION]
-set(${PROJECT_NAME}_VERSION 4.8.1)
+set(${PROJECT_NAME}_VERSION 4.7.1)

 # Prohibit in-source build
 if (${PROJECT_SOURCE_DIR} STREQUAL ${PROJECT_BINARY_DIR})
@@ -105,13 +104,6 @@ endif()
 # Include xSDK default CMake file.
 include("${CMAKE_CURRENT_SOURCE_DIR}/config/XSDKDefaults.cmake")

-# Path to MFEM's CMake modules and utilities.
-set(MFEM_CMAKE_PATH ${PROJECT_SOURCE_DIR}/config)
-set(CMAKE_MODULE_PATH ${MFEM_CMAKE_PATH}/cmake/modules)
-
-# Load MFEM CMake utilities.
-include(MfemCmakeUtilities)
-
 # Enable languages.
 enable_language(CXX)
 if (MINGW)
@@ -124,15 +116,17 @@ if (MFEM_USE_CUDA)
   if (MFEM_USE_HIP)
      message(FATAL_ERROR " *** MFEM_USE_HIP cannot be combined with MFEM_USE_CUDA.")
   endif()
-   # CUDAToolkit was added in CMake 3.17, so we require at least CMake 3.17 when
-   # CUDA is enabled:
-   if (CMAKE_VERSION VERSION_LESS 3.17.0)
-      message(FATAL_ERROR "CUDA support requires CMake >= 3.17")
-   endif()
   # Use ${CMAKE_CXX_COMPILER} as the cuda host compiler.
   if (NOT CMAKE_CUDA_HOST_COMPILER)
      set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
   endif()
+   enable_language(CUDA)
+   set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD} CACHE STRING
+      "CUDA standard to use.")
+   set(CMAKE_CUDA_STANDARD_REQUIRED ON CACHE BOOL
+      "Force the use of the chosen CUDA standard.")
+   set(CMAKE_CUDA_EXTENSIONS OFF CACHE BOOL "Enable CUDA standard extensions.")
+   set(CUDA_FLAGS "--expt-extended-lambda")
   if (CMAKE_VERSION VERSION_LESS 3.18.0)
      set(CUDA_FLAGS "-arch=${CUDA_ARCH} ${CUDA_FLAGS}")
   elseif (NOT CMAKE_CUDA_ARCHITECTURES)
@@ -146,33 +140,18 @@ if (MFEM_USE_CUDA)
      set(CUDA_ARCH "CMAKE_CUDA_ARCHITECTURES: ${CMAKE_CUDA_ARCHITECTURES}")
   endif()
   message(STATUS "Using CUDA architecture: ${CUDA_ARCH}")
-   enable_language(CUDA)
-   if (CMAKE_VERSION VERSION_LESS 3.18.0)
-     # backup try to detect if this is clang or nvcc
-     if(CMAKE_CUDA_COMPILER MATCHES "nvcc$")
-       # nvcc
-       set(MFEM_CUDA_COMPILER_IS_NVCC ON)
-       set(CUDA_FLAGS "${CUDA_FLAGS} --expt-extended-lambda --expt-relaxed-constexpr")
-     endif()
-   else()
-     if (CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
-       # nvcc
-       set(MFEM_CUDA_COMPILER_IS_NVCC ON)
-       set(CUDA_FLAGS "${CUDA_FLAGS} --expt-extended-lambda --expt-relaxed-constexpr")
-     endif()
+   if (CMAKE_VERSION VERSION_LESS 3.12.0)
+      # CMake versions 3.8 and 3.9 require this to work; 3.10 and 3.11 are not
+      # tested and may not actually need this (but should be ok to keep).
+      set(CUDA_FLAGS "-ccbin=${CMAKE_CXX_COMPILER} ${CUDA_FLAGS}")
+      set(CMAKE_CUDA_HOST_LINK_LAUNCHER ${CMAKE_CXX_COMPILER})
   endif()
-   set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD} CACHE STRING
-      "CUDA standard to use.")
-   set(CMAKE_CUDA_STANDARD_REQUIRED ON CACHE BOOL
-      "Force the use of the chosen CUDA standard.")
-   set(CMAKE_CUDA_EXTENSIONS OFF CACHE BOOL "Enable CUDA standard extensions.")
   set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${CUDA_FLAGS}")
   find_package(CUDAToolkit REQUIRED)
   set(CUSPARSE_FOUND TRUE)
   set(CUBLAS_FOUND TRUE)
-   # Initialize CUSPARSE_LIBRARIES and CUBLAS_LIBRARIES:
-   mfem_culib_set_libraries(CUSPARSE cusparse)
-   mfem_culib_set_libraries(CUBLAS cublas)
+   get_target_property(CUSPARSE_LIBRARIES CUDA::cusparse LOCATION)
+   get_target_property(CUBLAS_LIBRARIES CUDA::cublas LOCATION)
 endif()

 if (XSDK_ENABLE_C)
@@ -185,6 +164,13 @@ endif()
 # Suppress warnings about MACOSX_RPATH
 set(CMAKE_MACOSX_RPATH OFF CACHE BOOL "")

+# CMake needs to know where to find things
+set(MFEM_CMAKE_PATH ${PROJECT_SOURCE_DIR}/config)
+set(CMAKE_MODULE_PATH ${MFEM_CMAKE_PATH}/cmake/modules)
+
+# Load MFEM CMake utilities.
+include(MfemCmakeUtilities)
+
 string(TOUPPER "${PROJECT_NAME}" PROJECT_NAME_UC)
 mfem_version_to_int(${${PROJECT_NAME}_VERSION} ${PROJECT_NAME_UC}_VERSION)
 set(${PROJECT_NAME_UC}_VERSION_STRING ${${PROJECT_NAME}_VERSION})
@@ -269,11 +255,7 @@ if (MFEM_USE_OPENMP OR MFEM_USE_LEGACY_OPENMP)
  if (OPENMP_FOUND)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
    if (MFEM_USE_CUDA)
-      if(MFEM_CUDA_COMPILER_IS_NVCC)
-        set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=${OpenMP_CXX_FLAGS}")
-      else()
-        set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} ${OpenMP_CXX_FLAGS}")
-      endif()
+      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=${OpenMP_CXX_FLAGS}")
    endif()
  endif()
 endif()
@@ -405,11 +387,6 @@ if (MFEM_USE_GSLIB)
  find_package(GSLIB REQUIRED)
 endif()

-# HDF5
-if (MFEM_USE_HDF5)
-  find_package(HDF5 REQUIRED)
-endif()
-
 # NetCDF
 if (MFEM_USE_NETCDF)
  find_package(NetCDF REQUIRED)
@@ -549,10 +526,9 @@ if (MFEM_USE_TRIBOL)
  endif()
 endif()

+# Enzyme
 if (MFEM_USE_ENZYME)
-    find_package(Enzyme REQUIRED HINTS ${ENZYME_DIR})
-    message(STATUS "Enzyme found in ${ENZYME_DIR}.")
-    set(ENZYME_INCLUDE_DIRS ${ENZYME_DIR}/include)
+   find_package(ENZYME REQUIRED)
 endif()

 # MFEM_TIMER_TYPE
@@ -592,7 +568,7 @@ find_package(Threads REQUIRED)
 #    integers, the METIS header (with 32-bit indices, as used by mfem) needs to
 #    be before SuiteSparse.
 set(MFEM_TPLS OPENMP HYPRE LAPACK BLAS SuperLUDist STRUMPACK METIS SuiteSparse
-    SUNDIALS PETSC SLEPC MUMPS AXOM FMS CONDUIT Ginkgo GNUTLS GSLIB HDF5
+    SUNDIALS PETSC SLEPC MUMPS AXOM FMS CONDUIT Ginkgo GNUTLS GSLIB
    NETCDF MPFR PUMI HIOP POSIXCLOCKS MFEMBacktrace ZLIB OCCA CEED RAJA UMPIRE
    ADIOS2 MKL_CPARDISO MKL_PARDISO AMGX MAGMA CUSPARSE CUBLAS CALIPER CODIPACK
    BENCHMARK PARELAG TRIBOL MPI_CXX HIP HIPBLAS HIPSPARSE MOONOLITH BLITZ
@@ -704,9 +680,6 @@ if (MFEM_USE_MPI)
    target_link_libraries(mfem PUBLIC ${MPI_CXX_LINK_FLAGS})
  endif()
 endif()
-if (MFEM_USE_ENZYME)
-  target_link_libraries(mfem PUBLIC ClangEnzymeFlags)
-endif()

 set_target_properties(mfem PROPERTIES VERSION "${mfem_VERSION}")
 set_target_properties(mfem PROPERTIES SOVERSION "${mfem_VERSION}")
@@ -120,10 +120,7 @@ The MFEM source code has the following structure:
  |   └── superlu
  ├── fem
  │   ├── ceed
-  │   ├── dfem
-  │   ├── eltrans
  │   ├── fe
-  │   ├── gslib
  │   ├── integ
  │   ├── lor
  │   ├── moonolith
@@ -131,7 +128,6 @@ The MFEM source code has the following structure:
  │   └── tmop
  ├── general
  ├── linalg
-  │   ├── batched
  │   └── simd
  ├── mesh
  │   └── submesh
@@ -139,7 +135,6 @@ The MFEM source code has the following structure:
  │   ├── adjoint
  │   ├── autodiff
  │   ├── common
-  │   ├── dfem
  │   ├── dpg
  │   ├── electromagnetics
  │   ├── gslib
@@ -551,8 +546,6 @@ Before a PR can be merged, it should satisfy the following:
      - [ ] Add a short description of the example in the "Extensive Examples" section of `features.md`.
 - [ ] New miniapps:
   - [ ] All sample runs at the top of the miniapp source file work.
-   - [ ] Add to internal testing repo, if sample runs should be included in nightly tests [internally](#tests-at-llnl).
-   - [ ] Exclude long sample runs from automated testing, with `* ` (one space) before the command.
   - [ ] Update top-level `makefile` and `makefile` in corresponding miniapp directory.
   - [ ] Add the miniapp binary and any files generated by it to the top-level `.gitignore` file.
   - [ ] Update CMake build system:
@@ -747,7 +740,7 @@ and debug build is performed with a simple run of `ex1` to verify the executable
 - We mirror the `master` and `next` branches internally (to `gh-master` and
  `gh-next`) and run longer nightly tests via cron. On the weekends, a more
  extensive test is run which extracts and executes all the different sample
-  runs from each example and most miniapps.
+  runs from each example.

 - We also mirror PRs on the LLNL GitLab instance. PR mirroring can only be
  triggered by _LLNL developers_, but test status is publicly available. Only
@@ -122,14 +122,9 @@ Parallel build:
 (For METIS 5, see https://mfem.org/building/#parallel-build-using-metis-5)

 CUDA build:
-   (this build requires CMake 3.17 or newer)
+   (this build requires CMake 3.8 or newer)
   mkdir <mfem-build-dir> ; cd <mfem-build-dir>
-   cmake <mfem-source-dir> -DMFEM_USE_CUDA=YES -DCUDA_ARCH=sm_70
-   make -j 4
-
-HIP build:
-   mkdir <mfem-build-dir> ; cd <mfem-build-dir>
-   cmake <mfem-source-dir> -DMFEM_USE_HIP=YES -DHIP_ARCH=gfx942 -DCMAKE_CXX_COMPILER=amdclang++ -DCMAKE_HIP_COMPILER=amdclang++
+   cmake <mfem-source-dir> -DMFEM_USE_CUDA=YES
   make -j 4

 Example codes (serial/parallel, depending on the build):
@@ -263,7 +258,7 @@ See the configuration file config/defaults.mk for the default settings.
 Compilers:
   CXX      - C++ compiler, serial build
   MPICXX   - MPI C++ compiler, parallel build
-   CUDA_CXX - The CUDA compiler, 'nvcc' or 'clang++'
+   CUDA_CXX - The CUDA compiler, 'nvcc'

 Compiler options:
   OPTIM_FLAGS - Options for optimized build
@@ -423,10 +418,6 @@ MFEM_USE_GNUTLS = YES/NO
   When MFEM_USE_GNUTLS is enabled, the additional build options, GNUTLS_*, are
   also used, see below.

-MFEM_USE_HDF5 = YES/NO
-   The HDF5 library is used for input and output of HDF5 files, for example
-   Cubit mesh files or VTKHDF files for ParaView.
-
 MFEM_USE_NETCDF = YES/NO
   NetCDF is the library that is used by the SNL Cubit mesh generator to create
   Genesis mesh files. This option enables a reader for these files, which
@@ -608,12 +599,11 @@ MFEM_USE_TRIBOL = YES/NO

 MFEM_USE_ENZYME = YES/NO
   Enables automatic differentiation support through the LLVM plugin Enzyme.
-   This requires the compiler to be set to clang (>=14.0.0). We also advise the
-   use of the link time optimization (LTO) plugin, so functions defined over
-   multiple files (compilation units) can be differentiated automatically. This
-   requires to also use LLVM/LLD for linking. The recommended options are in
-   config/defaults.mk. For more detailed instructions, see the section "Specific
-   options for Enzyme" below.
+   This requires the compiler to be set to clang (>=14.0.0). We also advise to
+   use the link time optimization (LTO) plugin, to enable functions that you
+   define over multiple files (compilation units) and want to be differentiated
+   automatically, to work. This requires to also use LLVM/LLD for linking.
+   Recommended options are in config/defaults.mk.

 MFEM_BUILD_TAG = (any value)
   An optional tag to characterize the build. Exported to config/config.mk.
@@ -738,9 +728,6 @@ The specific libraries and their options are:
  Options: GNUTLS_OPT, GNUTLS_LIB.
  Versions: GnuTLS >= 2.12.0, older versions may work too.

- HDF5 (optional), used when MFEM_USE_HDF5 = YES, required for reading and
-  writing files in VTKHDF format.
-
 - NetCDF (optional), used when MFEM_USE_NETCDF = YES, required for reading Cubit
  mesh files. Also requires installation of HDF5 and ZLIB, as explained at the
  NetCDF web site. Note that we use the plain vanilla "C" version of NetCDF, you
@@ -836,7 +823,7 @@ The specific libraries and their options are:

 - CUDA (optional), used when MFEM_USE_CUDA = YES.
  URL: https://developer.nvidia.com/cuda-toolkit
-  Options: CUDA_CXX, CUDA_ARCH, CUDA_OPT, CUDA_LIB, CUDA_DIR (when CUDA_CXX=clang++).
+  Options: CUDA_CXX, CUDA_ARCH, CUDA_OPT, CUDA_LIB.
  Versions: CUDA >= 10.1.168.

 - HIP (optional), used when MFEM_USE_HIP = YES.
@@ -912,7 +899,7 @@ The specific libraries and their options are:
 - Enzyme, used when MFEM_USE_ENZYME = YES. Requires LLVM/Clang >= 14.0.0.
  URL: https://github.com/EnzymeAD/Enzyme
  Options: ENZYME_DIR, ENZYME_OPT, ENZYME_LIB.
-  Versions: Enzyme >= v0.0.176.
+  Versions: Enzyme >= v0.0.33.


 Building with CMake
@@ -1015,7 +1002,7 @@ Configuration variables (CMake)
 ===============================
 See the configuration file config/defaults.cmake for the default settings.

-Note: the option MFEM_USE_CUDA requires CMake version 3.17 or newer!
+Note: the option MFEM_USE_CUDA requires CMake version 3.8 or newer!

 Non-standard CMake variables for compilers:
   CXX    - If set, overwrite the auto-detected C++ compiler, serial build
@@ -1046,7 +1033,6 @@ MFEM_USE_STRUMPACK
 MFEM_USE_GINKGO
 MFEM_USE_AMGX
 MFEM_USE_GNUTLS
-MFEM_USE_HDF5
 MFEM_USE_NETCDF
 MFEM_USE_MPFR
 MFEM_USE_ZLIB
@@ -1175,89 +1161,6 @@ larger problems, there are two options:
 1. Building hypre with '--enable-bigint' defines the local and global indices to
   be 64-bit. This is convenient, but requires more memory than necessary.

-2. Building hypre with '--enable-mixedint' defines the local indices to be
+2. Building hypre with '--enable-mixedint' defines the local indiced to be
   32-bit, while using a 64-bit storage for global indices. This option is
   currently tested only in ex1p, and may not work in more general settings.
-
-Specific options for HIP
-========================
-MFEM expects the `ROCM_PATH` environment variable to be set to the path of the
-ROCM install, as well as having `$ROCM_PATH/bin` in `PATH`.
-
-Specific options for RAJA+HIP+MPI
-=================================
-RAJA uses CMake's built-in HIP support (added in CMake 3.21), while MFEM uses
-the older HIP C++ library build/linkage. To ensure proper build and linkage
-check that `CMAKE_CXX_COMPILER` and `CMAKE_HIP_COMPILER` are set to the same
-compiler. This is especially important when using an MPI compiler (for example
-crayCC) where some linker flags may get dropped if these two are not identical.
-
-Specific options for Enzyme
-===========================
-To work properly, MFEM and Enzyme need to use the same LLVM/Clang configuration.
-For example, on macOS this can be done by using Homebrew: first install Enzyme,
-which in turn installs LLVM as a dependency (as of May 2025, this is LLVM 19):
-
-   brew install enzyme
-
-In order to ensure the correct compiler choice for the MFEM makefile build, set
-
-   CXX = $(shell brew --prefix llvm@19)/bin/clang++
-
-in the user.mk file (adapted from config/defaults.mk, see the section "Building
-with GNU make" above). With MPI, it is convenient to set
-
-   MPICXX = OMPI_CXX=$(CXX) mpicxx
-
-for OpenMPI and
-
-   MPICXX = MPICH_CXX=$(CXX) mpicxx
-
-for MPICH.
-
-Additionally, the Enzyme directory needs to be set in user.mk as follows:
-
-   ENZYME_DIR = $(shell brew --prefix enzyme)
-
-Specifically, a full build on a Mac can be tested by adding the following
-user.mk file in the config/ directory
-
-   MFEM_USE_ENZYME = YES
-   ENZYME_DIR = $(shell brew --prefix enzyme)
-   LLVM_DIR = $(shell brew --prefix llvm@19)
-   CXX = $(LLVM_DIR)/bin/clang++
-   MFEM_USE_MPI = YES
-   MPICXX = OMPI_CXX=$(CXX) mpicxx
-
-and running
-
-   make config
-   make -j
-   cd miniapps/dfem
-   make
-   ./dfem-minimal-surface
-
-On Linux systems, for example Ubuntu 24.04, use the package manager to install
-the Enzyme dependencies
-
-   sudo apt install libclang-dev libzstd-dev llvm-dev clang
-
-and then clone and build Enzyme
-
-   cd $HOME
-   git clone https://github.com/EnzymeAD/Enzyme.git
-   cd Enzyme/enzyme && mkdir build && cd build
-   CC=clang CXX=clang++ cmake .. -DLLVM_DIR=/usr/lib/llvm-18/lib/cmake -DCMAKE_INSTALL_PREFIX=$HOME/Enzyme/enzyme/build
-   make -j
-   make install
-
-From here, one can proceed in the same way using the following user.mk settings
-
-   MFEM_USE_ENZYME = YES
-   ENZYME_DIR = $(HOME)/Enzyme/enzyme/build
-   CXX = clang++
-   MFEM_USE_MPI = YES
-   MPICXX = OMPI_CXX=$(CXX) mpicxx
-
-On other Linux systems the LLVM packages may have different names, for example
-on RHEL9, one needs to "sudo yum install llvm-devel libzstd clang-devel".
@@ -41,7 +41,6 @@ set(MFEM_USE_MAGMA @MFEM_USE_MAGMA@)
 set(MFEM_USE_HIOP @MFEM_USE_HIOP@)
 set(MFEM_USE_GNUTLS @MFEM_USE_GNUTLS@)
 set(MFEM_USE_GSLIB @MFEM_USE_GSLIB@)
-set(MFEM_USE_HDF5 @MFEM_USE_HDF5@)
 set(MFEM_USE_NETCDF @MFEM_USE_NETCDF@)
 set(MFEM_USE_PETSC @MFEM_USE_PETSC@)
 set(MFEM_USE_SLEPC @MFEM_USE_SLEPC@)
@@ -132,9 +132,6 @@
 // Enable Conduit support.
 #cmakedefine MFEM_USE_CONDUIT

-// Enable functionality based on the HDF5 library (reading VTKHDF files).
-#cmakedefine MFEM_USE_HDF5
-
 // Enable functionality based on the NetCDF library (reading CUBIT files).
 #cmakedefine MFEM_USE_NETCDF

@@ -0,0 +1,27 @@
+# Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
+# at the Lawrence Livermore National Laboratory. All Rights reserved. See files
+# LICENSE and NOTICE for details. LLNL-CODE-806117.
+#
+# This file is part of the MFEM library. For more information and source code
+# availability visit https://mfem.org.
+#
+# MFEM is free software; you can redistribute it and/or modify it under the
+# terms of the BSD-3 license. We welcome feedback and contributions, see file
+# CONTRIBUTING.md for details.
+
+message(STATUS "Looking for ENZYME ...")
+message(STATUS "   in ENZYME_DIR = ${ENZYME_DIR}")
+
+# Make sure the directory and version combination works. Do nothing otherwise.
+if(EXISTS "${ENZYME_DIR}/ClangEnzyme-${ENZYME_VERSION}.so")
+  message(STATUS "Found ENZYME: ${ENZYME_DIR}/ClangEnzyme-${ENZYME_VERSION}.so")
+
+  # Set ENZYME_FOUND
+  set(ENZYME_FOUND TRUE CACHE BOOL "ENZYME was found." FORCE)
+
+  # Set CXX flags to accommodate the Enzyme Clang plugin
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Xclang -load -Xclang ${ENZYME_DIR}/ClangEnzyme-${ENZYME_VERSION}.so -mllvm -enzyme-loose-types=1")
+  set(MFEM_USE_ENZYME YES)
+else()
+
+endif()
@@ -25,12 +25,7 @@ if (HYPRE_FOUND)
    find_package(rocsparse REQUIRED)
    find_package(rocrand REQUIRED)
  endif()
-  if (HYPRE_LIBRARIES AND HYPRE_INCLUDE_DIRS AND HYPRE_VERSION)
-    find_package_handle_standard_args(HYPRE
-      REQUIRED_VARS HYPRE_LIBRARIES HYPRE_INCLUDE_DIRS HYPRE_VERSION
-    )
-    return()
-  endif()
+  return()
 endif()

 include(MfemCmakeUtilities)
@@ -82,13 +77,11 @@ endif()

 if (HYPRE_FOUND AND HYPRE_USING_CUDA)
  find_package(CUDAToolkit REQUIRED)
-  # Initialize CUSPARSE_LIBRARIES, CURAND_LIBRARIES, and CUBLAS_LIBRARIES:
-  mfem_culib_set_libraries(CUSPARSE cusparse)
-  mfem_culib_set_libraries(CURAND curand)
-  mfem_culib_set_libraries(CUBLAS cublas)
-  mfem_culib_set_libraries(CUSOLVER cusolver)
+  get_target_property(CUSPARSE_LIBRARIES CUDA::cusparse LOCATION)
+  get_target_property(CURAND_LIBRARIES CUDA::curand LOCATION)
+  get_target_property(CUBLAS_LIBRARIES CUDA::cublas LOCATION)
  list(APPEND HYPRE_LIBRARIES ${CUSPARSE_LIBRARIES} ${CURAND_LIBRARIES}
-       ${CUBLAS_LIBRARIES} ${CUSOLVER_LIBRARIES})
+       ${CUBLAS_LIBRARIES})
  set(HYPRE_LIBRARIES ${HYPRE_LIBRARIES} CACHE STRING
      "HYPRE libraries + dependencies." FORCE)
  message(STATUS "Updated HYPRE_LIBRARIES: ${HYPRE_LIBRARIES}")
@@ -102,7 +95,3 @@ if (HYPRE_FOUND AND HYPRE_USING_HIP)
      "HYPRE libraries + dependencies." FORCE)
  message(STATUS "Updated HYPRE_LIBRARIES: ${HYPRE_LIBRARIES}")
 endif()
-
-find_package_handle_standard_args(HYPRE
-  REQUIRED_VARS HYPRE_LIBRARIES HYPRE_INCLUDE_DIRS HYPRE_VERSION
-)
@@ -19,10 +19,8 @@ mfem_find_package(MAGMA MAGMA MAGMA_DIR "include" "magma.h" "lib" "magma"
  "Paths to headers required by MAGMA." "Libraries required by MAGMA.")

 if (MAGMA_FOUND AND MFEM_USE_CUDA)
-  find_package(CUDAToolkit REQUIRED)
-  # Initialize CUSPARSE_LIBRARIES and CUBLAS_LIBRARIES:
-  mfem_culib_set_libraries(CUSPARSE cusparse)
-  mfem_culib_set_libraries(CUBLAS cublas)
+  get_target_property(CUSPARSE_LIBRARIES CUDA::cusparse LOCATION)
+  get_target_property(CUBLAS_LIBRARIES CUDA::cublas LOCATION)
  list(APPEND MAGMA_LIBRARIES ${CUSPARSE_LIBRARIES} ${CUBLAS_LIBRARIES})
  set(MAGMA_LIBRARIES ${MAGMA_LIBRARIES} CACHE STRING
      "MAGMA libraries + dependencies." FORCE)
@@ -123,10 +123,15 @@ macro(add_mfem_miniapp MFEM_EXE_NAME)

  # If CUDA is enabled, tag source files to be compiled with nvcc.
  if (MFEM_USE_CUDA)
-    set_source_files_properties(${MAIN_LIST} ${EXTRA_SOURCES_LIST}
-      PROPERTIES LANGUAGE CUDA)
-    if (MFEM_CUDA_COMPILER_IS_NVCC)
+    set_source_files_properties(${MAIN_LIST} ${EXTRA_SOURCES_LIST} PROPERTIES LANGUAGE CUDA)
+    if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
      list(TRANSFORM EXTRA_OPTIONS_LIST PREPEND "-Xcompiler=")
+    else()
+      set(LIST_)
+      foreach(item IN LISTS EXTRA_OPTIONS_LIST)
+        list(APPEND LIST_ "-Xcompiler=${item}")
+      endforeach()
+      set(EXTRA_OPTIONS_LIST ${LIST_})
    endif()
  endif()

@@ -152,21 +157,6 @@ macro(add_mfem_miniapp MFEM_EXE_NAME)
  endif()
 endmacro()

-# Macro for setting variables like '<culib>_LIBRARIES' where <culib> is a CUDA
-# library like cublas. This macro assumes that the CUDAToolkit module was loaded
-# successfully. Example usage:
-#   mfem_culib_set_libraries(CUBLAS cublas)
-macro(mfem_culib_set_libraries _CULIB _culib)
-  # The following command does not work with older CMake versions, e.g. 3.20:
-  #   get_target_property(${_CULIB}_LIBRARIES CUDA::${_culib} LOCATION)
-  # Therefore, we use the respective internal variable:
-  set(${_CULIB}_LIBRARIES ${CUDA_${_culib}_LIBRARY})
-  if (NOT ${_CULIB}_LIBRARIES)
-    message(FATAL_ERROR
-      "Error setting ${_CULIB}_LIBRARIES: ${${_CULIB}_LIBRARIES}")
-  endif()
-endmacro()
-

 # Auxiliary function, used in mfem_find_package().
 function(mfem_find_component Prefix DirVar IncSuffixes Header LibSuffixes Lib
@@ -879,8 +869,7 @@ function(mfem_export_mk_files)
      MFEM_USE_OCCA MFEM_USE_CEED MFEM_USE_CALIPER MFEM_USE_UMPIRE MFEM_USE_SIMD
      MFEM_USE_ADIOS2 MFEM_USE_MKL_CPARDISO MFEM_USE_MKL_PARDISO
      MFEM_USE_ADFORWARD MFEM_USE_CODIPACK MFEM_USE_BENCHMARK MFEM_USE_PARELAG
-      MFEM_USE_TRIBOL MFEM_USE_MOONOLITH MFEM_USE_ALGOIM MFEM_USE_ENZYME
-      MFEM_USE_HDF5)
+      MFEM_USE_TRIBOL MFEM_USE_MOONOLITH MFEM_USE_ALGOIM MFEM_USE_ENZYME)
  foreach(var ${CONFIG_MK_BOOL_VARS})
    if (${var})
      set(${var} YES)
@@ -93,17 +93,17 @@ macro (RESOLVE_LIBRARIES LIBS LINK_LINE)
        set (_directory_list ${_directory_list} ${libpath})
        set (token ${libname})
      endif (token MATCHES "^/")
-      set (_lib "NOTFOUND")
+      set (_lib "NOTFOUND" CACHE FILEPATH "Cleared" FORCE)
      find_library (_lib ${token} HINTS ${_directory_list} ${_root})
      if (_lib)
-        string (REPLACE "//" "/" _lib ${_lib})
+	string (REPLACE "//" "/" _lib ${_lib})
        list (APPEND _libs_found ${_lib})
      else (_lib)
        message (STATUS "Unable to find library ${token}")
      endif (_lib)
-      unset(_lib CACHE)
    endif (token MATCHES "-L([^\" ]+|\"[^\"]+\")")
  endforeach (token)
+  set (_lib "NOTFOUND" CACHE INTERNAL "Scratch variable" FORCE)
  # only the LAST occurrence of each library is required since there should be no circular dependencies
  if (_libs_found)
    list (REVERSE _libs_found)
@@ -132,9 +132,6 @@
 // Enable Conduit support.
 // #define MFEM_USE_CONDUIT

-// Enable functionality based on the HDF5 library
-// #define MFEM_USE_HDF5
-
 // Enable functionality based on the NetCDF library (reading CUBIT files).
 // #define MFEM_USE_NETCDF

@@ -40,7 +40,6 @@ MFEM_USE_GINKGO        = @MFEM_USE_GINKGO@
 MFEM_USE_AMGX          = @MFEM_USE_AMGX@
 MFEM_USE_MAGMA         = @MFEM_USE_MAGMA@
 MFEM_USE_GNUTLS        = @MFEM_USE_GNUTLS@
-MFEM_USE_HDF5          = @MFEM_USE_HDF5@
 MFEM_USE_NETCDF        = @MFEM_USE_NETCDF@
 MFEM_USE_PETSC         = @MFEM_USE_PETSC@
 MFEM_USE_SLEPC         = @MFEM_USE_SLEPC@
@@ -98,7 +97,7 @@ MFEM_MPIEXEC_NP = @MFEM_MPIEXEC_NP@
 MFEM_MPI_NP     = @MFEM_MPI_NP@

 # The NVCC compiler cannot link with -x=cu
-MFEM_LINK_FLAGS := $(filter-out -x=cu -xcuda -xhip, $(MFEM_FLAGS))
+MFEM_LINK_FLAGS := $(filter-out -x=cu -xhip, $(MFEM_FLAGS))

 # Optional extra configuration
@MFEM_CONFIG_EXTRA@
@@ -43,7 +43,6 @@ option(MFEM_USE_AMGX "Enable AmgX usage" OFF)
 option(MFEM_USE_MAGMA "Enable MAGMA usage" OFF)
 option(MFEM_USE_GNUTLS "Enable GNUTLS usage" OFF)
 option(MFEM_USE_GSLIB "Enable GSLIB usage" OFF)
-option(MFEM_USE_HDF5 "Enable HDF5 usage" OFF)
 option(MFEM_USE_NETCDF "Enable NETCDF usage" OFF)
 option(MFEM_USE_PETSC "Enable PETSc support." OFF)
 option(MFEM_USE_SLEPC "Enable SLEPc support." OFF)
@@ -268,8 +267,6 @@ set(TRIBOL_DIR "${MFEM_DIR}/../tribol" CACHE PATH "Path to Tribol")
 set(Tribol_REQUIRED_PACKAGES "Axom/core/mint/slam/slic" CACHE STRING
    "Additional packages required by Tribol")

-set(ENZYME_DIR "${MFEM_DIR}/../enzyme" CACHE PATH "Path to Enzyme")
-
 set(BLAS_INCLUDE_DIRS "" CACHE STRING "Path to BLAS headers.")
 set(BLAS_LIBRARIES "" CACHE STRING "The BLAS library.")
 set(LAPACK_INCLUDE_DIRS "" CACHE STRING "Path to LAPACK headers.")
@@ -24,7 +24,7 @@ EGREP_BIN = $(shell command -v egrep 2> /dev/null)
 CXX = g++
 MPICXX = mpicxx

-BASE_FLAGS  = -std=c++17
+BASE_FLAGS  = -std=c++11
 OPTIM_FLAGS = -O3 $(BASE_FLAGS)
 DEBUG_FLAGS = -g $(XCOMPILER)-Wall $(BASE_FLAGS)

@@ -43,23 +43,12 @@ SHARED = NO

 # CUDA configuration options
 #
-# If you set MFEM_USE_ENZYME=YES, must use CUDA_CXX=clang++
+# If you set MFEM_USE_ENZYME=YES, CUDA_CXX has to be configured to use cuda with
+# clang as its host compiler.
 CUDA_CXX = nvcc
 CUDA_ARCH = sm_60
-# Base CUDA install directory, only needed if building with clang+cuda:
-# The default setting is:
-# 1. If CUDA_HOME is defined and non-empty, use that.
-# 2. If nvcc is in the path, use the directory two levels up from that.
-# 3. Use /usr/local/cuda
-CUDA_DIR = $(or $(CUDA_HOME),$(patsubst %/,%,$(dir \
- $(patsubst %/,%,$(dir $(shell command -v nvcc))))),/usr/local/cuda)
-# flags for clang+cuda
-CLANG_CUDA_FLAGS = -xcuda --cuda-path=$(CUDA_DIR) --cuda-gpu-arch=$(CUDA_ARCH)
-# flags for nvcc
-NVCC_FLAGS = -x=cu --expt-extended-lambda --expt-relaxed-constexpr \
- -arch=$(CUDA_ARCH)
-# Prefixes for passing flags to the host compiler and linker when using
-# CUDA_CXX=nvcc
+CUDA_FLAGS = -x=cu --expt-extended-lambda -arch=$(CUDA_ARCH)
+# Prefixes for passing flags to the host compiler and linker when using CUDA_CXX
 CUDA_XCOMPILER = -Xcompiler=
 CUDA_XLINKER   = -Xlinker=

@@ -156,7 +145,6 @@ MFEM_USE_GINKGO        = NO
 MFEM_USE_AMGX          = NO
 MFEM_USE_MAGMA         = NO
 MFEM_USE_GNUTLS        = NO
-MFEM_USE_HDF5          = NO
 MFEM_USE_NETCDF        = NO
 MFEM_USE_PETSC         = NO
 MFEM_USE_SLEPC         = NO
@@ -238,7 +226,7 @@ HYPRE_OPT = -I$(HYPRE_DIR)/include
 HYPRE_LIB = -L$(HYPRE_DIR)/lib -lHYPRE
 ifeq (YES,$(MFEM_USE_CUDA))
   # This is only necessary when hypre is built with cuda:
-   HYPRE_LIB += -lcusolver -lcusparse -lcurand -lcublas
+   HYPRE_LIB += -lcusparse -lcurand -lcublas
 endif
 ifeq (YES,$(MFEM_USE_HIP))
   # This is only necessary when hypre is built with hip:
@@ -253,7 +241,7 @@ ifeq ($(MFEM_USE_SUPERLU)$(MFEM_USE_STRUMPACK)$(MFEM_USE_MUMPS),NONONO)
     METIS_OPT =
     METIS_LIB = -L$(METIS_DIR) -lmetis
   else
-     METIS_DIR = @MFEM_DIR@/../metis-5.1.0
+     METIS_DIR = @MFEM_DIR@/../metis-5.0
     METIS_OPT = -I$(METIS_DIR)/include
     METIS_LIB = -L$(METIS_DIR)/lib -lmetis
   endif
@@ -413,14 +401,9 @@ MAGMA_LIB = -L$(MAGMA_DIR)/lib -l:libmagma.a -lcublas -lcusparse $(LAPACK_LIB)
 GNUTLS_OPT =
 GNUTLS_LIB = -lgnutls

-# HDF5 library configuration
-HDF5_DIR   = $(HOME)/local
-HDF5_OPT = -I$(HDF5_DIR)/include
-HDF5_LIB = $(XLINKER)-rpath,$(HDF5_DIR)/lib -L$(HDF5_DIR)/lib -lhdf5_hl -lhdf5 \
-           $(ZLIB_LIB)
-
 # NetCDF library configuration
 NETCDF_DIR = $(HOME)/local
+HDF5_DIR   = $(HOME)/local
 NETCDF_OPT = -I$(NETCDF_DIR)/include -I$(HDF5_DIR)/include $(ZLIB_OPT)
 NETCDF_LIB = $(XLINKER)-rpath,$(NETCDF_DIR)/lib -L$(NETCDF_DIR)/lib\
 $(XLINKER)-rpath,$(HDF5_DIR)/lib -L$(HDF5_DIR)/lib\
@@ -501,8 +484,8 @@ SIDRE_LIB = \
 # Note that PUMI_DIR is needed -- it is used to check for gmi_sim.h
 PUMI_DIR = @MFEM_DIR@/../pumi-2.1.0
 PUMI_OPT = -I$(PUMI_DIR)/include
-PUMI_LIB = -L$(PUMI_DIR)/lib64 -L$(PUMI_DIR)/lib -lpumi -lcrv -lma -lmds -lapf\
-   -lpcu -lgmi -lparma -llion -lmth -lapf_zoltan -lspr
+PUMI_LIB = -L$(PUMI_DIR)/lib -lpumi -lcrv -lma -lmds -lapf -lpcu -lgmi -lparma\
+   -llion -lmth -lapf_zoltan -lspr

 # HIOP
 HIOP_DIR = @MFEM_DIR@/../hiop/install
@@ -522,9 +505,6 @@ GSLIB_LIB = -L$(GSLIB_DIR)/lib -lgs
 # CUDA library configuration
 CUDA_OPT =
 CUDA_LIB = -lcusparse -lcublas
-CLANG_CUDA_LIB = -L$(CUDA_DIR)/lib64 -L$(CUDA_DIR)/lib \
- $(XLINKER)-rpath,$(CUDA_DIR)/lib64,-rpath,$(CUDA_DIR)/lib \
- -lcudart -ldl -lrt -pthread

 # HIP library configuration
 HIP_OPT =
@@ -588,11 +568,7 @@ RAJA_LIB = $(XLINKER)-rpath,$(RAJA_DIR)/lib -L$(RAJA_DIR)/lib -lRAJA $(CAMP_LIB)
 # UMPIRE library configuration
 UMPIRE_DIR = @MFEM_DIR@/../umpire
 UMPIRE_OPT = -I$(UMPIRE_DIR)/include $(if $(CAMP_DIR), -I$(CAMP_DIR)/include)
-UMPIRE_LIB = -L$(UMPIRE_DIR)/lib -L$(UMPIRE_DIR)/lib64 -lumpire $(CAMP_LIB)
-ifdef FMT_DIR
-   UMPIRE_OPT += -I$(FMT_DIR)/include
-   UMPIRE_LIB += -L$(FMT_DIR)/lib -L$(FMT_DIR)/lib64 -lfmt
-endif
+UMPIRE_LIB = -L$(UMPIRE_DIR)/lib -lumpire $(CAMP_LIB)

 # MKL CPardiso library configuration
 MKL_CPARDISO_DIR ?=
@@ -624,20 +600,29 @@ TRIBOL_LIB = -L$(TRIBOL_DIR)/lib -ltribol -lredecomp -L$(AXOM_DIR)/lib -laxom_mi
   -laxom_slam -laxom_slic -laxom_core

 # Enzyme configuration
-ENZYME_DIR = @MFEM_DIR@/../enzyme
-ENZYME_PLUGIN = $(abspath $(wildcard $(subst \
-   @MFEM_DIR@,$(MFEM_DIR),$(ENZYME_DIR))/lib/ClangEnzyme-*.$(SO_EXT)))
-ifeq ($(MAKECMDGOALS)-$(MFEM_USE_ENZYME),config-YES)
-   ifeq ($(ENZYME_PLUGIN),)
-      $(error Unable to find the Enzyme pluging! Please set ENZYME_DIR)
-   endif
-   ifneq ($(words $(ENZYME_PLUGIN)),1)
-      $(error Multiple versions of the Enzyme pluging found! \
-              Please set ENZYME_PLUGIN directly)
-   endif
+
+# If you want to enable automatic differentiation at compile time, use the
+# options below, adapted to your configuration. To be more flexible, we
+# recommend using the Enzyme plugin during link time optimization. One option is
+# to add your options to the global compiler/linker flags like
+#
+# BASE_FLAGS += -flto
+# CXX_XLINKER += -fuse-ld=lld -Wl,--lto-legacy-pass-manager\
+#                -Wl,-mllvm=-load=$(ENZYME_DIR)/LLDEnzyme-$(ENZYME_VERSION).so -Wl,
+#
+ENZYME_DIR ?= @MFEM_DIR@/../enzyme
+ENZYME_VERSION ?= 14
+ENZYME_OPT = -fno-experimental-new-pass-manager -Xclang -load -Xclang $(ENZYME_DIR)/ClangEnzyme-$(ENZYME_VERSION).so
+ENZYME_LIB = ""
+
+# Google Benchmark, SUNDIALS >= 6.4.0, STRUMPACK, RAJA, UMPIRE, and Tribol require C++14:
+ifneq ($(filter YES,$(MFEM_USE_BENCHMARK) $(MFEM_USE_SUNDIALS) $(MFEM_USE_STRUMPACK) $(MFEM_USE_RAJA) $(MFEM_USE_UMPIRE) $(MFEM_USE_TRIBOL)),)
+    BASE_FLAGS = -std=c++14
+endif
+# Ginkgo requires C++17:
+ifeq ($(MFEM_USE_GINKGO),YES)
+   BASE_FLAGS = -std=c++17
 endif
-ENZYME_OPT = -fplugin=$(ENZYME_PLUGIN)
-ENZYME_LIB =

 # If YES, enable some informational messages
 VERBOSE = NO
@@ -17,7 +17,7 @@ We provide two containers, which you can either build or use directly from

 In the above, "ghcr.io" means "GitHub Container Registry" and
 is the [GitHub packages](https://github.com/features/packages) registry that supports
-Docker images and other OCI artifacts.
+Docker images and other OCI artifacts. 

 ### Ubuntu

@@ -132,7 +132,7 @@ examples.

 > Use this build for a development environment with spack and mfem

-This container is also [provided on GitHub packages](https://github.com/mfem/mfem/pkgs/container/mfem-ubuntu-base),
+This container is also [provided on GitHub packages](https://github.com/mfem/mfem/pkgs/container/mfem-ubuntu-base), 
 however you can build it locally too:

 ```bash
@@ -197,7 +197,7 @@ Average reduction factor = 0.140201

 This container is likely ideal for someone that wants to develop mfem itself.
 For other use cases, we recommend using the slimmer image. As an example,
-if you want to develop with your own code base (and mfem as is in the container)
+if you want to develop with your own code base (and mfem as is in the container) 
 you can bind to somewhere else in the container (e.g., src)

 ```bash
@@ -1,20 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 186a320..39e5356 100644
--- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8)
-+cmake_minimum_required(VERSION 3.12.0...4.0.0)
- project(METIS)
- 
- set(GKLIB_PATH "${CMAKE_SOURCE_DIR}/GKlib" CACHE PATH "path to GKlib")
-diff --git a/GKlib/CMakeLists.txt b/GKlib/CMakeLists.txt
-index 67b600a..44321a6 100644
--- a/GKlib/CMakeLists.txt
-+++ b/GKlib/CMakeLists.txt
-@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8)
-+cmake_minimum_required(VERSION 3.12.0...4.0.0)
- project(GKlib)
- 
- get_filename_component(abs "." ABSOLUTE)
@@ -22,7 +22,6 @@ vcpkg_extract_source_archive_ex(
        fix-linux-build-error.patch
        install-metisConfig.patch
        fix-INT_MIN_define.patch
-        cmake4.patch
 )

 vcpkg_configure_cmake(
@@ -1,38 +0,0 @@
-MFEM mesh v1.0
-
-#
-# MFEM Geometry Types (see fem/geom.hpp):
-#
-# POINT       = 0
-# SEGMENT     = 1
-# TRIANGLE    = 2
-# SQUARE      = 3
-# TETRAHEDRON = 4
-# CUBE        = 5
-# PRISM       = 6
-# PYRAMID     = 7
-#
-
-dimension
-3
-
-elements
-1
-1 7 0 1 2 3 4
-
-boundary
-5
-1 3 3 2 1 0
-2 2 0 1 4
-3 2 1 2 4
-4 2 2 3 4
-5 2 3 0 4
-
-vertices
-5
-3
-0.5 -0.5 0
-0.5 -0.5 0
-0.5 0.5 0
-0.5 0.5 0
-0 0 0.7071067811865475
@@ -115,7 +115,7 @@ vertices

 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_3D_P2
+FiniteElementCollection: Quadratic
 VDim: 3
 Ordering: 0

@@ -1,108 +0,0 @@
-MFEM mesh v1.0
-
-#
-# MFEM Geometry Types (see fem/geom.hpp):
-#
-# POINT       = 0
-# SEGMENT     = 1
-# TRIANGLE    = 2
-# SQUARE      = 3
-# TETRAHEDRON = 4
-# CUBE        = 5
-# PRISM       = 6
-# PYRAMID     = 7
-#
-
-dimension
-3
-
-elements
-16
-1 5 12 13 16 15 21 22 25 24
-1 6  9 12  8 18 21 17
-1 6 11  8 12 20 17 21
-1 6  3  2 12  6  5 15
-1 6 11 12  2 14 15  5
-1 6  3 12  0  4 13  1
-1 6  9  0 12 10  1 13
-1 7 12 13 22 21 19
-1 7 15 16 13 12  7
-1 7 12 21 24 15 23
-1 7  9 12 21 18 19
-1 7 11 20 21 12 23
-1 7  9 10 13 12 19
-1 7 11 12 15 14 23
-1 7  3  6 15 12  7
-1 7  3 12 13  4  7
-
-boundary
-39
- 1 3  5  6  3  2
- 2 2  6  7  3
- 2 2  7  4  3
- 3 3  3  4  1  0
- 4 2 11 12  8
- 4 2  9  8 12
- 5 2  3 12  2
- 5 2 11  2 12
- 6 3  0  1 10  9
- 7 2 10 19  9
- 7 2 18  9 19
- 8 3  8  9 18 17
- 9 2  4 13  1
- 9 2 10  1 13
-10 2  4  7 13
-10 2 16 13  7
-11 3 13 16 25 22
-12 2 10 13 19
-12 2 22 19 13
-13 2  6 15  7
-13 2 16  7 15
-14 2  6  5 15
-14 2 14 15  5
-15 2 14 23 15
-15 2 24 15 23
-16 3 16 15 24 25
-17 3  5  2 11 14
-18 2  3  0 12
-18 2  9 12  0
-19 3 11  8 17 20
-20 2 14 11 23
-20 2 20 23 11
-21 2 18 21 17
-21 2 20 17 21
-22 2 18 19 21
-22 2 22 21 19
-23 3 21 22 25 24
-24 2 20 21 23
-24 2 24 23 21
-
-vertices
-26
-3
-0 -1 -1
-1 -1 -1
-1 0 -1
-0 0 -1
-1 0 -1
-1 1 -1
-0 1 -1
-1 1 -1
-1 -1 0
-0 -1 0
-1 -1 0
-1 0 0
-0 0 0
-1 0 0
-1 1 0
-0 1 0
-1 1 0
-1 -1 1
-0 -1 1
-1 -1 1
-1 0 1
-0 0 1
-1 0 1
-1 1 1
-0 1 1
-1 1 1
@@ -56,7 +56,7 @@ vertices

 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_3D_P2
+FiniteElementCollection: Quadratic
 VDim: 3
 Ordering: 0

@@ -1,9 +1,9 @@
 MFEM INLINE mesh v1.0

 type = pyramid
-nx = 2
-ny = 2
-nz = 2
+nx = 4
+ny = 4
+nz = 4
 sx = 1.0
 sy = 1.0
 sz = 1.0
@@ -227,7 +227,7 @@ vertices

 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_2D_P2
+FiniteElementCollection: Quadratic
 VDim: 2
 Ordering: 0

@@ -65,7 +65,7 @@ vertices

 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_2D_P2
+FiniteElementCollection: Quadratic
 VDim: 2
 Ordering: 0

@@ -48,7 +48,7 @@ PROJECT_NAME           = MFEM
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = v4.8.1
+PROJECT_NUMBER         = v4.7.1

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -951,11 +951,7 @@ INPUT                  = @MFEM_SOURCE_DIR@/doc/CodeDocumentation.dox \
                         @MFEM_SOURCE_DIR@/fem/ceed/integrators/nlconvection \
                         @MFEM_SOURCE_DIR@/fem/ceed/interface \
                         @MFEM_SOURCE_DIR@/fem/ceed/solvers \
-                         @MFEM_SOURCE_DIR@/fem/dfem \
-                         @MFEM_SOURCE_DIR@/fem/eltrans \
                         @MFEM_SOURCE_DIR@/fem/fe \
-                         @MFEM_SOURCE_DIR@/fem/gslib \
-                         @MFEM_SOURCE_DIR@/fem/integ \
                         @MFEM_SOURCE_DIR@/fem/lor \
                         @MFEM_SOURCE_DIR@/fem/moonolith \
                         @MFEM_SOURCE_DIR@/fem/qinterp \
@@ -973,9 +969,6 @@ INPUT                  = @MFEM_SOURCE_DIR@/doc/CodeDocumentation.dox \
                         @MFEM_SOURCE_DIR@/miniapps/adjoint \
                         @MFEM_SOURCE_DIR@/miniapps/autodiff \
                         @MFEM_SOURCE_DIR@/miniapps/common \
-                         @MFEM_SOURCE_DIR@/miniapps/dfem \
-                         @MFEM_SOURCE_DIR@/miniapps/dpg \
-                         @MFEM_SOURCE_DIR@/miniapps/dpg/util \
                         @MFEM_SOURCE_DIR@/miniapps/electromagnetics \
                         @MFEM_SOURCE_DIR@/miniapps/gslib \
                         @MFEM_SOURCE_DIR@/miniapps/hdiv-linear-solver \
@@ -993,10 +986,12 @@ INPUT                  = @MFEM_SOURCE_DIR@/doc/CodeDocumentation.dox \
                         @MFEM_SOURCE_DIR@/miniapps/performance \
                         @MFEM_SOURCE_DIR@/miniapps/shifted \
                         @MFEM_SOURCE_DIR@/miniapps/solvers \
-                         @MFEM_SOURCE_DIR@/miniapps/spde \
                         @MFEM_SOURCE_DIR@/miniapps/tools \
                         @MFEM_SOURCE_DIR@/miniapps/toys \
-                         @MFEM_SOURCE_DIR@/miniapps/tribol
+                         @MFEM_SOURCE_DIR@/miniapps/tribol \
+                         @MFEM_SOURCE_DIR@/miniapps/spde \
+                         @MFEM_SOURCE_DIR@/miniapps/dpg \
+                         @MFEM_SOURCE_DIR@/miniapps/dpg/util

 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -42,10 +42,10 @@ namespace mfem {
 * - mfem::forall functions in forall.hpp
 *
 * <H3>Example codes</H3>
- * - <a class="el" href="ex0_8cpp_source.html">Example 0</a>: simplest example, nodal H1 FEM for the Poisson problem
- * - <a class="el" href="ex0p_8cpp_source.html">Example 0p</a>: simplest parallel example, nodal H1 FEM for the Poisson problem
- * - <a class="el" href="examples_2ex1_8cpp_source.html">Example 1</a>: nodal H1 FEM for the Poisson problem (same discretization as ex0 but with more sophisticated options)
- * - <a class="el" href="examples_2ex1p_8cpp_source.html">Example 1p</a>: parallel nodal H1 FEM for the Poisson problem (same discretization as ex0p but with more sophisticated options)
+ * - <a class="el" href="ex0_8cpp_source.html">Example 0</a>: simplest example, nodal H1 FEM for the Laplace problem
+ * - <a class="el" href="ex0p_8cpp_source.html">Example 0p</a>: simplest parallel example, nodal H1 FEM for the Laplace problem
+ * - <a class="el" href="examples_2ex1_8cpp_source.html">Example 1</a>: nodal H1 FEM for the Laplace problem (same discretization as ex0 but with more sophisticated options)
+ * - <a class="el" href="examples_2ex1p_8cpp_source.html">Example 1p</a>: parallel nodal H1 FEM for the Laplace problem (same discretization as ex0p but with more sophisticated options)
 * - <a class="el" href="ex2_8cpp_source.html">Example 2</a>: vector FEM for linear elasticity
 * - <a class="el" href="ex2p_8cpp_source.html">Example 2p</a>: parallel vector FEM for linear elasticity
 * - <a class="el" href="ex3_8cpp_source.html">Example 3</a>: Nedelec H(curl) FEM for the definite Maxwell problem
@@ -54,12 +54,12 @@ namespace mfem {
 * - <a class="el" href="ex4p_8cpp_source.html">Example 4p</a>: parallel Raviart-Thomas H(div) FEM for the grad-div problem
 * - <a class="el" href="ex5_8cpp_source.html">Example 5</a>: mixed pressure-velocity FEM for the Darcy problem
 * - <a class="el" href="ex5p_8cpp_source.html">Example 5p</a>: parallel mixed pressure-velocity FEM for the Darcy problem
- * - <a class="el" href="ex6_8cpp_source.html">Example 6</a>: non-conforming adaptive mesh refinement for the Poisson problem
- * - <a class="el" href="ex6p_8cpp_source.html">Example 6p</a>: parallel non-conforming adaptive mesh refinement for the Poisson problem
- * - <a class="el" href="ex7_8cpp_source.html">Example 7</a>: screened Poisson problem on a surface (the unit sphere)
- * - <a class="el" href="ex7p_8cpp_source.html">Example 7p</a>: parallel screened Poisson problem on a surface (the unit sphere)
- * - <a class="el" href="ex8_8cpp_source.html">Example 8</a>: Discontinuous Petrov-Galerkin (DPG) for the Poisson problem
- * - <a class="el" href="ex8p_8cpp_source.html">Example 8p</a>: parallel Discontinuous Petrov-Galerkin (DPG) for the Poisson problem
+ * - <a class="el" href="ex6_8cpp_source.html">Example 6</a>: non-conforming adaptive mesh refinement for the Laplace problem
+ * - <a class="el" href="ex6p_8cpp_source.html">Example 6p</a>: parallel non-conforming adaptive mesh refinement for the Laplace problem
+ * - <a class="el" href="ex7_8cpp_source.html">Example 7</a>: Laplace problem on a surface (the unit sphere)
+ * - <a class="el" href="ex7p_8cpp_source.html">Example 7p</a>: parallel Laplace problem on a surface (the unit sphere)
+ * - <a class="el" href="ex8_8cpp_source.html">Example 8</a>: Discontinuous Petrov-Galerkin (DPG) for the Laplace problem
+ * - <a class="el" href="ex8p_8cpp_source.html">Example 8p</a>: parallel Discontinuous Petrov-Galerkin (DPG) for the Laplace problem
 * - <a class="el" href="ex9_8cpp_source.html">Example 9</a>: Discontinuous Galerkin (DG) time-dependent advection
 * - <a class="el" href="ex9p_8cpp_source.html">Example 9p</a>: parallel Discontinuous Galerkin (DG) time-dependent advection
 * - <a class="el" href="ex10_8cpp_source.html">Example 10</a>: time-dependent implicit nonlinear elasticity
@@ -67,8 +67,8 @@ namespace mfem {
 * - <a class="el" href="ex11p_8cpp_source.html">Example 11p</a>: parallel Laplace eigensolver
 * - <a class="el" href="ex12p_8cpp_source.html">Example 12p</a>: parallel linear elasticity eigensolver
 * - <a class="el" href="ex13p_8cpp_source.html">Example 13p</a>: parallel Maxwell eigensolver
- * - <a class="el" href="ex14_8cpp_source.html">Example 14</a>: Discontinuous Galerkin (DG) for the Poisson problem
- * - <a class="el" href="ex14p_8cpp_source.html">Example 14p</a>: parallel Discontinuous Galerkin (DG) for the Poisson problem
+ * - <a class="el" href="ex14_8cpp_source.html">Example 14</a>: Discontinuous Galerkin (DG) for the Laplace problem
+ * - <a class="el" href="ex14p_8cpp_source.html">Example 14p</a>: parallel Discontinuous Galerkin (DG) for the Laplace problem
 * - <a class="el" href="ex15_8cpp_source.html">Example 15</a>: dynamic AMR for Laplace with prescribed time-dependent source
 * - <a class="el" href="ex15p_8cpp_source.html">Example 15p</a>: parallel dynamic AMR for Laplace with prescribed time-dependent source
 * - <a class="el" href="ex16_8cpp_source.html">Example 16</a>: time-dependent nonlinear heat equation
@@ -90,8 +90,8 @@ namespace mfem {
 * - <a class="el" href="ex24p_8cpp_source.html">Example 24p</a>: parallel mixed finite element spaces and interpolators
 * - <a class="el" href="ex25_8cpp_source.html">Example 25</a>: simulation of electromagnetic wave propagation using a Perfectly Matched Layer (PML)
 * - <a class="el" href="ex25p_8cpp_source.html">Example 25p</a>: parallel simulation of electromagnetic wave propagation using a Perfectly Matched Layer (PML)
- * - <a class="el" href="ex26_8cpp_source.html">Example 26</a>: multigrid preconditioner for the Poisson problem using nodal H1 FEM
- * - <a class="el" href="ex26p_8cpp_source.html">Example 26p</a>: parallel multigrid preconditioner for the Poisson problem using nodal H1 FEM
+ * - <a class="el" href="ex26_8cpp_source.html">Example 26</a>: multigrid preconditioner for the Laplace problem using nodal H1 FEM
+ * - <a class="el" href="ex26p_8cpp_source.html">Example 26p</a>: parallel multigrid preconditioner for the Laplace problem using nodal H1 FEM
 * - <a class="el" href="ex27_8cpp_source.html">Example 27</a>: boundary conditions for the Laplace problem
 * - <a class="el" href="ex27p_8cpp_source.html">Example 27p</a>: parallel boundary conditions for the Laplace problem
 * - <a class="el" href="ex28_8cpp_source.html">Example 28</a>: sliding contact in elasticity
@@ -230,8 +230,8 @@ namespace mfem {
 * - <a class="el" href="parheat_8cpp_source.html">Optimization gradients</a>: Gradients of PDE-constrained function
 * - <a class="el" href="par__example_8cpp_source.html">Parallel AD</a>: Parallel p-Laplacian example
 * - <a class="el" href="seq__example_8cpp_source.html">Serial AD</a>: Serial p-Laplacian example
- * - <a class="el" href="miniapps_2performance_2ex1_8cpp_source.html">HPC Example 1</a>: high-performance nodal H1 FEM for the Poisson problem
- * - <a class="el" href="miniapps_2performance_2ex1p_8cpp_source.html">HPC Example 1p</a>: high-performance parallel nodal H1 FEM for the Poisson problem
+ * - <a class="el" href="miniapps_2performance_2ex1_8cpp_source.html">HPC Example 1</a>: high-performance nodal H1 FEM for the Laplace problem
+ * - <a class="el" href="miniapps_2performance_2ex1p_8cpp_source.html">HPC Example 1p</a>: high-performance parallel nodal H1 FEM for the Laplace problem
 * - <a class="el" href="generate__random__field_8cpp_source.html">SPDE Solvers</a>: SPDE solver random field generation
 * - <a class="el" href="contact-patch-test_8cpp_source.html">Contact</a>: mortar contact patch test for elasticity
 * - <a class="el" href="multidomain_8cpp_source.html">Multidomain miniapp</a>: Multidomain and Submesh demonstration miniapp
@@ -12,7 +12,7 @@
 //               ex1 --amgx-file precon.json --amgx-preconditioner -d cuda
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -10,7 +10,7 @@
 //               mpirun -np 4 ex1p --amgx-file amg_pcg.json
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -7,7 +7,7 @@
 //               ex0 -m ../data/square-disc.mesh -o 2
 //
 // Description: This example code demonstrates the most basic usage of MFEM to
-//              define a simple finite element discretization of the Poisson
+//              define a simple finite element discretization of the Laplace
 //              problem -Delta u = 1 with zero Dirichlet boundary conditions.
 //              General 2D/3D mesh files and finite element polynomial degrees
 //              can be specified by command line options.
@@ -8,7 +8,7 @@
 //
 // Description: This example code demonstrates the most basic parallel usage of
 //              MFEM to define a simple finite element discretization of the
-//              Poisson problem -Delta u = 1 with zero Dirichlet boundary
+//              Laplace problem -Delta u = 1 with zero Dirichlet boundary
 //              conditions. General 2D/3D serial mesh files and finite element
 //              polynomial degrees can be specified by command line options.

@@ -50,7 +50,7 @@
 //               ex1 -m ../data/beam-tet.mesh -pa -d ceed-cuda:/gpu/cuda/ref
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -27,7 +27,7 @@
 //
 // Description:  This example code demonstrates the use of MFEM to define a
 //               discontinuous Galerkin (DG) finite element discretization of
-//               the Poisson problem -Delta u = 1 with homogeneous Dirichlet
+//               the Laplace problem -Delta u = 1 with homogeneous Dirichlet
 //               boundary conditions. Finite element spaces of any order,
 //               including zero on regular grids, are supported. The example
 //               highlights the use of discontinuous spaces and DG-specific face
@@ -26,7 +26,7 @@
 //
 // Description:  This example code demonstrates the use of MFEM to define a
 //               discontinuous Galerkin (DG) finite element discretization of
-//               the Poisson problem -Delta u = 1 with homogeneous Dirichlet
+//               the Laplace problem -Delta u = 1 with homogeneous Dirichlet
 //               boundary conditions. Finite element spaces of any order,
 //               including zero on regular grids, are supported. The example
 //               highlights the use of discontinuous spaces and DG-specific face
@@ -159,7 +159,7 @@ int main(int argc, char *argv[])
   FiniteElementSpace fespace(&mesh, &fec);

   // 6. As in Example 1p, we set up bilinear and linear forms corresponding to
-   //    the Poisson problem -\Delta u = 1. We don't assemble the discrete
+   //    the Laplace problem -\Delta u = 1. We don't assemble the discrete
   //    problem yet, this will be done in the inner loop.
   BilinearForm a(&fespace);
   LinearForm b(&fespace);
@@ -446,7 +446,7 @@ real_t bdr_func(const Vector &pt, real_t t)
   return composite_func(pt, t, front, ball);
 }

-// Laplacian of the exact solution, used for the right hand side.
+// Laplace of the exact solution, used for the right hand side.
 real_t rhs_func(const Vector &pt, real_t t)
 {
   return composite_func(pt, t, front_laplace, ball_laplace);
@@ -181,7 +181,7 @@ int main(int argc, char *argv[])
   ParFiniteElementSpace fespace(&pmesh, &fec);

   // 7. As in Example 1p, we set up bilinear and linear forms corresponding to
-   //    the Poisson problem -\Delta u = 1. We don't assemble the discrete
+   //    the Laplace problem -\Delta u = 1. We don't assemble the discrete
   //    problem yet, this will be done in the inner loop.
   ParBilinearForm a(&fespace);
   ParLinearForm b(&fespace);
@@ -507,7 +507,7 @@ real_t bdr_func(const Vector &pt, real_t t)
   return composite_func(pt, t, front, ball);
 }

-// Laplacian of the exact solution, used for the right hand side.
+// Laplace of the exact solution, used for the right hand side.
 real_t rhs_func(const Vector &pt, real_t t)
 {
   return composite_func(pt, t, front_laplace, ball_laplace);
@@ -45,7 +45,7 @@
 //               mpirun -np 4 ex1p -m ../data/beam-tet.mesh -pa -d ceed-cpu
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -62,9 +62,14 @@ static real_t epsilon_ = 1.0;
 static real_t sigma_ = 20.0;
 static real_t omega_ = 10.0;

-complex<real_t> u0_exact(const Vector &x);
-void u1_exact(const Vector &, ComplexVector &);
-void u2_exact(const Vector &, ComplexVector &);
+real_t u0_real_exact(const Vector &);
+real_t u0_imag_exact(const Vector &);
+
+void u1_real_exact(const Vector &, Vector &);
+void u1_imag_exact(const Vector &, Vector &);
+
+void u2_real_exact(const Vector &, Vector &);
+void u2_imag_exact(const Vector &, Vector &);

 bool check_for_inline_mesh(const char * mesh_file);

@@ -210,48 +215,54 @@ int main(int argc, char *argv[])
   ComplexGridFunction * u_exact = NULL;
   if (exact_sol) { u_exact = new ComplexGridFunction(fespace); }

-   ComplexFunctionCoefficient u0(u0_exact);
-   ComplexVectorFunctionCoefficient u1(dim, u1_exact);
-   ComplexVectorFunctionCoefficient u2(dim, u2_exact);
+   FunctionCoefficient u0_r(u0_real_exact);
+   FunctionCoefficient u0_i(u0_imag_exact);
+   VectorFunctionCoefficient u1_r(dim, u1_real_exact);
+   VectorFunctionCoefficient u1_i(dim, u1_imag_exact);
+   VectorFunctionCoefficient u2_r(dim, u2_real_exact);
+   VectorFunctionCoefficient u2_i(dim, u2_imag_exact);

-   ComplexConstantCoefficient oneCoef(1.0);
+   ConstantCoefficient zeroCoef(0.0);
+   ConstantCoefficient oneCoef(1.0);

+   Vector zeroVec(dim); zeroVec = 0.0;
   Vector  oneVec(dim);  oneVec = 0.0; oneVec[(prob==2)?(dim-1):0] = 1.0;
-   ComplexVectorConstantCoefficient oneVecCoef(oneVec);
+   VectorConstantCoefficient zeroVecCoef(zeroVec);
+   VectorConstantCoefficient oneVecCoef(oneVec);

   switch (prob)
   {
      case 0:
         if (exact_sol)
         {
-            u.ProjectBdrCoefficient(u0, ess_bdr);
-            u_exact->ProjectCoefficient(u0);
+            u.ProjectBdrCoefficient(u0_r, u0_i, ess_bdr);
+            u_exact->ProjectCoefficient(u0_r, u0_i);
         }
         else
         {
-            u.ProjectBdrCoefficient(oneCoef, ess_bdr);
+            u.ProjectBdrCoefficient(oneCoef, zeroCoef, ess_bdr);
         }
         break;
      case 1:
         if (exact_sol)
         {
-            u.ProjectBdrCoefficientTangent(u1, ess_bdr);
-            u_exact->ProjectCoefficient(u1);
+            u.ProjectBdrCoefficientTangent(u1_r, u1_i, ess_bdr);
+            u_exact->ProjectCoefficient(u1_r, u1_i);
         }
         else
         {
-            u.ProjectBdrCoefficientTangent(oneVecCoef, ess_bdr);
+            u.ProjectBdrCoefficientTangent(oneVecCoef, zeroVecCoef, ess_bdr);
         }
         break;
      case 2:
         if (exact_sol)
         {
-            u.ProjectBdrCoefficientNormal(u2, ess_bdr);
-            u_exact->ProjectCoefficient(u2);
+            u.ProjectBdrCoefficientNormal(u2_r, u2_i, ess_bdr);
+            u_exact->ProjectCoefficient(u2_r, u2_i);
         }
         else
         {
-            u.ProjectBdrCoefficientNormal(oneVecCoef, ess_bdr);
+            u.ProjectBdrCoefficientNormal(oneVecCoef, zeroVecCoef, ess_bdr);
         }
         break;
      default: break; // This should be unreachable
@@ -289,24 +300,27 @@ int main(int argc, char *argv[])
   ConstantCoefficient lossCoef(omega_ * sigma_);
   ConstantCoefficient negMassCoef(omega_ * omega_ * epsilon_);

-   ComplexConstantCoefficient complexMassCoef(-omega_ * omega_ * epsilon_,
-                                              omega_ * sigma_);
-
   SesquilinearForm *a = new SesquilinearForm(fespace, conv);
   if (pa) { a->SetAssemblyLevel(AssemblyLevel::PARTIAL); }
   switch (prob)
   {
      case 0:
-         a->AddDomainIntegrator<DiffusionIntegrator>(stiffnessCoef);
-         a->AddDomainIntegrator<MassIntegrator>(complexMassCoef);
+         a->AddDomainIntegrator(new DiffusionIntegrator(stiffnessCoef),
+                                NULL);
+         a->AddDomainIntegrator(new MassIntegrator(massCoef),
+                                new MassIntegrator(lossCoef));
         break;
      case 1:
-         a->AddDomainIntegrator<CurlCurlIntegrator>(stiffnessCoef);
-         a->AddDomainIntegrator<VectorFEMassIntegrator>(complexMassCoef);
+         a->AddDomainIntegrator(new CurlCurlIntegrator(stiffnessCoef),
+                                NULL);
+         a->AddDomainIntegrator(new VectorFEMassIntegrator(massCoef),
+                                new VectorFEMassIntegrator(lossCoef));
         break;
      case 2:
-         a->AddDomainIntegrator<DivDivIntegrator>(stiffnessCoef);
-         a->AddDomainIntegrator<VectorFEMassIntegrator>(complexMassCoef);
+         a->AddDomainIntegrator(new DivDivIntegrator(stiffnessCoef),
+                                NULL);
+         a->AddDomainIntegrator(new VectorFEMassIntegrator(massCoef),
+                                new VectorFEMassIntegrator(lossCoef));
         break;
      default: break; // This should be unreachable
   }
@@ -422,24 +436,29 @@ int main(int argc, char *argv[])

   if (exact_sol)
   {
-      real_t err_u = -1.0;
+      real_t err_r = -1.0;
+      real_t err_i = -1.0;

      switch (prob)
      {
         case 0:
-            err_u = u.ComputeL2Error(u0);
+            err_r = u.real().ComputeL2Error(u0_r);
+            err_i = u.imag().ComputeL2Error(u0_i);
            break;
         case 1:
-            err_u = u.ComputeL2Error(u1);
+            err_r = u.real().ComputeL2Error(u1_r);
+            err_i = u.imag().ComputeL2Error(u1_i);
            break;
         case 2:
-            err_u = u.ComputeL2Error(u2);
+            err_r = u.real().ComputeL2Error(u2_r);
+            err_i = u.imag().ComputeL2Error(u2_i);
            break;
         default: break; // This should be unreachable
      }

      cout << endl;
-      cout << "|| u_h - u ||_{L^2} = " << err_u << endl;
+      cout << "|| Re (u_h - u) ||_{L^2} = " << err_r << endl;
+      cout << "|| Im (u_h - u) ||_{L^2} = " << err_i << endl;
      cout << endl;
   }

@@ -545,14 +564,36 @@ complex<real_t> u0_exact(const Vector &x)
   return std::exp(-i * kappa * x[dim - 1]);
 }

-void u1_exact(const Vector &x, ComplexVector &v)
+real_t u0_real_exact(const Vector &x)
 {
-   int dim = x.Size();
-   v.SetSize(dim); v = 0.0; v[0] = u0_exact(x);
+   return u0_exact(x).real();
 }

-void u2_exact(const Vector &x, ComplexVector &v)
+real_t u0_imag_exact(const Vector &x)
+{
+   return u0_exact(x).imag();
+}
+
+void u1_real_exact(const Vector &x, Vector &v)
 {
   int dim = x.Size();
-   v.SetSize(dim); v = 0.0; v[dim-1] = u0_exact(x);
+   v.SetSize(dim); v = 0.0; v[0] = u0_real_exact(x);
+}
+
+void u1_imag_exact(const Vector &x, Vector &v)
+{
+   int dim = x.Size();
+   v.SetSize(dim); v = 0.0; v[0] = u0_imag_exact(x);
+}
+
+void u2_real_exact(const Vector &x, Vector &v)
+{
+   int dim = x.Size();
+   v.SetSize(dim); v = 0.0; v[dim-1] = u0_real_exact(x);
+}
+
+void u2_imag_exact(const Vector &x, Vector &v)
+{
+   int dim = x.Size();
+   v.SetSize(dim); v = 0.0; v[dim-1] = u0_imag_exact(x);
 }
@@ -62,10 +62,6 @@ static real_t epsilon_ = 1.0;
 static real_t sigma_ = 20.0;
 static real_t omega_ = 10.0;

-complex<real_t> u0_exact(const Vector &x);
-void u1_exact(const Vector &, ComplexVector &);
-void u2_exact(const Vector &, ComplexVector &);
-
 real_t u0_real_exact(const Vector &);
 real_t u0_imag_exact(const Vector &);

@@ -248,22 +244,13 @@ int main(int argc, char *argv[])
   ParComplexGridFunction * u_exact = NULL;
   if (exact_sol) { u_exact = new ParComplexGridFunction(fespace); }

-   ComplexFunctionCoefficient u0(u0_exact);
-   ComplexVectorFunctionCoefficient u1(dim, u1_exact);
-   ComplexVectorFunctionCoefficient u2(dim, u2_exact);
-
-   ComplexConstantCoefficient oneCoef(1.0);
-
-   Vector  oneVec(dim);  oneVec = 0.0; oneVec[(prob==2)?(dim-1):0] = 1.0;
-   ComplexVectorConstantCoefficient oneVecCoef(oneVec);
-
   FunctionCoefficient u0_r(u0_real_exact);
   FunctionCoefficient u0_i(u0_imag_exact);
   VectorFunctionCoefficient u1_r(dim, u1_real_exact);
   VectorFunctionCoefficient u1_i(dim, u1_imag_exact);
   VectorFunctionCoefficient u2_r(dim, u2_real_exact);
   VectorFunctionCoefficient u2_i(dim, u2_imag_exact);
-   /*
+
   ConstantCoefficient zeroCoef(0.0);
   ConstantCoefficient oneCoef(1.0);

@@ -271,40 +258,40 @@ int main(int argc, char *argv[])
   Vector  oneVec(dim);  oneVec = 0.0; oneVec[(prob==2)?(dim-1):0] = 1.0;
   VectorConstantCoefficient zeroVecCoef(zeroVec);
   VectorConstantCoefficient oneVecCoef(oneVec);
-   */
+
   switch (prob)
   {
      case 0:
         if (exact_sol)
         {
-            u.ProjectBdrCoefficient(u0, ess_bdr);
-            u_exact->ProjectCoefficient(u0);
+            u.ProjectBdrCoefficient(u0_r, u0_i, ess_bdr);
+            u_exact->ProjectCoefficient(u0_r, u0_i);
         }
         else
         {
-            u.ProjectBdrCoefficient(oneCoef, ess_bdr);
+            u.ProjectBdrCoefficient(oneCoef, zeroCoef, ess_bdr);
         }
         break;
      case 1:
         if (exact_sol)
         {
-            u.ProjectBdrCoefficientTangent(u1, ess_bdr);
-            u_exact->ProjectCoefficient(u1);
+            u.ProjectBdrCoefficientTangent(u1_r, u1_i, ess_bdr);
+            u_exact->ProjectCoefficient(u1_r, u1_i);
         }
         else
         {
-            u.ProjectBdrCoefficientTangent(oneVecCoef, ess_bdr);
+            u.ProjectBdrCoefficientTangent(oneVecCoef, zeroVecCoef, ess_bdr);
         }
         break;
      case 2:
         if (exact_sol)
         {
-            u.ProjectBdrCoefficientNormal(u2, ess_bdr);
-            u_exact->ProjectCoefficient(u2);
+            u.ProjectBdrCoefficientNormal(u2_r, u2_i, ess_bdr);
+            u_exact->ProjectCoefficient(u2_r, u2_i);
         }
         else
         {
-            u.ProjectBdrCoefficientNormal(oneVecCoef, ess_bdr);
+            u.ProjectBdrCoefficientNormal(oneVecCoef, zeroVecCoef, ess_bdr);
         }
         break;
      default: break; // This should be unreachable
@@ -344,24 +331,27 @@ int main(int argc, char *argv[])
   ConstantCoefficient lossCoef(omega_ * sigma_);
   ConstantCoefficient negMassCoef(omega_ * omega_ * epsilon_);

-   ComplexConstantCoefficient complexMassCoef(-omega_ * omega_ * epsilon_,
-                                              omega_ * sigma_);
-
   ParSesquilinearForm *a = new ParSesquilinearForm(fespace, conv);
   if (pa) { a->SetAssemblyLevel(AssemblyLevel::PARTIAL); }
   switch (prob)
   {
      case 0:
-         a->AddDomainIntegrator<DiffusionIntegrator>(stiffnessCoef);
-         a->AddDomainIntegrator<MassIntegrator>(complexMassCoef);
+         a->AddDomainIntegrator(new DiffusionIntegrator(stiffnessCoef),
+                                NULL);
+         a->AddDomainIntegrator(new MassIntegrator(massCoef),
+                                new MassIntegrator(lossCoef));
         break;
      case 1:
-         a->AddDomainIntegrator<CurlCurlIntegrator>(stiffnessCoef);
-         a->AddDomainIntegrator<VectorFEMassIntegrator>(complexMassCoef);
+         a->AddDomainIntegrator(new CurlCurlIntegrator(stiffnessCoef),
+                                NULL);
+         a->AddDomainIntegrator(new VectorFEMassIntegrator(massCoef),
+                                new VectorFEMassIntegrator(lossCoef));
         break;
      case 2:
-         a->AddDomainIntegrator<DivDivIntegrator>(stiffnessCoef);
-         a->AddDomainIntegrator<VectorFEMassIntegrator>(complexMassCoef);
+         a->AddDomainIntegrator(new DivDivIntegrator(stiffnessCoef),
+                                NULL);
+         a->AddDomainIntegrator(new VectorFEMassIntegrator(massCoef),
+                                new VectorFEMassIntegrator(lossCoef));
         break;
      default: break; // This should be unreachable
   }
@@ -485,18 +475,22 @@ int main(int argc, char *argv[])

   if (exact_sol)
   {
-      real_t err_u = -1.0;
+      real_t err_r = -1.0;
+      real_t err_i = -1.0;

      switch (prob)
      {
         case 0:
-            err_u = u.ComputeL2Error(u0);
+            err_r = u.real().ComputeL2Error(u0_r);
+            err_i = u.imag().ComputeL2Error(u0_i);
            break;
         case 1:
-            err_u = u.ComputeL2Error(u1);
+            err_r = u.real().ComputeL2Error(u1_r);
+            err_i = u.imag().ComputeL2Error(u1_i);
            break;
         case 2:
-            err_u = u.ComputeL2Error(u2);
+            err_r = u.real().ComputeL2Error(u2_r);
+            err_i = u.imag().ComputeL2Error(u2_i);
            break;
         default: break; // This should be unreachable
      }
@@ -504,7 +498,8 @@ int main(int argc, char *argv[])
      if ( myid == 0 )
      {
         cout << endl;
-         cout << "|| u_h - u ||_{L^2} = " << err_u << endl;
+         cout << "|| Re (u_h - u) ||_{L^2} = " << err_r << endl;
+         cout << "|| Im (u_h - u) ||_{L^2} = " << err_i << endl;
         cout << endl;
      }
   }
@@ -632,12 +627,6 @@ real_t u0_imag_exact(const Vector &x)
   return u0_exact(x).imag();
 }

-void u1_exact(const Vector &x, ComplexVector &v)
-{
-   int dim = x.Size();
-   v.SetSize(dim); v = 0.0; v[0] = u0_exact(x);
-}
-
 void u1_real_exact(const Vector &x, Vector &v)
 {
   int dim = x.Size();
@@ -650,12 +639,6 @@ void u1_imag_exact(const Vector &x, Vector &v)
   v.SetSize(dim); v = 0.0; v[0] = u0_imag_exact(x);
 }

-void u2_exact(const Vector &x, ComplexVector &v)
-{
-   int dim = x.Size();
-   v.SetSize(dim); v = 0.0; v[dim-1] = u0_exact(x);
-}
-
 void u2_real_exact(const Vector &x, Vector &v)
 {
   int dim = x.Size();
@@ -94,7 +94,7 @@ WaveOperator::WaveOperator(FiniteElementSpace &f,
   M->AddDomainIntegrator(new MassIntegrator());
   M->Assemble();

-   // Apply BCs
+   // Apply Bcs
   fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
   K->FormSystemMatrix(ess_tdof_list, Kmat);
   M->FormSystemMatrix(ess_tdof_list, Mmat);
@@ -17,7 +17,7 @@
 //               ex26 -m ../data/beam-hex.mesh -d cuda
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions
 //               as in Example 1.
 //
@@ -14,7 +14,7 @@
 //               mpirun -np 4 ex26p -d ceed-cuda
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions
 //               as in Example 1.
 //
@@ -10,7 +10,7 @@
 // Description:  This example code demonstrates the use of MFEM to define a
 //               finite element discretization of a PDE on a 2 dimensional
 //               surface embedded in a 3 dimensional domain. In this case we
-//               solve the Poisson problem -Div(sigma Grad u) = 1, with
+//               solve the Laplace problem -Div(sigma Grad u) = 1, with
 //               homogeneous Dirichlet boundary conditions, where sigma is an
 //               anisotropic diffusion constant defined as a 3x3 matrix
 //               coefficient.
@@ -10,7 +10,7 @@
 // Description:  This example code demonstrates the use of MFEM to define a
 //               finite element discretization of a PDE on a 2 dimensional
 //               surface embedded in a 3 dimensional domain. In this case we
-//               solve the Poisson problem -Div(sigma Grad u) = 1, with
+//               solve the Laplace problem -Div(sigma Grad u) = 1, with
 //               homogeneous Dirichlet boundary conditions, where sigma is an
 //               anisotropic diffusion constant defined as a 3x3 matrix
 //               coefficient.
@@ -390,7 +390,7 @@ public:


 /**
- @brief Class for surface linear form integrator
+ @brief Class for surface linearform integrator

 Integrator to demonstrate the use of the surface integration rule on an
 implicit surface defined by a level-set.
@@ -460,7 +460,7 @@ public:
 };

 /**
- @brief Class for subdomain linear form integrator
+ @brief Class for subdomain linearform integrator

 Integrator to demonstrate the use of the subdomain integration rule within
 an area defined by an implicit surface defined by a level-set.
@@ -546,7 +546,7 @@ int main(int argc, char *argv[])
   args.AddOption(&ref_levels, "-r", "--refine", "Number of meh refinements");
   args.AddOption(&method, "-m", "--method",
                  "Cut integration method: 0 for moments-based, 1 for Algoim.");
-   args.AddOption(&inttype, "-i", "--integration-type",
+   args.AddOption(&inttype, "-i", "--integrationtype",
                  "IntegrationType to demonstrate");
   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
                  "--no-visualization",
@@ -16,7 +16,7 @@
 //
 //               The particular problem being solved here is nearly the same
 //               as that in example 1 i.e. a simple finite element
-//               discretization of the Poisson problem -Delta u = 1 with
+//               discretization of the Laplace problem -Delta u = 1 with
 //               homogeneous Dirichlet boundary conditions and, in this case,
 //               an inhomogeneous diffusion coefficient. The diffusion
 //               coefficient is given a small default value throughout the
@@ -16,7 +16,7 @@
 //
 //               The particular problem being solved here is nearly the same
 //               as that in example 1 i.e. a simple finite element
-//               discretization of the Poisson problem -Delta u = 1 with
+//               discretization of the Laplace problem -Delta u = 1 with
 //               homogeneous Dirichlet boundary conditions and, in this case,
 //               an inhomogeneous diffusion coefficient. The diffusion
 //               coefficient is given a small default value throughout the
@@ -65,7 +65,6 @@ int main(int argc, char *argv[])
   bool static_cond = false;
   bool hybridization = false;
   bool pa = false;
-   bool ea = false;
   const char *device_config = "cpu";
   bool visualization = 1;

@@ -84,14 +83,18 @@ int main(int argc, char *argv[])
                  "--no-hybridization", "Enable hybridization.");
   args.AddOption(&pa, "-pa", "--partial-assembly", "-no-pa",
                  "--no-partial-assembly", "Enable Partial Assembly.");
-   args.AddOption(&ea, "-ea", "--element-assembly", "-no-ea",
-                  "--no-element-assembly", "Enable Element Assembly.");
   args.AddOption(&device_config, "-d", "--device",
                  "Device configuration string, see Device::Configure().");
   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
                  "--no-visualization",
                  "Enable or disable GLVis visualization.");
-   args.ParseCheck();
+   args.Parse();
+   if (!args.Good())
+   {
+      args.PrintUsage(cout);
+      return 1;
+   }
+   args.PrintOptions(cout);
   kappa = freq * M_PI;

   // 2. Enable hardware devices such as GPUs, and programming models such as
@@ -163,7 +166,6 @@ int main(int argc, char *argv[])
   Coefficient *beta  = new ConstantCoefficient(1.0);
   BilinearForm *a = new BilinearForm(fespace);
   if (pa) { a->SetAssemblyLevel(AssemblyLevel::PARTIAL); }
-   if (ea) { a->SetAssemblyLevel(AssemblyLevel::ELEMENT); }
   a->AddDomainIntegrator(new DivDivIntegrator(*alpha));
   a->AddDomainIntegrator(new VectorFEMassIntegrator(*beta));

@@ -71,7 +71,6 @@ int main(int argc, char *argv[])
   bool static_cond = false;
   bool hybridization = false;
   bool pa = false;
-   bool ea = false;
   const char *device_config = "cpu";
   bool visualization = 1;

@@ -90,14 +89,24 @@ int main(int argc, char *argv[])
                  "--no-hybridization", "Enable hybridization.");
   args.AddOption(&pa, "-pa", "--partial-assembly", "-no-pa",
                  "--no-partial-assembly", "Enable Partial Assembly.");
-   args.AddOption(&ea, "-ea", "--element-assembly", "-no-ea",
-                  "--no-element-assembly", "Enable Element Assembly.");
   args.AddOption(&device_config, "-d", "--device",
                  "Device configuration string, see Device::Configure().");
   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
                  "--no-visualization",
                  "Enable or disable GLVis visualization.");
-   args.ParseCheck();
+   args.Parse();
+   if (!args.Good())
+   {
+      if (myid == 0)
+      {
+         args.PrintUsage(cout);
+      }
+      return 1;
+   }
+   if (myid == 0)
+   {
+      args.PrintOptions(cout);
+   }
   kappa = freq * M_PI;

   // 3. Enable hardware devices such as GPUs, and programming models such as
@@ -185,7 +194,6 @@ int main(int argc, char *argv[])
   Coefficient *beta  = new ConstantCoefficient(1.0);
   ParBilinearForm *a = new ParBilinearForm(fespace);
   if (pa) { a->SetAssemblyLevel(AssemblyLevel::PARTIAL); }
-   if (ea) { a->SetAssemblyLevel(AssemblyLevel::ELEMENT); }
   a->AddDomainIntegrator(new DivDivIntegrator(*alpha));
   a->AddDomainIntegrator(new VectorFEMassIntegrator(*beta));

@@ -25,7 +25,7 @@
 //               ex6 -pa -d ceed-cuda:/gpu/cuda/shared
 //
 // Description:  This is a version of Example 1 with a simple adaptive mesh
-//               refinement loop. The problem being solved is again the Poisson
+//               refinement loop. The problem being solved is again the Laplace
 //               equation -Delta u = 1 with homogeneous Dirichlet boundary
 //               conditions. The problem is solved on a sequence of meshes which
 //               are locally refined in a conforming (triangles, tetrahedrons)
@@ -113,7 +113,7 @@ int main(int argc, char *argv[])
   FiniteElementSpace fespace(&mesh, &fec);

   // 6. As in Example 1, we set up bilinear and linear forms corresponding to
-   //    the Poisson problem -\Delta u = 1. We don't assemble the discrete
+   //    the Laplace problem -\Delta u = 1. We don't assemble the discrete
   //    problem yet, this will be done in the main loop.
   BilinearForm a(&fespace);
   if (pa)
@@ -3,7 +3,6 @@
 // Compile with: make ex6p
 //
 // Sample runs:  mpirun -np 4 ex6p -m ../data/star-hilbert.mesh -o 2
-//               mpirun -np 4 ex6p -m ../data/star-hilbert.mesh -pref
 //               mpirun -np 4 ex6p -m ../data/square-disc.mesh -rm 1 -o 1
 //               mpirun -np 4 ex6p -m ../data/square-disc.mesh -rm 1 -o 2 -h1
 //               mpirun -np 4 ex6p -m ../data/square-disc.mesh -o 2 -cs
@@ -29,7 +28,7 @@
 //               mpirun -np 4 ex6p -pa -d ceed-cuda:/gpu/cuda/shared
 //
 // Description:  This is a version of Example 1 with a simple adaptive mesh
-//               refinement loop. The problem being solved is again the Poisson
+//               refinement loop. The problem being solved is again the Laplace
 //               equation -Delta u = 1 with homogeneous Dirichlet boundary
 //               conditions. The problem is solved on a sequence of meshes which
 //               are locally refined in a conforming (triangles, tetrahedrons)
@@ -42,12 +41,6 @@
 //               from coarse to fine meshes, restarting from a checkpoint, as
 //               well as persistent GLVis visualization are also illustrated.
 //
-//               There is also the option to use hp-refinement. Real
-//               applications should use some problem-dependent criteria for
-//               selecting between h- and p-refinement, but in this example, we
-//               simply alternate between refinement types to demonstrate the
-//               capabilities.
-//
 //               We recommend viewing Example 1 before viewing this example.

 #include "mfem.hpp"
@@ -76,8 +69,6 @@ int main(int argc, char *argv[])
   bool smooth_rt = true;
   bool restart = false;
   bool visualization = true;
-   bool rebalance = true;
-   bool usePRefinement = false;

   OptionsParser args(argc, argv);
   args.AddOption(&mesh_file, "-m", "--mesh",
@@ -99,10 +90,6 @@ int main(int argc, char *argv[])
                  "Stop after reaching this many degrees of freedom.");
   args.AddOption(&smooth_rt, "-rt", "--smooth-rt", "-h1", "--smooth-h1",
                  "Represent the smooth flux in RT or vector H1 space.");
-   args.AddOption(&usePRefinement, "-pref", "--p-refine", "-no-pref",
-                  "--no-p-refine", "Alternate between h- and p-refinement.");
-   args.AddOption(&rebalance, "-reb", "--rebalance", "-no-reb",
-                  "--no-rebalance", "Load balance the nonconforming mesh.");
   args.AddOption(&restart, "-res", "--restart", "-no-res", "--no-restart",
                  "Restart computation from the last checkpoint.");
   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
@@ -122,15 +109,6 @@ int main(int argc, char *argv[])
      args.PrintOptions(cout);
   }

-   if (usePRefinement && rebalance)
-   {
-      rebalance = false;
-      if (myid == 0)
-      {
-         cout << "Load balancing is not performed with p-refinements.\n";
-      }
-   }
-
   // 3. Enable hardware devices such as GPUs, and programming models such as
   //    CUDA, OCCA, RAJA and OpenMP based on command line options.
   Device device(device_config);
@@ -208,7 +186,7 @@ int main(int argc, char *argv[])
   ParFiniteElementSpace fespace(pmesh, &fec);

   // 11. As in Example 1p, we set up bilinear and linear forms corresponding to
-   //     the Poisson problem -\Delta u = 1. We don't assemble the discrete
+   //     the Laplace problem -\Delta u = 1. We don't assemble the discrete
   //     problem yet, this will be done in the main loop.
   ParBilinearForm a(&fespace);
   if (pa)
@@ -343,15 +321,7 @@ int main(int argc, char *argv[])
      if (visualization)
      {
         sout << "parallel " << num_procs << " " << myid << "\n";
-         if (usePRefinement)
-         {
-            std::unique_ptr<GridFunction> vis_x = x.ProlongateToMaxOrder();
-            sout << "solution\n" << *pmesh << *vis_x << flush;
-         }
-         else
-         {
-            sout << "solution\n" << *pmesh << x << flush;
-         }
+         sout << "solution\n" << *pmesh << x << flush;
      }

      if (global_dofs >= max_dofs)
@@ -367,31 +337,8 @@ int main(int argc, char *argv[])
      //     estimator to obtain element errors, then it selects elements to be
      //     refined and finally it modifies the mesh. The Stop() method can be
      //     used to determine if a stopping criterion was met.
-
-      // Simply alternate between h- and p-refinement.
-      const bool pRefine = usePRefinement && ((it % 2) == 1);
-      bool stop = false;
-      Array<pRefinement> prefinements;
-      if (pRefine)
-      {
-         Array<Refinement> refinements;
-         refiner.MarkWithoutRefining(*pmesh, refinements);
-         stop = pmesh->ReduceInt(refinements.Size()) == 0LL;
-
-         prefinements.SetSize(refinements.Size());
-         for (int i=0; i<refinements.Size(); ++i)
-         {
-            prefinements[i].index = refinements[i].index;
-            prefinements[i].delta = 1;  // Increase the element order by 1
-         }
-      }
-      else
-      {
-         refiner.Apply(*pmesh);
-         stop = refiner.Stop();
-      }
-
-      if (stop)
+      refiner.Apply(*pmesh);
+      if (refiner.Stop())
      {
         if (myid == 0)
         {
@@ -405,20 +352,12 @@ int main(int argc, char *argv[])
      //     to any GridFunctions over the space. In this case, the update
      //     matrix is an interpolation matrix so the updated GridFunction will
      //     still represent the same function as before refinement.
-      if (pRefine)
-      {
-         fespace.PRefineAndUpdate(prefinements);
-      }
-      else
-      {
-         fespace.Update();
-      }
-
+      fespace.Update();
      x.Update();

      // 25. Load balance the mesh, and update the space and solution. Currently
      //     available only for nonconforming meshes.
-      if (pmesh->Nonconforming() && rebalance)
+      if (pmesh->Nonconforming())
      {
         pmesh->Rebalance();

@@ -450,42 +389,6 @@ int main(int argc, char *argv[])
      }
   }

-   // Save result
-   if (usePRefinement)
-   {
-      L2_FECollection fecL2(0, dim);
-      ParFiniteElementSpace l2fespace(pmesh, &fecL2);
-      ParGridFunction xo(&l2fespace); // Element order field
-      xo = 0.0;
-
-      for (int e=0; e<pmesh->GetNE(); ++e)
-      {
-         const int p_elem = fespace.GetElementOrder(e);
-         Array<int> dofs;
-         l2fespace.GetElementDofs(e, dofs);
-         xo[dofs[0]] = p_elem;
-      }
-
-      ostringstream mesh_name, sol_name, order_name;
-      mesh_name << "mesh." << setfill('0') << setw(6) << myid;
-      sol_name << "sol." << setfill('0') << setw(6) << myid;
-      order_name << "order." << setfill('0') << setw(6) << myid;
-
-      ofstream mesh_ofs(mesh_name.str().c_str());
-      mesh_ofs.precision(8);
-      pmesh->ParPrint(mesh_ofs);
-
-      ofstream sol_ofs(sol_name.str().c_str());
-      sol_ofs.precision(8);
-
-      std::unique_ptr<ParGridFunction> vis_x = x.ProlongateToMaxOrder();
-      vis_x->Save(sol_ofs);
-
-      ofstream order_ofs(order_name.str().c_str());
-      order_ofs.precision(8);
-      xo.Save(order_ofs);
-   }
-
   delete smooth_flux_fes;
   delete smooth_flux_fec;
   delete pmesh;
@@ -9,8 +9,8 @@
 //
 // Description:  This example code demonstrates the use of MFEM to define a
 //               triangulation of a unit sphere and a simple isoparametric
-//               finite element discretization of the screened Poisson problem,
-//               -Delta u + u = f.
+//               finite element discretization of the Laplace problem with mass
+//               term, -Delta u + u = f.
 //
 //               The example highlights mesh generation, the use of mesh
 //               refinement, high-order meshes and finite elements, as well as
@@ -9,8 +9,8 @@
 //
 // Description:  This example code demonstrates the use of MFEM to define a
 //               triangulation of a unit sphere and a simple isoparametric
-//               finite element discretization of the screened Poisson problem,
-//               -Delta u + u = f.
+//               finite element discretization of the Laplace problem with mass
+//               term, -Delta u + u = f.
 //
 //               The example highlights mesh generation, the use of mesh
 //               refinement, high-order meshes and finite elements, as well as
@@ -15,7 +15,7 @@
 //
 // Description:  This example code demonstrates the use of the Discontinuous
 //               Petrov-Galerkin (DPG) method in its primal 2x2 block form as a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = f with homogeneous Dirichlet boundary conditions. We
 //               use high-order continuous trial space, a high-order interfacial
 //               (trace) space, and a high-order discontinuous test space
@@ -14,7 +14,7 @@
 //
 // Description:  This example code demonstrates the use of the Discontinuous
 //               Petrov-Galerkin (DPG) method in its primal 2x2 block form as a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = f with homogeneous Dirichlet boundary conditions. We
 //               use high-order continuous trial space, a high-order interfacial
 //               (trace) space, and a high-order discontinuous test space
@@ -35,7 +35,7 @@
 //               ex1 -m ../../data/beam-hex.mesh -pa -d cuda
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -33,7 +33,7 @@
   "id": "public-white",
   "metadata": {},
   "source": [
-    "This is the simplest MFEM example and a good starting point for new users. The example demonstrates the use of MFEM to define and solve an $H^1$ finite element discretization of the Poisson problem\n",
+    "This is the simplest MFEM example and a good starting point for new users. The example demonstrates the use of MFEM to define and solve an $H^1$ finite element discretization of the Laplace problem\n",
    "\n",
    "$$\n",
    "-\\Delta u = 1\n",
@@ -189,7 +189,7 @@ clean-build:
 clean-exec:
 	@rm -f refined.mesh displaced.mesh mesh.* ex5.mesh ex6p-checkpoint.*
 	@rm -rf Example5* Example9* Example15* Example16* Example23* ParaView
-	@rm -f sphere_refined.* sol.* sol_u.* sol_p.* sol_r.* sol_i.* order.*
+	@rm -f sphere_refined.* sol.* sol_u.* sol_p.* sol_r.* sol_i.*
 	@rm -f ex9.mesh ex9-mesh.* ex9-init.* ex9-final.*
 	@rm -f deformed.* velocity.* elastic_energy.* mode_* mode_deriv_* flux.*
 	@rm -f ex5-p-*.bp ex9-p-*.bp ex12-p-*.bp ex16-p-*.bp
@@ -16,16 +16,10 @@
 //               multi-physics applications.
 //
 //               This particular example is only for serial runtimes.
-//               For non-conforming meshes please have a look at example
-//               "ex2p.cpp".

 #include "example_utils.hpp"
 #include "mfem.hpp"

-#ifndef MFEM_USE_MOONOLITH
-#error This example requires that MFEM is built with MFEM_USE_MOONOLITH=YES
-#endif
-
 using namespace mfem;
 using namespace std;

@@ -221,8 +215,8 @@ int main(int argc, char *argv[])
         mfem::out << "l2 error: src: " << src_err << ", dest: " << dest_err
                   << std::endl;

-         plot(*src_mesh, src_fun, "source", 0);
-         plot(*dest_mesh, dest_fun, "destination", 1);
+         plot(*src_mesh, src_fun, "source");
+         plot(*dest_mesh, dest_fun, "destination");
      }
   }
   else
@@ -8,23 +8,18 @@
 //   mpirun -np 4 ex1p -s ../../data/inline-hex.mesh -d ../../data/inline-tet.mesh
 //
 // Description:  This example code demonstrates the use of MFEM for transferring
-//               discrete fields from one conforming finite element mesh to another. The
+//               discrete fields from one finite element mesh to another. The
 //               meshes can be of arbitrary shape and completely unrelated with
 //               each other. This feature can be used for implementing immersed
 //               domain methods for fluid-structure interaction or general
 //               multi-physics applications.
 //
 //               This particular example is for parallel runtimes. Vector FE is
-//               an experimental feature in parallel. For non-conforming meshes
-//               please have a look at example "ex2p.cpp".
+//               an experimental feature in parallel.

 #include "example_utils.hpp"
 #include "mfem.hpp"

-#ifndef MFEM_USE_MOONOLITH
-#error This example requires that MFEM is built with MFEM_USE_MOONOLITH=YES
-#endif
-
 using namespace mfem;
 using namespace std;

@@ -55,8 +50,6 @@ int main(int argc, char *argv[])
   int dest_fe_order = 1;
   bool visualization = true;
   bool use_vector_fe = false;
-   bool use_h1 = true;
-   bool use_vector_space = false;
   bool verbose = false;
   bool assemble_mass_and_coupling_together = true;

@@ -79,28 +72,14 @@ int main(int argc, char *argv[])
   args.AddOption(&verbose, "-verb", "--verbose", "--no-verb", "--no-verbose",
                  "Enable/Disable verbose output");
   args.AddOption(&use_vector_fe, "-vfe", "--use_vector_fe", "-no-vfe",
-                  "--no-vector_fe",
-                  "Use RT|ND vector finite elements (Experimental)");
-   args.AddOption(&use_vector_space, "-vfs", "--use_vector_space", "-no-vfs",
-                  "--no-vector_space",
-                  "Use Lagrange vector finite elements (Experimental)");
-   args.AddOption(&use_h1, "-h1", "--use-h1", "-nh1", "--no-h1",
-                  "Use H1 collection");
+                  "--no-vector_fe", "Use vector finite elements (Experimental)");
   args.AddOption(&assemble_mass_and_coupling_together, "-act",
                  "--assemble_mass_and_coupling_together", "-no-act",
                  "--no-assemble_mass_and_coupling_together",
-                  "Assemble mass and coupling operators together (better for "
-                  "non-affine elements)");
+                  "Assemble mass and coupling operators together (better for non-affine elements)");
   args.Parse();
   check_options(args);

-   if (use_vector_fe && use_vector_space)
-   {
-      mfem::err <<
-                "WARNING: use_vector_fe and use_vector_space options"
-                "are both true, ignoring use_vector_fe\n";
-   }
-
   shared_ptr<Mesh> src_mesh, dest_mesh;

   ifstream imesh;
@@ -190,30 +169,17 @@ int main(int argc, char *argv[])
   }
   else
   {
-
-      if (use_h1)
-      {
-         src_fe_coll =
-            make_shared<H1_FECollection>(source_fe_order, src_mesh->Dimension());
-         dest_fe_coll =
-            make_shared<H1_FECollection>(dest_fe_order, dest_mesh->Dimension());
-      }
-      else
-      {
-         src_fe_coll =
-            make_shared<L2_FECollection>(source_fe_order, src_mesh->Dimension());
-         dest_fe_coll =
-            make_shared<L2_FECollection>(dest_fe_order, dest_mesh->Dimension());
-      }
+      src_fe_coll =
+         make_shared<L2_FECollection>(source_fe_order, src_mesh->Dimension());
+      dest_fe_coll =
+         make_shared<L2_FECollection>(dest_fe_order, dest_mesh->Dimension());
   }

-   auto src_fe = make_shared<ParFiniteElementSpace>(
-                    p_src_mesh.get(), src_fe_coll.get(),
-                    use_vector_space ? src_mesh->Dimension() : 1);
+   auto src_fe =
+      make_shared<ParFiniteElementSpace>(p_src_mesh.get(), src_fe_coll.get());

-   auto dest_fe = make_shared<ParFiniteElementSpace>(
-                     p_dest_mesh.get(), dest_fe_coll.get(),
-                     use_vector_space ? dest_mesh->Dimension() : 1);
+   auto dest_fe =
+      make_shared<ParFiniteElementSpace>(p_dest_mesh.get(), dest_fe_coll.get());

   ParGridFunction src_fun(src_fe.get());

@@ -223,7 +189,7 @@ int main(int argc, char *argv[])
   // To be used with vector fe
   VectorFunctionCoefficient vector_coeff(dim, &vector_fun);

-   if (use_vector_fe || use_vector_space)
+   if (use_vector_fe)
   {
      src_fun.ProjectCoefficient(vector_coeff);
      src_fun.Update();
@@ -243,11 +209,7 @@ int main(int argc, char *argv[])
      assemble_mass_and_coupling_together);
   assembler.SetVerbose(verbose);

-   if (use_vector_space)
-   {
-      assembler.AddMortarIntegrator(make_shared<LagrangeVectorL2MortarIntegrator>());
-   }
-   else if (use_vector_fe)
+   if (use_vector_fe)
   {
      assembler.AddMortarIntegrator(make_shared<VectorL2MortarIntegrator>());
   }
@@ -281,8 +243,8 @@ int main(int argc, char *argv[])
                      << std::endl;
         }

-         plot(*p_src_mesh, src_fun, "source", 0);
-         plot(*p_dest_mesh, dest_fun, "destination", 1);
+         plot(*p_src_mesh, src_fun, "source");
+         plot(*p_dest_mesh, dest_fun, "destination");
      }
   }
   else
@@ -20,10 +20,6 @@
 #include "example_utils.hpp"
 #include "mfem.hpp"

-#ifndef MFEM_USE_MOONOLITH
-#error This example requires that MFEM is built with MFEM_USE_MOONOLITH=YES
-#endif
-
 using namespace mfem;
 using namespace std;

@@ -190,8 +186,8 @@ int main(int argc, char *argv[])
                      << std::endl;
         }

-         plot(*p_src_mesh, src_fun, "source", 0);
-         plot(*p_dest_mesh, dest_fun, "destination", 1);
+         plot(*p_src_mesh, src_fun, "source");
+         plot(*p_dest_mesh, dest_fun, "destination");
      }
   }
   else
@@ -84,8 +84,7 @@ void vector_fun(const mfem::Vector &x, mfem::Vector &f)
   f = n;
 }

-inline void plot(mfem::Mesh &mesh, mfem::GridFunction &x, std::string title,
-                 const int plot_number = 0)
+inline void plot(mfem::Mesh &mesh, mfem::GridFunction &x, std::string title)
 {
   using namespace std;
   using namespace mfem;
@@ -104,18 +103,5 @@ inline void plot(mfem::Mesh &mesh, mfem::GridFunction &x, std::string title,
   sol_sock.precision(8);
   sol_sock << "solution\n" << mesh << x
            << "window_title '"<< title << "'\n" << flush;
-
-   sol_sock << "window_geometry ";
-   sol_sock << (plot_number * 600)  << " " << 0 << " " << 600 << " " << 600 <<
-            "\n";
-
-   if (mesh.Dimension() == 2)
-   {
-      sol_sock  << "keys jRmclA\n";
-   }
-   else
-   {
-      sol_sock  << "keys rmclAa\n";
-   }
   sol_sock << flush;
 }
@@ -10,7 +10,7 @@
 //               mpirun -np 4 ex1p -pa -d cuda --petscopts rc_ex1p_device
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -8,7 +8,7 @@
 //    mpirun -np 4 ex6p -m ../../data/amr-quad.mesh -nonoverlapping
 //
 // Description:  This is a version of Example 1 with a simple adaptive mesh
-//               refinement loop. The problem being solved is again the Poisson
+//               refinement loop. The problem being solved is again the Laplace
 //               equation -Delta u = 1 with homogeneous Dirichlet boundary
 //               conditions. The problem is solved on a sequence of meshes which
 //               are locally refined in a conforming (triangles, tetrahedrons)
@@ -131,7 +131,7 @@ int main(int argc, char *argv[])
   ParFiniteElementSpace fespace(&pmesh, &fec);

   // 7. As in Example 1p, we set up bilinear and linear forms corresponding to
-   //    the Poisson problem -\Delta u = 1. We don't assemble the discrete
+   //    the Laplace problem -\Delta u = 1. We don't assemble the discrete
   //    problem yet, this will be done in the main loop.
   ParBilinearForm a(&fespace);
   ParLinearForm b(&fespace);
@@ -11,7 +11,7 @@
 //               creating a symbolic link to the above directory in ../../data.
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -12,7 +12,7 @@
 //               creating a symbolic link to the above directory in ../../data.
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -6,7 +6,7 @@
 // Sample runs:  mpirun -np 8 ex6p
 //
 // Description:  This is a version of Example 1 with a simple adaptive mesh
-//               refinement loop. The problem being solved is again the Poisson
+//               refinement loop. The problem being solved is again the Laplace
 //               equation -Delta u = 1 with homogeneous Dirichlet boundary
 //               conditions. The problem is solved on a sequence of meshes which
 //               are adapted in a conforming (tetrahedrons) manner according
@@ -26,7 +26,7 @@
 //               mpirun -np 4 ex1p -m ../../data/mobius-strip.mesh
 //
 // Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Poisson problem
+//               simple finite element discretization of the Laplace problem
 //               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
 //               Specifically, we discretize using a FE space of the specified
 //               order, or if order < 1 using an isoparametric/isogeometric
@@ -35,7 +35,6 @@ set(SRCS
  integ/bilininteg_mass_ea.cpp
  integ/bilininteg_mixedcurl_pa.cpp
  integ/bilininteg_mixedvecgrad_pa.cpp
-  integ/bilininteg_trace_jump_ea.cpp
  integ/bilininteg_transpose_ea.cpp
  integ/bilininteg_vecdiffusion_mf.cpp
  integ/bilininteg_vecdiffusion_pa.cpp
@@ -47,7 +46,6 @@ set(SRCS
  integ/bilininteg_diffusion_kernels.cpp
  integ/bilininteg_elasticity_kernels.cpp
  integ/bilininteg_hcurl_kernels.cpp
-  integ/bilininteg_hdiv_ea.cpp
  integ/bilininteg_hdiv_kernels.cpp
  integ/bilininteg_hcurlhdiv_kernels.cpp
  integ/bilininteg_mass_kernels.cpp
@@ -59,15 +57,12 @@ set(SRCS
  integ/nonlininteg_vecconvection_pa.cpp
  integ/nonlininteg_vecconvection_mf.cpp
  coefficient.cpp
-  complex_coefficient.cpp
  complex_fem.cpp
  convergence.cpp
  datacollection.cpp
  dgmassinv.cpp
  doftrans.cpp
-  dfem/doperator.cpp
  eltrans.cpp
-  batchitrans.cpp
  estimators.cpp
  fe.cpp
  fe/face_map_utils.cpp
@@ -78,7 +73,6 @@ set(SRCS
  fe/fe_nd.cpp
  fe/fe_nurbs.cpp
  fe/fe_pos.cpp
-  fe/fe_pyramid.cpp
  fe/fe_rt.cpp
  fe/fe_ser.cpp
  fe_coll.cpp
@@ -86,7 +80,6 @@ set(SRCS
  geom.cpp
  gridfunc.cpp
  hybridization.cpp
-  hybridization_ext.cpp
  intrules.cpp
  intrules_cut.cpp
  ceed/interface/basis.cpp
@@ -163,7 +156,6 @@ set(SRCS
  transfer.cpp
  hyperbolic.cpp
  integrator.cpp
-  bounds.cpp
  )

 set(HDRS
@@ -177,21 +169,12 @@ set(HDRS
  integ/bilininteg_hcurlhdiv_kernels.hpp
  integ/bilininteg_mass_kernels.hpp
  coefficient.hpp
-  complex_coefficient.hpp
  complex_fem.hpp
  convergence.hpp
  datacollection.hpp
  dgmassinv.hpp
  dgmassinv_kernels.hpp
  doftrans.hpp
-  dfem/doperator.hpp
-  dfem/fieldoperator.hpp
-  dfem/integrate.hpp
-  dfem/parameterspace.hpp
-  dfem/qfunction_apply.hpp
-  dfem/qfunction_transform.hpp
-  dfem/tuple.hpp
-  dfem/util.hpp
  eltrans.hpp
  estimators.hpp
  fe.hpp
@@ -203,7 +186,6 @@ set(HDRS
  fe/fe_nd.hpp
  fe/fe_nurbs.hpp
  fe/fe_pos.hpp
-  fe/fe_pyramid.hpp
  fe/fe_rt.hpp
  fe/fe_ser.hpp
  fe_coll.hpp
@@ -212,7 +194,6 @@ set(HDRS
  geom.hpp
  gridfunc.hpp
  hybridization.hpp
-  hybridization_ext.hpp
  intrules.hpp
  intrules_cut.hpp
  kernel_dispatch.hpp
@@ -249,7 +230,6 @@ set(HDRS
  nonlinearform_ext.hpp
  nonlininteg.hpp
  qfunction.hpp
-  qinterp/det.hpp
  qinterp/eval.hpp
  qinterp/eval_hdiv.hpp
  qinterp/grad.hpp
@@ -276,7 +256,6 @@ set(HDRS
  transfer.hpp
  hyperbolic.hpp
  integrator.hpp
-  bounds.hpp
  )

 if (MFEM_USE_SIDRE)
@@ -71,11 +71,15 @@ BilinearForm::BilinearForm(FiniteElementSpace * f)
   sequence = f->GetSequence();
   mat = mat_e = NULL;
   extern_bfs = 0;
+   element_matrices = NULL;
+   static_cond = NULL;
+   hybridization = NULL;
   precompute_sparsity = 0;
   diag_policy = DIAG_KEEP;

   assembly = AssemblyLevel::LEGACY;
   batch = 1;
+   ext = NULL;
 }

 BilinearForm::BilinearForm (FiniteElementSpace * f, BilinearForm * bf, int ps)
@@ -85,11 +89,15 @@ BilinearForm::BilinearForm (FiniteElementSpace * f, BilinearForm * bf, int ps)
   sequence = f->GetSequence();
   mat_e = NULL;
   extern_bfs = 1;
+   element_matrices = NULL;
+   static_cond = NULL;
+   hybridization = NULL;
   precompute_sparsity = ps;
   diag_policy = DIAG_KEEP;

   assembly = AssemblyLevel::LEGACY;
   batch = 1;
+   ext = NULL;

   // Copy the pointers to the integrators
   domain_integs = bf->domain_integs;
@@ -119,16 +127,16 @@ void BilinearForm::SetAssemblyLevel(AssemblyLevel assembly_level)
         break;
      case AssemblyLevel::FULL:
         SetDiagonalPolicy( DIAG_ONE ); // Only diagonal policy supported on device
-         ext.reset(new FABilinearFormExtension(this));
+         ext = new FABilinearFormExtension(this);
         break;
      case AssemblyLevel::ELEMENT:
-         ext.reset(new EABilinearFormExtension(this));
+         ext = new EABilinearFormExtension(this);
         break;
      case AssemblyLevel::PARTIAL:
-         ext.reset(new PABilinearFormExtension(this));
+         ext = new PABilinearFormExtension(this);
         break;
      case AssemblyLevel::NONE:
-         ext.reset(new MFBilinearFormExtension(this));
+         ext = new MFBilinearFormExtension(this);
         break;
      default:
         MFEM_ABORT("BilinearForm: unknown assembly level");
@@ -137,13 +145,14 @@ void BilinearForm::SetAssemblyLevel(AssemblyLevel assembly_level)

 void BilinearForm::EnableStaticCondensation()
 {
+   delete static_cond;
   if (assembly != AssemblyLevel::LEGACY)
   {
-      static_cond.reset();
+      static_cond = NULL;
      MFEM_WARNING("Static condensation not supported for this assembly level");
      return;
   }
-   static_cond.reset(new StaticCondensation(fes));
+   static_cond = new StaticCondensation(fes);
   if (static_cond->ReducesTrueVSize())
   {
      bool symmetric = false;      // TODO
@@ -152,7 +161,8 @@ void BilinearForm::EnableStaticCondensation()
   }
   else
   {
-      static_cond.reset();
+      delete static_cond;
+      static_cond = NULL;
   }
 }

@@ -160,18 +170,15 @@ void BilinearForm::EnableHybridization(FiniteElementSpace *constr_space,
                                       BilinearFormIntegrator *constr_integ,
                                       const Array<int> &ess_tdof_list)
 {
-   if (assembly != AssemblyLevel::LEGACY && assembly != AssemblyLevel::ELEMENT)
+   delete hybridization;
+   if (assembly != AssemblyLevel::LEGACY)
   {
      delete constr_integ;
-      hybridization.reset();
+      hybridization = NULL;
      MFEM_WARNING("Hybridization not supported for this assembly level");
      return;
   }
-   hybridization.reset(new Hybridization(fes, constr_space));
-   if (assembly == AssemblyLevel::ELEMENT)
-   {
-      hybridization->EnableDeviceExecution();
-   }
+   hybridization = new Hybridization(fes, constr_space);
   hybridization->SetConstraintIntegrator(constr_integ);
   hybridization->Init(ess_tdof_list);
 }
@@ -224,8 +231,8 @@ void BilinearForm::Finalize (int skip_zeros)
      if (!static_cond) { mat->Finalize(skip_zeros); }
      if (mat_e) { mat_e->Finalize(skip_zeros); }
      if (static_cond) { static_cond->Finalize(); }
+      if (hybridization) { hybridization->Finalize(); }
   }
-   if (hybridization) { hybridization->Finalize(); }
 }

 void BilinearForm::AddDomainIntegrator(BilinearFormIntegrator *bfi)
@@ -458,14 +465,11 @@ void BilinearForm::Assemble(int skip_zeros)
   if (ext)
   {
      ext->Assemble();
-      if (hybridization)
-      {
-         hybridization->AssembleElementMatrices(GetElementMatrices());
-      }
      return;
   }

   ElementTransformation *eltrans;
+   DofTransformation * doftrans;
   Mesh *mesh = fes -> GetMesh();
   DenseMatrix elmat, *elmat_p;

@@ -502,14 +506,13 @@ void BilinearForm::Assemble(int skip_zeros)
         }
      }

-      DofTransformation doftrans;
      // Element-wise integration
      for (int i = 0; i < fes -> GetNE(); i++)
      {
         // Set both doftrans (potentially needed to assemble the element
         // matrix) and vdofs, which is also needed when the element matrices
         // are pre-assembled.
-         fes->GetElementVDofs(i, vdofs, doftrans);
+         doftrans = fes->GetElementVDofs(i, vdofs);
         if (element_matrices)
         {
            elmat_p = &(*element_matrices)(i);
@@ -547,7 +550,10 @@ void BilinearForm::Assemble(int skip_zeros)
            {
               elmat_p = &elmat;
            }
-            doftrans.TransformDual(elmat);
+            if (doftrans)
+            {
+               doftrans->TransformDual(elmat);
+            }
            elmat_p = &elmat;
         }
         if (static_cond)
@@ -625,14 +631,13 @@ void BilinearForm::Assemble(int skip_zeros)
         }
      }

-      DofTransformation doftrans;
      for (int i = 0; i < fes -> GetNBE(); i++)
      {
         const int bdr_attr = mesh->GetBdrAttribute(i);
         if (bdr_attr_marker[bdr_attr-1] == 0) { continue; }

         const FiniteElement &be = *fes->GetBE(i);
-         fes -> GetBdrElementVDofs (i, vdofs, doftrans);
+         doftrans = fes -> GetBdrElementVDofs (i, vdofs);
         eltrans = fes -> GetBdrElementTransformation (i);
         int k = 0;
         for (; k < boundary_integs.Size(); k++)
@@ -652,7 +657,10 @@ void BilinearForm::Assemble(int skip_zeros)
            boundary_integs[k]->AssembleElementMatrix(be, *eltrans, elemmat);
            elmat += elemmat;
         }
-         doftrans.TransformDual(elmat);
+         if (doftrans)
+         {
+            doftrans->TransformDual(elmat);
+         }
         elmat_p = &elmat;
         if (!static_cond)
         {
@@ -827,19 +835,7 @@ void BilinearForm::FormLinearSystem(const Array<int> &ess_tdof_list, Vector &x,
 {
   if (ext)
   {
-      if (hybridization)
-      {
-         FormSystemMatrix(ess_tdof_list, A);
-         ConstrainedOperator A_constrained(this, ess_tdof_list);
-         A_constrained.EliminateRHS(x, b);
-         hybridization->ReduceRHS(b, B);
-         X.SetSize(B.Size());
-         X = 0.0;
-      }
-      else
-      {
-         ext->FormLinearSystem(ess_tdof_list, x, b, A, X, B, copy_interior);
-      }
+      ext->FormLinearSystem(ess_tdof_list, x, b, A, X, B, copy_interior);
      return;
   }
   const SparseMatrix *P = fes->GetConformingProlongation();
@@ -907,16 +903,7 @@ void BilinearForm::FormSystemMatrix(const Array<int> &ess_tdof_list,
 {
   if (ext)
   {
-      if (hybridization)
-      {
-         const int remove_zeros = 0;
-         Finalize(remove_zeros);
-         A.Reset(&hybridization->GetMatrix(), false);
-      }
-      else
-      {
-         ext->FormSystemMatrix(ess_tdof_list, A);
-      }
+      ext->FormSystemMatrix(ess_tdof_list, A);
      return;
   }

@@ -957,7 +944,7 @@ void BilinearForm::FormSystemMatrix(const Array<int> &ess_tdof_list,
 void BilinearForm::RecoverFEMSolution(const Vector &X,
                                      const Vector &b, Vector &x)
 {
-   if (ext && !hybridization)
+   if (ext)
   {
      ext->RecoverFEMSolution(X, b, x);
      return;
@@ -1014,26 +1001,16 @@ void BilinearForm::RecoverFEMSolution(const Vector &X,

 void BilinearForm::ComputeElementMatrices()
 {
-   if (element_matrices) { return; }
-
-   if (auto *ea_ext = dynamic_cast<EABilinearFormExtension*>(ext.get()))
+   if (element_matrices || domain_integs.Size() == 0 || fes->GetNE() == 0)
   {
-      element_matrices.reset(new DenseTensor);
-      ea_ext->GetElementMatrices(*element_matrices, ElementDofOrdering::NATIVE, true);
-      return;
-   }
-
-   if (domain_integs.Size() == 0 || fes->GetNE() == 0)
-   {
-      element_matrices.reset(new DenseTensor);
      return;
   }

   int num_elements = fes->GetNE();
   int num_dofs_per_el = fes->GetTypicalFE()->GetDof() * fes->GetVDim();

-   element_matrices.reset(new DenseTensor(num_dofs_per_el, num_dofs_per_el,
-                                          num_elements));
+   element_matrices = new DenseTensor(num_dofs_per_el, num_dofs_per_el,
+                                      num_elements);

   DenseMatrix tmp;
   IsoparametricTransformation eltrans;
@@ -1064,12 +1041,6 @@ void BilinearForm::ComputeElementMatrices()
   }
 }

-const DenseTensor &BilinearForm::GetElementMatrices()
-{
-   ComputeElementMatrices(); // Won't recompute if element_matrices exists
-   return *element_matrices;
-}
-
 void BilinearForm::EliminateEssentialBC(const Array<int> &bdr_attr_is_ess,
                                        const Vector &sol, Vector &rhs,
                                        DiagonalPolicy dpolicy)
@@ -1257,13 +1228,15 @@ void BilinearForm::Update(FiniteElementSpace *nfes)
   delete mat_e;
   mat_e = NULL;
   FreeElementMatrices();
-   static_cond.reset();
+   delete static_cond;
+   static_cond = NULL;

   if (full_update)
   {
      delete mat;
      mat = NULL;
-      hybridization.reset();
+      delete hybridization;
+      hybridization = NULL;
      sequence = fes->GetSequence();
   }
   else
@@ -1286,6 +1259,9 @@ BilinearForm::~BilinearForm()
 {
   delete mat_e;
   delete mat;
+   delete element_matrices;
+   delete static_cond;
+   delete hybridization;

   if (!extern_bfs)
   {
@@ -1297,6 +1273,8 @@ BilinearForm::~BilinearForm()
      for (k=0; k < boundary_face_integs.Size(); k++)
      { delete boundary_face_integs[k]; }
   }
+
+   delete ext;
 }


@@ -1323,6 +1301,7 @@ MixedBilinearForm::MixedBilinearForm (FiniteElementSpace *tr_fes,
   mat = NULL;
   mat_e = NULL;
   extern_bfs = 1;
+   ext = NULL;

   // Copy the pointers to the integrators
   domain_integs = mbf->domain_integs;
@@ -1352,22 +1331,22 @@ void MixedBilinearForm::SetAssemblyLevel(AssemblyLevel assembly_level)
      case AssemblyLevel::LEGACY:
         break;
      case AssemblyLevel::FULL:
-         // ext.reset(new FAMixedBilinearFormExtension(this));
+         // ext = new FAMixedBilinearFormExtension(this);
         // Use the original BilinearForm implementation for now
         break;
      case AssemblyLevel::ELEMENT:
-         MFEM_ABORT("Element assembly not supported yet... stay tuned!");
-         // ext.reset(new EAMixedBilinearFormExtension(this));
+         mfem_error("Element assembly not supported yet... stay tuned!");
+         // ext = new EAMixedBilinearFormExtension(this);
         break;
      case AssemblyLevel::PARTIAL:
-         ext.reset(new PAMixedBilinearFormExtension(this));
+         ext = new PAMixedBilinearFormExtension(this);
         break;
      case AssemblyLevel::NONE:
-         MFEM_ABORT("Matrix-free action not supported yet... stay tuned!");
-         // ext.reset(new MFMixedBilinearFormExtension(this));
+         mfem_error("Matrix-free action not supported yet... stay tuned!");
+         // ext = new MFMixedBilinearFormExtension(this);
         break;
      default:
-         MFEM_ABORT("Unknown assembly level");
+         mfem_error("Unknown assembly level");
   }
 }

@@ -1525,6 +1504,8 @@ void MixedBilinearForm::Assemble(int skip_zeros)
   }

   ElementTransformation *eltrans;
+   DofTransformation * dom_dof_trans;
+   DofTransformation * ran_dof_trans;
   DenseMatrix elmat;

   Mesh *mesh = test_fes -> GetMesh();
@@ -1547,12 +1528,11 @@ void MixedBilinearForm::Assemble(int skip_zeros)
         }
      }

-      DofTransformation dom_dof_trans, ran_dof_trans;
      for (int i = 0; i < test_fes -> GetNE(); i++)
      {
         const int elem_attr = mesh->GetAttribute(i);
-         trial_fes->GetElementVDofs (i, trial_vdofs, dom_dof_trans);
-         test_fes->GetElementVDofs (i, test_vdofs, ran_dof_trans);
+         dom_dof_trans = trial_fes -> GetElementVDofs (i, trial_vdofs);
+         ran_dof_trans = test_fes  -> GetElementVDofs (i, test_vdofs);
         eltrans = test_fes -> GetElementTransformation (i);

         elmat.SetSize(test_vdofs.Size(), trial_vdofs.Size());
@@ -1568,7 +1548,10 @@ void MixedBilinearForm::Assemble(int skip_zeros)
               elmat += elemmat;
            }
         }
-         TransformDual(ran_dof_trans, dom_dof_trans, elmat);
+         if (ran_dof_trans || dom_dof_trans)
+         {
+            TransformDual(ran_dof_trans, dom_dof_trans, elmat);
+         }
         mat -> AddSubMatrix (test_vdofs, trial_vdofs, elmat, skip_zeros);
      }
   }
@@ -1596,14 +1579,13 @@ void MixedBilinearForm::Assemble(int skip_zeros)
         }
      }

-      DofTransformation dom_dof_trans, ran_dof_trans;
      for (int i = 0; i < test_fes -> GetNBE(); i++)
      {
         const int bdr_attr = mesh->GetBdrAttribute(i);
         if (bdr_attr_marker[bdr_attr-1] == 0) { continue; }

-         trial_fes->GetBdrElementVDofs (i, trial_vdofs, dom_dof_trans);
-         test_fes->GetBdrElementVDofs (i, test_vdofs, ran_dof_trans);
+         dom_dof_trans = trial_fes -> GetBdrElementVDofs (i, trial_vdofs);
+         ran_dof_trans = test_fes  -> GetBdrElementVDofs (i, test_vdofs);
         eltrans = test_fes -> GetBdrElementTransformation (i);

         elmat.SetSize(test_vdofs.Size(), trial_vdofs.Size());
@@ -1618,7 +1600,10 @@ void MixedBilinearForm::Assemble(int skip_zeros)
                                                        *eltrans, elemmat);
            elmat += elemmat;
         }
-         TransformDual(ran_dof_trans, dom_dof_trans, elmat);
+         if (ran_dof_trans || dom_dof_trans)
+         {
+            TransformDual(ran_dof_trans, dom_dof_trans, elmat);
+         }
         mat -> AddSubMatrix (test_vdofs, trial_vdofs, elmat, skip_zeros);
      }
   }
@@ -2358,6 +2343,7 @@ MixedBilinearForm::~MixedBilinearForm()
      for (i = 0; i < boundary_trace_face_integs.Size(); i++)
      { delete boundary_trace_face_integs[i]; }
   }
+   delete ext;
 }

 void DiscreteLinearOperator::SetAssemblyLevel(AssemblyLevel assembly_level)
@@ -2374,16 +2360,16 @@ void DiscreteLinearOperator::SetAssemblyLevel(AssemblyLevel assembly_level)
         // Use the original implementation for now
         break;
      case AssemblyLevel::ELEMENT:
-         MFEM_ABORT("Element assembly not supported yet... stay tuned!");
+         mfem_error("Element assembly not supported yet... stay tuned!");
         break;
      case AssemblyLevel::PARTIAL:
-         ext.reset(new PADiscreteLinearOperatorExtension(this));
+         ext = new PADiscreteLinearOperatorExtension(this);
         break;
      case AssemblyLevel::NONE:
-         MFEM_ABORT("Matrix-free action not supported yet... stay tuned!");
+         mfem_error("Matrix-free action not supported yet... stay tuned!");
         break;
      default:
-         MFEM_ABORT("Unknown assembly level");
+         mfem_error("Unknown assembly level");
   }
 }

@@ -2396,6 +2382,8 @@ void DiscreteLinearOperator::Assemble(int skip_zeros)
   }

   ElementTransformation *eltrans;
+   DofTransformation * dom_dof_trans;
+   DofTransformation * ran_dof_trans;
   DenseMatrix elmat;

   Mesh *mesh = test_fes->GetMesh();
@@ -2418,13 +2406,11 @@ void DiscreteLinearOperator::Assemble(int skip_zeros)
         }
      }

-      DofTransformation dom_dof_trans;
-      DofTransformation ran_dof_trans;
      for (int i = 0; i < test_fes->GetNE(); i++)
      {
         const int elem_attr = mesh->GetAttribute(i);
-         trial_fes->GetElementVDofs(i, trial_vdofs, dom_dof_trans);
-         test_fes->GetElementVDofs(i, test_vdofs, ran_dof_trans);
+         dom_dof_trans = trial_fes->GetElementVDofs(i, trial_vdofs);
+         ran_dof_trans = test_fes->GetElementVDofs(i, test_vdofs);
         eltrans = test_fes->GetElementTransformation(i);

         elmat.SetSize(test_vdofs.Size(), trial_vdofs.Size());
@@ -2440,7 +2426,10 @@ void DiscreteLinearOperator::Assemble(int skip_zeros)
               elmat += elemmat;
            }
         }
-         TransformPrimal(ran_dof_trans, dom_dof_trans, elemmat);
+         if (ran_dof_trans || dom_dof_trans)
+         {
+            TransformPrimal(ran_dof_trans, dom_dof_trans, elemmat);
+         }
         mat->SetSubMatrix(test_vdofs, trial_vdofs, elemmat, skip_zeros);
      }
   }
@@ -83,7 +83,7 @@ protected:
   /** @brief Extension for supporting Full Assembly (FA),
       Element Assembly (EA),Partial Assembly (PA),
       or Matrix Free assembly (MF). */
-   std::unique_ptr<BilinearFormExtension> ext;
+   BilinearFormExtension *ext;

   /** Indicates if the sparse matrix is sorted after assembly when using
       Full Assembly (FA). */
@@ -122,10 +122,10 @@ protected:
   mutable DenseMatrix elemmat;
   mutable Array<int>  vdofs;

-   std::unique_ptr<DenseTensor> element_matrices;
+   DenseTensor *element_matrices; ///< Owned.

-   std::unique_ptr<StaticCondensation> static_cond;
-   std::unique_ptr<Hybridization> hybridization;
+   StaticCondensation *static_cond; ///< Owned.
+   Hybridization *hybridization; ///< Owned.

   /** @brief This data member allows one to specify what should be done to the
       diagonal matrix entries and corresponding RHS values upon elimination of
@@ -148,11 +148,13 @@ protected:
   BilinearForm() : Matrix (0)
   {
      fes = NULL; sequence = -1;
-      mat = mat_e = NULL; extern_bfs = 0;
+      mat = mat_e = NULL; extern_bfs = 0; element_matrices = NULL;
+      static_cond = NULL; hybridization = NULL;
      precompute_sparsity = 0;
      diag_policy = DIAG_KEEP;
      assembly = AssemblyLevel::LEGACY;
      batch = 1;
+      ext = NULL;
   }

 private:
@@ -212,7 +214,7 @@ public:
   /// Returns the assembly level
   AssemblyLevel GetAssemblyLevel() const { return assembly; }

-   Hybridization *GetHybridization() const { return hybridization.get(); }
+   Hybridization *GetHybridization() const { return hybridization; }

   /** @brief Enable the use of static condensation. For details see the
       description for class StaticCondensation in fem/staticcond.hpp This
@@ -222,7 +224,7 @@ public:

   /** @brief Check if static condensation was actually enabled by a previous
       call to EnableStaticCondensation(). */
-   bool StaticCondensationIsEnabled() const { return static_cond != nullptr; }
+   bool StaticCondensationIsEnabled() const { return static_cond; }

   /// Return the trace FE space associated with static condensation.
   FiniteElementSpace *SCFESpace() const
@@ -567,20 +569,12 @@ public:
   void RecoverFEMSolution(const Vector &X, const Vector &b,
                           Vector &x) override;

-   /// @brief Compute and store internally all element matrices.
-   ///
-   /// If AssemblyLevel::ELEMENT is selected with SetAssemblyLevel(), this will
-   /// use efficient (device-accelerated) assembly of the element matrices.
+   /// Compute and store internally all element matrices.
   void ComputeElementMatrices();

   /// Free the memory used by the element matrices.
-   void FreeElementMatrices() { element_matrices.reset(); }
-
-   /// @brief Return a DenseTensor containing the assembled element matrices.
-   ///
-   /// If AssemblyLevel::ELEMENT is selected with SetAssemblyLevel(), this will
-   /// use efficient (device-accelerated) assembly of the element matrices.
-   const DenseTensor &GetElementMatrices();
+   void FreeElementMatrices()
+   { delete element_matrices; element_matrices = NULL; }

   /// Compute the element matrix of the given element
   /** The element matrix is computed by calling the domain integrators
@@ -766,7 +760,7 @@ protected:

   /** Extension for supporting Full Assembly (FA), Element Assembly (EA),
       Partial Assembly (PA), or Matrix Free assembly (MF). */
-   std::unique_ptr<MixedBilinearFormExtension> ext;
+   MixedBilinearFormExtension *ext;

   /** @brief Indicates the BilinearFormIntegrator%s stored in
       MixedBilinearForm#domain_integs, MixedBilinearForm#boundary_integs,
@@ -16,7 +16,6 @@
 #include "bilinearform.hpp"
 #include "pbilinearform.hpp"
 #include "pgridfunc.hpp"
-#include "fe/face_map_utils.hpp"
 #include "ceed/interface/util.hpp"

 namespace mfem
@@ -78,7 +77,7 @@ void MFBilinearFormExtension::AssembleDiagonal(Vector &y) const
         dynamic_cast<const ElementRestriction*>(elem_restrict);
      if (H1elem_restrict)
      {
-         H1elem_restrict->AbsMultTranspose(localY, y);
+         H1elem_restrict->MultTransposeUnsigned(localY, y);
      }
      else
      {
@@ -456,7 +455,7 @@ void PABilinearFormExtension::AssembleDiagonal(Vector &y) const
            dynamic_cast<const ElementRestriction*>(elem_restrict);
         if (H1elem_restrict)
         {
-            H1elem_restrict->AbsMultTranspose(localY, y);
+            H1elem_restrict->MultTransposeUnsigned(localY, y);
         }
         else
         {
@@ -491,7 +490,7 @@ void PABilinearFormExtension::AssembleDiagonal(Vector &y) const
         assemble_diagonal_with_markers(*bdr_integs[i], bdr_markers[i],
                                        bdr_attributes, bdr_face_Y);
      }
-      bdr_face_restrict_lex->AddAbsMultTranspose(bdr_face_Y, y);
+      bdr_face_restrict_lex->AddMultTransposeUnsigned(bdr_face_Y, y);
   }
 }

@@ -526,8 +525,7 @@ void PABilinearFormExtension::FormLinearSystem(const Array<int> &ess_tdof_list,
   A.Reset(oper); // A will own oper
 }

-void PABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
-                                           const bool useAbs) const
+void PABilinearFormExtension::Mult(const Vector &x, Vector &y) const
 {
   Array<BilinearFormIntegrator*> &integrators = *a->GetDBFI();

@@ -559,13 +557,11 @@ void PABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
      {
         if (integrators[i]->Patchwise())
         {
-            MFEM_ASSERT(!useAbs, "AbsMult not implemented with NURBS!")
            integrators[i]->AddMultNURBSPA(x, y);
         }
         else
         {
-            if (useAbs) { integrators[i]->AddAbsMultPA(x, y); }
-            else { integrators[i]->AddMultPA(x, y); }
+            integrators[i]->AddMultPA(x, y);
         }
      }
   }
@@ -574,30 +570,14 @@ void PABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
      if (iSz)
      {
         Array<Array<int>*> &elem_markers = *a->GetDBFI_Marker();
-         auto H1elem_restrict =
-            dynamic_cast<const ElementRestriction*>(elem_restrict);
-         if (H1elem_restrict && useAbs)
-         {
-            H1elem_restrict->AbsMult(x, localX);
-         }
-         else
-         {
-            elem_restrict->Mult(x, localX);
-         }
+         elem_restrict->Mult(x, localX);
         localY = 0.0;
         for (int i = 0; i < iSz; ++i)
         {
            AddMultWithMarkers(*integrators[i], localX, elem_markers[i],
-                               elem_attributes, false, localY, useAbs);
-         }
-         if (H1elem_restrict && useAbs)
-         {
-            H1elem_restrict->AbsMultTranspose(localY, y);
-         }
-         else
-         {
-            elem_restrict->MultTranspose(localY, y);
+                               elem_attributes, false, localY);
         }
+         elem_restrict->MultTranspose(localY, y);
      }
      else
      {
@@ -609,7 +589,6 @@ void PABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
   const int iFISz = intFaceIntegrators.Size();
   if (int_face_restrict_lex && iFISz>0)
   {
-      MFEM_ASSERT(!useAbs, "AbsMult not implemented for face integrators!")
      // When assembling interior face integrators for DG spaces, we need to
      // exchange the face-neighbor information. This happens inside member
      // functions of the 'int_face_restrict_lex'. To avoid repeated calls to
@@ -671,7 +650,6 @@ void PABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
   const bool has_bdr_integs = (n_bdr_face_integs > 0 || n_bdr_integs > 0);
   if (bdr_face_restrict_lex && has_bdr_integs)
   {
-      MFEM_ASSERT(!useAbs, "AbsMult not implemented for bdr integrators!")
      Array<Array<int>*> &bdr_markers = *a->GetBBFI_Marker();
      Array<Array<int>*> &bdr_face_markers = *a->GetBFBFI_Marker();
      bdr_face_restrict_lex->Mult(x, bdr_face_X);
@@ -849,39 +827,22 @@ void PABilinearFormExtension::AddMultWithMarkers(
   const Array<int> *markers,
   const Array<int> &attributes,
   const bool transpose,
-   Vector &y,
-   const bool useAbs) const
+   Vector &y) const
 {
   if (markers)
   {
      tmp_evec.SetSize(y.Size());
      tmp_evec = 0.0;
-      if (useAbs)
-      {
-         if (transpose) { integ.AddAbsMultTransposePA(x, tmp_evec); }
-         else { integ.AddAbsMultPA(x, tmp_evec); }
-      }
-      else
-      {
-         if (transpose) { integ.AddMultTransposePA(x, tmp_evec); }
-         else { integ.AddMultPA(x, tmp_evec); }
-      }
+      if (transpose) { integ.AddMultTransposePA(x, tmp_evec); }
+      else { integ.AddMultPA(x, tmp_evec); }
      const int ne = attributes.Size();
      const int nd = x.Size() / ne;
      AddWithMarkers_(ne, nd, tmp_evec, *markers, attributes, y);
   }
   else
   {
-      if (useAbs)
-      {
-         if (transpose) { integ.AddAbsMultTransposePA(x, y); }
-         else { integ.AddAbsMultPA(x, y); }
-      }
-      else
-      {
-         if (transpose) { integ.AddMultTransposePA(x, y); }
-         else { integ.AddMultPA(x, y); }
-      }
+      if (transpose) { integ.AddMultTransposePA(x, y); }
+      else { integ.AddMultPA(x, y); }
   }
 }

@@ -903,137 +864,52 @@ void EABilinearFormExtension::Assemble()
   ne = trial_fes->GetMesh()->GetNE();
   elemDofs = trial_fes->GetTypicalFE()->GetDof();

-   Vector ea_data_tmp;
+   ea_data.SetSize(ne*elemDofs*elemDofs, Device::GetMemoryType());
+   ea_data.UseDevice(true);

-   auto add_with_markers = [&](const Vector &ea_1, Vector &ea_2, const int ne_,
-                               const Array<int> &markers, const Array<int> &attrs,
-                               const bool add)
+   Array<BilinearFormIntegrator*> &integrators = *a->GetDBFI();
+   const int integratorCount = integrators.Size();
+   if ( integratorCount == 0 )
   {
-      if (ne_ == 0) { return; }
-      const int sz = ea_1.Size() / ne_;
-      const int *d_m = markers.Read();
-      const int *d_a = attrs.Read();
-      const auto d_ea_1 = Reshape(ea_1.Read(), sz, ne_);
-      auto d_ea_2 = Reshape(add ? ea_2.ReadWrite() : ea_2.Write(), sz, ne_);
-
-      mfem::forall(sz*ne_, [=] MFEM_HOST_DEVICE (int idx)
-      {
-         const int i = idx % sz;
-         const int e = idx / sz;
-         const real_t val = d_m[d_a[e] - 1] ? d_ea_1(i, e) : 0.0;
-         if (add)
-         {
-            d_ea_2(i, e) += val;
-         }
-         else
-         {
-            d_ea_2(i, e) = val;
-         }
-      });
-   };
-
+      ea_data = 0.0;
+   }
+   for (int i = 0; i < integratorCount; ++i)
   {
-      ea_data.SetSize(ne*elemDofs*elemDofs);
-      ea_data.UseDevice(true);
-      Array<BilinearFormIntegrator*> &integrators = *a->GetDBFI();
-      Array<Array<int>*> &markers_array = *a->GetDBFI_Marker();
-
-      if (integrators.Size() == 0) { ea_data = 0.0; }
-
-      for (int i = 0; i < integrators.Size(); ++i)
-      {
-         const bool add = (i > 0);
-         const Array<int> *markers = markers_array[i];
-         if (markers == nullptr)
-         {
-            integrators[i]->AssembleEA(*a->FESpace(), ea_data, add);
-         }
-         else
-         {
-            ea_data_tmp.SetSize(ea_data.Size());
-            integrators[i]->AssembleEA(*a->FESpace(), ea_data_tmp, false);
-            add_with_markers(ea_data_tmp, ea_data, ne, *markers,
-                             elem_attributes, add);
-         }
-      }
+      integrators[i]->AssembleEA(*a->FESpace(), ea_data, i);
   }

   faceDofs = trial_fes->GetTypicalTraceElement()->GetDof();

+   MFEM_VERIFY(a->GetBBFI()->Size() == 0,
+               "Element assembly does not support AddBoundaryIntegrator yet.");
+
+   Array<BilinearFormIntegrator*> &intFaceIntegrators = *a->GetFBFI();
+   const int intFaceIntegratorCount = intFaceIntegrators.Size();
+   if (intFaceIntegratorCount>0)
   {
-      Array<BilinearFormIntegrator*> &bdr_integs = *a->GetBBFI();
-      Array<Array<int>*> &markers_array = *a->GetBBFI_Marker();
-      const int n_bdr_integs = bdr_integs.Size();
-      if (n_bdr_integs > 0)
-      {
-         nf_bdr = trial_fes->GetNFbyType(FaceType::Boundary);
-         ea_data_bdr.SetSize(nf_bdr*faceDofs*faceDofs);
-      }
-      for (int i = 0; i < n_bdr_integs; ++i)
-      {
-         const bool add = (i > 0);
-         const Array<int> *markers = markers_array[i];
-         if (markers == nullptr)
-         {
-            bdr_integs[i]->AssembleEABoundary(*a->FESpace(), ea_data_bdr, add);
-         }
-         else
-         {
-            ea_data_tmp.SetSize(ea_data_bdr.Size());
-            bdr_integs[i]->AssembleEABoundary(*a->FESpace(), ea_data_tmp, add);
-            add_with_markers(ea_data_tmp, ea_data_bdr, nf_bdr, *markers,
-                             bdr_attributes, add);
-         }
-      }
+      nf_int = trial_fes->GetNFbyType(FaceType::Interior);
+      ea_data_int.SetSize(2*nf_int*faceDofs*faceDofs, Device::GetMemoryType());
+      ea_data_ext.SetSize(2*nf_int*faceDofs*faceDofs, Device::GetMemoryType());
+   }
+   for (int i = 0; i < intFaceIntegratorCount; ++i)
+   {
+      intFaceIntegrators[i]->AssembleEAInteriorFaces(*a->FESpace(),
+                                                     ea_data_int,
+                                                     ea_data_ext,
+                                                     i);
   }

+   Array<BilinearFormIntegrator*> &bdrFaceIntegrators = *a->GetBFBFI();
+   const int boundFaceIntegratorCount = bdrFaceIntegrators.Size();
+   if (boundFaceIntegratorCount>0)
   {
-      Array<BilinearFormIntegrator*> &intFaceIntegrators = *a->GetFBFI();
-      const int intFaceIntegratorCount = intFaceIntegrators.Size();
-      if (intFaceIntegratorCount>0)
-      {
-         nf_int = trial_fes->GetNFbyType(FaceType::Interior);
-         ea_data_int.SetSize(2*nf_int*faceDofs*faceDofs);
-         ea_data_ext.SetSize(2*nf_int*faceDofs*faceDofs);
-      }
-      for (int i = 0; i < intFaceIntegratorCount; ++i)
-      {
-         const bool add = (i > 0);
-         intFaceIntegrators[i]->AssembleEAInteriorFaces(*a->FESpace(),
-                                                        ea_data_int,
-                                                        ea_data_ext,
-                                                        add);
-      }
+      nf_bdr = trial_fes->GetNFbyType(FaceType::Boundary);
+      ea_data_bdr.SetSize(nf_bdr*faceDofs*faceDofs, Device::GetMemoryType());
+      ea_data_bdr = 0.0;
   }
-
+   for (int i = 0; i < boundFaceIntegratorCount; ++i)
   {
-      Array<BilinearFormIntegrator*> &bdr_face_integs = *a->GetBFBFI();
-      Array<Array<int>*> &markers_array = *a->GetBFBFI_Marker();
-      const int n_bdr_face_integs = bdr_face_integs.Size();
-      if (n_bdr_face_integs > 0)
-      {
-         nf_bdr = trial_fes->GetNFbyType(FaceType::Boundary);
-         ea_data_bdr.SetSize(nf_bdr*faceDofs*faceDofs);
-      }
-      for (int i = 0; i < n_bdr_face_integs; ++i)
-      {
-         const bool add = (i > 0);
-         const Array<int> *markers = markers_array[i];
-         if (markers == nullptr)
-         {
-            bdr_face_integs[i]->AssembleEABoundaryFaces(
-               *a->FESpace(), ea_data_bdr, add);
-         }
-         else
-         {
-            ea_data_tmp.SetSize(ea_data_bdr.Size());
-            bdr_face_integs[i]->AssembleEABoundaryFaces(*a->FESpace(),
-                                                        ea_data_tmp,
-                                                        add);
-            add_with_markers(ea_data_tmp, ea_data_bdr, nf_bdr, *markers,
-                             bdr_attributes, add);
-         }
-      }
+      bdrFaceIntegrators[i]->AssembleEABoundaryFaces(*a->FESpace(),ea_data_bdr,i);
   }

   if (factorize_face_terms && int_face_restrict_lex)
@@ -1048,13 +924,8 @@ void EABilinearFormExtension::Assemble()
   }
 }

-void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
-                                           const bool useTranspose,
-                                           const bool useAbs) const
+void EABilinearFormExtension::Mult(const Vector &x, Vector &y) const
 {
-   auto elemRest = dynamic_cast<const ElementRestriction*>(elem_restrict);
-   MFEM_ASSERT(useAbs?(elemRest!=nullptr):true,
-               "elem_restrict is not ElementRestriction*!")
   // Apply the Element Restriction
   const bool useRestrict = !DeviceCanUseCeed() && elem_restrict;
   if (!useRestrict)
@@ -1062,11 +933,6 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
      y.UseDevice(true); // typically this is a large vector, so store on device
      y = 0.0;
   }
-   else if (useAbs)
-   {
-      elemRest->AbsMult(x, localX);
-      localY = 0.0;
-   }
   else
   {
      elem_restrict->Mult(x, localX);
@@ -1074,55 +940,25 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
   }
   // Apply the Element Matrices
   {
-      Vector abs_ea_data;
-      if (useAbs)
-      {
-         abs_ea_data = ea_data;
-         abs_ea_data.Abs();
-      }
      const int NDOFS = elemDofs;
      auto X = Reshape(useRestrict?localX.Read():x.Read(), NDOFS, ne);
      auto Y = Reshape(useRestrict?localY.ReadWrite():y.ReadWrite(), NDOFS, ne);
-      auto A = Reshape(useAbs?abs_ea_data.Read():ea_data.Read(), NDOFS, NDOFS, ne);
-      if (!useTranspose)
+      auto A = Reshape(ea_data.Read(), NDOFS, NDOFS, ne);
+      mfem::forall(ne*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
      {
-         mfem::forall(ne*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
+         const int e = glob_j/NDOFS;
+         const int j = glob_j%NDOFS;
+         real_t res = 0.0;
+         for (int i = 0; i < NDOFS; i++)
         {
-            const int e = glob_j/NDOFS;
-            const int j = glob_j%NDOFS;
-            real_t res = 0.0;
-            for (int i = 0; i < NDOFS; i++)
-            {
-               res += A(i, j, e)*X(i, e);
-            }
-            Y(j, e) += res;
-         });
-      }
-      else
-      {
-         mfem::forall(ne*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
-         {
-            const int e = glob_j/NDOFS;
-            const int j = glob_j%NDOFS;
-            real_t res = 0.0;
-            for (int i = 0; i < NDOFS; i++)
-            {
-               res += A(j, i, e)*X(i, e);
-            }
-            Y(j, e) += res;
-         });
-      }
+            res += A(i, j, e)*X(i, e);
+         }
+         Y(j, e) += res;
+      });
      // Apply the Element Restriction transposed
      if (useRestrict)
      {
-         if (useAbs)
-         {
-            elemRest->AbsMultTranspose(localY, y);
-         }
-         else
-         {
-            elem_restrict->MultTranspose(localY, y);
-         }
+         elem_restrict->MultTranspose(localY, y);
      }
   }

@@ -1131,7 +967,6 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
   const int iFISz = intFaceIntegrators.Size();
   if (int_face_restrict_lex && iFISz>0)
   {
-      MFEM_VERIFY(!useAbs, "AbsMult not implemented with Face integrators!")
      // Apply the Interior Face Restriction
      int_face_restrict_lex->Mult(x, int_face_X);
      if (int_face_X.Size()>0)
@@ -1143,65 +978,7 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
         auto Y = Reshape(int_face_Y.ReadWrite(), NDOFS, 2, nf_int);
         if (!factorize_face_terms)
         {
-            Vector abs_ea_data_int(ea_data_int.Size());
-            if (useAbs)
-            {
-               abs_ea_data_int = ea_data_int;
-               abs_ea_data_int.Abs();
-            }
-            auto A_int = Reshape(useAbs?abs_ea_data_int.Read():ea_data_int.Read(),
-                                 NDOFS, NDOFS, 2, nf_int);
-            if (!useTranspose)
-            {
-               mfem::forall(nf_int*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
-               {
-                  const int f = glob_j/NDOFS;
-                  const int j = glob_j%NDOFS;
-                  real_t res = 0.0;
-                  for (int i = 0; i < NDOFS; i++)
-                  {
-                     res += A_int(i, j, 0, f)*X(i, 0, f);
-                  }
-                  Y(j, 0, f) += res;
-                  res = 0.0;
-                  for (int i = 0; i < NDOFS; i++)
-                  {
-                     res += A_int(i, j, 1, f)*X(i, 1, f);
-                  }
-                  Y(j, 1, f) += res;
-               });
-            }
-            else
-            {
-               mfem::forall(nf_int*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
-               {
-                  const int f = glob_j/NDOFS;
-                  const int j = glob_j%NDOFS;
-                  real_t res = 0.0;
-                  for (int i = 0; i < NDOFS; i++)
-                  {
-                     res += A_int(j, i, 0, f)*X(i, 0, f);
-                  }
-                  Y(j, 0, f) += res;
-                  res = 0.0;
-                  for (int i = 0; i < NDOFS; i++)
-                  {
-                     res += A_int(j, i, 1, f)*X(i, 1, f);
-                  }
-                  Y(j, 1, f) += res;
-               });
-            }
-         }
-         Vector abs_ea_data_ext(ea_data_ext.Size());
-         if (useAbs)
-         {
-            abs_ea_data_ext = ea_data_ext;
-            abs_ea_data_ext.Abs();
-         }
-         auto A_ext = Reshape(useAbs?abs_ea_data_ext.Read():ea_data_ext.Read(),
-                              NDOFS, NDOFS, 2, nf_int);
-         if (!useTranspose)
-         {
+            auto A_int = Reshape(ea_data_int.Read(), NDOFS, NDOFS, 2, nf_int);
            mfem::forall(nf_int*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
            {
               const int f = glob_j/NDOFS;
@@ -1209,58 +986,55 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
               real_t res = 0.0;
               for (int i = 0; i < NDOFS; i++)
               {
-                  res += A_ext(i, j, 0, f)*X(i, 0, f);
+                  res += A_int(i, j, 0, f)*X(i, 0, f);
               }
-               Y(j, 1, f) += res;
+               Y(j, 0, f) += res;
               res = 0.0;
               for (int i = 0; i < NDOFS; i++)
               {
-                  res += A_ext(i, j, 1, f)*X(i, 1, f);
+                  res += A_int(i, j, 1, f)*X(i, 1, f);
               }
-               Y(j, 0, f) += res;
+               Y(j, 1, f) += res;
            });
         }
-         else
+         auto A_ext = Reshape(ea_data_ext.Read(), NDOFS, NDOFS, 2, nf_int);
+         mfem::forall(nf_int*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
         {
-            mfem::forall(nf_int*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
+            const int f = glob_j/NDOFS;
+            const int j = glob_j%NDOFS;
+            real_t res = 0.0;
+            for (int i = 0; i < NDOFS; i++)
            {
-               const int f = glob_j/NDOFS;
-               const int j = glob_j%NDOFS;
-               real_t res = 0.0;
-               for (int i = 0; i < NDOFS; i++)
-               {
-                  res += A_ext(j, i, 1, f)*X(i, 0, f);
-               }
-               Y(j, 1, f) += res;
-               res = 0.0;
-               for (int i = 0; i < NDOFS; i++)
-               {
-                  res += A_ext(j, i, 0, f)*X(i, 1, f);
-               }
-               Y(j, 0, f) += res;
-            });
-         }
+               res += A_ext(i, j, 0, f)*X(i, 0, f);
+            }
+            Y(j, 1, f) += res;
+            res = 0.0;
+            for (int i = 0; i < NDOFS; i++)
+            {
+               res += A_ext(i, j, 1, f)*X(i, 1, f);
+            }
+            Y(j, 0, f) += res;
+         });
         // Apply the Interior Face Restriction transposed
         int_face_restrict_lex->AddMultTransposeInPlace(int_face_Y, y);
      }
   }

   // Treatment of boundary faces
-   if (!factorize_face_terms && bdr_face_restrict_lex && ea_data_bdr.Size() > 0)
+   Array<BilinearFormIntegrator*> &bdrFaceIntegrators = *a->GetBFBFI();
+   const int bFISz = bdrFaceIntegrators.Size();
+   if (!factorize_face_terms && bdr_face_restrict_lex && bFISz>0)
   {
-      MFEM_ASSERT(!useAbs, "AbsMult not implemented with Face integrators!")
      // Apply the Boundary Face Restriction
-      // TODO: AbsMult if needed
      bdr_face_restrict_lex->Mult(x, bdr_face_X);
-      bdr_face_Y = 0.0;
-      // Apply the boundary face matrices
-      const int NDOFS = faceDofs;
-      auto X = Reshape(bdr_face_X.Read(), NDOFS, nf_bdr);
-      auto Y = Reshape(bdr_face_Y.ReadWrite(), NDOFS, nf_bdr);
-      auto A = Reshape(ea_data_bdr.Read(), NDOFS, NDOFS, nf_bdr);
-      if (!useTranspose)
+      if (bdr_face_X.Size()>0)
      {
-         // TODO: useAbs
+         bdr_face_Y = 0.0;
+         // Apply the boundary face matrices
+         const int NDOFS = faceDofs;
+         auto X = Reshape(bdr_face_X.Read(), NDOFS, nf_bdr);
+         auto Y = Reshape(bdr_face_Y.ReadWrite(), NDOFS, nf_bdr);
+         auto A = Reshape(ea_data_bdr.Read(), NDOFS, NDOFS, nf_bdr);
         mfem::forall(nf_bdr*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
         {
            const int f = glob_j/NDOFS;
@@ -1272,10 +1046,123 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
            }
            Y(j, f) += res;
         });
+         // Apply the Boundary Face Restriction transposed
+         bdr_face_restrict_lex->AddMultTransposeInPlace(bdr_face_Y, y);
      }
-      else
+   }
+}
+
+void EABilinearFormExtension::MultTranspose(const Vector &x, Vector &y) const
+{
+   // Apply the Element Restriction
+   const bool useRestrict = !DeviceCanUseCeed() && elem_restrict;
+   if (!useRestrict)
+   {
+      y.UseDevice(true); // typically this is a large vector, so store on device
+      y = 0.0;
+   }
+   else
+   {
+      elem_restrict->Mult(x, localX);
+      localY = 0.0;
+   }
+   // Apply the Element Matrices transposed
+   {
+      const int NDOFS = elemDofs;
+      auto X = Reshape(useRestrict?localX.Read():x.Read(), NDOFS, ne);
+      auto Y = Reshape(useRestrict?localY.ReadWrite():y.ReadWrite(), NDOFS, ne);
+      auto A = Reshape(ea_data.Read(), NDOFS, NDOFS, ne);
+      mfem::forall(ne*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
      {
-         // TODO: useAbs
+         const int e = glob_j/NDOFS;
+         const int j = glob_j%NDOFS;
+         real_t res = 0.0;
+         for (int i = 0; i < NDOFS; i++)
+         {
+            res += A(j, i, e)*X(i, e);
+         }
+         Y(j, e) += res;
+      });
+      // Apply the Element Restriction transposed
+      if (useRestrict)
+      {
+         elem_restrict->MultTranspose(localY, y);
+      }
+   }
+
+   // Treatment of interior faces
+   Array<BilinearFormIntegrator*> &intFaceIntegrators = *a->GetFBFI();
+   const int iFISz = intFaceIntegrators.Size();
+   if (int_face_restrict_lex && iFISz>0)
+   {
+      // Apply the Interior Face Restriction
+      int_face_restrict_lex->Mult(x, int_face_X);
+      if (int_face_X.Size()>0)
+      {
+         int_face_Y = 0.0;
+         // Apply the interior face matrices transposed
+         const int NDOFS = faceDofs;
+         auto X = Reshape(int_face_X.Read(), NDOFS, 2, nf_int);
+         auto Y = Reshape(int_face_Y.ReadWrite(), NDOFS, 2, nf_int);
+         if (!factorize_face_terms)
+         {
+            auto A_int = Reshape(ea_data_int.Read(), NDOFS, NDOFS, 2, nf_int);
+            mfem::forall(nf_int*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
+            {
+               const int f = glob_j/NDOFS;
+               const int j = glob_j%NDOFS;
+               real_t res = 0.0;
+               for (int i = 0; i < NDOFS; i++)
+               {
+                  res += A_int(j, i, 0, f)*X(i, 0, f);
+               }
+               Y(j, 0, f) += res;
+               res = 0.0;
+               for (int i = 0; i < NDOFS; i++)
+               {
+                  res += A_int(j, i, 1, f)*X(i, 1, f);
+               }
+               Y(j, 1, f) += res;
+            });
+         }
+         auto A_ext = Reshape(ea_data_ext.Read(), NDOFS, NDOFS, 2, nf_int);
+         mfem::forall(nf_int*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
+         {
+            const int f = glob_j/NDOFS;
+            const int j = glob_j%NDOFS;
+            real_t res = 0.0;
+            for (int i = 0; i < NDOFS; i++)
+            {
+               res += A_ext(j, i, 1, f)*X(i, 0, f);
+            }
+            Y(j, 1, f) += res;
+            res = 0.0;
+            for (int i = 0; i < NDOFS; i++)
+            {
+               res += A_ext(j, i, 0, f)*X(i, 1, f);
+            }
+            Y(j, 0, f) += res;
+         });
+         // Apply the Interior Face Restriction transposed
+         int_face_restrict_lex->AddMultTransposeInPlace(int_face_Y, y);
+      }
+   }
+
+   // Treatment of boundary faces
+   Array<BilinearFormIntegrator*> &bdrFaceIntegrators = *a->GetBFBFI();
+   const int bFISz = bdrFaceIntegrators.Size();
+   if (!factorize_face_terms && bdr_face_restrict_lex && bFISz>0)
+   {
+      // Apply the Boundary Face Restriction
+      bdr_face_restrict_lex->Mult(x, bdr_face_X);
+      if (bdr_face_X.Size()>0)
+      {
+         bdr_face_Y = 0.0;
+         // Apply the boundary face matrices transposed
+         const int NDOFS = faceDofs;
+         auto X = Reshape(bdr_face_X.Read(), NDOFS, nf_bdr);
+         auto Y = Reshape(bdr_face_Y.ReadWrite(), NDOFS, nf_bdr);
+         auto A = Reshape(ea_data_bdr.Read(), NDOFS, NDOFS, nf_bdr);
         mfem::forall(nf_bdr*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
         {
            const int f = glob_j/NDOFS;
@@ -1287,144 +1174,9 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
            }
            Y(j, f) += res;
         });
+         // Apply the Boundary Face Restriction transposed
+         bdr_face_restrict_lex->AddMultTransposeInPlace(bdr_face_Y, y);
      }
-      // Apply the Boundary Face Restriction transposed
-      // TODO: AbsMultTranspose if needed
-      bdr_face_restrict_lex->AddMultTransposeInPlace(bdr_face_Y, y);
-   }
-}
-
-void EABilinearFormExtension::GetElementMatrices(
-   DenseTensor &element_matrices, ElementDofOrdering ordering, bool add_bdr)
-{
-   // Ensure the EA data is assembled
-   if (ea_data.Size() == 0) { Assemble(); }
-
-   const int ndofs = elemDofs;
-   element_matrices.SetSize(ndofs, ndofs, ne);
-   const int N = element_matrices.TotalSize();
-
-   const auto d_ea_data = Reshape(ea_data.Read(), ndofs, ndofs, ne);
-   auto d_element_matrices = Reshape(element_matrices.Write(),
-                                     ndofs, ndofs,
-                                     ne);
-
-   const int *d_dof_map = nullptr;
-   Array<int> dof_map;
-   if (ordering == ElementDofOrdering::NATIVE)
-   {
-      const TensorBasisElement* tbe =
-         dynamic_cast<const TensorBasisElement*>(trial_fes->GetFE(0));
-      if (tbe)
-      {
-         // Deep copy to avoid issues with host device (see similar comment in
-         // HybridizationExtension::ConstructC).
-         dof_map = tbe->GetDofMap();
-         d_dof_map = dof_map.Read();
-      }
-   }
-
-   if (d_dof_map)
-   {
-      // Reordering required
-      mfem::forall(N, [=] MFEM_HOST_DEVICE (int idx)
-      {
-         const int e = idx / ndofs / ndofs;
-         const int i = idx % ndofs;
-         const int j = (idx / ndofs) % ndofs;
-         const int ii_s = d_dof_map[i];
-         const int ii = (ii_s >= 0) ? ii_s : -1 - ii_s;
-         const int s_i = (ii_s >= 0) ? 1 : -1;
-         const int jj_s = d_dof_map[j];
-         const int jj = (jj_s >= 0) ? jj_s : -1 - jj_s;
-         const int s_j = (jj_s >= 0) ? 1 : -1;
-         d_element_matrices(ii, jj, e) = s_i*s_j*d_ea_data(j, i, e);
-      });
-   }
-   else
-   {
-      // No reordering required
-      mfem::forall(N, [=] MFEM_HOST_DEVICE (int idx)
-      {
-         const int e = idx / ndofs / ndofs;
-         const int i = idx % ndofs;
-         const int j = (idx / ndofs) % ndofs;
-         d_element_matrices(i, j, e) = d_ea_data(j, i, e);
-      });
-   }
-
-   if (add_bdr && ea_data_bdr.Size() > 0)
-   {
-      const int ndof_face = faceDofs;
-      const auto d_ea_bdr = Reshape(ea_data_bdr.Read(),
-                                    ndof_face, ndof_face, nf_bdr);
-
-      // Get all the local face maps (mapping from lexicographic face index to
-      // lexicographic volume index, depending on the local face index).
-      const Mesh &mesh = *trial_fes->GetMesh();
-      const int dim = mesh.Dimension();
-      const int n_faces_per_el = 2*dim; // assuming tensor product
-      Array<int> face_maps(ndof_face * n_faces_per_el);
-      for (int lf_i = 0; lf_i < n_faces_per_el; ++lf_i)
-      {
-         Array<int> face_map(ndof_face);
-         trial_fes->GetFE(0)->GetFaceMap(lf_i, face_map);
-         for (int i = 0; i < ndof_face; ++i)
-         {
-            face_maps[i + lf_i*ndof_face] = face_map[i];
-         }
-      }
-
-      Array<int> face_info(nf_bdr * 2);
-      {
-         int fidx = 0;
-         for (int f = 0; f < mesh.GetNumFaces(); ++f)
-         {
-            Mesh::FaceInformation finfo = mesh.GetFaceInformation(f);
-            if (!finfo.IsBoundary()) { continue; }
-            face_info[0 + fidx*2] = finfo.element[0].local_face_id;
-            face_info[1 + fidx*2] = finfo.element[0].index;
-            fidx++;
-         }
-      }
-
-      const auto d_face_maps = Reshape(face_maps.Read(), ndof_face, n_faces_per_el);
-      const auto d_face_info = Reshape(face_info.Read(), 2, nf_bdr);
-
-      const bool reorder = (ordering == ElementDofOrdering::NATIVE);
-
-      mfem::forall_2D(nf_bdr, ndof_face, ndof_face, [=] MFEM_HOST_DEVICE (int f)
-      {
-         const int lf_i = d_face_info(0, f);
-         const int e = d_face_info(1, f);
-         // Loop over face indices in "native ordering"
-         MFEM_FOREACH_THREAD(i_lex_face, x, ndof_face)
-         {
-            // Convert from lexicographic face DOF to volume DOF
-            const int i_lex = d_face_maps(i_lex_face, lf_i);
-
-            const int ii_s = d_dof_map[i_lex];
-            const int ii = (ii_s >= 0) ? ii_s : -1 - ii_s;
-
-            const int i = reorder ? ii : i_lex;
-            const int s_i = (ii_s < 0 && reorder) ? -1 : 1;
-
-            MFEM_FOREACH_THREAD(j_lex_face, y, ndof_face)
-            {
-               // Convert from lexicographic face DOF to volume DOF
-               const int j_lex = d_face_maps(j_lex_face, lf_i);
-
-               const int jj_s = d_dof_map[j_lex];
-               const int jj = (jj_s >= 0) ? jj_s : -1 - jj_s;
-
-               const int j = reorder ? jj : j_lex;
-               const int s_j = (jj_s < 0 && reorder) ? -1 : 1;
-
-               AtomicAdd(d_element_matrices(i, j, e),
-                         s_i*s_j*d_ea_bdr(i_lex_face, j_lex_face, f));
-            }
-         }
-      });
   }
 }

@@ -1949,7 +1701,7 @@ void PAMixedBilinearFormExtension::AssembleDiagonal_ADAt(const Vector &D,
         dynamic_cast<const ElementRestriction*>(elem_restrict_trial);
      if (H1elem_restrict_trial)
      {
-         H1elem_restrict_trial->AbsMult(D, localTrial);
+         H1elem_restrict_trial->MultUnsigned(D, localTrial);
      }
      else
      {
@@ -1975,7 +1727,7 @@ void PAMixedBilinearFormExtension::AssembleDiagonal_ADAt(const Vector &D,
         dynamic_cast<const ElementRestriction*>(elem_restrict_test);
      if (H1elem_restrict_test)
      {
-         H1elem_restrict_test->AbsMultTranspose(localTest, diag);
+         H1elem_restrict_test->MultTransposeUnsigned(localTest, diag);
      }
      else
      {
@@ -2031,7 +1783,7 @@ void PADiscreteLinearOperatorExtension::Assemble()
      dynamic_cast<const ElementRestriction*>(elem_restrict_test);
   if (elem_restrict)
   {
-      elem_restrict->AbsMultTranspose(ones, test_multiplicity);
+      elem_restrict->MultTransposeUnsigned(ones, test_multiplicity);
   }
   else
   {
@@ -91,17 +91,12 @@ public:
                         Vector &x, Vector &b,
                         OperatorHandle &A, Vector &X, Vector &B,
                         int copy_interior = 0) override;
-   void Mult(const Vector &x, Vector &y) const override
-   { MultInternal(x,y); }
-   void AbsMult(const Vector &x, Vector &y) const override
-   { MultInternal(x,y, true); }
+   void Mult(const Vector &x, Vector &y) const override;
   void MultTranspose(const Vector &x, Vector &y) const override;
   void Update() override;

 protected:
   void SetupRestrictionOperators(const L2FaceValues m);
-   void MultInternal(const Vector &x, Vector &y,
-                     const bool useAbs = false) const;

   /// @brief Accumulate the action (or transpose) of the integrator on @a x
   /// into @a y, taking into account the (possibly null) @a markers array.
@@ -115,14 +110,12 @@ protected:
   /// @param attributes Array of element or boundary element attributes.
   /// @param transpose Compute the action or transpose of the integrator .
   /// @param y Output E-vector
-   /// @param useAbs Apply absolute-value operator
   void AddMultWithMarkers(const BilinearFormIntegrator &integ,
                           const Vector &x,
                           const Array<int> *markers,
                           const Array<int> &attributes,
                           const bool transpose,
-                           Vector &y,
-                           const bool useAbs = false) const;
+                           Vector &y) const;

   /// @brief Performs the same function as AddMultWithMarkers, but takes as
   /// input and output face normal derivatives.
@@ -159,30 +152,8 @@ public:
   EABilinearFormExtension(BilinearForm *form);

   void Assemble() override;
-
-   void Mult(const Vector &x, Vector &y) const override
-   { MultInternal(x, y, false); }
-   void AbsMult(const Vector &x, Vector &y) const override
-   { MultInternal(x, y, false, true); }
-   void MultTranspose(const Vector &x, Vector &y) const override
-   { MultInternal(x, y, true); }
-   void AbsMultTranspose(const Vector &x, Vector &y) const override
-   { MultInternal(x, y, true, true); }
-
-   /// @brief Populates @a element_matrices with the element matrices.
-   ///
-   /// The element matrices are converted from row-major (how they are stored in
-   /// @a ea_data) to column-major format.
-   ///
-   /// If @a ordering is ElementDofOrdering::NATIVE, then the matrices are
-   /// reordered from the lexicographic ordering used internally.
-   void GetElementMatrices(DenseTensor &element_matrices,
-                           ElementDofOrdering ordering,
-                           bool add_bdr);
-
-   // This method needs to be public due to 'nvcc' restriction.
-   void MultInternal(const Vector &x, Vector &y, const bool useTranspose,
-                     const bool useAbs = false) const;
+   void Mult(const Vector &x, Vector &y) const override;
+   void MultTranspose(const Vector &x, Vector &y) const override;
 };

 /// Data and methods for fully-assembled bilinear forms
@@ -72,14 +72,6 @@ void BilinearFormIntegrator::AssembleEA(const FiniteElementSpace &fes,
              "   is not implemented for this class.");
 }

-void BilinearFormIntegrator::AssembleEABoundary(const FiniteElementSpace &fes,
-                                                Vector &emat,
-                                                const bool add)
-{
-   MFEM_ABORT("BilinearFormIntegrator::AssembleEABoundary(...)\n"
-              "   is not implemented for this class.");
-}
-
 void BilinearFormIntegrator::AssembleEAInteriorFaces(const FiniteElementSpace
                                                     &fes,
                                                     Vector &ea_data_int,
@@ -90,16 +82,6 @@ void BilinearFormIntegrator::AssembleEAInteriorFaces(const FiniteElementSpace
              "   is not implemented for this class.");
 }

-void BilinearFormIntegrator::AssembleEAInteriorFaces(
-   const FiniteElementSpace &trial_fes,
-   const FiniteElementSpace &test_fes,
-   Vector &emat,
-   const bool add)
-{
-   MFEM_ABORT("BilinearFormIntegrator::AssembleEAInteriorFaces(...)\n"
-              "   is not implemented for this class.");
-}
-
 void BilinearFormIntegrator::AssembleEABoundaryFaces(const FiniteElementSpace
                                                     &fes,
                                                     Vector &ea_data_bdr,
@@ -121,12 +103,6 @@ void BilinearFormIntegrator::AddMultPA(const Vector &, Vector &) const
              "   is not implemented for this class.");
 }

-void BilinearFormIntegrator::AddAbsMultPA(const Vector &, Vector &) const
-{
-   MFEM_ABORT("BilinearFormIntegrator:AddAbsMultPA:(...)\n"
-              "   is not implemented for this class.");
-}
-
 void BilinearFormIntegrator::AddMultNURBSPA(const Vector &, Vector &) const
 {
   MFEM_ABORT("BilinearFormIntegrator::AddMultNURBSPA(...)\n"
@@ -139,13 +115,6 @@ void BilinearFormIntegrator::AddMultTransposePA(const Vector &, Vector &) const
              "   is not implemented for this class.");
 }

-void BilinearFormIntegrator::AddAbsMultTransposePA(const Vector &,
-                                                   Vector &) const
-{
-   MFEM_ABORT("BilinearFormIntegrator::AddAbsMultTransposePA(...)\n"
-              "   is not implemented for this class.");
-}
-
 void BilinearFormIntegrator::AssembleMF(const FiniteElementSpace &fes)
 {
   MFEM_ABORT("BilinearFormIntegrator::AssembleMF(...)\n"
@@ -431,14 +400,6 @@ void SumIntegrator::AddMultPA(const Vector& x, Vector& y) const
   }
 }

-void SumIntegrator::AddAbsMultPA(const Vector& x, Vector& y) const
-{
-   for (int i = 0; i < integrators.Size(); i++)
-   {
-      integrators[i]->AddAbsMultPA(x, y);
-   }
-}
-
 void SumIntegrator::AddMultTransposePA(const Vector &x, Vector &y) const
 {
   for (int i = 0; i < integrators.Size(); i++)
@@ -447,14 +408,6 @@ void SumIntegrator::AddMultTransposePA(const Vector &x, Vector &y) const
   }
 }

-void SumIntegrator::AddAbsMultTransposePA(const Vector &x, Vector &y) const
-{
-   for (int i = 0; i < integrators.Size(); i++)
-   {
-      integrators[i]->AddAbsMultTransposePA(x, y);
-   }
-}
-
 void SumIntegrator::AssembleMF(const FiniteElementSpace &fes)
 {
   for (int i = 0; i < integrators.Size(); i++)
@@ -2876,18 +2829,17 @@ void VectorDivergenceIntegrator::AssembleElementMatrix2(
   DenseMatrix &elmat)
 {
   dim  = trial_fe.GetDim();
-   sdim = Trans.GetSpaceDim();
   int trial_dof = trial_fe.GetDof();
   int test_dof = test_fe.GetDof();
   real_t c;

   dshape.SetSize (trial_dof, dim);
-   gshape.SetSize (trial_dof, sdim);
-   Jadj.SetSize (dim, sdim);
-   divshape.SetSize (sdim*trial_dof);
+   gshape.SetSize (trial_dof, dim);
+   Jadj.SetSize (dim);
+   divshape.SetSize (dim*trial_dof);
   shape.SetSize (test_dof);

-   elmat.SetSize (test_dof, sdim*trial_dof);
+   elmat.SetSize (test_dof, dim*trial_dof);

   const IntegrationRule *ir = GetIntegrationRule(trial_fe, test_fe, Trans);

@@ -2901,15 +2853,13 @@ void VectorDivergenceIntegrator::AssembleElementMatrix2(
      trial_fe.CalcDShape (ip, dshape);
      test_fe.CalcPhysShape (Trans, shape);

-      // AdjugateJacobian = / adj(J),         if J is square
-      //                    \ adj(J^t.J).J^t, otherwise
      CalcAdjugate(Trans.Jacobian(), Jadj);
+
      Mult (dshape, Jadj, gshape);

      gshape.GradToDiv (divshape);

      c = ip.weight;
-      if (dim != sdim) { c /= Trans.Weight(); }
      if (Q)
      {
         c *= Q -> Eval (Trans, ip);
@@ -2950,11 +2900,6 @@ void DivDivIntegrator::AssembleElementMatrix(
   if (ir == NULL)
   {
      int order = 2 * el.GetOrder() - 2; // <--- OK for RTk
-      if (el.Space() == FunctionSpace::Uk)
-      {
-         order += 2;
-      }
-
      ir = &IntRules.Get(el.GetGeomType(), order);
   }

@@ -78,8 +78,6 @@ public:
       called. */
   void AddMultPA(const Vector &x, Vector &y) const override;

-   virtual void AddAbsMultPA(const Vector &x, Vector &y) const;
-
   /// Method for partially assembled action on NURBS patches.
   virtual void AddMultNURBSPA(const Vector&x, Vector&y) const;

@@ -92,8 +90,6 @@ public:
       called. */
   virtual void AddMultTransposePA(const Vector &x, Vector &y) const;

-   virtual void AddAbsMultTransposePA(const Vector &x, Vector &y) const;
-
   /// Method defining element assembly.
   /** The result of the element assembly is added to the @a emat Vector if
       @a add is true. Otherwise, if @a add is false, we set @a emat. */
@@ -128,25 +124,11 @@ public:
   /// Assemble diagonal and add it to Vector @a diag.
   virtual void AssembleDiagonalMF(Vector &diag);

-   virtual void AssembleEABoundary(const FiniteElementSpace &fes,
-                                   Vector &ea_data_bdr,
-                                   const bool add = true);
-
   virtual void AssembleEAInteriorFaces(const FiniteElementSpace &fes,
                                        Vector &ea_data_int,
                                        Vector &ea_data_ext,
                                        const bool add = true);

-   /// @brief Method defining element assembly for mixed trace integrators.
-   ///
-   /// This is the element assembly analogue of AssembleFaceMatrix(const
-   /// FiniteElement&, const FiniteElement&, const FiniteElement&,
-   /// FaceElementTransformations&, DenseMatrix&).
-   virtual void AssembleEAInteriorFaces(const FiniteElementSpace &trial_fes,
-                                        const FiniteElementSpace &test_fes,
-                                        Vector &emat,
-                                        const bool add = true);
-
   virtual void AssembleEABoundaryFaces(const FiniteElementSpace &fes,
                                        Vector &ea_data_bdr,
                                        const bool add = true);
@@ -401,7 +383,6 @@ public:
   void AssembleEA(const FiniteElementSpace &fes, Vector &emat,
                   const bool add) override;

-   using BilinearFormIntegrator::AssembleEAInteriorFaces;
   void AssembleEAInteriorFaces(const FiniteElementSpace &fes,
                                Vector &ea_data_int,
                                Vector &ea_data_ext,
@@ -500,12 +481,8 @@ public:

   void AddMultTransposePA(const Vector &x, Vector &y) const override;

-   void AddAbsMultTransposePA(const Vector &x, Vector &y) const override;
-
   void AddMultPA(const Vector& x, Vector& y) const override;

-   void AddAbsMultPA(const Vector& x, Vector& y) const override;
-
   void AssembleMF(const FiniteElementSpace &fes) override;

   void AddMultMF(const Vector &x, Vector &y) const override;
@@ -517,7 +494,6 @@ public:
   void AssembleEA(const FiniteElementSpace &fes, Vector &emat,
                   const bool add) override;

-   using BilinearFormIntegrator::AssembleEAInteriorFaces;
   void AssembleEAInteriorFaces(const FiniteElementSpace &fes,
                                Vector &ea_data_int,
                                Vector &ea_data_ext,
@@ -2328,12 +2304,8 @@ public:

   void AddMultPA(const Vector&, Vector&) const override;

-   void AddAbsMultPA(const Vector&, Vector&) const override;
-
   void AddMultTransposePA(const Vector&, Vector&) const override;

-   void AddAbsMultTransposePA(const Vector&, Vector&) const override;
-
   void AddMultNURBSPA(const Vector&, Vector&) const override;

   void AddMultPatchPA(const int patch, const Vector &x, Vector &y) const;
@@ -2378,8 +2350,6 @@ protected:
   const FaceGeometricFactors *face_geom; ///< Not owned
   int dim, ne, nq, dofs1D, quad1D;

-   void AssembleEA_(Vector &ea, const bool add);
-
 public:

   using ApplyKernelType = void(*)(const int, const Array<real_t>&,
@@ -2420,10 +2390,7 @@ public:
   void AssembleEA(const FiniteElementSpace &fes, Vector &emat,
                   const bool add) override;

-   virtual void AssembleEABoundary(const FiniteElementSpace &fes, Vector &emat,
-                                   const bool add) override;
-
-   virtual void AssembleDiagonalPA(Vector &diag) override;
+   void AssembleDiagonalPA(Vector &diag) override;

   void AssembleDiagonalMF(Vector &diag) override;

@@ -2431,12 +2398,8 @@ public:

   void AddMultPA(const Vector&, Vector&) const override;

-   void AddAbsMultPA(const Vector&, Vector&) const override;
-
   void AddMultTransposePA(const Vector&, Vector&) const override;

-   void AddAbsMultTransposePA(const Vector&, Vector&) const override;
-
   static const IntegrationRule &GetRule(const FiniteElement &trial_fe,
                                         const FiniteElement &test_fe,
                                         const ElementTransformation &Trans);
@@ -2832,7 +2795,6 @@ public:
   using BilinearFormIntegrator::AssemblePA;
   void AssemblePA(const FiniteElementSpace &fes) override;
   void AddMultPA(const Vector &x, Vector &y) const override;
-   void AddAbsMultPA(const Vector &x, Vector &y) const override;
   void AssembleDiagonalPA(Vector& diag) override;

   const Coefficient *GetCoefficient() const { return Q; }
@@ -2950,11 +2912,8 @@ public:
   void AssemblePA(const FiniteElementSpace &trial_fes,
                   const FiniteElementSpace &test_fes) override;
   void AddMultPA(const Vector &x, Vector &y) const override;
-   void AddAbsMultPA(const Vector &x, Vector &y) const override;
   void AddMultTransposePA(const Vector &x, Vector &y) const override;
   void AssembleDiagonalPA(Vector& diag) override;
-   void AssembleEA(const FiniteElementSpace &fes, Vector &emat,
-                   const bool add) override;

   const Coefficient *GetCoefficient() const { return Q; }
 };
@@ -2976,7 +2935,7 @@ private:
   Vector pa_data;
   const DofToQuad *trial_maps, *test_maps; ///< Not owned
   const GeometricFactors *geom;            ///< Not owned
-   int dim, sdim, ne, nq;
+   int dim, ne, nq;
   int trial_dofs1D, test_dofs1D, quad1D;

 public:
@@ -3022,6 +2981,11 @@ class DivDivIntegrator: public BilinearFormIntegrator
 protected:
   Coefficient *Q;

+   using BilinearFormIntegrator::AssemblePA;
+   void AssemblePA(const FiniteElementSpace &fes) override;
+   void AddMultPA(const Vector &x, Vector &y) const override;
+   void AssembleDiagonalPA(Vector& diag) override;
+
 private:
 #ifndef MFEM_THREAD_SAFE
   Vector divshape, te_divshape;
@@ -3048,13 +3012,6 @@ public:
                               ElementTransformation &Trans,
                               DenseMatrix &elmat) override;

-   using BilinearFormIntegrator::AssemblePA;
-   void AssemblePA(const FiniteElementSpace &fes) override;
-   void AddMultPA(const Vector &x, Vector &y) const override;
-   void AssembleDiagonalPA(Vector& diag) override;
-   void AssembleEA(const FiniteElementSpace &fes, Vector &emat,
-                   const bool add) override;
-
   const Coefficient *GetCoefficient() const { return Q; }
 };

@@ -3354,7 +3311,6 @@ public:

   void AddMultPA(const Vector&, Vector&) const override;

-   using BilinearFormIntegrator::AssembleEAInteriorFaces;
   void AssembleEAInteriorFaces(const FiniteElementSpace& fes,
                                Vector &ea_data_int,
                                Vector &ea_data_ext,
@@ -3668,12 +3624,6 @@ public:
                           const FiniteElement &test_fe2,
                           FaceElementTransformations &Trans,
                           DenseMatrix &elmat) override;
-
-   using BilinearFormIntegrator::AssembleEAInteriorFaces;
-   void AssembleEAInteriorFaces(const FiniteElementSpace &trial_fes,
-                                const FiniteElementSpace &test_fes,
-                                Vector &emat,
-                                const bool add = true) override;
 };

 /** Integrator for the DPG form:$ \langle v, w \rangle $ over a face (the interface) where
@@ -1,715 +0,0 @@
-// Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-// at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-// LICENSE and NOTICE for details. LLNL-CODE-806117.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability visit https://mfem.org.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the BSD-3 license. We welcome feedback and contributions, see file
-// CONTRIBUTING.md for details.
-
-// Implementation of bounds
-
-#include "bounds.hpp"
-
-#include <limits>
-#include <cstring>
-#include <string>
-#include <cmath>
-#include <iostream>
-#include <algorithm>
-
-namespace mfem
-{
-
-using namespace std;
-
-void PLBound::Setup(const int nb_i, const int ncp_i,
-                    const int b_type_i, const int cp_type_i,
-                    const real_t tol_i)
-{
-   MFEM_VERIFY(b_type_i >= 0 && b_type_i <= 2, "Bases not supported. "
-               "Please read class description to see supported types.");
-   MFEM_VERIFY(cp_type_i == 0 || cp_type_i == 1,
-               "Control point type not supported. Please read class "
-               "description to see supported types.");
-   nb = nb_i;
-   ncp = ncp_i;
-   b_type = b_type_i;
-   cp_type = cp_type_i;
-   tol = tol_i;
-   lbound.SetSize(nb, ncp);
-   ubound.SetSize(nb, ncp);
-   nodes.SetSize(nb);
-   weights.SetSize(nb);
-   control_points.SetSize(ncp);
-
-   auto scalenodes = [](const Vector &in, const real_t a, const real_t b) -> Vector
-   {
-      Vector outVec(in.Size());
-      real_t maxv = in.Max();
-      real_t minv = in.Min();
-      for (int i = 0; i < in.Size(); i++)
-      {
-         outVec(i) = a + (b-a)*(in(i)-minv)/(maxv-minv);
-      }
-      return outVec;
-   };
-   MFEM_VERIFY(ncp >= 2,"At least 2 control points are required.");
-
-   if (cp_type == 0) // GL + End Point
-   {
-      control_points(0) = 0.0;
-      control_points(ncp-1) = 1.0;
-      if (ncp > 2)
-      {
-         const real_t *x = poly1d.GetPoints(ncp-3, 0);
-         MFEM_VERIFY(x, "Error in getting points.");
-         for (int i = 0; i < ncp-2; i++)
-         {
-            control_points(i+1) = x[i];
-         }
-      }
-   }
-   else if (cp_type == 1) // Chebyshev
-   {
-      auto GetChebyshevNodes = [](int n) -> Vector
-      {
-         Vector cheb(n);
-         for (int i = 0; i < n; ++i)
-         {
-            cheb(i) = -cos(M_PI * (static_cast<real_t>(i) / (n - 1)));
-         }
-         return cheb;
-      };
-      control_points = GetChebyshevNodes(ncp);
-   }
-   else
-   {
-      MFEM_ABORT("Unsupported interval points. Use [0,1].\n");
-   }
-   control_points = scalenodes(control_points, 0.0, 1.0); // rescale to [0,1]
-
-   Poly_1D::Basis &basis1d(poly1d.GetBasis(nb-1, b_type));
-
-   // Initialize bounds
-   lbound = 0.0;
-   ubound = 0.0;
-
-   Vector bmv(nb), bpv(nb), bv(nb); // basis values
-   Vector bdmv(nb), bdpv(nb), bdv(nb); // basis derivative values
-   Vector vals(3);
-
-   // See Section 3.1.1 of https://arxiv.org/pdf/2501.12349 for explanation of
-   // procedure below.
-   for (int j = 0; j < ncp; j++)
-   {
-      real_t x = control_points(j);
-      real_t xm = x;
-      if (j != 0)
-      {
-         xm = 0.5*(control_points(j-1)+control_points(j));
-      }
-      real_t xp = x;
-      if (j != ncp-1)
-      {
-         xp = 0.5*(control_points(j)+control_points(j+1));
-      }
-      basis1d.Eval(xm, bmv, bdmv);
-      basis1d.Eval(xp, bpv, bdpv);
-      basis1d.Eval(x, bv);
-      real_t dm = x-xm;
-      real_t dp = x-xp;
-      for (int i = 0; i < nb; i++)
-      {
-         if (j == 0)
-         {
-            lbound(i, j) = bv(i);
-            ubound(i, j) = bv(i);
-         }
-         else if (j == ncp-1)
-         {
-            lbound(i, j) = bv(i);
-            ubound(i, j) = bv(i);
-         }
-         else
-         {
-            vals(0)  = bv(i);
-            vals(1) =  bmv(i) +  dm*bdmv(i);
-            vals(2) =  bpv(i) +  dp*bdpv(i);
-            lbound(i, j) = vals.Min()-tol; // tolerance for good measure
-            ubound(i, j) = vals.Max()+tol; // tolerance for good measure
-         }
-      }
-   }
-
-   IntegrationRule irule(nb);
-   if (b_type == 0)
-   {
-      QuadratureFunctions1D::GaussLegendre(nb, &irule);
-      for (int i = 0; i < nb; i++)
-      {
-         weights(i) = irule.IntPoint(i).weight;
-         nodes(i) = irule.IntPoint(i).x;
-      }
-   }
-   else if (b_type == 1)
-   {
-      QuadratureFunctions1D::GaussLobatto(nb, &irule);
-      for (int i = 0; i < nb; i++)
-      {
-         weights(i) = irule.IntPoint(i).weight;
-         nodes(i) = irule.IntPoint(i).x;
-      }
-   }
-   else if (b_type == 2)
-   {
-      QuadratureFunctions1D::ClosedUniform(nb, &irule);
-      for (int i = 0; i < nb; i++)
-      {
-         weights(i) = irule.IntPoint(i).weight;
-         nodes(i) = irule.IntPoint(i).x;
-      }
-   }
-
-   if (b_type == 2)
-   {
-      nodes_int.SetSize(nb);
-      weights_int.SetSize(nb);
-      IntegrationRule irule_int(nb);
-      {
-         QuadratureFunctions1D::GaussLobatto(nb, &irule_int);
-         for (int i = 0; i < nb; i++)
-         {
-            weights_int(i) = irule_int.IntPoint(i).weight;
-            nodes_int(i) = irule_int.IntPoint(i).x;
-         }
-      }
-
-      SetupBernsteinBasisMat(basisMatNodes, nodes);
-      // Setup memory for lu factors
-      basisMatLU = basisMatNodes;
-      lu_ip.SetSize(nb);
-      // Compute lu factors
-      LUFactors lu(basisMatLU.GetData(), lu_ip.GetData());
-      bool factor = lu.Factor(nb);
-      MFEM_VERIFY(factor,"Failure in LU factorization in PLBound.");
-
-      // Setup the Bernstein basis matrix for the GLL integration points. This
-      // is used to compute linear fit.
-      SetupBernsteinBasisMat(basisMatInt, nodes_int);
-   }
-   else
-   {
-      nodes_int.SetDataAndSize(nodes.GetData(), nb);
-      weights_int.SetDataAndSize(weights.GetData(), nb);
-   }
-}
-
-PLBound::PLBound(FiniteElementSpace *fes, int ncp_i, int cp_type_i)
-{
-   MFEM_VERIFY(!fes->IsVariableOrder(),
-               "Variable order meshes not yet supported.");
-   const char *name = fes->FEColl()->Name();
-   string cname = name;
-
-   cp_type = cp_type_i;
-   b_type = BasisType::Invalid;
-   nb = fes->GetMaxElementOrder()+1;
-   tol = 0.0;
-
-   int minncp = 2;
-   if (nb > 12)
-   {
-      minncp = 2*nb;
-   }
-   else if (!strncmp(name, "H1_", 3) && strncmp(name, "H1_Trace_", 9))
-   {
-      // H1 GLL
-      b_type = BasisType::GaussLobatto;
-      minncp = min_ncp_gll_x[cp_type][nb-2];
-   }
-   else if (!strncmp(name, "H1Pos_", 6) && strncmp(name, "H1Pos_Trace_", 12))
-   {
-      // H1 Positive
-      b_type = BasisType::Positive;
-      minncp = min_ncp_pos_x[cp_type][nb-2];
-   }
-   else if (!strncmp(name, "L2_", 3) && strncmp(name, "L2_T", 4))
-   {
-      // L2 Gauss-Legendre
-      b_type = BasisType::GaussLegendre;
-      minncp = min_ncp_gl_x[cp_type][nb-2];
-   }
-   else if (!strncmp(name, "L2_T1", 5))
-   {
-      // L2 GLL
-      b_type = BasisType::GaussLobatto;
-      minncp = min_ncp_gll_x[cp_type][nb-2];
-   }
-   else if (!strncmp(name, "L2_T2", 5))
-   {
-      // L2 Positive
-      b_type = BasisType::Positive;
-      minncp = min_ncp_pos_x[cp_type][nb-2];
-   }
-   else
-   {
-      MFEM_ABORT("Only H1 GLL/Positive & L2 GL/GLL/Positive bases supported.");
-   }
-
-   ncp = std::max(minncp, ncp_i);
-
-   Setup(nb, ncp, b_type, cp_type, tol);
-}
-
-void PLBound::Get1DBounds(Vector &coeff, Vector &intmin, Vector &intmax) const
-{
-   real_t x,w;
-   intmin.SetSize(ncp);
-   intmax.SetSize(ncp);
-   intmin = 0.0;
-   intmax = 0.0;
-   Vector coeffm(nb);
-   coeffm = 0.0;
-
-   real_t a0 = 0.0;
-   real_t a1 = 0.0;
-
-   Vector nodal_vals, nodal_integ_vals;
-   if (b_type == 2) // compute values at equispaced nodes and GLL nodes
-   {
-      nodal_vals.SetSize(nb);
-      nodal_integ_vals.SetSize(nb);
-      Vector shape(nb);
-      for (int i = 0; i < nb; i++)
-      {
-         basisMatNodes.GetRow(i, shape);
-         nodal_vals(i) = shape*coeff;
-         basisMatInt.GetRow(i, shape);
-         nodal_integ_vals(i) = shape*coeff;
-      }
-   }
-   else
-   {
-      nodal_vals.SetDataAndSize(coeff.GetData(), nb);
-      nodal_integ_vals.SetDataAndSize(coeff.GetData(), nb);
-   }
-
-   // compute L2 projection for linear bases: a0 + a1*x
-   if (proj)
-   {
-      for (int i = 0; i < nb; i++)
-      {
-         x = 2.0*nodes_int(i)-1;
-         w = 2.0*weights_int(i);
-         a0 += 0.5*nodal_integ_vals(i)*w;
-         a1 += 1.5*nodal_integ_vals(i)*w*x;
-      }
-
-      // offset the linear fit from nodal values
-      for (int i = 0; i < nb; i++)
-      {
-         x = 2.0*nodes(i)-1;
-         coeffm(i) = nodal_vals(i) - a0 - a1*x;
-      }
-
-      // compute coefficients for Bernstein
-      if (b_type == 2)
-      {
-         LUFactors lu(basisMatLU.GetData(), lu_ip.GetData());
-         lu.Solve(nb, 1, coeffm.GetData());
-      }
-
-      // initialize the bounds to be the linear fit
-      for (int j = 0; j < ncp; j++)
-      {
-         x = 2.0*control_points(j)-1;
-         intmin(j) = a0 + a1*x;
-         intmax(j) = intmin(j);
-      }
-   }
-   else
-   {
-      coeffm.SetDataAndSize(coeff.GetData(), nb);
-   }
-
-   for (int i = 0; i < nb; i++)
-   {
-      real_t c = coeffm(i);
-      for (int j = 0; j < ncp; j++)
-      {
-         intmin(j) += min(lbound(i,j)*c, ubound(i,j)*c);
-         intmax(j) += max(lbound(i,j)*c, ubound(i,j)*c);
-      }
-   }
-}
-
-void PLBound::Get2DBounds(Vector &coeff, Vector &intmin, Vector &intmax) const
-{
-   intmin.SetSize(ncp*ncp);
-   intmax.SetSize(ncp*ncp);
-   intmin = 0.0;
-   intmax = 0.0;
-   Vector intminT(ncp*nb);
-   Vector intmaxT(ncp*nb);
-   // Get bounds for each row of the solution
-   for (int i = 0; i < nb; i++)
-   {
-      Vector solcoeff(coeff.GetData()+i*nb, nb);
-      Vector intminrow(intminT.GetData()+i*ncp, ncp);
-      Vector intmaxrow(intmaxT.GetData()+i*ncp, ncp);
-      Get1DBounds(solcoeff, intminrow, intmaxrow);
-   }
-   Vector intminT2 = intminT;
-
-   // Compute a0 and a1 for each column of nodes
-   Vector a0V(ncp), a1V(ncp);
-   a0V = 0.0;
-   a1V = 0.0;
-   real_t x,w,t;
-   if (proj)
-   {
-      if (b_type == 2)
-      {
-         // Note: DenseMatrix uses column-major ordering so we will need to
-         // transpose the matrix.
-         DenseMatrix intminTM(intminT.GetData(), ncp, nb),
-                     intmaxTM(intmaxT.GetData(), ncp, nb),
-                     intmeanTM(ncp, nb);
-         DenseMatrix minvalsM(nb, ncp), maxvalsM(nb, ncp), meanintvalsM(nb, ncp);
-         MultABt(basisMatNodes, intminTM, minvalsM);
-         MultABt(basisMatNodes, intmaxTM, maxvalsM);
-         intmeanTM = intminTM;
-         intmeanTM += intmaxTM;
-         intmeanTM *= 0.5;
-         MultABt(basisMatInt, intmeanTM, meanintvalsM);
-
-         // Compute the linear fit along each column and then offset it from
-         // the bounds on the coefficient.
-         // Note: Since Bernstein bases are positive, we can use the lower
-         // bounds to compute the lower bounding polynomial and subtract the
-         // linear fit before finding the Bernstein coefficients corresponding
-         // to the perturbation. Same for upper bounds. If the bases were not
-         // always positive, it is not yet clear if the perturbation
-         // coefficients will be this straightforward to compute.
-         for (int j = 0; j < ncp; j++) // row of interval points
-         {
-            for (int i = 0; i < nb; i++)
-            {
-               x = 2.0*nodes_int(i)-1; // x-coordinate
-               w = 2.0*weights_int(i); // weight
-               t = meanintvalsM(i,j);
-               a0V(j) += 0.5*t*w;
-               a1V(j) += 1.5*t*w*x;
-            }
-            // Offset linear fit
-            for (int i = 0; i < nb; i++)
-            {
-               x = 2.0*nodes(i)-1; // x-coordinate
-               minvalsM(i,j) -= a0V(j) + a1V(j)*x;
-               maxvalsM(i,j) -= a0V(j) + a1V(j)*x;
-            }
-            // Compute Bernstein coefficients
-            LUFactors lu(basisMatLU.GetData(), lu_ip.GetData());
-            lu.Solve(nb, 1, minvalsM.GetColumn(j));
-            lu.Solve(nb, 1, maxvalsM.GetColumn(j));
-            for (int i = 0; i < nb; i++)
-            {
-               intminT(i*ncp+j) = minvalsM(i,j);
-               intmaxT(i*ncp+j) = maxvalsM(i,j);
-            }
-         }
-      }
-      else
-      {
-         for (int j = 0; j < nb; j++) // row of nodes
-         {
-            x = 2.0*nodes(j)-1; // x-coordinate
-            w = 2.0*weights(j); // weight
-            for (int i = 0; i < ncp; i++) // column of interval points
-            {
-               t = 0.5*(intminT(j*ncp+i)+intmaxT(j*ncp+i));
-               a0V(i) += 0.5*t*w;
-               a1V(i) += 1.5*t*w*x;
-            }
-         }
-         // offset the linear fit from nodal values
-         for (int j = 0; j < nb; j++) // row of nodes
-         {
-            x = 2.0*nodes(j)-1; // x-coordinate
-            for (int i = 0; i < ncp; i++) // column of interval points
-            {
-               t = a0V(i) + a1V(i)*x;
-               intminT(j*ncp+i) -= t;
-               intmaxT(j*ncp+i) -= t;
-            }
-         }
-      }
-
-      // Initialize bounds using a0 and a1 values
-      for (int j = 0; j < ncp; j++) // row j
-      {
-         x = 2.0*control_points(j)-1;
-         for (int i = 0; i < ncp; i++) // column i
-         {
-            intmin(j*ncp+i) = a0V(i) + a1V(i)*x;
-            intmax(j*ncp+i) = intmin(j*ncp+i);
-         }
-      }
-   }
-
-   // Compute bounds
-   int id1 = 0, id2 = 0;
-   Vector vals(4);
-   for (int j = 0; j < nb; j++)
-   {
-      for (int i = 0; i < ncp; i++) // ith column
-      {
-         real_t w0 = intminT(id1++);
-         real_t w1 = intmaxT(id2++);
-         for (int k = 0; k < ncp; k++) // kth row
-         {
-            vals(0) = w0*lbound(j,k);
-            vals(1) = w0*ubound(j,k);
-            vals(2) = w1*lbound(j,k);
-            vals(3) = w1*ubound(j,k);
-            intmin(k*ncp+i) += vals.Min();
-            intmax(k*ncp+i) += vals.Max();
-         }
-      }
-   }
-}
-
-void PLBound::Get3DBounds(Vector &coeff, Vector &intmin, Vector &intmax) const
-{
-   int nb2 = nb*nb,
-       ncp2 = ncp*ncp,
-       ncp3 = ncp*ncp*ncp;
-
-   intmin.SetSize(ncp3);
-   intmax.SetSize(ncp3);
-   intmin = 0.0;
-   intmax = 0.0;
-   Vector intminT(ncp2*nb);
-   Vector intmaxT(ncp2*nb);
-
-   // Get bounds for each slice of the solution
-   for (int i = 0; i < nb; i++)
-   {
-      Vector solcoeff(coeff.GetData()+i*nb2, nb2);
-      Vector intminrow(intminT.GetData()+i*ncp2, ncp2);
-      Vector intmaxrow(intmaxT.GetData()+i*ncp2, ncp2);
-      Get2DBounds(solcoeff, intminrow, intmaxrow);
-   }
-   DenseMatrix intminTM(intminT.GetData(), ncp2, nb),
-               intmaxTM(intmaxT.GetData(), ncp2, nb);
-
-   // Compute a0 and a1 for each tower of nodes
-   Vector a0V(ncp2), a1V(ncp2);
-   a0V = 0.0;
-   a1V = 0.0;
-   real_t x,w,t;
-   if (proj)
-   {
-      if (b_type == 2) // Bernstein bases
-      {
-         // Compute the mean coefficients along each tower.
-         for (int j = 0; j < ncp2; j++) // slice of interval points
-         {
-            Vector meanBounds(nb), minBounds(nb), maxBounds(nb);
-            intminTM.GetRow(j, minBounds);
-            intmaxTM.GetRow(j, maxBounds);
-            for (int i = 0; i < nb; i++) // column of nodes
-            {
-               meanBounds(i) = 0.5*(minBounds(i)+maxBounds(i));
-            }
-            Vector meanNodalIntVals(nb);
-            Vector minNodalVals(nb);
-            Vector maxNodalVals(nb);
-            Vector row(nb);
-            for (int i = 0; i < nb; i++)
-            {
-               basisMatNodes.GetRow(i, row);
-               minNodalVals(i) = row*minBounds;
-               maxNodalVals(i) = row*maxBounds;
-               basisMatInt.GetRow(i, row);
-               meanNodalIntVals(i) = row*meanBounds;
-            }
-            // linear fit along each tower
-            for (int i = 0; i < nb; i++)
-            {
-               x = 2.0*nodes_int(i)-1; // x-coordinate
-               w = 2.0*weights_int(i); // weight
-               a0V(j) += 0.5*meanNodalIntVals(i)*w;
-               a1V(j) += 1.5*meanNodalIntVals(i)*w*x;
-            }
-            // offset the linear fit from bounding coefficients
-            for (int i = 0; i < nb; i++)
-            {
-               x = 2.0*nodes(i)-1; // x-coordinate
-               minBounds(i) -= a0V(j) + a1V(j)*x;
-               maxBounds(i) -= a0V(j) + a1V(j)*x;
-            }
-            // Compute Bernstein coefficients
-            LUFactors lu(basisMatLU.GetData(), lu_ip.GetData());
-            lu.Solve(nb, 1, minBounds.GetData());
-            lu.Solve(nb, 1, maxBounds.GetData());
-            for (int i = 0; i < nb; i++)
-            {
-               intminT(i*ncp2+j) = minBounds(i);
-               intmaxT(i*ncp2+j) = maxBounds(i);
-            }
-         }
-      }
-      else
-      {
-         // nodal bases
-         for (int j = 0; j < nb; j++) // tower of nodes
-         {
-            x = 2.0*nodes(j)-1; // x-coordinate
-            w = 2.0*weights(j); // weight
-            for (int i = 0; i < ncp2; i++) // slice of interval points
-            {
-               t = 0.5*(intminT(j*ncp2+i)+intmaxT(j*ncp2+i));
-               a0V(i) += 0.5*t*w;
-               a1V(i) += 1.5*t*w*x;
-            }
-         }
-         // offset the linear fit from nodal values
-         for (int j = 0; j < nb; j++) // row of nodes
-         {
-            x = 2.0*nodes(j)-1; // x-coordinate
-            for (int i = 0; i < ncp2; i++) // column of interval points
-            {
-               t = a0V(i) + a1V(i)*x;
-               intminT(j*ncp2+i) -= t;
-               intmaxT(j*ncp2+i) -= t;
-            }
-         }
-      }
-
-      // Initialize bounds using a0 and a1 values
-      for (int j = 0; j < ncp; j++) // slice j
-      {
-         x = 2.0*control_points(j)-1;
-         for (int i = 0; i < ncp2; i++) // tower i
-         {
-            intmin(j*ncp2+i) = a0V(i) + a1V(i)*x;
-            intmax(j*ncp2+i) = a0V(i) + a1V(i)*x;
-         }
-      }
-   }
-
-   // Compute bounds
-   int id1 = 0, id2 = 0;
-   Vector vals(4);
-   for (int j = 0; j < nb; j++)
-   {
-      for (int i = 0; i < ncp2; i++) // ith tower
-      {
-         real_t w0 = intminT(id1++);
-         real_t w1 = intmaxT(id2++);
-         for (int k = 0; k < ncp; k++) // kth slice
-         {
-            vals(0) = w0*lbound(j,k);
-            vals(1) = w0*ubound(j,k);
-            vals(2) = w1*lbound(j,k);
-            vals(3) = w1*ubound(j,k);
-            intmin(k*ncp2+i) += vals.Min();
-            intmax(k*ncp2+i) += vals.Max();
-         }
-      }
-   }
-}
-
-void PLBound::GetNDBounds(int rdim, Vector &coeff,
-                          Vector &intmin, Vector &intmax) const
-{
-   if (rdim == 1)
-   {
-      Get1DBounds(coeff, intmin, intmax);
-   }
-   else if (rdim == 2)
-   {
-      Get2DBounds(coeff, intmin, intmax);
-   }
-   else if (rdim == 3)
-   {
-      Get3DBounds(coeff, intmin, intmax);
-   }
-   else
-   {
-      MFEM_ABORT("Currently not supported.");
-   }
-}
-
-void PLBound::SetupBernsteinBasisMat(DenseMatrix &basisMat,
-                                     Vector &nodesBern) const
-{
-   const int nbern = nodesBern.Size();
-   L2_SegmentElement el(nbern-1, 2); // we use L2 to leverage lexicographic order
-   Array<int> ordering = el.GetLexicographicOrdering();
-   basisMat.SetSize(nbern, nbern);
-   Vector shape(nbern);
-   IntegrationPoint ip;
-   for (int i = 0; i < nbern; i++)
-   {
-      ip.x = nodesBern(i);
-      el.CalcShape(ip, shape);
-      basisMat.SetRow(i, shape);
-   }
-}
-
-constexpr int PLBound::min_ncp_gl_x[2][11];
-constexpr int PLBound::min_ncp_gll_x[2][11];
-constexpr int PLBound::min_ncp_pos_x[2][11];
-
-int PLBound::GetMinimumPointsForGivenBases(int nb_i, int b_type_i,
-                                           int cp_type_i) const
-{
-   MFEM_VERIFY(b_type_i >= 0 && b_type_i <= 2, "Invalid node type. Specify 0 "
-               "for GL, 1 for GLL, and 2 for positive " "bases.");
-   MFEM_VERIFY(cp_type_i == 0 || cp_type_i == 1, "Invalid control point type. "
-               "Specify 0 for GL+end points, 1 for Chebyshev.");
-   if (nb_i > 12)
-   {
-      MFEM_ABORT("GetMinimumPointsForGivenBases can only be used for maximum "
-                 "order = 11, i.e. nb=12. 2*nb points should be sufficient to "
-                 "bound the bases up to nb = 30.");
-   }
-   else if (b_type_i == 0)
-   {
-      return min_ncp_gl_x[cp_type_i][nb_i-2];
-   }
-   else if (b_type_i == 1)
-   {
-      return min_ncp_gll_x[cp_type_i][nb_i-2];
-   }
-   else if (b_type_i == 2)
-   {
-      return min_ncp_pos_x[cp_type_i][nb_i-2];
-   }
-   return 0;
-}
-
-void PLBound::Print(std::ostream &outp) const
-{
-   outp << "PLBound nb: " << nb << std::endl;
-   outp << "PLBound ncp: " << ncp << std::endl;
-   outp << "PLBound b_type: " << b_type << std::endl;
-   outp << "PLBound cp_type: " << cp_type << std::endl;
-   outp << "Print nodes: " << std::endl;
-   nodes.Print(outp);
-   outp << "Print weights: " << std::endl;
-   weights.Print(outp);
-   outp << "Print control_points: " << std::endl;
-   control_points.Print(outp);
-   outp << "Print lower bounds: " << std::endl;
-   lbound.Print(outp);
-   outp << "Print upper bounds: " << std::endl;
-   ubound.Print(outp);
-}
-
-}
@@ -1,136 +0,0 @@
-// Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-// at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-// LICENSE and NOTICE for details. LLNL-CODE-806117.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability visit https://mfem.org.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the BSD-3 license. We welcome feedback and contributions, see file
-// CONTRIBUTING.md for details.
-
-#ifndef MFEM_BOUND
-#define MFEM_BOUND
-
-#include "../config/config.hpp"
-#include "fespace.hpp"
-
-namespace mfem
-{
-
-/** @name Piecewise linear bounds of bases
-    \brief Piecewise linear bounds of bases can be used to compute bounds on the grid function in each element. The bounds for the bases are constructed based on the following parameters:
-
-    (i) @b nb: number of bases/nodes in 1D (i.e. polynomial order+1),
-
-    (ii) @b b_type: bases type, 0 - Lagrange interpolants on Gauss-Legendre nodes, 1 - Lagrange interpolants on Gauss-Lobatto-Legendre nodes, and
-    2 - Positive/Bernstein bases on uniformly distributed nodes,
-
-    (iii) @b ncp: number of control points used to construct the piecewise linear bounds
-
-    (iv) @b cp_type: control point distribution. 0 - GL + end-points,
-                    1 - Chebyshev.
-
-    Note: @b nb and @b b_type are inferred directly from the grid-function.
-
-    If the user does not specify @b ncp and @b cp_type, the minimum value of
-    @b ncp is used that would bound the bases for the @b cp_type. We default
-    to @b cp_type = 0 as it requires fewer number of points to bound the bases. Typically, @b ncp = 2 @b nb is sufficient to get fairly compact bounds, and increasing @b ncp results in tighter bounds.
-
-    Finally, only tensor-product elements are currently supported.
-
-    For more technical details see:
-    Mittal et al., "General Field Evaluation in High-Order Meshes on GPUs" &
-    Dzanic et al., "A method for bounding high-order finite element
-    functions: Applications to mesh validity and bounds-preserving limiters".
-*/
-class PLBound
-{
-private:
-   int nb; // #mesh nodes in 1D
-   int ncp; // #control points in 1D
-   int b_type; // bases type: 0 - GL, 1 - GLL, 2 - Bernstein
-   int cp_type; // control points type: 0 - GL+Ends, 1 - Chebyshev
-   bool proj = true; // Use linear projection to compute bounds.
-   real_t tol = 0.0; // offset bounds to avoid round-off errors
-   Vector nodes, weights, control_points;
-   DenseMatrix lbound, ubound; // nb x ncp matrices with bounds of all bases
-   // Some auxillary storage for computing the bounds with Bernstein
-   DenseMatrix basisMatNodes; // Bernstein bases at equispaced nodes
-   DenseMatrix basisMatInt;   // Bernstein bases at GLL nodes
-   Vector nodes_int, weights_int; // Integration nodes and weights
-   DenseMatrix basisMatLU;    // Used to compute LU factors for Bernstein
-   mutable Array<int> lu_ip;
-
-   // stores min_ncp for nb = 2..12 for Lagrange interpolants on GL nodes
-   // with GL+end points and Chebyshev points as control points
-   static constexpr int min_ncp_gl_x[2][11]= {{3,5,6,8,9,10,11,11,12,13,14},
-      {3,5,8,9,11,12,14,15,17,18,20}
-   };
-
-   // stores min_ncp for nb = 2..12 for Lagrange interpolants on GLL nodes
-   // with GL+end points and Chebyshev points as control points
-   static constexpr int min_ncp_gll_x[2][11]= {{3,5,7,8,9,10,12,13,14,15,16},
-      {3,5,8,10,12,13,15,17,19,21,22}
-   };
-
-   // stores min_ncp for nb = 2..12 for Bernstein bases with GL+end points
-   // and Chebyshev points as control points
-   static constexpr int min_ncp_pos_x[2][11]= {{3,5,7,8,8,9,10,10,11,12,13},
-      {3,5,8,9,11,12,13,13,14,15,16}
-   };
-
-public:
-   // Constructor
-   PLBound(const int nb_i, const int ncp_i, const int b_type_i,
-           const int cp_type_i, const real_t tol_i)
-   {
-      Setup(nb_i, ncp_i, b_type_i, cp_type_i, tol_i);
-   }
-
-   // Constructor
-   PLBound(FiniteElementSpace *fes, int ncp_i = -1, int cp_type_i = 0);
-
-   // Get minimum number of control points needed to bound the given bases
-   int GetMinimumPointsForGivenBases(int nb_i, int b_type_i,
-                                     int cp_type_i) const;
-
-   // Print information about the bounds
-   void Print(std::ostream &outp = mfem::out) const;
-
-   // Enable (default) or disable linear projection before bounding.
-   // This projection increases the computational cost but results in tighter
-   // bounds.
-   void SetProjectionFlagForBounding(bool proj_) { proj = proj_; }
-
-   /// Compute piecewise linear bounds for the lexicographically-ordered
-   /// coefficients in @a coeff in 1D/2D/3D.
-   void GetNDBounds(int rdim, Vector &coeff,
-                    Vector &intmin, Vector &intmax) const;
-
-   /// Get number of control points used to compute the bounds.
-   int GetNControlPoints() const { return ncp; }
-private:
-   /// Compute piecewise linear bounds for the lexicographically-ordered
-   /// coefficients in @a coeff in 1D.
-   void Get1DBounds(Vector &coeff, Vector &intmin, Vector &intmax) const;
-
-   /// Compute piecewise linear bounds for the lexicographically-ordered
-   /// coefficients in @a coeff in 2D.
-   void Get2DBounds(Vector &coeff, Vector &intmin, Vector &intmax) const;
-
-   /// Compute piecewise linear bounds for the lexicographically-ordered
-   /// coefficients in @a coeff in 3D.
-   void Get3DBounds(Vector &coeff, Vector &intmin, Vector &intmax) const;
-
-   /// Setup matrix used to compute values at given 1D locations in [0,1]
-   /// for Bernstein bases.
-   void SetupBernsteinBasisMat(DenseMatrix &basisMat, Vector &nodesBern) const;
-
-   void Setup(const int nb_i, const int ncp_i, const int b_type_i,
-              const int cp_type_i, const real_t tol_i);
-};
-
-} // namespace mfem
-
-#endif // MFEM_BOUND
@@ -240,9 +240,7 @@ public:
       Vector argument instead of Vector. */
   MFEM_DEPRECATED FunctionCoefficient(real_t (*f)(Vector &))
   {
-      // Cast first to (void*) to suppress a warning from newer version of
-      // Clang when using -Wextra.
-      Function = reinterpret_cast<real_t(*)(const Vector&)>((void*)f);
+      Function = reinterpret_cast<real_t(*)(const Vector&)>(f);
      TDFunction = NULL;
   }

@@ -252,10 +250,7 @@ public:
   MFEM_DEPRECATED FunctionCoefficient(real_t (*tdf)(Vector &, real_t))
   {
      Function = NULL;
-      // Cast first to (void*) to suppress a warning from newer version of
-      // Clang when using -Wextra.
-      TDFunction =
-         reinterpret_cast<real_t(*)(const Vector&,real_t)>((void*)tdf);
+      TDFunction = reinterpret_cast<real_t(*)(const Vector&,real_t)>(tdf);
   }

   /// Evaluate the coefficient at @a ip.
@@ -1,217 +0,0 @@
-// Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-// at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-// LICENSE and NOTICE for details. LLNL-CODE-806117.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability visit https://mfem.org.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the BSD-3 license. We welcome feedback and contributions, see file
-// CONTRIBUTING.md for details.
-
-#include "complex_fem.hpp"
-#include "../general/forall.hpp"
-
-using namespace std;
-
-namespace mfem
-{
-
-real_t
-RealPartCoefficient::Eval(ElementTransformation &T,
-                          const IntegrationPoint &ip)
-{
-   complex_t val = complex_coef_.Eval(T, ip);
-   return val.real();
-}
-
-real_t
-ImagPartCoefficient::Eval(ElementTransformation &T,
-                          const IntegrationPoint &ip)
-{
-   complex_t val = complex_coef_.Eval(T, ip);
-   return val.imag();
-}
-
-RealPartVectorCoefficient::RealPartVectorCoefficient(ComplexVectorCoefficient &
-                                                     complex_vcoef)
-   : VectorCoefficient(complex_vcoef.GetVDim()),
-     complex_vcoef_(complex_vcoef),
-     val_(vdim)
-{}
-
-void
-RealPartVectorCoefficient::Eval(Vector &V, ElementTransformation &T,
-                                const IntegrationPoint &ip)
-{
-   complex_vcoef_.Eval(val_, T, ip);
-   V = val_.real();
-}
-
-ImagPartVectorCoefficient::ImagPartVectorCoefficient(ComplexVectorCoefficient &
-                                                     complex_vcoef)
-   : VectorCoefficient(complex_vcoef.GetVDim()),
-     complex_vcoef_(complex_vcoef),
-     val_(vdim)
-{}
-
-void
-ImagPartVectorCoefficient::Eval(Vector &V, ElementTransformation &T,
-                                const IntegrationPoint &ip)
-{
-   complex_vcoef_.Eval(val_, T, ip);
-   V = val_.imag();
-}
-
-RealPartMatrixCoefficient::RealPartMatrixCoefficient(ComplexMatrixCoefficient &
-                                                     complex_mcoef)
-   : MatrixCoefficient(complex_mcoef.GetHeight(), complex_mcoef.GetWidth()),
-     complex_mcoef_(complex_mcoef),
-     val_(height, width)
-{}
-
-void
-RealPartMatrixCoefficient::Eval(DenseMatrix &M, ElementTransformation &T,
-                                const IntegrationPoint &ip)
-{
-   complex_mcoef_.Eval(val_, T, ip);
-   M = val_.real();
-}
-
-ImagPartMatrixCoefficient::ImagPartMatrixCoefficient(ComplexMatrixCoefficient &
-                                                     complex_mcoef)
-   : MatrixCoefficient(complex_mcoef.GetHeight(), complex_mcoef.GetWidth()),
-     complex_mcoef_(complex_mcoef),
-     val_(height, width)
-{}
-
-void
-ImagPartMatrixCoefficient::Eval(DenseMatrix &M, ElementTransformation &T,
-                                const IntegrationPoint &ip)
-{
-   complex_mcoef_.Eval(val_, T, ip);
-   M = val_.imag();
-}
-
-ComplexCoefficient::ComplexCoefficient()
-   : time(0.),
-     re_part_coef_(*this), im_part_coef_(*this),
-     real_coef_(re_part_coef_), imag_coef_(im_part_coef_)
-{ }
-
-ComplexCoefficient::ComplexCoefficient(Coefficient &c_r,
-                                       Coefficient &c_i)
-   : time(c_r.GetTime()),
-     re_part_coef_(*this), im_part_coef_(*this),
-     real_coef_(c_r), imag_coef_(c_i)
-{
-   c_i.SetTime(time);
-}
-
-complex_t
-ComplexCoefficient::Eval(ElementTransformation &T,
-                         const IntegrationPoint &ip)
-{
-   // Avoid circular dependency
-   MFEM_VERIFY(std::addressof(real_coef_) != std::addressof(re_part_coef_) &&
-               std::addressof(imag_coef_) != std::addressof(im_part_coef_),
-               "Classes dervied from ComplexCoefficient must either "
-               "implement an Eval method or supply Coefficients "
-               "for both the real and imaginary parts of the field.");
-
-   return complex_t(real_coef_.Eval(T, ip), imag_coef_.Eval(T, ip));
-}
-
-ComplexVectorCoefficient::ComplexVectorCoefficient(VectorCoefficient &v_r,
-                                                   VectorCoefficient &v_i)
-   : vdim(v_r.GetVDim()), time(v_r.GetTime()),
-     re_part_vcoef_(*this), im_part_vcoef_(*this),
-     real_vcoef_(v_r), imag_vcoef_(v_i)
-{
-   MFEM_ASSERT(v_r.GetVDim() == v_i.GetVDim(), "ComplexVectorCoefficient"
-               " - incompatible vector dimensions of real and imaginary parts.");
-
-   v_i.SetTime(time);
-}
-
-void ComplexVectorCoefficient::Eval(ComplexVector &V, ElementTransformation &T,
-                                    const IntegrationPoint &ip)
-{
-   // Avoid circular dependency
-   MFEM_VERIFY(std::addressof(real_vcoef_) != std::addressof(re_part_vcoef_) &&
-               std::addressof(imag_vcoef_) != std::addressof(im_part_vcoef_),
-               "Classes dervied from ComplexVectorCoefficient must either "
-               "implement an Eval method or supply VectorCoefficients "
-               "for both the real and imaginary parts of the field.");
-
-   V_r_.SetSize(vdim);
-   V_i_.SetSize(vdim);
-
-   real_vcoef_.Eval(V_r_, T, ip);
-   imag_vcoef_.Eval(V_i_, T, ip);
-
-   V.Set(V_r_, V_i_);
-}
-
-ComplexConstantCoefficient::ComplexConstantCoefficient(
-   const complex_t z)
-   : val(z), real_coef(z.real()), imag_coef(z.imag())
-{
-   real_coef_ = real_coef;
-   imag_coef_ = imag_coef;
-}
-
-ComplexConstantCoefficient::ComplexConstantCoefficient(
-   real_t z_r, real_t z_i)
-   : real_coef(z_r), imag_coef(z_i)
-{
-   val = complex_t(z_r, z_i);
-
-   real_coef_ = real_coef;
-   imag_coef_ = imag_coef;
-}
-
-complex_t ComplexFunctionCoefficient::Eval(ElementTransformation & T,
-                                           const IntegrationPoint & ip)
-{
-   real_t x[3];
-   Vector transip(x, 3);
-
-   T.Transform(ip, transip);
-
-   if (Function)
-   {
-      return Function(transip);
-   }
-   else
-   {
-      return TDFunction(transip, GetTime());
-   }
-}
-
-void ComplexVectorFunctionCoefficient::Eval(ComplexVector &V,
-                                            ElementTransformation &T,
-                                            const IntegrationPoint &ip)
-{
-   real_t x[3];
-   Vector transip(x, 3);
-
-   T.Transform(ip, transip);
-
-   V.SetSize(vdim);
-   if (Function)
-   {
-      Function(transip, V);
-   }
-   else
-   {
-      TDFunction(transip, GetTime(), V);
-   }
-   if (Q)
-   {
-      V *= Q->Eval(T, ip, GetTime());
-   }
-}
-
-} // end namespace mfem
-
@@ -1,523 +0,0 @@
-// Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
-// at the Lawrence Livermore National Laboratory. All Rights reserved. See files
-// LICENSE and NOTICE for details. LLNL-CODE-806117.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability visit https://mfem.org.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the BSD-3 license. We welcome feedback and contributions, see file
-// CONTRIBUTING.md for details.
-
-#ifndef MFEM_COMPLEX_COEFFICIENT
-#define MFEM_COMPLEX_COEFFICIENT
-
-#include "../config/config.hpp"
-#include "../linalg/linalg.hpp"
-#include "coefficient.hpp"
-#include "intrules.hpp"
-#include "eltrans.hpp"
-
-namespace mfem
-{
-
-class ComplexCoefficient;
-class ComplexVectorCoefficient;
-class ComplexMatrixCoefficient;
-
-/// Standard Coefficient which returns the real part of a ComplexCoefficient
-class RealPartCoefficient : public Coefficient
-{
-private:
-   ComplexCoefficient &complex_coef_;
-
-public:
-   RealPartCoefficient(ComplexCoefficient & complex_coef)
-      : complex_coef_(complex_coef) {}
-
-   real_t Eval(ElementTransformation &T,
-               const IntegrationPoint &ip);
-};
-
-/// Standard Coefficient which returns the imaginary part of a
-/// ComplexCoefficient
-class ImagPartCoefficient : public Coefficient
-{
-private:
-   ComplexCoefficient &complex_coef_;
-
-public:
-   ImagPartCoefficient(ComplexCoefficient & complex_coef)
-      : complex_coef_(complex_coef) {}
-
-   real_t Eval(ElementTransformation &T,
-               const IntegrationPoint &ip);
-};
-
-typedef ImagPartCoefficient ImaginaryPartCoefficient;
-
-class RealPartVectorCoefficient : public VectorCoefficient
-{
-private:
-   ComplexVectorCoefficient &complex_vcoef_;
-   mutable ComplexVector val_;
-
-public:
-   RealPartVectorCoefficient(ComplexVectorCoefficient & complex_vcoef);
-
-   void Eval(Vector &V, ElementTransformation &T,
-             const IntegrationPoint &ip);
-};
-
-class ImagPartVectorCoefficient : public VectorCoefficient
-{
-private:
-   ComplexVectorCoefficient &complex_vcoef_;
-   mutable ComplexVector val_;
-
-public:
-   ImagPartVectorCoefficient(ComplexVectorCoefficient & complex_vcoef);
-
-   void Eval(Vector &V, ElementTransformation &T,
-             const IntegrationPoint &ip);
-};
-
-typedef ImagPartVectorCoefficient ImaginaryPartVectorCoefficient;
-
-class RealPartMatrixCoefficient : public MatrixCoefficient
-{
-private:
-   ComplexMatrixCoefficient &complex_mcoef_;
-   mutable ComplexTypeDenseMatrix val_;
-
-public:
-   RealPartMatrixCoefficient(ComplexMatrixCoefficient & complex_mcoef);
-
-   void Eval(DenseMatrix &M, ElementTransformation &T,
-             const IntegrationPoint &ip);
-};
-
-class ImagPartMatrixCoefficient : public MatrixCoefficient
-{
-private:
-   ComplexMatrixCoefficient &complex_mcoef_;
-   mutable ComplexTypeDenseMatrix val_;
-
-public:
-   ImagPartMatrixCoefficient(ComplexMatrixCoefficient & complex_mcoef);
-
-   void Eval(DenseMatrix &V, ElementTransformation &T,
-             const IntegrationPoint &ip);
-};
-
-typedef ImagPartMatrixCoefficient ImaginaryPartMatrixCoefficient;
-
-/** @brief Base class ComplexCoefficients that optionally depend on space and
-    time. These are used by the SesquilinearForm, ComplexLinearForm, and
-    ComplexGridFunction classes to represent the physical coefficients in
-    the PDEs that are being discretized. This class can also be used in a more
-    general way to represent functions that don't necessarily belong to a FE
-    space, e.g., to project onto ComplexGridFunctions to use as initial
-    conditions, exact solutions, etc. See, e.g., ex22 for these uses. */
-class ComplexCoefficient
-{
-protected:
-   real_t time;
-
-private:
-   RealPartCoefficient re_part_coef_;
-   ImagPartCoefficient im_part_coef_;
-
-protected:
-   Coefficient &real_coef_;
-   Coefficient &imag_coef_;
-
-public:
-
-   ComplexCoefficient();
-   ComplexCoefficient(Coefficient &c_r, Coefficient &c_i);
-
-   /// Set the time for time dependent coefficients
-   virtual void SetTime(real_t t)
-   { time = t; real_coef_.SetTime(t); imag_coef_.SetTime(t); }
-
-   /// Get the time for time dependent coefficients
-   real_t GetTime() { return time; }
-
-   /** @brief Evaluate the coefficient in the element described by @a T at the
-       point @a ip. */
-   /** @note When this method is called, the caller must make sure that the
-       IntegrationPoint associated with @a T is the same as @a ip. This can be
-       achieved by calling T.SetIntPoint(&ip). */
-   virtual complex_t Eval(ElementTransformation &T,
-                          const IntegrationPoint &ip);
-
-   /** @brief Evaluate the coefficient in the element described by @a T at the
-       point @a ip at time @a t. */
-   /** @note When this method is called, the caller must make sure that the
-       IntegrationPoint associated with @a T is the same as @a ip. This can be
-       achieved by calling T.SetIntPoint(&ip). */
-   complex_t Eval(ElementTransformation &T,
-                  const IntegrationPoint &ip, real_t t)
-   {
-      SetTime(t);
-      return Eval(T, ip);
-   }
-
-   /** @brief Access a standard Coefficient object reproducing the real part of
-       the complex-valued field */
-   /** @note By default this method returns an internal object which
-       computes the complex value using the above Eval method and
-       returns its real part. Custom implementations may choose to
-       override this method with a more efficient real-valued
-       coefficient. */
-   virtual Coefficient & real() { return real_coef_; }
-
-   /** @brief Access a standard Coefficient object reproducing the imaginary
-       part of the complex-valued field */
-   /** @note By default this method returns an internal object which
-       computes the complex value using the above Eval method and
-       returns its imaginary part. Custom implementations may choose to
-       override this method with a more efficient real-valued
-       coefficient. */
-   virtual Coefficient & imag() { return imag_coef_; }
-
-   virtual ~ComplexCoefficient() { }
-};
-
-/** @brief Base class ComplexVectorCoefficients that optionally depend
-    on space and time. These are used by the SesquilinearForm,
-    ComplexLinearForm, and ComplexGridFunction classes to represent
-    the physical vector-valued coefficients in the PDEs that are being
-    discretized. This class can also be used in a more general way to
-    represent functions that don't necessarily belong to a FE space,
-    e.g., to project onto ComplexGridFunctions to use as initial
-    conditions, exact solutions, etc. See, e.g., ex22 for these
-    uses. */
-class ComplexVectorCoefficient
-{
-protected:
-   int vdim;
-   real_t time;
-
-private:
-   RealPartVectorCoefficient re_part_vcoef_;
-   ImagPartVectorCoefficient im_part_vcoef_;
-
-protected:
-   VectorCoefficient &real_vcoef_;
-   VectorCoefficient &imag_vcoef_;
-
-   mutable Vector V_r_;
-   mutable Vector V_i_;
-
-public:
-   ComplexVectorCoefficient(int vd)
-      : vdim(vd), time(0.),
-        re_part_vcoef_(*this), im_part_vcoef_(*this),
-        real_vcoef_(re_part_vcoef_), imag_vcoef_(im_part_vcoef_)
-   { }
-
-   ComplexVectorCoefficient(VectorCoefficient &v_r, VectorCoefficient &v_i);
-
-
-   /// Set the time for time dependent coefficients
-   virtual void SetTime(real_t t)
-   { time = t; real_vcoef_.SetTime(t); imag_vcoef_.SetTime(t); }
-
-   /// Get the time for time dependent coefficients
-   real_t GetTime() { return time; }
-
-   /// Returns dimension of the vector.
-   int GetVDim() { return vdim; }
-
-   /** @brief Evaluate the vector coefficient in the element described by @a T
-       at the point @a ip, storing the result in @a V. */
-   /** @note When this method is called, the caller must make sure that the
-       IntegrationPoint associated with @a T is the same as @a ip. This can be
-       achieved by calling T.SetIntPoint(&ip). */
-   virtual void Eval(ComplexVector &V, ElementTransformation &T,
-                     const IntegrationPoint &ip);
-
-   /** @brief Evaluate the vector coefficient in the element described by @a T
-       at the point @a ip at time @a t, storing the result in @a V. */
-   /** @note When this method is called, the caller must make sure that the
-       IntegrationPoint associated with @a T is the same as @a ip. This can be
-       achieved by calling T.SetIntPoint(&ip). */
-   void Eval(ComplexVector &V, ElementTransformation &T,
-             const IntegrationPoint &ip, real_t t)
-   {
-      SetTime(t);
-      Eval(V, T, ip);
-   }
-
-   /** @brief Access a standard Coefficient object reproducing the real part of
-       the complex-valued field */
-   /** @note By default this method returns an internal object which
-       computes the complex value using the above Eval method and
-       returns its real part. Custom implementations may choose to
-       override this method with a more efficient real-valued
-       coefficient. */
-   virtual VectorCoefficient & real() { return real_vcoef_; }
-
-   /** @brief Access a standard Coefficient object reproducing the imaginary
-       part of the complex-valued field */
-   /** @note By default this method returns an internal object which
-       computes the complex value using the above Eval method and
-       returns its imaginary part. Custom implementations may choose to
-       override this method with a more efficient real-valued
-       coefficient. */
-   virtual VectorCoefficient & imag() { return imag_vcoef_; }
-
-   virtual ~ComplexVectorCoefficient() { }
-};
-
-/** @brief Base class ComplexMatrixCoefficients that optionally depend
-    on space and time. These are used by the SesquilinearForm,
-    ComplexLinearForm, and ComplexGridFunction classes to represent
-    the physical matrix-valued coefficients in the PDEs that are being
-    discretized. This class can also be used in a more general way to
-    represent functions that don't necessarily belong to a FE space.
-    See, e.g., ex22 for these uses. */
-class ComplexMatrixCoefficient
-{
-protected:
-   int height, width;
-   real_t time;
-
-private:
-   RealPartMatrixCoefficient re_part_mcoef_;
-   ImagPartMatrixCoefficient im_part_mcoef_;
-
-protected:
-   MatrixCoefficient &real_mcoef_;
-   MatrixCoefficient &imag_mcoef_;
-
-   mutable DenseMatrix M_r_;
-   mutable DenseMatrix M_i_;
-
-public:
-   /// Construct a dim x dim matrix coefficient.
-   explicit ComplexMatrixCoefficient(int dim)
-      : height(dim), width(dim), time(0.),
-        re_part_mcoef_(*this), im_part_mcoef_(*this),
-        real_mcoef_(re_part_mcoef_), imag_mcoef_(im_part_mcoef_)
-   { }
-
-   /// Construct a h x w matrix coefficient.
-   ComplexMatrixCoefficient(int h, int w) :
-      height(h), width(w), time(0.),
-      re_part_mcoef_(*this), im_part_mcoef_(*this),
-      real_mcoef_(re_part_mcoef_), imag_mcoef_(im_part_mcoef_)
-   { }
-
-   /// Set the time for time dependent coefficients
-   virtual void SetTime(real_t t) { time = t; }
-
-   /// Get the time for time dependent coefficients
-   real_t GetTime() { return time; }
-
-   /// Get the height of the matrix.
-   int GetHeight() const { return height; }
-
-   /// Get the width of the matrix.
-   int GetWidth() const { return width; }
-
-   /// For backward compatibility get the width of the matrix.
-   int GetVDim() const { return width; }
-
-   /** @brief Evaluate the matrix coefficient in the element described by @a T
-       at the point @a ip, storing the result in @a K. */
-   /** @note When this method is called, the caller must make sure that the
-       IntegrationPoint associated with @a T is the same as @a ip. This can be
-       achieved by calling T.SetIntPoint(&ip). */
-   virtual void Eval(ComplexTypeDenseMatrix &K, ElementTransformation &T,
-                     const IntegrationPoint &ip) = 0;
-
-   /** @brief Access a standard Coefficient object reproducing the real part of
-       the complex-valued field */
-   /** @note By default this method returns an internal object which
-       computes the complex value using the above Eval method and
-       returns its real part. Custom implementations may choose to
-       override this method with a more efficient real-valued
-       coefficient. */
-   virtual MatrixCoefficient & real() { return real_mcoef_; }
-
-   /** @brief Access a standard Coefficient object reproducing the imaginary
-       part of the complex-valued field */
-   /** @note By default this method returns an internal object which
-       computes the complex value using the above Eval method and
-       returns its imaginary part. Custom implementations may choose to
-       override this method with a more efficient real-valued
-       coefficient. */
-   virtual MatrixCoefficient & imag() { return imag_mcoef_; }
-
-   virtual ~ComplexMatrixCoefficient() { }
-};
-
-/// A complex-valued coefficient that is constant across space and time
-class ComplexConstantCoefficient : public ComplexCoefficient
-{
-private:
-   complex_t val;
-
-   ConstantCoefficient real_coef;
-   ConstantCoefficient imag_coef;
-
-public:
-   ComplexConstantCoefficient(const complex_t z);
-
-   ComplexConstantCoefficient(real_t z_r, real_t z_i = 0.);
-
-   complex_t Eval(ElementTransformation &T,
-                  const IntegrationPoint &ip) { return val; }
-};
-
-/// Complex-valued vector coefficient that is constant in space and time.
-class ComplexVectorConstantCoefficient : public ComplexVectorCoefficient
-{
-private:
-   ComplexVector vec;
-
-public:
-   /// Construct the coefficient with constant vector @a v.
-   ComplexVectorConstantCoefficient(const ComplexVector &v)
-      : ComplexVectorCoefficient(v.Size()), vec(v) { }
-
-   /// Construct the coefficient with constant vector @a v.
-   ComplexVectorConstantCoefficient(const Vector &v)
-      : ComplexVectorCoefficient(v.Size()), vec(v) { }
-
-   using ComplexVectorCoefficient::Eval;
-
-   ///  Evaluate the vector coefficient at @a ip.
-   void Eval(ComplexVector &V, ElementTransformation &T,
-             const IntegrationPoint &ip) override { V = vec; }
-
-   /// Return a reference to the constant vector in this class.
-   const ComplexVector& GetVec() const { return vec; }
-};
-
-/// Complex-valued vector coefficient that is constant in space and time.
-class ComplexMatrixConstantCoefficient : public ComplexMatrixCoefficient
-{
-private:
-   ComplexTypeDenseMatrix mat;
-
-public:
-   /// Construct the coefficient with constant vector @a v.
-   ComplexMatrixConstantCoefficient(const ComplexTypeDenseMatrix &m)
-      : ComplexMatrixCoefficient(m.Height(), m.Width()), mat(m) { }
-
-   /// Construct the coefficient with constant vector @a v.
-   ComplexMatrixConstantCoefficient(const DenseMatrix &m)
-      : ComplexMatrixCoefficient(m.Height(), m.Width()), mat(m) { }
-
-   using ComplexMatrixCoefficient::Eval;
-
-   ///  Evaluate the matrix coefficient at @a ip.
-   void Eval(ComplexTypeDenseMatrix &M, ElementTransformation &T,
-             const IntegrationPoint &ip) override { M = mat; }
-
-   /// Return a reference to the constant matrix in this class.
-   const ComplexTypeDenseMatrix& GetMat() const { return mat; }
-};
-
-/// A general complex-valued function coefficient
-class ComplexFunctionCoefficient : public ComplexCoefficient
-{
-protected:
-   std::function<complex_t(const Vector &)> Function;
-   std::function<complex_t(const Vector &, real_t)> TDFunction;
-
-public:
-   /// Define a time-independent coefficient from a std function
-   /** \param F time-independent std::function */
-   ComplexFunctionCoefficient(std::function<complex_t
-                              (const Vector &)> F)
-      : Function(std::move(F))
-   { }
-
-   /// Define a time-dependent coefficient from a std function
-   /** \param TDF time-dependent function */
-   ComplexFunctionCoefficient(std::function<complex_t
-                              (const Vector &, real_t)> TDF)
-      : TDFunction(std::move(TDF))
-   { }
-
-   /// (DEPRECATED) Define a time-independent coefficient from a C-function
-   /** @deprecated Use the method where the C-function, @a f, uses a const
-       Vector argument instead of Vector. */
-   MFEM_DEPRECATED ComplexFunctionCoefficient(complex_t
-                                              (*f)(Vector &))
-   {
-      // Cast first to (void*) to suppress a warning from newer version of
-      // Clang when using -Wextra.
-      Function = reinterpret_cast<complex_t(*)
-                 (const Vector&)>((void*)f);
-      TDFunction = NULL;
-   }
-
-   /// (DEPRECATED) Define a time-dependent coefficient from a C-function
-   /** @deprecated Use the method where the C-function, @a tdf, uses a const
-       Vector argument instead of Vector. */
-   MFEM_DEPRECATED ComplexFunctionCoefficient(complex_t
-                                              (*tdf)(Vector &, real_t))
-   {
-      Function = NULL;
-      // Cast first to (void*) to suppress a warning from newer version of
-      // Clang when using -Wextra.
-      TDFunction =
-         reinterpret_cast<complex_t(*)(const Vector&,
-                                       real_t)>((void*)tdf);
-   }
-
-   /// Evaluate the coefficient at @a ip.
-   complex_t Eval(ElementTransformation &T,
-                  const IntegrationPoint &ip) override;
-};
-
-/// A general vector function coefficient
-class ComplexVectorFunctionCoefficient : public ComplexVectorCoefficient
-{
-private:
-   std::function<void(const Vector &, ComplexVector &)> Function;
-   std::function<void(const Vector &, real_t, ComplexVector &)> TDFunction;
-   ComplexCoefficient *Q;
-
-public:
-   /// Define a time-independent complex-valued vector coefficient
-   /// from a std function
-   /** \param dim - the size of the vector
-       \param F - time-independent function
-       \param q - optional scalar Coefficient to scale the vector coefficient */
-   ComplexVectorFunctionCoefficient(int dim,
-                                    std::function<void(const Vector &,
-                                                       ComplexVector &)> F,
-                                    ComplexCoefficient *q = nullptr)
-      : ComplexVectorCoefficient(dim), Function(std::move(F)), Q(q)
-   { }
-
-   /// Define a time-dependent complex-valued vector coefficient from
-   /// a std function
-   /** \param dim - the size of the vector
-       \param TDF - time-dependent function
-       \param q - optional scalar ComplexCoefficient to scale the vector coefficient */
-   ComplexVectorFunctionCoefficient(int dim,
-                                    std::function<void(const Vector &, real_t,
-                                                       ComplexVector &)> TDF,
-                                    ComplexCoefficient *q = nullptr)
-      : ComplexVectorCoefficient(dim), TDFunction(std::move(TDF)), Q(q)
-   { }
-
-   using ComplexVectorCoefficient::Eval;
-   /// Evaluate the vector coefficient at @a ip.
-   void Eval(ComplexVector &V, ElementTransformation &T,
-             const IntegrationPoint &ip) override;
-
-   virtual ~ComplexVectorFunctionCoefficient() { }
-};
-
-} // end namespace mfem
-
-#endif
@@ -96,23 +96,6 @@ ComplexGridFunction::ProjectCoefficient(Coefficient &real_coeff,
   gfi->SyncAliasMemory(*this);
 }

-void
-ComplexGridFunction::ProjectCoefficient(Coefficient &real_coeff)
-{
-   gfr->SyncMemory(*this);
-   gfi->SyncMemory(*this);
-   gfr->ProjectCoefficient(real_coeff);
-   *gfi = 0.0;
-   gfr->SyncAliasMemory(*this);
-   gfi->SyncAliasMemory(*this);
-}
-
-void
-ComplexGridFunction::ProjectCoefficient(ComplexCoefficient &coeff)
-{
-   this->ProjectCoefficient(coeff.real(), coeff.imag());
-}
-
 void
 ComplexGridFunction::ProjectCoefficient(VectorCoefficient &real_vcoeff,
                                        VectorCoefficient &imag_vcoeff)
@@ -125,23 +108,6 @@ ComplexGridFunction::ProjectCoefficient(VectorCoefficient &real_vcoeff,
   gfi->SyncAliasMemory(*this);
 }

-void
-ComplexGridFunction::ProjectCoefficient(VectorCoefficient &real_vcoeff)
-{
-   gfr->SyncMemory(*this);
-   gfi->SyncMemory(*this);
-   gfr->ProjectCoefficient(real_vcoeff);
-   *gfi = 0.0;
-   gfr->SyncAliasMemory(*this);
-   gfi->SyncAliasMemory(*this);
-}
-
-void
-ComplexGridFunction::ProjectCoefficient(ComplexVectorCoefficient &vcoeff)
-{
-   this->ProjectCoefficient(vcoeff.real(), vcoeff.imag());
-}
-
 void
 ComplexGridFunction::ProjectBdrCoefficient(Coefficient &real_coeff,
                                           Coefficient &imag_coeff,
@@ -155,26 +121,6 @@ ComplexGridFunction::ProjectBdrCoefficient(Coefficient &real_coeff,
   gfi->SyncAliasMemory(*this);
 }

-void
-ComplexGridFunction::ProjectBdrCoefficient(Coefficient &real_coeff,
-                                           Array<int> &attr)
-{
-   ConstantCoefficient zero_coeff(0.0);
-   gfr->SyncMemory(*this);
-   gfi->SyncMemory(*this);
-   gfr->ProjectBdrCoefficient(real_coeff, attr);
-   gfi->ProjectBdrCoefficient(zero_coeff, attr);
-   gfr->SyncAliasMemory(*this);
-   gfi->SyncAliasMemory(*this);
-}
-
-void
-ComplexGridFunction::ProjectBdrCoefficient(ComplexCoefficient &coeff,
-                                           Array<int> &attr)
-{
-   this->ProjectBdrCoefficient(coeff.real(), coeff.imag(), attr);
-}
-
 void
 ComplexGridFunction::ProjectBdrCoefficientNormal(VectorCoefficient &real_vcoeff,
                                                 VectorCoefficient &imag_vcoeff,
@@ -188,28 +134,6 @@ ComplexGridFunction::ProjectBdrCoefficientNormal(VectorCoefficient &real_vcoeff,
   gfi->SyncAliasMemory(*this);
 }

-void
-ComplexGridFunction::ProjectBdrCoefficientNormal(VectorCoefficient &real_vcoeff,
-                                                 Array<int> &attr)
-{
-   Vector zero_vec(real_vcoeff.GetVDim()); zero_vec = 0.;
-   VectorConstantCoefficient zero_vcoeff(zero_vec);
-   gfr->SyncMemory(*this);
-   gfi->SyncMemory(*this);
-   gfr->ProjectBdrCoefficientNormal(real_vcoeff, attr);
-   gfi->ProjectBdrCoefficientNormal(zero_vcoeff, attr);
-   gfr->SyncAliasMemory(*this);
-   gfi->SyncAliasMemory(*this);
-}
-
-void
-ComplexGridFunction::ProjectBdrCoefficientNormal(
-   ComplexVectorCoefficient &vcoeff,
-   Array<int> &attr)
-{
-   this->ProjectBdrCoefficientNormal(vcoeff.real(), vcoeff.imag(), attr);
-}
-
 void
 ComplexGridFunction::ProjectBdrCoefficientTangent(VectorCoefficient
                                                  &real_vcoeff,
@@ -225,80 +149,6 @@ ComplexGridFunction::ProjectBdrCoefficientTangent(VectorCoefficient
   gfi->SyncAliasMemory(*this);
 }

-void
-ComplexGridFunction::ProjectBdrCoefficientTangent(VectorCoefficient
-                                                  &real_vcoeff,
-                                                  Array<int> &attr)
-{
-   Vector zero_vec(real_vcoeff.GetVDim()); zero_vec = 0.;
-   VectorConstantCoefficient zero_vcoeff(zero_vec);
-   gfr->SyncMemory(*this);
-   gfi->SyncMemory(*this);
-   gfr->ProjectBdrCoefficientTangent(real_vcoeff, attr);
-   gfi->ProjectBdrCoefficientTangent(zero_vcoeff, attr);
-   gfr->SyncAliasMemory(*this);
-   gfi->SyncAliasMemory(*this);
-}
-
-void
-ComplexGridFunction::ProjectBdrCoefficientTangent(
-   ComplexVectorCoefficient &vcoeff,
-   Array<int> &attr)
-{
-   this->ProjectBdrCoefficientTangent(vcoeff.real(), vcoeff.imag(), attr);
-}
-
-real_t
-ComplexGridFunction::ComputeL2Error(Coefficient &re_exsol,
-                                    Coefficient &im_exsol,
-                                    const IntegrationRule *irs[],
-                                    const Array<int> *elems) const
-{
-   real_t err_r = gfr->ComputeL2Error(re_exsol, irs, elems);
-   real_t err_i = gfi->ComputeL2Error(im_exsol, irs, elems);
-
-   return sqrt(err_r * err_r + err_i * err_i);
-}
-
-real_t
-ComplexGridFunction::ComputeL2Error(Coefficient &re_exsol,
-                                    const IntegrationRule *irs[],
-                                    const Array<int> *elems) const
-{
-   ConstantCoefficient zero_coef(0.0);
-
-   real_t err_r = gfr->ComputeL2Error(re_exsol, irs, elems);
-   real_t err_i = gfi->ComputeL2Error(zero_coef, irs, elems);
-
-   return sqrt(err_r * err_r + err_i * err_i);
-}
-
-real_t
-ComplexGridFunction::ComputeL2Error(VectorCoefficient &re_exsol,
-                                    VectorCoefficient &im_exsol,
-                                    const IntegrationRule *irs[],
-                                    const Array<int> *elems) const
-{
-   real_t err_r = gfr->ComputeL2Error(re_exsol, irs, elems);
-   real_t err_i = gfi->ComputeL2Error(im_exsol, irs, elems);
-
-   return sqrt(err_r * err_r + err_i * err_i);
-}
-
-real_t
-ComplexGridFunction::ComputeL2Error(VectorCoefficient &re_exsol,
-                                    const IntegrationRule *irs[],
-                                    const Array<int> *elems) const
-{
-   Vector zero_vec(re_exsol.GetVDim()); zero_vec = 0.0;
-   VectorConstantCoefficient zero_coef(zero_vec);
-
-   real_t err_r = gfr->ComputeL2Error(re_exsol, irs, elems);
-   real_t err_i = gfi->ComputeL2Error(zero_coef, irs, elems);
-
-   return sqrt(err_r * err_r + err_i * err_i);
-}
-

 ComplexLinearForm::ComplexLinearForm(FiniteElementSpace *fes,
                                     ComplexOperator::Convention convention)
@@ -637,7 +487,7 @@ SesquilinearForm::FormLinearSystem(const Array<int> &ess_tdof_list,

   if (RealInteg() && ImagInteg())
   {
-      // Modify RHS and off-diagonal blocks (imaginary parts of the matrix) to
+      // Modify RHS and offdiagonal blocks (imaginary parts of the matrix) to
      // conform with standard essential BC treatment
      if (A_i.Is<ConstrainedOperator>())
      {
@@ -726,7 +576,7 @@ SesquilinearForm::FormSystemMatrix(const Array<int> &ess_tdof_list,

   if (RealInteg() && ImagInteg())
   {
-      // Modify off-diagonal blocks (imaginary parts of the matrix) to conform
+      // Modify offdiagonal blocks (imaginary parts of the matrix) to conform
      // with standard essential BC treatment
      if (A_i.Is<ConstrainedOperator>())
      {
@@ -881,17 +731,6 @@ ParComplexGridFunction::ProjectCoefficient(Coefficient &real_coeff,
   pgfi->SyncAliasMemory(*this);
 }

-void
-ParComplexGridFunction::ProjectCoefficient(Coefficient &real_coeff)
-{
-   pgfr->SyncMemory(*this);
-   pgfi->SyncMemory(*this);
-   pgfr->ProjectCoefficient(real_coeff);
-   *pgfi = 0.0;
-   pgfr->SyncAliasMemory(*this);
-   pgfi->SyncAliasMemory(*this);
-}
-
 void
 ParComplexGridFunction::ProjectCoefficient(VectorCoefficient &real_vcoeff,
                                           VectorCoefficient &imag_vcoeff)
@@ -904,17 +743,6 @@ ParComplexGridFunction::ProjectCoefficient(VectorCoefficient &real_vcoeff,
   pgfi->SyncAliasMemory(*this);
 }

-void
-ParComplexGridFunction::ProjectCoefficient(VectorCoefficient &real_vcoeff)
-{
-   pgfr->SyncMemory(*this);
-   pgfi->SyncMemory(*this);
-   pgfr->ProjectCoefficient(real_vcoeff);
-   *pgfi = 0.0;
-   pgfr->SyncAliasMemory(*this);
-   pgfi->SyncAliasMemory(*this);
-}
-
 void
 ParComplexGridFunction::ProjectBdrCoefficient(Coefficient &real_coeff,
                                              Coefficient &imag_coeff,
@@ -928,19 +756,6 @@ ParComplexGridFunction::ProjectBdrCoefficient(Coefficient &real_coeff,
   pgfi->SyncAliasMemory(*this);
 }

-void
-ParComplexGridFunction::ProjectBdrCoefficient(Coefficient &real_coeff,
-                                              Array<int> &attr)
-{
-   ConstantCoefficient zero_coeff(0.0);
-   pgfr->SyncMemory(*this);
-   pgfi->SyncMemory(*this);
-   pgfr->ProjectBdrCoefficient(real_coeff, attr);
-   pgfi->ProjectBdrCoefficient(zero_coeff, attr);
-   pgfr->SyncAliasMemory(*this);
-   pgfi->SyncAliasMemory(*this);
-}
-
 void
 ParComplexGridFunction::ProjectBdrCoefficientNormal(VectorCoefficient
                                                    &real_vcoeff,
@@ -956,21 +771,6 @@ ParComplexGridFunction::ProjectBdrCoefficientNormal(VectorCoefficient
   pgfi->SyncAliasMemory(*this);
 }

-void
-ParComplexGridFunction::ProjectBdrCoefficientNormal(VectorCoefficient
-                                                    &real_vcoeff,
-                                                    Array<int> &attr)
-{
-   Vector zero_vec(real_vcoeff.GetVDim()); zero_vec = 0.;
-   VectorConstantCoefficient zero_vcoeff(zero_vec);
-   pgfr->SyncMemory(*this);
-   pgfi->SyncMemory(*this);
-   pgfr->ProjectBdrCoefficientNormal(real_vcoeff, attr);
-   pgfi->ProjectBdrCoefficientNormal(zero_vcoeff, attr);
-   pgfr->SyncAliasMemory(*this);
-   pgfi->SyncAliasMemory(*this);
-}
-
 void
 ParComplexGridFunction::ProjectBdrCoefficientTangent(VectorCoefficient
                                                     &real_vcoeff,
@@ -986,21 +786,6 @@ ParComplexGridFunction::ProjectBdrCoefficientTangent(VectorCoefficient
   pgfi->SyncAliasMemory(*this);
 }

-void
-ParComplexGridFunction::ProjectBdrCoefficientTangent(VectorCoefficient
-                                                     &real_vcoeff,
-                                                     Array<int> &attr)
-{
-   Vector zero_vec(real_vcoeff.GetVDim()); zero_vec = 0.;
-   VectorConstantCoefficient zero_vcoeff(zero_vec);
-   pgfr->SyncMemory(*this);
-   pgfi->SyncMemory(*this);
-   pgfr->ProjectBdrCoefficientTangent(real_vcoeff, attr);
-   pgfi->ProjectBdrCoefficientTangent(zero_vcoeff, attr);
-   pgfr->SyncAliasMemory(*this);
-   pgfi->SyncAliasMemory(*this);
-}
-
 void
 ParComplexGridFunction::Distribute(const Vector *tv)
 {
@@ -1040,31 +825,6 @@ ParComplexGridFunction::ParallelProject(Vector &tv) const
   tvi.SyncAliasMemory(tv);
 }

-real_t
-ParComplexGridFunction::ComputeL2Error(Coefficient &exsolr,
-                                       const IntegrationRule *irs[],
-                                       Array<int> *elems) const
-{
-   ConstantCoefficient zeroCoef(0.0);
-
-   real_t err_r = pgfr->ComputeL2Error(exsolr, irs, elems);
-   real_t err_i = pgfi->ComputeL2Error(zeroCoef, irs, elems);
-   return sqrt(err_r * err_r + err_i * err_i);
-}
-
-real_t
-ParComplexGridFunction::ComputeL2Error(VectorCoefficient &exsolr,
-                                       const IntegrationRule *irs[],
-                                       Array<int> *elems) const
-{
-   Vector zeroVec(exsolr.GetVDim()); zeroVec = 0.0;
-   VectorConstantCoefficient zeroCoef(zeroVec);
-
-   real_t err_r = pgfr->ComputeL2Error(exsolr, irs, elems);
-   real_t err_i = pgfi->ComputeL2Error(zeroCoef, irs, elems);
-   return sqrt(err_r * err_r + err_i * err_i);
-}
-

 ParComplexLinearForm::ParComplexLinearForm(ParFiniteElementSpace *pfes,
                                           ComplexOperator::Convention
@@ -1476,7 +1236,7 @@ ParSesquilinearForm::FormLinearSystem(const Array<int> &ess_tdof_list,
         d_B_r[j] = d_X_r[j];
         d_B_i[j] = d_X_i[j];
      });
-      // Modify off-diagonal blocks (imaginary parts of the matrix) to conform
+      // Modify offdiagonal blocks (imaginary parts of the matrix) to conform
      // with standard essential BC treatment
      if (A_i.Type() == Operator::Hypre_ParCSR)
      {
@@ -1564,7 +1324,7 @@ ParSesquilinearForm::FormSystemMatrix(const Array<int> &ess_tdof_list,

   if (RealInteg() && ImagInteg())
   {
-      // Modify off-diagonal blocks (imaginary parts of the matrix) to conform
+      // Modify offdiagonal blocks (imaginary parts of the matrix) to conform
      // with standard essential BC treatment
      if ( A_i.Type() == Operator::Hypre_ParCSR )
      {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Stowell, Mark L.	ef5f729245	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev # Conflicts: # fem/bilininteg.hpp # fem/coefficient.cpp # fem/coefficient.hpp # linalg/hypre.cpp # linalg/hypre.hpp # linalg/solvers.cpp # makefile # miniapps/common/pfem_extras.hpp # miniapps/electromagnetics/tesla_solver.hpp	2025-03-13 17:43:24 -07:00
Stowell, Mark L	6fa5a0b096	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev # Conflicts: # fem/coefficient.cpp # fem/coefficient.hpp	2019-04-01 11:27:41 -07:00
Stowell, Mark L	3bd8349909	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev	2018-11-08 18:00:03 -08:00
Stowell, Mark L	af82ee8560	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev	2018-10-20 12:18:07 -07:00
Stowell, Mark L	2ac542c720	Attempting to support 2D curl cleaning	2018-10-20 12:17:00 -07:00
Mark L. Stowell	e6f828a5fe	Attempting to add curl free projection...	2018-10-18 13:07:44 -07:00
Mark L. Stowell	4d756edd80	Adding DivergenceFree/Irrotational projectors for RT spaces	2018-10-18 10:29:50 -07:00
Stowell, Mark L	cf5bd1f5cc	make style	2018-10-18 00:17:32 -07:00
Stowell, Mark L	7173dd2002	Adding H1 diffusion solver	2018-10-18 00:16:56 -07:00
Stowell, Mark L	50182bf440	Adding perturbed elliptic case	2018-10-17 19:51:12 -07:00
Stowell, Mark L	24bfcc5165	Initializing a solution vector before solve	2018-10-17 10:20:38 -07:00
Stowell, Mark L	302f22f297	Switching to analytic evaluation of b vector field	2018-10-16 15:34:29 -07:00
Stowell, Mark L	1637fcd933	Adding argument to control lower bound of mesh size	2018-10-16 13:13:56 -07:00
Stowell, Mark L	2563506174	make style	2018-10-14 16:14:31 -07:00
Stowell, Mark L	60640c3f7e	Adding computation of full thermal flux	2018-10-14 10:39:39 -07:00
Stowell, Mark L	f221521203	make style	2018-10-14 10:12:37 -07:00
Stowell, Mark L	1d9e736af6	Adding a miniapp which solve for thermal flux in HDiv	2018-10-14 10:10:55 -07:00
Stowell, Mark L	d80dbfd99a	Adding flux computation	2018-10-10 16:46:17 -07:00
Stowell, Mark L	3f44043e60	Adding steady state anisotropic diffusion solver	2018-10-10 12:48:07 -07:00
Stowell, Mark L	b218959bca	Inserting the thermal flux solver	2018-10-03 10:33:45 -07:00
Stowell, Mark L	aee7bc9d43	Adding first draft of hybrid diffusion solver	2018-10-01 16:14:53 -07:00
Stowell, Mark L	31cac320d4	Bugfix in activation of nonlinear solver	2018-10-01 15:08:15 -07:00
Stowell, Mark L	e7e0fb0a88	Adding a specialized miniapp to duplicate results from the van Es papper	2018-09-30 21:47:54 -07:00
Stowell, Mark L	ba71d13980	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev	2018-09-25 13:04:15 -07:00
Stowell, Mark L	5c326a5535	Fixing a typo in a comment	2018-09-25 13:02:39 -07:00
Stowell, Mark L	9457f7e5b6	Switching to nonlinear solver	2018-09-24 15:45:49 -07:00
Stowell, Mark L	ff030ee970	Adding another time dependent test case	2018-09-24 12:45:36 -07:00
Stowell, Mark L	2be9e1f36c	Adding a steady state solver to the thermal miniapps	2018-09-24 12:45:03 -07:00
Stowell, Mark L	7671cd9f36	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev	2018-09-16 13:17:34 -07:00
Stowell, Mark L	f89a633fda	make style	2018-09-14 14:41:13 -07:00
Stowell, Mark L	4ce1cef6b8	Adding SetOperator methods to HyprePCG, HypreGMRES, HypreDiagScale, and HypreParaSails	2018-09-14 14:34:13 -07:00
Stowell, Mark L	c667bf3025	Fixing HypreGMRES::SetOperator method in the presence of a preconditioner	2018-09-14 13:47:29 -07:00
Stowell, Mark L	e1678afe40	Using new HypreGMRES with SetOperator method	2018-09-10 16:46:25 -07:00
Stowell, Mark L	c0291398ed	Implementing HypreGMRES::SetOperator method	2018-09-10 16:45:59 -07:00
Stowell, Mark L	0b4f10d79d	Debugging gradient check	2018-09-09 16:29:15 -07:00
Stowell, Mark L	8dfd0e1547	Adding NewtonSolver method to validate gradient	2018-09-09 16:28:18 -07:00
Stowell, Mark L	caf239c99a	Updating with time dependent source and exact solution	2018-09-09 00:39:58 -07:00
Stowell, Mark L	44c33aece0	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev	2018-09-08 23:59:16 -07:00
Stowell, Mark L	ed49856390	Merge branch 'aniso-diffusion-dev' of github.com:mfem/mfem into aniso-diffusion-dev	2018-09-06 14:13:18 -07:00
Stowell, Mark L	4fef6ca298	make style	2018-09-06 14:12:28 -07:00
Stowell, Mark L	d9d809e81c	Adding "thermal" to miniapps subdirectories	2018-09-06 14:12:16 -07:00
Stowell, Mark L	51e85ccd84	Fixing nonlinear solve and applying 'make style'	2018-09-06 14:11:54 -07:00
Mark L. Stowell	4304159303	Merge branch 'aniso-diffusion-dev' of github.com:mfem/mfem into aniso-diffusion-dev	2018-09-05 16:56:05 -07:00
Stowell, Mark L	6276268e52	Retain zeros to maintain sparsity pattern	2018-09-05 16:54:59 -07:00
Mark L. Stowell	580ae34842	Retaining zeros to maintain sparsity pattern	2018-09-05 16:51:10 -07:00
Stowell, Mark L	97eaf8efbc	Parallelizing the linear solves	2018-09-05 15:48:28 -07:00
Stowell, Mark L	e6621c9b0c	Parallel bug	2018-09-05 15:25:18 -07:00
Stowell, Mark L	461246f80e	Adding a missing overload	2018-09-05 13:29:10 -07:00
Stowell, Mark L	a5941ee72f	Bugfix: reinitializing matrices before reassembling	2018-09-05 11:10:09 -07:00
Stowell, Mark L	c4c2ceab59	Linear case now working	2018-09-05 10:15:17 -07:00
Stowell, Mark L	88b99a1719	Fixing vector dimension in vector grid functions	2018-09-05 10:14:52 -07:00
Stowell, Mark L	7aa7b4ee53	Adjusting initialization order so that vector size is known earlier	2018-09-03 11:19:27 -07:00
Stowell, Mark L	bcf87fee29	Modifying VectorGridFunctionCoefs to accept NULL pointers	2018-09-03 11:06:32 -07:00
Stowell, Mark L	2949dc5a46	Adding makefile for miniapps/thermal	2018-09-03 10:48:11 -07:00
Stowell, Mark L	b0dbadd007	Adding first draft of non-linear thermal diffusion solver	2018-09-03 10:19:34 -07:00
Stowell, Mark L	6ca1f95979	Adding scalar multiplication by a constant	2018-08-31 22:54:36 -07:00
Stowell, Mark L	39794585c4	Adding an Identity Matrix Coefficient	2018-08-31 16:50:02 -07:00
Stowell, Mark L	65a71259f1	Merge remote-tracking branch 'origin/elementwise-error-dev' into aniso-diffusion-dev	2018-08-31 16:49:37 -07:00
Stowell, Mark L	3f4e8324d4	Adding a coefficient which computes a unit vector field from a vector field	2018-08-29 14:26:29 -07:00
Stowell, Mark L	9fca398741	Adding ability to alter derived coefficients	2018-08-29 13:59:38 -07:00
Stowell, Mark L	a2b8f7a129	Merge remote-tracking branch 'origin/master' into aniso-diffusion-dev	2018-08-29 09:28:15 -07:00
Stowell, Mark L	a367631ce5	Adding various coefficients which are sums or products of other coefficients	2018-08-28 16:34:13 -07:00
Stowell, Mark L	d7718f5c57	make style	2018-08-28 14:51:48 -07:00
Stowell, Mark L	fe88c4685d	Adding coefficients to compute div, grad, or curl of grid functions.	2018-08-28 14:24:15 -07:00