remove print

add derivative call

commit to check compatibility on CI

dual type for non enzyme ci

change dependent variable

add dual transformation

back to non generic lambda for nvcc

check constexpr mechanism with CI

testing out lambda-less approach

cleanup

Revert "testing out lambda-less approach"

This reverts commit 6808fe0693c2589abf3c0c929e0a10b9a5050d4d.

# Conflicts:
#	tests/unit/dfem/test_functional.cpp

simpler approach

.github/actions/sanitize/config/action.yml

@@ -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

.github/actions/sanitize/mfem/action.yml

@@ -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

.github/actions/sanitize/mpi/action.yml

@@ -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

.github/actions/sanitize/restore/action.yml

@@ -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

.github/actions/sanitize/setup/action.yml

@@ -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}}

.github/workflows/README.md

@@ -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.

.github/workflows/builds-and-tests.yml

@@ -132,14 +132,12 @@ jobs:
             hypre-target: int32
             precision: fp64
             enzyme: true
-            config-opts: MFEM_USE_ENZYME=YES ENZYME_DIR=$(brew --prefix enzyme) LDFLAGS=-L$LLVM_PREFIX/lib/c++
+            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' || '' }}
 
     runs-on: ${{ matrix.os }}
 
-    continue-on-error: ${{ matrix.enzyme && true || false }}
-
     steps:
       # Fix 'No space left on device' errors for Ubuntu builds.
       - name: Run Actions Cleaner
@@ -170,13 +168,10 @@ jobs:
           env
         shell: bash
 
-      # For info on Xcode see:
-      #  - https://github.com/actions/runner-images/issues/12541
-      #  - https://github.com/actions/runner-images/blob/releases/macos-15-arm64/20250811/images/macos/macos-15-arm64-Readme.md#xcode
       - name: Xcode version setup (MacOS)
         if: matrix.os == 'macos-latest'
         run: |
-          XCODE_PATH="/Applications/Xcode_16.4.app"
+          XCODE_PATH="/Applications/Xcode_15.3.app"
           echo "> sudo xcode-select -s ${XCODE_PATH}"
           sudo xcode-select -s ${XCODE_PATH}
           echo "> g++ -v"
@@ -294,12 +289,10 @@ jobs:
         run: |
           export HOMEBREW_NO_INSTALL_CLEANUP=1
           brew update
-          brew install enzyme
-          ENZYME_LLVM=$(brew info enzyme | sed -n 's/^Required:.*\(llvm[^ ]*\).*/\1/p')
-          LLVM_PREFIX=$(brew --prefix $ENZYME_LLVM)
-          echo "LLVM_PREFIX=$LLVM_PREFIX" >> $GITHUB_ENV
-          echo "OMPI_CC=$LLVM_PREFIX/bin/clang" >> $GITHUB_ENV
-          echo "OMPI_CXX=$LLVM_PREFIX/bin/clang++" >> $GITHUB_ENV
+          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

.github/workflows/mfem-sanitizer.yml

@@ -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++17
+                      -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

.github/workflows/sanitize-build-hypre.yml

@@ -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

.github/workflows/sanitize-build-libcxx.yml

@@ -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

.github/workflows/sanitize-build-lsan.yml

@@ -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

.github/workflows/sanitize-build-metis.yml

@@ -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}}

.github/workflows/sanitize-tests.yml

@@ -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}}"

.github/workflows/sanitizers.yml

@@ -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

.github/workflows/stale.yml

@@ -29,47 +29,3 @@ jobs:
         operations-per-run: 500
         exempt-issue-labels: "bug,WIP,ready-for-review,in-review,in-next"
         exempt-pr-labels: "bug,WIP,ready-for-review,in-review,in-next"
-
-  # Stale action for PRs with "in-review" label.
-  stale-in-review-pr:
-
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-      actions: write
-
-    steps:
-    - uses: actions/stale@v9
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-pr-message: ':warning: This PR has been automatically marked as stale because it has not had any activity in the last 150 days. *If no activity occurs in the next 30 days, it will be automatically closed.* Thank you for your contributions.'
-        only-pr-labels: "in-review"
-        days-before-pr-stale: 150
-        days-before-pr-close: 30
-        days-before-issue-stale: -1
-        days-before-issue-close: -1
-        stale-pr-label: 'stale'
-        operations-per-run: 500
-
-  # Stale action for PRs with "WIP" label.
-  stale-wip-pr:
-
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-      actions: write
-
-    steps:
-    - uses: actions/stale@v9
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-pr-message: ':warning: This PR has been automatically marked as stale because it has not had any activity in the last 300 days. *If no activity occurs in the next 30 days, it will be automatically closed.* Thank you for your contributions.'
-        only-pr-labels: "WIP"
-        days-before-pr-stale: 300
-        days-before-pr-close: 30
-        days-before-issue-stale: -1
-        days-before-issue-close: -1
-        stale-pr-label: 'stale'
-        operations-per-run: 500

.gitignore

@@ -208,13 +208,10 @@ miniapps/electromagnetics/volta
 miniapps/electromagnetics/tesla
 miniapps/electromagnetics/maxwell
 miniapps/electromagnetics/joule
-miniapps/electromagnetics/lorentz
 miniapps/electromagnetics/Volta-AMR*
 miniapps/electromagnetics/Tesla-AMR*
 miniapps/electromagnetics/Maxwell-Parallel*
-miniapps/electromagnetics/Joule_[0-9]*
-miniapps/electromagnetics/Lorentz_[0-9]*
-miniapps/electromagnetics/Lorentz.dat
+miniapps/electromagnetics/Joule_*
 
 miniapps/gslib/field-diff
 miniapps/gslib/field-interp
@@ -235,7 +232,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
@@ -266,13 +262,11 @@ 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/*
+miniapps/mtop/ParHeat*
 miniapps/mtop/seqheat
-miniapps/mtop/SeqHeat/*
+miniapps/mtop/SeqHeat*
 
 miniapps/autodiff/paradiff
 miniapps/autodiff/seqadiff
@@ -280,7 +274,7 @@ miniapps/autodiff/seqtest
 miniapps/autodiff/par_example
 miniapps/autodiff/seq_example
 miniapps/autodiff/seq_test
-miniapps/autodiff/Example/*
+miniapps/autodiff/Exampl*
 
 miniapps/navier/navier_mms
 miniapps/navier/navier_kovasznay
@@ -303,7 +297,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
@@ -322,7 +315,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
@@ -344,7 +336,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
@@ -411,15 +402,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_*

.gitlab-ci.yml

@@ -22,7 +22,7 @@ include:
 # the "needs" keyword and express the DAG of jobs for more efficiency.
 # - We use setup and setup_baseline phases to download content outside of mfem
 #   directory.
-# - Allocate/Release is where Dane resource are allocated/released once for all.
+# - Allocate/Release is where ruby resource are allocated/released once for all.
 # - Build and Test is where we build and MFEM for multiple toolchains.
 # - Baseline_checks gathers baseline-type test suites execution
 # - Baseline_publish, only available on master, allows to update baseline
@@ -53,7 +53,7 @@ variables:
   AUTOTEST_COMMIT: "YES"
 
 # Trigger subpipelines:
-dane-build-and-test:
+ruby-build-and-test:
   stage: sub-pipelines
   variables:
     # Explicitly pass down values that we want to be able to set when triggering
@@ -61,10 +61,10 @@ dane-build-and-test:
     AUTOTEST: "${AUTOTEST}"
     AUTOTEST_COMMIT: "${AUTOTEST_COMMIT}"
   trigger:
-    include: .gitlab/dane-build-and-test.yml
+    include: .gitlab/ruby-build-and-test.yml
     strategy: depend
 
-dane-baseline:
+ruby-baseline:
   stage: sub-pipelines
   variables:
     # Explicitly pass down values that we want to be able to set when triggering
@@ -73,7 +73,7 @@ dane-baseline:
     AUTOTEST: "${AUTOTEST}"
     AUTOTEST_COMMIT: "${AUTOTEST_COMMIT}"
   trigger:
-    include: .gitlab/dane-baseline.yml
+    include: .gitlab/ruby-baseline.yml
     strategy: depend
 
 lassen-build-and-test:

.gitlab/README.md

@@ -24,7 +24,7 @@ and `test type`.
 
 Machines typically include:
 
-* Dane: Intel Sapphire Rapids
+* Ruby: 2nd Gen Intel Xeon (Cascade Lake)
 * Lassen: Power9 + Nvidia GPU
 * Corona: AMD GPU
 
@@ -76,13 +76,13 @@ with a spack spec of MFEM, within the limits permitted by the MFEM spack
 package.
 
 In any build-and-test sub-pipeline a job basically consists in defining the
-spack spec to use. Adding a job on Dane for example resumes to:
+spack spec to use. Adding a job on ruby for example resumes to:
 
 ```yaml
 <job_name>:
   variables:
     SPEC: "<spack_spec>"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 ```
 
 The remaining and non trivial work is to make sure this spec is working. To

.gitlab/configs/common.yml

@@ -24,7 +24,7 @@ variables:
 # TODO: add a clean-up mechanism
   BUILD_ROOT: ${USER_CI_TOP_DIR}/${CI_PROJECT_NAME}-${MACHINE_NAME}-pipeline-${CI_PIPELINE_ID}
 
-# On LLNL's Dane, there is only one allocation shared among jobs in order to
+# On LLNL's ruby, there is only one allocation shared among jobs in order to
 # save time and resource. This allocation has to be uniquely named so that we
 # are sure to retrieve it.
   ALLOC_NAME: ${CI_PROJECT_NAME}_ci_${CI_PIPELINE_ID}

.gitlab/configs/ruby-config.yml

@@ -9,17 +9,17 @@
 # terms of the BSD-3 license. We welcome feedback and contributions, see file
 # CONTRIBUTING.md for details.
 
-# GitLab pipelines configurations for the Dane machine at LLNL
+# GitLab pipelines configurations for the Ruby machine at LLNL
 variables:
-  MACHINE_NAME: dane
+  MACHINE_NAME: ruby
 
-.on_dane:
+.on_ruby:
   tags:
     - shell
-    - dane
+    - ruby
   rules:
-    # Don't run dane jobs if...
-    - if: '$CI_COMMIT_BRANCH =~ /_qnone/ || $ON_DANE == "OFF"'
+    # Don't run ruby jobs if...
+    - if: '$CI_COMMIT_BRANCH =~ /_qnone/ || $ON_RUBY == "OFF"'
       when: never
     # Don't run autotest update if...
     - if: '$CI_JOB_NAME =~ /report/ && $AUTOTEST != "YES"'
@@ -40,17 +40,16 @@ variables:
     - when: on_success
 
 # Spack helped builds
-# Generic dane build job, extending build script
-.build_and_test_on_dane:
-  extends: [.on_dane]
+# Generic ruby build job, extending build script
+.build_and_test_on_ruby:
+  extends: [.on_ruby]
   stage: build_and_test
   script:
     # THREADS is used by 'tests/gitlab/build_and_test', run below
-    # Dane has 224 threads/node and we run 7 separate jobs: 224=7*32
-    - export THREADS=28
+    - export THREADS=16
     - echo ${ALLOC_NAME}
     - export JOBID=$(squeue -h --name=${ALLOC_NAME} --format=%A)
     - echo ${JOBID}
     - echo ${MFEM_DATA_DIR}
     - echo ${SPEC}
-    - srun $( [[ -n "${JOBID}" ]] && echo "--jobid=${JOBID}" ) --reservation=ci -t 60 -N 1 tests/gitlab/build_and_test --spec "${SPEC}" --data-dir "${MFEM_DATA_DIR}" --data
+    - srun $( [[ -n "${JOBID}" ]] && echo "--jobid=${JOBID}" ) --reservation=ci -t 45 -N 1 tests/gitlab/build_and_test --spec "${SPEC}" --data-dir "${MFEM_DATA_DIR}" --data

.gitlab/configs/setup-baseline.yml

@@ -18,7 +18,7 @@
 setup_baseline:
   tags:
     - shell
-    - dane
+    - ruby
   stage: setup
   variables:
     GIT_STRATEGY: none

.gitlab/configs/setup-build-and-test.yml

@@ -16,7 +16,7 @@
 setup:
   tags:
     - shell
-    - dane
+    - ruby
   stage: setup
   variables:
     GIT_STRATEGY: none

.gitlab/ruby-baseline.yml

@@ -19,8 +19,8 @@ stages:
   - cleanup
   - baseline_publish
 
-baselinecheck_mfem_intel_dane:
-  extends: [.on_dane]
+baselinecheck_mfem_intel_ruby:
+  extends: [.on_ruby]
   stage: baseline_check
   variables:
     # TPLS_DIR is used in .gitlab/scripts/baseline to provide the tpls location
@@ -31,8 +31,8 @@ baselinecheck_mfem_intel_dane:
   script:
     - echo ${BUILD_ROOT}
     - echo ${TPLS_DIR}
-    # Used by the tests in MFEM/tests, dane has 224 threads/node:
-    - export MFEM_TEST_NP=192
+    # Used by the tests in MFEM/tests:
+    - export MFEM_TEST_NP=48
     # The next script uses the following environment variables:
     # * BASELINE_TEST, SYS_TYPE, CI_PROJECT_DIR, ARTIFACTS_DIR,
     # * BUILD_ROOT, TPLS_DIR, MACHINE_NAME
@@ -44,7 +44,7 @@ baselinecheck_mfem_intel_dane:
   allow_failure: true
 
 cleanup:
-  extends: .on_dane
+  extends: .on_ruby
   stage: cleanup
   variables:
     GIT_STRATEGY: none
@@ -53,7 +53,7 @@ cleanup:
     - rm -rf "${BUILD_ROOT}" || true
 
 report_baseline:
-  extends: [.on_dane]
+  extends: [.on_ruby]
   stage: baseline_report
   script:
     - echo ${MACHINE_NAME}
@@ -113,8 +113,8 @@ report_baseline:
         exit $err
       ) 9> autotest.lock
 
-baselinepublish_mfem_dane:
-  extends: [.on_dane]
+baselinepublish_mfem_ruby:
+  extends: [.on_ruby]
   stage: baseline_publish
   rules:
     # - if: '$CI_COMMIT_BRANCH == "master" || $REBASELINE == "YES"'
@@ -129,5 +129,5 @@ baselinepublish_mfem_dane:
 
 include:
   - local: .gitlab/configs/common.yml
-  - local: .gitlab/configs/dane-config.yml
+  - local: .gitlab/configs/ruby-config.yml
   - local: .gitlab/configs/setup-baseline.yml

.gitlab/ruby-build-and-test.yml

@@ -19,54 +19,54 @@ stages:
 allocate_resource:
   variables:
     GIT_STRATEGY: none
-  extends: .on_dane
+  extends: .on_ruby
   stage: allocate_resource
   script:
     - echo ${ALLOC_NAME}
     - salloc --exclusive --nodes=1 --reservation=ci --time=60 --no-shell --job-name=${ALLOC_NAME}
   timeout: 6h
 
-# GitLab jobs for the Dane machine at LLNL
+# GitLab jobs for the Ruby machine at LLNL
 debug_ser_gcc_10:
   variables:
     SPEC: "%gcc@10.3.1 +debug~mpi"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 
 debug_par_gcc_10:
   variables:
     SPEC: "%gcc@10.3.1 +debug+mpi"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 
 opt_ser_gcc_10:
   variables:
     SPEC: "%gcc@10.3.1 ~mpi"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 
 opt_par_gcc_10:
   variables:
     SPEC: "%gcc@10.3.1"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 
 opt_par_gcc_10_sundials:
   variables:
     SPEC: "%gcc@10.3.1 +sundials"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 
 opt_par_gcc_10_petsc:
   variables:
     SPEC: "%gcc@10.3.1 +petsc ^petsc+mumps~superlu-dist"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 
 opt_par_gcc_10_pumi:
   variables:
     SPEC: "%gcc@10.3.1 +pumi"
-  extends: .build_and_test_on_dane
+  extends: .build_and_test_on_ruby
 
 # Release
 release_resource:
   variables:
     GIT_STRATEGY: none
-  extends: .on_dane
+  extends: .on_ruby
   stage: release_resource_and_report
   script:
     - echo ${ALLOC_NAME}
@@ -78,17 +78,17 @@ release_resource:
 report_job_success:
   stage: release_resource_and_report
   extends:
-    - .on_dane
+    - .on_ruby
     - .report_job_success
 
 report_job_failure:
   stage: release_resource_and_report
   extends:
-    - .on_dane
+    - .on_ruby
     - .report_job_failure
 
 include:
   - local: .gitlab/configs/common.yml
-  - local: .gitlab/configs/dane-config.yml
+  - local: .gitlab/configs/ruby-config.yml
   - local: .gitlab/configs/setup-build-and-test.yml
   - local: .gitlab/configs/report-build-and-test.yml

.gitlab/scripts/baseline

@@ -14,7 +14,7 @@
 # locals
 glob_err=${BASELINE_TEST}.err
 base=${BASELINE_TEST}-${SYS_TYPE}
-if [[ "${MACHINE_NAME}" == "dane" ]]; then
+if [[ "${MACHINE_NAME}" == "ruby" ]]; then
   base="${BASELINE_TEST}-${MACHINE_NAME}"
 fi
 base_diff=${base}.diff
@@ -31,7 +31,7 @@ cd tests
 mkdir _${BASELINE_TEST} && cd _${BASELINE_TEST}
 
 # run
-if [[ "${MACHINE_NAME}" == "dane" ]]; then
+if [[ "${MACHINE_NAME}" == "ruby" ]]; then
   salloc --nodes=1 --exclusive --reservation=ci ../runtest ../../mfem "${BASELINE_TEST} ${TPLS_DIR}"
 elif [[ ${MACHINE_NAME} == "corona" ]]; then
   salloc --nodes=1 -t 60 -p pbatch ../runtest ../../mfem "${BASELINE_TEST} ${TPLS_DIR}"

.gitlab/scripts/rebaseline

@@ -11,7 +11,7 @@
 # terms of the BSD-3 license. We welcome feedback and contributions, see file
 # CONTRIBUTING.md for details.
 
-# There will be collision between corona and dane baselines.
+# There will be collision between corona and ruby baselines.
 # Once the corresponding files have been generated, we can switch to machine
 # specific ref.
 ARTIFACT_PATH=${CI_PROJECT_DIR}/${ARTIFACTS_DIR}/baseline-${SYS_TYPE}
@@ -21,7 +21,7 @@ PATCH_FILE=${ARTIFACT_PATH}.patch
 FULL_FILE=${ARTIFACT_PATH}.out
 DIFF_FILE=${ARTIFACT_PATH}.diff
 
-# There will be collision between corona and dane baselines.
+# There will be collision between corona and ruby baselines.
 # Once the corresponding files have been generated, we can switch to machine
 # specific ref.
 SAVED_NAME=baseline-${SYS_TYPE}.saved

CHANGELOG

@@ -27,34 +27,11 @@ Discretization improvements
 - In the ParMoonolith integration, added support for variational resampling of
   H1 vector fields.
 
-- Added support for boundary integration to the hyperbolic framework. In this
-  regard, new classes `BdrHyperbolicDirichletIntegrator` and
-  `BoundaryHyperbolicFlowIntegrator` have been introduced for implementation
-  of weak Dirichlet boundary conditions with a general flux or for the linear
-  case respectively.
-
-- Added method to compute piecewise linear bounds on high-order functions on
-  tensor-product elements.
-
-- Parallel anisotropic refinement of hexahedral meshes is now supported,
-  provided that neighboring hexahedra are not refined in conflicting directions.
-  A new ParMesh method is added to check for such conflicts, before refinement.
-
 Meshing improvements
 --------------------
-
-- Introduced NC-patch NURBS meshes, which are conforming element-wise but allow
-  for nonconforming patch topology. This new mesh format supports element
-  spacing formulas for refinement, as well as local refinement factors for a
-  subset of knot vectors.
-
 - 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
@@ -63,68 +40,11 @@ GPU computing
   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.
-
-- Implemented a GPU-accelerated matrix-free AMR derefinement `GridFunction`
-  update operator. This supports mixed geometry meshes and variable order
-  spaces, and is the default derefinement operator constructed by
-  `FiniteElementSpace::Update` and `ParFiniteElementSpace::Update`.
-  The operator requires `FiniteElementSpace::Nonconforming() == true`.
-- Added new method: GridFunction::GetGradients, with GPU support, for computing
-  the gradients of a GridFunction on all elements.
-- Added GPU support in GradientGridFunctionCoefficient and
-  InnerProductCoefficient by implementing their Project methods.
-
-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`.
-
-- Added a new miniapp (meshing/mesh-bounding-boxes) that computes the bounding
-  boxes for each element of a given mesh, and the bounds on the determinant of
-  the Jacobian of the transformation.
-
-- Added a new miniapp (tools/gridfunction-bounds) to compute piecewise linear
-  bounds on a given high-order grid function.
-
-- Added a new miniapp (electromagnetics/lorentz) which computes the trajectory
-  of a charged particle, subject to Lorentz forces, in electrostatic and/or
-  magnetostatic fields as computed by the volta or tesla miniapps.
-
 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.
-
-- FindPointsGSLIB has a new constructor that accepts the mesh object and
-  internally calls the Setup() method so that the user does not have to.
-  The FreeData() method has also been moved to the destructor so the user does
-  not need to manually free-up the memory if the destructor is called before
-  MPI_Finalize().
 
 Version 4.8, released on Apr 9, 2025
 ====================================

CMakeLists.txt

@@ -278,11 +278,6 @@ if (MFEM_USE_OPENMP OR MFEM_USE_LEGACY_OPENMP)
   endif()
 endif()
 
-# Umpire (must be included before hypre, so hypre can use it if needed)
-if (MFEM_USE_UMPIRE)
-   find_package(UMPIRE REQUIRED)
-endif()
-
 # MPI -> hypre; PETSc (optional)
 if (MFEM_USE_MPI)
   find_package(MPI REQUIRED)
@@ -500,13 +495,14 @@ endif()
 
 # RAJA
 if (MFEM_USE_RAJA)
-   # RAJA uses FindCUDA, which needs CMP0146=OLD in CMake >= 3.27
-   if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.27.0)
-      cmake_policy(SET CMP0146 OLD)
-   endif()
    find_package(RAJA REQUIRED)
 endif()
 
+# UMPIRE
+if (MFEM_USE_UMPIRE)
+   find_package(UMPIRE REQUIRED)
+endif()
+
 # GOOGLE-BENCHMARK
 if (MFEM_USE_BENCHMARK)
    find_package(Benchmark REQUIRED)
@@ -600,25 +596,18 @@ set(MFEM_TPLS OPENMP HYPRE LAPACK BLAS SuperLUDist STRUMPACK METIS SuiteSparse
     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
-    ALGOIM ENZYME CUDA::cudart)
+    ALGOIM ENZYME)
 
-# Add all created targets and *_FOUND libraries in the variables TPL_TARGETS and
-# TPL_LIBRARIES, respectively.
-set(TPL_TARGETS)
+# Add all *_FOUND libraries in the variable TPL_LIBRARIES.
 set(TPL_LIBRARIES "")
 set(TPL_INCLUDE_DIRS "")
 foreach(TPL IN LISTS MFEM_TPLS)
-  if (${TPL}_FOUND OR TARGET ${TPL})
+  if (${TPL}_FOUND)
     message(STATUS "MFEM: using package ${TPL}")
-    if (TARGET ${TPL})
-      list(APPEND TPL_TARGETS ${TPL})
-    else()
-      list(APPEND TPL_LIBRARIES ${${TPL}_LIBRARIES})
-      list(APPEND TPL_INCLUDE_DIRS ${${TPL}_INCLUDE_DIRS})
-    endif()
+    list(APPEND TPL_LIBRARIES ${${TPL}_LIBRARIES})
+    list(APPEND TPL_INCLUDE_DIRS ${${TPL}_INCLUDE_DIRS})
   endif()
 endforeach(TPL)
-
 list(REVERSE TPL_LIBRARIES)
 list(REMOVE_DUPLICATES TPL_LIBRARIES)
 list(REVERSE TPL_LIBRARIES)
@@ -691,10 +680,7 @@ set(MFEM_INSTALL_DIR ${CMAKE_INSTALL_PREFIX})
 # Declaring the library
 mfem_add_library(mfem ${SOURCES} ${HEADERS} ${MASTER_HEADERS})
 # message(STATUS "TPL_LIBRARIES = ${TPL_LIBRARIES}")
-target_link_libraries(mfem PUBLIC ${TPL_LIBRARIES} ${TPL_TARGETS})
-if (TPL_TARGETS)
-  add_dependencies(mfem ${TPL_TARGETS})
-endif()
+target_link_libraries(mfem PUBLIC ${TPL_LIBRARIES})
 if (MINGW)
   target_link_libraries(mfem PRIVATE ws2_32)
 endif()

INSTALL

@@ -121,11 +121,6 @@ Parallel build:
    make -j 4
 (For METIS 5, see https://mfem.org/building/#parallel-build-using-metis-5)
 
-Parallel build with fetching of hypre and METIS:
-   mkdir <mfem-buil-dir> ; cd <mfem-build-dir>
-   cmake <mfem-source-dir> -DMFEM_USE_MPI=YES -DFETCH_TPLS=YES
-   make -j 4
-
 CUDA build:
    (this build requires CMake 3.17 or newer)
    mkdir <mfem-build-dir> ; cd <mfem-build-dir>
@@ -668,7 +663,6 @@ The specific libraries and their options are:
 - OpenMP (optional), usually part of compiler, used when either MFEM_USE_OPENMP
   or MFEM_USE_LEGACY_OPENMP is set to YES.
   Options: OPENMP_OPT, OPENMP_LIB.
-  Versions: OpenMP >= 3.1 when MFEM_USE_OPENMP=YES.
 
 - High-resolution POSIX clocks: when using MFEM_TIMER_TYPE = 2, it may be
   necessary to link with a system library (e.g. librt.so).
@@ -848,7 +842,6 @@ The specific libraries and their options are:
 - HIP (optional), used when MFEM_USE_HIP = YES.
   URL: https://rocmdocs.amd.com
   Options: HIP_CXX, HIP_ARCH, HIP_OPT, HIP_LIB.
-  Versions: ROCm >= 5.6.1.
 
 - OCCA (optional), used when MFEM_USE_OCCA = YES.
   URL: https://libocca.org
@@ -859,7 +852,7 @@ The specific libraries and their options are:
   URL: https://github.com/CEED/libCEED
        https://ceed.exascaleproject.org/libceed
   Options: CEED_DIR, CEED_OPT, CEED_LIB.
-  Versions: libCEED >= 0.12.0.
+  Versions: libCEED >= 0.12.
 
 - RAJA (optional), used when MFEM_USE_RAJA = YES.
   Beginning with MFEM v4.5.1, only RAJA v2022.10.3+ is supported.
@@ -1081,9 +1074,6 @@ The following options are CMake specific:
 MFEM_ENABLE_TESTING  - Enable the ctest framework for testing.
 MFEM_ENABLE_EXAMPLES - Build all of the examples by default.
 MFEM_ENABLE_MINIAPPS - Build all of the miniapps by default.
-FETCH_TPLS           - Enable fetching of all supported third-party libraries.
-HYPRE_FETCH          - Enable fetching of hypre.
-METIS_FETCH          - Enable fetching of metis.
 
 External libraries (CMake):
 ---------------------------
@@ -1145,12 +1135,6 @@ The following built-in CMake packages are also used:
       set the <LIBNAME>_LIBRARIES option directly; the configuration option
       <LIBNAME>_DIR is not supported.
 
-The MFEM CMake build system also provides fetching (automated building) for the
-packages/libraries listed below. Note that when fetching is enabled, any related
-auto-detection functionality is disabled.
-
- - HYPRE
- - METIS
 
 Building without GNU make or CMake
 ==================================

config/cmake/MFEMConfig.cmake.in

@@ -84,31 +84,6 @@ set_and_check(MFEM_LIBRARY_DIR "@PACKAGE_LIB_INSTALL_DIR@")
 
 check_required_components(MFEM)
 
-include(CMakeFindDependencyMacro)
-
-if (MFEM_USE_CUDA)
-  # required for projects linking to MFEM+CUDA, even if they don't use CUDA directly
-  find_dependency(CUDAToolkit)
-endif (MFEM_USE_CUDA)
-
-if (MFEM_USE_HIP)
-  # hip/rocm uses the modern MFEM way of linking to targets, need to find dependencies
-  find_dependency(HIP)
-  find_dependency(HIPBLAS)
-  find_dependency(HIPSPARSE)
-  if (MFEM_USE_MPI)
-    # assume HYPRE uses HIP
-    # alternatively could check HYPRE_USING_HIP
-    find_dependency(rocsparse)
-    find_dependency(rocrand)
-    find_dependency(rocsolver)
-  endif (MFEM_USE_MPI)
-endif (MFEM_USE_HIP)
-
-if (MFEM_USE_RAJA)
-   find_dependency(RAJA)
-endif()
-
 if (NOT TARGET mfem)
   include(${CMAKE_CURRENT_LIST_DIR}/MFEMTargets.cmake)
 endif (NOT TARGET mfem)

config/cmake/modules/FindHYPRE.cmake

@@ -9,25 +9,21 @@
 # terms of the BSD-3 license. We welcome feedback and contributions, see file
 # CONTRIBUTING.md for details.
 
-# Defines the following variables if fetching of TPLs is disabled (default):
+# Defines the following variables:
 #   - HYPRE_FOUND
 #   - HYPRE_LIBRARIES
 #   - HYPRE_INCLUDE_DIRS
 #   - HYPRE_VERSION
 #   - HYPRE_USING_CUDA (internal)
 #   - HYPRE_USING_HIP (internal)
-# otherwise, the following are defined:
-#   - HYPRE (imported library target)
-#   - HYPRE_VERSION (cache variable)
 
-if (HYPRE_FOUND OR TARGET HYPRE)
+if (HYPRE_FOUND)
   if (HYPRE_USING_CUDA)
     find_package(CUDAToolkit REQUIRED)
   endif()
   if (HYPRE_USING_HIP)
     find_package(rocsparse REQUIRED)
     find_package(rocrand REQUIRED)
-    find_package(rocsolver REQUIRED)
   endif()
   if (HYPRE_LIBRARIES AND HYPRE_INCLUDE_DIRS AND HYPRE_VERSION)
     find_package_handle_standard_args(HYPRE
@@ -37,95 +33,6 @@ if (HYPRE_FOUND OR TARGET HYPRE)
   endif()
 endif()
 
-if (HYPRE_FETCH OR FETCH_TPLS)
-  # Collect all HYPRE_ENABLE variables and pass them to hypre, assuming they are BOOL.
-  set(HYPRE_CMAKE_OPTIONS "")
-  get_cmake_property(all_vars VARIABLES)
-  foreach(var ${all_vars})
-    if(var MATCHES "^HYPRE_ENABLE")
-      list(APPEND HYPRE_CMAKE_OPTIONS "-D${var}:BOOL=${${var}}")
-    endif()
-  endforeach()
-
-  set(HYPRE_FETCH_VERSION 2.33.0)
-  set(HYPRE_FETCH_TAG "v${HYPRE_FETCH_VERSION}" CACHE STRING "Tag, branch, or commit for HYPRE")
-  add_library(HYPRE STATIC IMPORTED)
-  # set options and associated dependencies
-  list(APPEND HYPRE_CMAKE_OPTIONS -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE})
-  if (MFEM_USE_CUDA)
-    list(APPEND HYPRE_CMAKE_OPTIONS -DHYPRE_ENABLE_CUDA:BOOL=ON -DCMAKE_CUDA_ARCHITECTURES:STRING=${CMAKE_CUDA_ARCHITECTURES})
-    find_package(CUDAToolkit REQUIRED)
-    target_link_libraries(HYPRE INTERFACE CUDA::cusparse CUDA::curand CUDA::cublas)
-  elseif (MFEM_USE_HIP)
-    list(APPEND HYPRE_CMAKE_OPTIONS -DHYPRE_ENABLE_HIP:BOOL=ON)
-    find_package(rocsparse REQUIRED)
-    find_package(rocrand REQUIRED)
-    target_link_libraries(HYPRE INTERFACE rocsparse rocrand)
-  endif()
-  if (MFEM_USE_CUDA OR MFEM_USE_HIP)
-    if (MFEM_USE_UMPIRE)
-      if (EXISTS ${umpire_DIR})
-        list(APPEND HYPRE_CMAKE_OPTIONS -DHYPRE_ENABLE_UMPIRE:BOOL=ON -Dumpire_DIR:PATH=${umpire_DIR})
-      else()
-        message(FATAL_ERROR "MFEM_USE_UMPIRE=ON, however umpire_DIR isn't visible to HYPRE")
-      endif()
-    else()
-      list(APPEND HYPRE_CMAKE_OPTIONS -DHYPRE_ENABLE_UMPIRE:BOOL=OFF)
-      message(WARNING
-"================================================================================
- Umpire is disabled while building HYPRE with GPU support.
- This is not recommended for performance reasons!
- Consider enabling Umpire with -DMFEM_USE_UMPIRE=ON and providing -DUMPIRE_DIR.
-================================================================================")
-    endif()
-  endif()
-  if (MFEM_USE_SINGLE)
-    list(APPEND HYPRE_CMAKE_OPTIONS -DHYPRE_ENABLE_SINGLE:BOOL=ON)
-  endif()
-  # define external project and create future include directory so it is present
-  # to pass CMake checks at end of MFEM configuration step
-  message(STATUS "Will fetch HYPRE ${HYPRE_FETCH_TAG} to be built with ${HYPRE_CMAKE_OPTIONS}")
-  set(HYPRE_INSTALL ${CMAKE_BINARY_DIR}/fetch/hypre)
-  include(ExternalProject)
-  ExternalProject_Add(hypre
-    GIT_REPOSITORY https://github.com/hypre-space/hypre.git
-    GIT_TAG ${HYPRE_FETCH_TAG}
-    GIT_SHALLOW TRUE
-    GIT_PROGRESS TRUE
-    UPDATE_DISCONNECTED TRUE
-    SOURCE_SUBDIR src
-    PREFIX ${HYPRE_INSTALL}
-    BUILD_COMMAND ${CMAKE_COMMAND} --build . -- -j${CMAKE_BUILD_PARALLEL_LEVEL}
-    CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${HYPRE_INSTALL} -DCMAKE_INSTALL_LIBDIR:PATH=lib ${HYPRE_CMAKE_OPTIONS})
-  file(MAKE_DIRECTORY ${HYPRE_INSTALL}/include)
-  # set imported library target properties
-  add_dependencies(HYPRE hypre)
-  set_target_properties(HYPRE PROPERTIES
-    IMPORTED_LOCATION ${HYPRE_INSTALL}/lib/libHYPRE.a
-    INTERFACE_INCLUDE_DIRECTORIES ${HYPRE_INSTALL}/include)
-  # convert HYPRE version to integer
-  if (HYPRE_FETCH_TAG MATCHES "^v?([0-9]+)\\.([0-9]+)\\.([0-9]+)$")
-    # Exact release tag X.Y.Z
-    string(REGEX MATCHALL "[0-9]+" HYPRE_SPLIT_VERSION "${HYPRE_FETCH_TAG}")
-  elseif (HYPRE_FETCH_VERSION MATCHES "([0-9]+)\\.([0-9]+)(\\.([0-9]+))?")
-    string(REGEX MATCHALL "[0-9]+" HYPRE_SPLIT_VERSION "${HYPRE_FETCH_VERSION}")
-  else (NOT DEFINED HYPRE_VERSION)
-    message(FATAL_ERROR "Unable to find HYPRE release version. Please provide it via -DHYPRE_VERSION")
-  endif()
-  if (HYPRE_SPLIT_VERSION AND NOT DEFINED HYPRE_VERSION)
-    list(GET HYPRE_SPLIT_VERSION 0 HYPRE_MAJOR_VERSION)
-    list(GET HYPRE_SPLIT_VERSION 1 HYPRE_MINOR_VERSION)
-    if (HYPRE_SPLIT_VERSION GREATER 2)
-      list(GET HYPRE_SPLIT_VERSION 2 HYPRE_PATCH_VERSION)
-    else()
-      set(HYPRE_PATCH_VERSION 0)
-    endif()
-    math(EXPR HYPRE_VERSION "10000*${HYPRE_MAJOR_VERSION} + 100*${HYPRE_MINOR_VERSION} + ${HYPRE_PATCH_VERSION}")
-    set(HYPRE_VERSION ${HYPRE_VERSION} CACHE STRING "HYPRE version." FORCE)
-  endif()
-  return()
-endif()
-
 include(MfemCmakeUtilities)
 mfem_find_package(HYPRE HYPRE HYPRE_DIR "include" "HYPRE.h" "lib" "HYPRE"
   "Paths to headers required by HYPRE." "Libraries required by HYPRE."
@@ -190,8 +97,7 @@ endif()
 if (HYPRE_FOUND AND HYPRE_USING_HIP)
   find_package(rocsparse REQUIRED)
   find_package(rocrand REQUIRED)
-  find_package(rocsolver REQUIRED)
-  list(APPEND HYPRE_LIBRARIES ${rocsparse_LIBRARIES} ${rocrand_LIBRARIES} roc::rocsolver roc::rocblas)
+  list(APPEND HYPRE_LIBRARIES ${rocsparse_LIBRARIES} ${rocrand_LIBRARIES})
   set(HYPRE_LIBRARIES ${HYPRE_LIBRARIES} CACHE STRING
       "HYPRE libraries + dependencies." FORCE)
   message(STATUS "Updated HYPRE_LIBRARIES: ${HYPRE_LIBRARIES}")

config/cmake/modules/FindMETIS.cmake

@@ -9,39 +9,10 @@
 # terms of the BSD-3 license. We welcome feedback and contributions, see file
 # CONTRIBUTING.md for details.
 
-# Defines the following variables if fetching of TPLs is disabled (default):
+# Defines the following variables:
 #   - METIS_FOUND
 #   - METIS_LIBRARIES
 #   - METIS_INCLUDE_DIRS
-#   - METIS_VERSION_5
-# otherwise, the following are defined:
-#   - METIS (imported library target)
-#   - METIS_VERSION_5 (cache variable)
-
-if (METIS_FETCH OR FETCH_TPLS)
-  set(METIS_FETCH_VERSION 4.0.3)
-  add_library(METIS STATIC IMPORTED)
-  # define external project
-  message(STATUS "Will fetch METIS ${METIS_FETCH_VERSION} to be built with default options")
-  set(PREFIX ${CMAKE_BINARY_DIR}/fetch/metis)
-  include(ExternalProject)
-  ExternalProject_Add(metis
-    GIT_REPOSITORY https://github.com/mfem/tpls
-    GIT_TAG b60352fbe9675d374b00828055e55be4584c7995 # tag from 1/16/25
-    GIT_SHALLOW TRUE
-    UPDATE_DISCONNECTED TRUE
-    PREFIX ${PREFIX}
-    CONFIGURE_COMMAND tar -xzf ../metis/metis-${METIS_FETCH_VERSION}-mac.tgz --strip=1
-    BUILD_COMMAND $(MAKE) COPTIONS=-Wno-incompatible-pointer-types
-    INSTALL_COMMAND mkdir -p ${PREFIX}/lib && cp libmetis.a ${PREFIX}/lib/)
-  # set imported library target properties
-  add_dependencies(METIS metis)
-  set_target_properties(METIS PROPERTIES
-    IMPORTED_LOCATION ${PREFIX}/lib/libmetis.a)
-  # set cache variables that would otherwise be set after mfem_find_package call
-  set(METIS_VERSION_5 FALSE CACHE BOOL "Is METIS version 5?")
-  return()
-endif()
 
 include(MfemCmakeUtilities)
 mfem_find_package(METIS METIS METIS_DIR "include;Lib" "metis.h"

config/cmake/modules/MfemCmakeUtilities.cmake

@@ -718,7 +718,7 @@ function(mfem_get_target_options Target CompileOptsVar LinkOptsVar)
   get_target_property(IsImported ${tgt} IMPORTED)
   # message(STATUS "${tgt}[IMPORTED]: ${IsImported}")
   # Generally, the possible target types are: STATIC_LIBRARY, MODULE_LIBRARY,
-  # SHARED_LIBRARY, INTERFACE_LIBRARY, UNKNOWN_LIBRARY, EXECUTABLE.
+  # SHARED_LIBRARY, INTERFACE_LIBRARY, EXECUTABLE.
   get_target_property(type ${tgt} TYPE)
   # message(STATUS "${tgt}[TYPE]: ${type}")
   unset(ImportConfig)
@@ -766,7 +766,7 @@ function(mfem_get_target_options Target CompileOptsVar LinkOptsVar)
     else()
       message(STATUS " *** Warning: [${tgt}] LOCATION not defined!")
     endif()
-  elseif ("${type}" STREQUAL "SHARED_LIBRARY" OR "${type}" STREQUAL "UNKNOWN_LIBRARY")
+  elseif ("${type}" STREQUAL "SHARED_LIBRARY")
     get_target_property(Location ${tgt} LOCATION)
     if (Location)
       get_filename_component(Dir ${Location} DIRECTORY)
@@ -932,14 +932,12 @@ function(mfem_export_mk_files)
   endif()
   set(MFEM_BUILD_TAG "${CMAKE_SYSTEM}")
   set(MFEM_PREFIX "${CMAKE_INSTALL_PREFIX}")
-  # For the next 4 variables, these are the values for the build-tree version of
+  # For the next 4 variable, these are the values for the build-tree version of
   # 'config.mk'
   set(MFEM_INC_DIR "${PROJECT_BINARY_DIR}")
   set(MFEM_LIB_DIR "${PROJECT_BINARY_DIR}")
   set(MFEM_TEST_MK "${PROJECT_SOURCE_DIR}/config/test.mk")
   set(MFEM_CONFIG_EXTRA "MFEM_BUILD_DIR ?= ${PROJECT_BINARY_DIR}")
-  # TODO: CUDA/HIP support:
-  set(MFEM_XLINKER "${CMAKE_CXX_LINKER_WRAPPER_FLAG}")
   set(MFEM_MPIEXEC ${MPIEXEC})
   if (NOT MFEM_MPIEXEC)
     set(MFEM_MPIEXEC "mpirun")

config/config.hpp

@@ -23,14 +23,11 @@
 #include "_config.hpp"
 #endif
 
-#include <cstdint>
-#include <climits>
-
 namespace mfem
 {
 
 #if (defined(MFEM_USE_CUDA) && defined(__CUDACC__)) || \
-    (defined(MFEM_USE_HIP) && defined(__HIP__))
+    (defined(MFEM_USE_HIP) && defined(__HIPCC__))
 #define MFEM_HOST_DEVICE __host__ __device__
 #else
 #define MFEM_HOST_DEVICE

config/config.mk.in

@@ -88,7 +88,6 @@ MFEM_BUILD_TAG = @MFEM_BUILD_TAG@
 MFEM_PREFIX    = @MFEM_PREFIX@
 MFEM_INC_DIR   = @MFEM_INC_DIR@
 MFEM_LIB_DIR   = @MFEM_LIB_DIR@
-MFEM_XLINKER   = @MFEM_XLINKER@
 
 # Location of test.mk
 MFEM_TEST_MK = @MFEM_TEST_MK@

config/defaults.cmake

@@ -89,12 +89,6 @@ option(MFEM_ENABLE_EXAMPLES "Build all of the examples" OFF)
 option(MFEM_ENABLE_MINIAPPS "Build all of the miniapps" OFF)
 option(MFEM_ENABLE_BENCHMARKS "Build all of the benchmarks" OFF)
 
-# Allow a user to specify fetching of certain third-party libraries instead of
-# searching for existing installations.
-option(FETCH_TPLS "Enable fetching of all supported third-party libraries" OFF)
-option(HYPRE_FETCH "Enable fetching of hypre" OFF)
-option(METIS_FETCH "Enable fetching of METIS" OFF)
-
 # Setting CXX/MPICXX on the command line or in user.cmake will overwrite the
 # autodetected C++ compiler.
 # set(CXX g++)

config/defaults.mk

@@ -57,7 +57,7 @@ CUDA_DIR = $(or $(CUDA_HOME),$(patsubst %/,%,$(dir \
 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) -isystem "$(CUDA_DIR)/include"
+ -arch=$(CUDA_ARCH)
 # Prefixes for passing flags to the host compiler and linker when using
 # CUDA_CXX=nvcc
 CUDA_XCOMPILER = -Xcompiler=

data/escher-p2.mesh

@@ -115,7 +115,7 @@ vertices
 
 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_3D_P2
+FiniteElementCollection: Quadratic
 VDim: 3
 Ordering: 0
 

data/fichera-q2.mesh

@@ -56,7 +56,7 @@ vertices
 
 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_3D_P2
+FiniteElementCollection: Quadratic
 VDim: 3
 Ordering: 0
 

data/mfem.mesh

@@ -1,593 +0,0 @@
-MFEM mesh v1.0
-
-# Created by: Pointwise
-
-# MFEM Geometry Types:
-#
-# POINT       = 0
-# SEGMENT     = 1
-# TRIANGLE    = 2
-# SQUARE      = 3
-# TETRAHEDRON = 4
-# CUBE        = 5
-# PRISM       = 6
-
-dimension
-2
-
-elements
-160
-1 3 1 164 163 0
-1 3 164 165 162 163
-1 3 2 166 164 1
-1 3 166 132 165 164
-1 3 3 167 166 2
-1 3 167 131 132 166
-1 3 4 168 167 3
-1 3 168 130 131 167
-1 3 5 169 168 4
-1 3 169 129 130 168
-1 3 6 170 169 5
-1 3 170 128 129 169
-1 3 171 172 170 6
-1 3 172 127 128 170
-1 3 124 125 172 171
-1 3 125 126 127 172
-1 3 162 165 173 161
-1 3 165 132 133 173
-1 3 161 173 174 160
-1 3 173 133 134 174
-1 3 160 174 175 159
-1 3 174 134 135 175
-1 3 6 7 176 171
-1 3 7 8 177 176
-1 3 171 176 123 124
-1 3 176 177 122 123
-1 3 159 175 178 158
-1 3 175 135 136 178
-1 3 158 178 179 157
-1 3 178 136 137 179
-1 3 157 179 180 156
-1 3 179 137 138 180
-1 3 122 177 181 121
-1 3 177 8 182 181
-1 3 8 9 183 182
-1 3 9 10 184 183
-1 3 10 11 185 184
-1 3 11 12 186 185
-1 3 12 13 187 186
-1 3 13 14 15 187
-1 3 121 181 119 120
-1 3 181 182 118 119
-1 3 182 183 117 118
-1 3 183 184 188 117
-1 3 184 185 109 188
-1 3 185 186 108 109
-1 3 186 187 189 108
-1 3 187 15 16 189
-1 3 109 110 190 188
-1 3 110 111 191 190
-1 3 111 112 113 191
-1 3 188 190 116 117
-1 3 190 191 115 116
-1 3 191 113 114 115
-1 3 189 192 107 108
-1 3 192 193 106 107
-1 3 193 194 105 106
-1 3 194 195 104 105
-1 3 195 196 103 104
-1 3 16 17 192 189
-1 3 17 18 193 192
-1 3 18 19 194 193
-1 3 19 20 195 194
-1 3 20 21 196 195
-1 3 97 98 197 96
-1 3 98 99 198 197
-1 3 99 100 199 198
-1 3 100 101 200 199
-1 3 101 102 201 200
-1 3 102 103 202 201
-1 3 103 196 203 202
-1 3 196 21 22 203
-1 3 96 197 204 95
-1 3 197 198 39 204
-1 3 198 199 38 39
-1 3 199 200 205 38
-1 3 200 201 32 205
-1 3 201 202 31 32
-1 3 202 203 206 31
-1 3 203 22 23 206
-1 3 32 33 207 205
-1 3 33 34 35 207
-1 3 205 207 37 38
-1 3 207 35 36 37
-1 3 39 40 208 204
-1 3 40 41 209 208
-1 3 41 42 210 209
-1 3 42 43 211 210
-1 3 43 44 212 211
-1 3 204 208 94 95
-1 3 208 209 93 94
-1 3 209 210 92 93
-1 3 210 211 91 92
-1 3 211 212 90 91
-1 3 90 212 213 89
-1 3 212 44 214 213
-1 3 44 45 215 214
-1 3 45 46 216 215
-1 3 46 47 217 216
-1 3 47 48 218 217
-1 3 48 49 219 218
-1 3 49 50 51 219
-1 3 89 213 87 88
-1 3 213 214 86 87
-1 3 214 215 85 86
-1 3 215 216 84 85
-1 3 216 217 83 84
-1 3 217 218 82 83
-1 3 218 219 220 82
-1 3 219 51 52 220
-1 3 53 221 220 52
-1 3 221 81 82 220
-1 3 54 222 221 53
-1 3 222 80 81 221
-1 3 55 223 222 54
-1 3 223 79 80 222
-1 3 26 27 224 25
-1 3 27 28 29 224
-1 3 25 224 225 24
-1 3 224 29 30 225
-1 3 24 225 206 23
-1 3 225 30 31 206
-1 3 154 155 226 153
-1 3 155 156 180 226
-1 3 153 226 227 152
-1 3 226 180 138 227
-1 3 152 227 228 151
-1 3 227 138 139 228
-1 3 151 228 229 150
-1 3 228 139 140 229
-1 3 150 229 230 149
-1 3 229 140 141 230
-1 3 149 230 231 148
-1 3 230 141 142 231
-1 3 148 231 232 147
-1 3 231 142 143 232
-1 3 147 232 145 146
-1 3 232 143 144 145
-1 3 56 233 223 55
-1 3 233 78 79 223
-1 3 57 234 233 56
-1 3 234 77 78 233
-1 3 58 235 234 57
-1 3 235 76 77 234
-1 3 61 236 59 60
-1 3 236 235 58 59
-1 3 62 237 236 61
-1 3 237 76 235 236
-1 3 63 238 237 62
-1 3 238 75 76 237
-1 3 64 239 238 63
-1 3 239 74 75 238
-1 3 65 240 239 64
-1 3 240 73 74 239
-1 3 66 241 240 65
-1 3 241 72 73 240
-1 3 67 242 241 66
-1 3 242 71 72 241
-1 3 68 69 242 67
-1 3 69 70 71 242
-
-boundary
-164
-3 1 0 1
-3 1 1 2
-3 1 2 3
-3 1 3 4
-3 1 4 5
-3 1 5 6
-3 1 6 7
-3 1 7 8
-3 1 8 9
-3 1 9 10
-3 1 10 11
-3 1 11 12
-3 1 12 13
-3 1 13 14
-3 1 16 17
-3 1 17 18
-3 1 18 19
-3 1 19 20
-3 1 20 21
-3 1 21 22
-3 1 22 23
-3 1 23 24
-3 1 24 25
-3 1 25 26
-3 1 26 27
-3 1 27 28
-3 1 28 29
-3 1 29 30
-3 1 30 31
-3 1 31 32
-3 1 32 33
-3 1 33 34
-3 1 34 35
-3 1 35 36
-3 1 36 37
-3 1 37 38
-3 1 38 39
-3 1 39 40
-3 1 40 41
-3 1 41 42
-3 1 42 43
-3 1 43 44
-3 1 49 50
-3 1 48 49
-3 1 47 48
-3 1 46 47
-3 1 45 46
-3 1 44 45
-3 1 52 53
-3 1 53 54
-3 1 54 55
-3 1 57 58
-3 1 56 57
-3 1 55 56
-3 1 60 61
-3 1 61 62
-3 1 62 63
-3 1 63 64
-3 1 64 65
-3 1 65 66
-3 1 66 67
-3 1 67 68
-3 1 75 76
-3 1 74 75
-3 1 73 74
-3 1 72 73
-3 1 71 72
-3 1 70 71
-3 1 76 77
-3 1 77 78
-3 1 78 79
-3 1 81 82
-3 1 80 81
-3 1 79 80
-3 1 82 83
-3 1 83 84
-3 1 84 85
-3 1 85 86
-3 1 86 87
-3 1 87 88
-3 1 94 95
-3 1 93 94
-3 1 92 93
-3 1 91 92
-3 1 90 91
-3 1 96 97
-3 1 95 96
-3 1 97 98
-3 1 98 99
-3 1 99 100
-3 1 100 101
-3 1 101 102
-3 1 102 103
-3 1 107 108
-3 1 106 107
-3 1 105 106
-3 1 104 105
-3 1 103 104
-3 1 108 109
-3 1 109 110
-3 1 110 111
-3 1 111 112
-3 1 112 113
-3 1 113 114
-3 1 114 115
-3 1 115 116
-3 1 116 117
-3 1 119 120
-3 1 118 119
-3 1 117 118
-3 1 131 132
-3 1 130 131
-3 1 129 130
-3 1 128 129
-3 1 127 128
-3 1 126 127
-3 1 132 133
-3 1 133 134
-3 1 134 135
-3 1 137 138
-3 1 136 137
-3 1 135 136
-3 1 138 139
-3 1 139 140
-3 1 140 141
-3 1 141 142
-3 1 142 143
-3 1 143 144
-3 1 147 148
-3 1 146 147
-3 1 153 154
-3 1 152 153
-3 1 151 152
-3 1 150 151
-3 1 149 150
-3 1 148 149
-3 1 156 157
-3 1 157 158
-3 1 158 159
-3 1 161 162
-3 1 160 161
-3 1 159 160
-2 1 69 70
-2 1 68 69
-3 1 88 89
-3 1 89 90
-3 1 121 122
-3 1 120 121
-3 1 123 124
-3 1 122 123
-3 1 125 126
-3 1 124 125
-1 1 144 145
-1 1 145 146
-3 1 15 16
-3 1 14 15
-3 1 50 51
-3 1 51 52
-3 1 59 60
-3 1 58 59
-3 1 154 155
-3 1 155 156
-3 1 163 0
-3 1 162 163
-
-vertices
-243
-2
-4 4
-4 3.5
-4 3
-4 2.5
-4 2
-4 1.5
-4 1
-4.5 1
-5 1
-5 1.5
-5 2
-5 2.5
-5 3
-5 3.5
-5 4
-5.500 4
-6 4
-6.500 4
-7 4
-7.5 4
-8 4
-8.5 4
-9 4
-9.5 4
-10 4
-10.5 4
-11 4
-11 3.5
-11 3
-10.5 3
-10 3
-9.5 3
-9.5 2.5
-10 2.5
-10.5 2.5
-10.5 2
-10.5 1.5
-10 1.5
-9.5 1.5
-9.5 1
-10 1
-10.5 1
-11 1
-11.5 1
-12 1
-12 1.5
-12 2
-12 2.5
-12 3
-12 3.5
-12 4
-12.5 4
-13 4
-13.333 3.75
-13.666 3.5
-14.000 3.25
-14.333 3.5
-14.666 3.75
-15.000 4
-15.500 4
-16.000 4
-16.000 3.5
-16.000 3
-16.000 2.5
-16.000 2
-16.000 1.5
-16.000 1
-16.000 0.5
-16.000 0
-15.500 0
-15.000 0
-15.000 0.5000000000000002
-15.000 1
-15.000 1.5
-15.000 2
-15.000 2.5
-15.000 3
-14.666 2.75
-14.333 2.5
-14.000 2.25
-13.666 2.5
-13.333 2.75
-13 3
-13 2.5
-13 2
-13 1.5
-13 1
-13 0.500
-13 0
-12.5 0
-12 0
-11.5 0
-11 0
-10.5 0
-10 0
-9.5 0
-9 0
-8.5 0
-8.5 0.5
-8.5 1
-8.5 1.5
-8.5 2
-8.5 2.5
-8.5 3
-8 3
-7.5 3
-7 3
-6.500 3
-6 3
-6 2.5
-6.5 2.5
-7 2.5
-7.5 2.5
-7.5 2
-7.5 1.5
-7.000 1.5
-6.5 1.5
-6 1.5
-6 1
-6 0.5
-6 0
-5.5 0
-5 0
-4.5 0
-4 0
-3.5 0
-3 0
-3 0.500
-3 1
-3 1.5
-3 2
-3 2.5
-3 3
-2.666 2.75
-2.333 2.5
-2.000 2.25
-1.666 2.5
-1.333 2.75
-1.000 3
-1.000 2.5
-1.000 2
-1.000 1.5
-1.000 1
-1.000 0.5000
-1.000 0
-0.5000 0
-0.0000 0
-0.0000 0.5
-0.0000 1
-0.0000 1.5
-0.0000 2
-0.0000 2.5
-0.0000 3
-0.0000 3.5
-0.0000 4
-0.5000 4
-1.000 4
-1.333 3.75
-1.666 3.5
-2.000 3.25
-2.333 3.5
-2.666 3.75
-3 4
-3.5 4
-3.5 3.5
-3 3.5
-3.5 3
-3.5 2.5
-3.5 2
-3.5 1.5
-3.5 1
-4 0.5
-3.5 0.5
-2.666 3.25
-2.333 3
-2.000 2.75
-4.5 0.5
-5 0.5
-1.666 3
-1.333 3.25
-1.000 3.5
-5.5 0.5
-5.500 1
-5.500 1.5
-5.500 2
-5.500 2.5
-5.500 3
-5.500 3.5
-6 2
-6 3.5
-6.5 2
-7 2
-6.5 3.5
-7 3.5
-7.5 3.5
-8 3.5
-8.5 3.5
-9 0.5
-9 1
-9 1.5
-9 2
-9 2.5
-9 3
-9 3.5
-9.5 0.5
-9.5 2
-9.5 3.5
-10 2
-10 0.5
-10.5 0.5
-11 0.5
-11.5 0.5
-12 0.5
-12.5 0.500
-12.5 1
-12.5 1.5
-12.5 2
-12.5 2.5
-12.5 3
-12.5 3.5
-13 3.5
-13.333 3.250
-13.666 3
-14.000 2.75
-10.5 3.5
-10 3.5
-0.500 3.5
-0.500 3
-0.500 2.5
-0.500 2
-0.500 1.5
-0.500 1
-0.500 0.5
-14.333 3
-14.666 3.25
-15.000 3.5
-15.500 3.5
-15.500 3
-15.500 2.5
-15.500 2
-15.500 1.5
-15.500 1
-15.500 0.5

data/nc-nurbs3d.mesh

@@ -1,342 +0,0 @@
-MFEM NURBS NC-patch mesh v1.0
-dimension
-3
-
-elements
-13
-0 1 5 0 8 10 11 9 4 6 7 5
-0 1 5 0 18 8 24 32 30 23 36 38
-0 1 5 0 0 18 32 14 12 30 38 29
-0 1 5 0 32 24 10 20 38 36 26 35
-0 1 5 0 14 32 20 2 29 38 35 16
-0 1 5 0 30 23 36 38 31 22 37 39
-0 1 5 0 12 30 38 29 13 31 39 28
-0 1 5 0 38 36 26 35 39 37 27 34
-0 1 5 0 29 38 35 16 28 39 34 17
-0 1 5 0 31 22 37 39 19 9 25 33
-0 1 5 0 13 31 39 28 1 19 33 15
-0 1 5 0 39 37 27 34 33 25 11 21
-0 1 5 0 28 39 34 17 15 33 21 3
-
-boundary
-31
-9999 3 8 10 6 4
-9999 3 10 11 7 6
-9999 3 11 9 5 7
-9999 3 9 8 4 5
-9999 3 4 6 7 5
-9999 3 32 24 8 18
-9999 3 18 8 23 30
-9999 3 14 32 18 0
-9999 3 0 18 30 12
-9999 3 14 0 12 29
-9999 3 20 10 24 32
-9999 3 10 20 35 26
-9999 3 2 20 32 14
-9999 3 20 2 16 35
-9999 3 2 14 29 16
-9999 3 30 23 22 31
-9999 3 12 30 31 13
-9999 3 29 12 13 28
-9999 3 26 35 34 27
-9999 3 35 16 17 34
-9999 3 16 29 28 17
-9999 3 31 22 9 19
-9999 3 19 9 25 33
-9999 3 13 31 19 1
-9999 3 28 13 1 15
-9999 3 1 19 33 15
-9999 3 27 34 21 11
-9999 3 33 25 11 21
-9999 3 34 17 3 21
-9999 3 17 28 15 3
-9999 3 15 33 21 3
-
-vertex_to_knotspan
-8
-23 0 1 8 10 11 9
-22 0 2 8 10 11 9
-24 1 0 8 10 11 9
-36 1 1 8 10 11 9
-37 1 2 8 10 11 9
-25 1 3 8 10 11 9
-26 2 1 8 10 11 9
-27 2 2 8 10 11 9
-
-coordinates
-40
-3
-0 0 0
-0 1 0
-4 0 0
-4 1 0
-0 0 4
-0 1 4
-4 0 4
-4 1 4
-0 0 2
-0 1 2
-4 0 2
-4 1 2
-0 0.333333333333333 0
-0 0.666666666666667 0
-2 0 0
-2 1 0
-4 0.333333333333334 0
-4 0.666666666666667 0
-0 0 1
-0 1 1
-4 0 1
-4 1 1
-0 0.666666666666667 2
-0 0.333333333333333 2
-2 0 2
-2 1 2
-4 0.333333333333333 2
-4 0.666666666666667 2
-2 0.666666666666667 0
-2 0.333333333333333 0
-0 0.333333333333333 1
-0 0.666666666666667 1
-1.81325211007895 0 1
-1.81325211007895 1 1
-4 0.666666666666667 1
-4 0.333333333333333 1
-2 0.333333333333333 2
-2 0.666666666666667 2
-1.81325211007895 0.333333333333333 1
-1.81325211007895 0.666666666666667 1
-
-edges
-87
-0 8 10
-1 10 11
-0 9 11
-1 8 9
-0 4 6
-1 6 7
-0 5 7
-1 4 5
-2 4 8
-2 6 10
-2 7 11
-2 5 9
-9 18 8
-7 8 24
-9 32 24
-7 18 32
-9 30 23
-7 23 36
-9 38 36
-7 30 38
-3 18 30
-3 8 23
-3 24 36
-3 32 38
-8 0 18
-8 14 32
-7 0 14
-8 12 30
-8 29 38
-7 12 29
-3 0 12
-3 14 29
-6 24 10
-9 20 10
-6 32 20
-6 36 26
-9 35 26
-6 38 35
-3 10 26
-3 20 35
-8 2 20
-6 14 2
-8 16 35
-6 29 16
-3 2 16
-9 31 22
-7 22 37
-9 39 37
-7 31 39
-4 30 31
-4 23 22
-4 36 37
-4 38 39
-8 13 31
-8 28 39
-7 13 28
-4 12 13
-4 29 28
-6 37 27
-9 34 27
-6 39 34
-4 26 27
-4 35 34
-8 17 34
-6 28 17
-4 16 17
-9 19 9
-7 9 25
-9 33 25
-7 19 33
-5 31 19
-5 22 9
-5 37 25
-5 39 33
-8 1 19
-8 15 33
-7 1 15
-5 13 1
-5 28 15
-6 25 11
-9 21 11
-6 33 21
-5 27 11
-5 34 21
-8 3 21
-6 15 3
-5 17 3
-
-knotvectors
-10
-1 3 0 0 0.5 1 1
-1 4 0 0 0.333333333333333 0.666666666666667 1 1
-1 3 0 0 0.5 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-
-spacing
-0
-
-weights
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-
-FiniteElementSpace
-FiniteElementCollection: NURBS1
-VDim: 3
-Ordering: 1
-
-0 0 0
-0 1 0
-4 0 0
-4 1 0
-0 0 4
-0 1 4
-4 0 4
-4 1 4
-0 0 2
-0 1 2
-4 0 2
-4 1 2
-0 0.333333333333333 0
-0 0.666666666666667 0
-2 0 0
-2 1 0
-4 0.333333333333334 0
-4 0.666666666666667 0
-0 0 1
-0 1 1
-4 0 1
-4 1 1
-0 0.666666666666667 2
-0 0.333333333333333 2
-2 0 2
-2 1 2
-4 0.333333333333333 2
-4 0.666666666666667 2
-2 0.666666666666667 0
-2 0.333333333333333 0
-0 0.333333333333333 1
-0 0.666666666666667 1
-1.81325211007895 0 1
-1.81325211007895 1 1
-4 0.666666666666667 1
-4 0.333333333333333 1
-2 0.333333333333333 2
-2 0.666666666666667 2
-1.81325211007895 0.333333333333333 1
-1.81325211007895 0.666666666666667 1
-2 0 4
-4 0.333333333333333 4
-4 0.666666666666667 4
-2 1 4
-0 0.333333333333333 4
-0 0.666666666666667 4
-0 0 3
-4 0 3
-4 1 3
-0 1 3
-2 0 3
-4 0.333333333333333 3
-4 0.666666666666667 3
-2 1 3
-0 0.666666666666667 3
-0 0.333333333333333 3
-2 0.333333333333333 4
-2 0.666666666666667 4
-2 0.333333333333333 3
-2 0.666666666666667 3

data/nc3-nurbs.mesh

@@ -1,96 +0,0 @@
-MFEM NURBS NC-patch mesh v1.0
-dimension
-2
-
-# rank attr geom ref_type nodes/children
-elements
-3
-0 1 3 0 0 4 5 1
-0 1 3 0 6 7 4 2
-0 1 3 0 6 3 5 7
-
-# attr geom nodes
-boundary
-7
-1 1 0 4
-1 1 5 1
-1 1 1 0
-1 1 2 6
-1 1 6 3
-1 1 4 2
-1 1 5 3
-
-vertex_to_knotspan
-1
-7 1 4 5
-
-# top-level node coordinates
-coordinates
-8
-2
-0 0
-0 1
-2 0
-2 1
-1 0
-1 1
-2 0.5
-1 0.5
-
-edges
-11
-0 0 4
-1 4 5
-0 1 5
-1 0 1
-2 6 7
-4 7 4
-2 2 4
-4 6 2
-3 6 3
-2 3 5
-3 7 5
-
-knotvectors
-5
-1 3 0 0 0.5 1 1
-1 3 0 0 0.5 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-1 2 0 0 1 1
-
-spacing
-0
-
-weights
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-1.0
-
-FiniteElementSpace
-FiniteElementCollection: NURBS1
-VDim: 2
-Ordering: 1
-
-0 0
-0 1
-2 0
-2 1
-1 0
-1 1
-2 0.5
-1 0.5
-0.5 0
-0.5 1
-0 0.5
-0.5 0.5
-mfem_mesh_end

data/square-disc-p2.mesh

@@ -227,7 +227,7 @@ vertices
 
 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_2D_P2
+FiniteElementCollection: Quadratic
 VDim: 2
 Ordering: 0
 

data/star-q2.mesh

@@ -65,7 +65,7 @@ vertices
 
 nodes
 FiniteElementSpace
-FiniteElementCollection: H1_2D_P2
+FiniteElementCollection: Quadratic
 VDim: 2
 Ordering: 0
 

doc/CodeDocumentation.dox

@@ -202,7 +202,6 @@ namespace mfem {
  * - <a class="el" href="tesla_8cpp_source.html">Tesla</a>: simple magnetostatics simulation code
  * - <a class="el" href="maxwell_8cpp_source.html">Maxwell</a>: simple transient full-wave electromagnetics simulation code
  * - <a class="el" href="joule_8cpp_source.html">Joule</a>: transient magnetics and Joule heating miniapp
- * - <a class="el" href="lorentz_8cpp_source.html">Lorentz</a>: simple particle tracking code based on the Lorentz force
  * - <a class="el" href="classmfem_1_1navier_1_1NavierSolver.html">Navier</a>: solve the transient incompressible Navier-Stokes equations
  * - <a class="el" href="mobius-strip_8cpp_source.html">Mobius Strip</a>: generate various Mobius strip-like meshes
  * - <a class="el" href="klein-bottle_8cpp_source.html">Klein Bottle</a>: generate three types of Klein bottle surfaces

examples/CMakeLists.txt

@@ -205,15 +205,6 @@ if (MFEM_ENABLE_TESTING)
       $<TARGET_FILE:ex25p> "-no-vis" "--mumps-solver"
       ${MPIEXEC_POSTFLAGS})
   endif()
-
-  # Parallel libCEED example
-  if (MFEM_USE_CEED AND MFEM_USE_MPI)
-    add_test(NAME ex1p_ceed_np=${MFEM_MPI_NP}
-      COMMAND ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${MFEM_MPI_NP}
-      ${MPIEXEC_PREFLAGS}
-      $<TARGET_FILE:ex1p> "-no-vis" "-d ceed-cpu" "-pa" "-a"
-      ${MPIEXEC_POSTFLAGS})
-  endif()
 endif()
 
 # Include the examples/amgx directory if AmgX is enabled

examples/ex1.cpp

@@ -27,7 +27,6 @@
 //               ex1 -m ../data/fichera-amr.mesh
 //               ex1 -m ../data/mobius-strip.mesh
 //               ex1 -m ../data/mobius-strip.mesh -o -1 -sc
-//               ex1 -m ../data/nc3-nurbs.mesh -o -1
 //
 // Device sample runs:
 //               ex1 -pa -d cuda

examples/makefile

@@ -173,12 +173,6 @@ ex11p-test-cpardiso: ex11p
 	@$(call mfem-test,$<, $(RUN_MPI), MKL_CPARDISO example,--cpardiso)
 test-par-YES: ex11p-test-cpardiso
 endif
-ifeq ($(MFEM_USE_CEED),YES)
-ex1p-test-ceed: ex1p
-	@$(call mfem-test,$<, $(RUN_MPI),\
-	   Parallel libCEED example,-d ceed-cpu -pa -a)
-test-par-YES: ex1p-test-ceed
-endif
 
 # Testing: "test" target and mfem-test* variables are defined in config/test.mk
 

examples/sundials/ex16.cpp

@@ -28,8 +28,10 @@
 //
 //               The example demonstrates the use of nonlinear operators (the
 //               class ConductionOperator defining C(u)), as well as their
-//               implicit time integration. By default, this example uses the
-//               SUNDIALS ODE solvers from CVODE and ARKODE.
+//               implicit time integration. Note that implementing the method
+//               ConductionOperator::ImplicitSolve is the only requirement for
+//               high-order implicit (SDIRK) time integration. By default, this
+//               example uses the SUNDIALS ODE solvers from CVODE and ARKODE.
 //
 //               We recommend viewing examples 2, 9 and 10 before viewing this
 //               example.
@@ -49,16 +51,15 @@ using namespace mfem;
  *  and K(u) is the diffusion operator with diffusivity depending on u:
  *  (\kappa + \alpha u).
  *
- *  Class ConductionOperator represents the above ODE operator as a
- *  TimeDependentOperator for use with native MFEM integrators and CVODE
- *  integrators, i.e., F(u, k, t) = G(u, t) with F(u, du/dt, t) = du/dt and
- *  G(u, t) = -K(u) u
+ *  Class ConductionOperatorOperator represents the above ODE operator in the
+ *  general form F(u, k, t) = G(u, t) where
  *
- *  Class ConductionOperator represents the above ODE operator as an
- *  ARKStepODE for use with ARKODE integrators, i.e., either M du/dt = -K(u) u
- *  (mass form) or du/dt = -inv(M) K(u) u (MFEM form)
+ *    1. F(u, du/dt, t) = du/dt            (ODE is expressed in EXPLICIT form)
+ *       G(u, t) = - inv(M) K(u) u
+ *    2. F(u, du/dt, t) = M du/dt          (ODE is expressed in IMPLICIT form)
+ *       G(u, t) = - K(u) u
  */
-class ConductionOperator : public TimeDependentOperator, public ARKStepODE
+class ConductionOperator : public TimeDependentOperator
 {
    FiniteElementSpace &fespace;
    Array<int> ess_tdof_list; // this list remains empty for pure Neumann b.c.
@@ -80,90 +81,50 @@ class ConductionOperator : public TimeDependentOperator, public ARKStepODE
 
    mutable Vector z; // auxiliary vector
 
-   const bool use_mass_form;
-
 public:
 
    ConductionOperator(FiniteElementSpace &f, const real_t alpha,
                       const real_t kappa, const Vector &u,
-                      const bool use_mass_form);
+                      const Type &ode_expression_type);
 
    // Compute K(u_n) for use as an approximation in - K(u) u
    void SetConductionTensor(const Vector &u);
 
-   // ********* methods for MFEM native time integrators *********
+   /** Compute G(u, t) as defined in the IMPLICIT expression form of the ODE
+    operator, i.e., @a v = - K(u_n) @a u. Note that K(u_n) is an
+      approximation to K(u). */
+   void ExplicitMult(const Vector &u, Vector &v) const override;
 
-   /** Solve for k in F(u, k, t) = G(u, t), i.e., @a k = - inv(M) K(u_n) @a u.
+   /** Solve for k in F(u, k, t) = G(u, t) for either EXPLICIT or IMPLICIT
+       expression forms of the ODE operator, i.e., @a k = - inv(M) K(u_n) @a u.
        Note that K(u_n) is an approximation to K(u). */
    void Mult(const Vector &u, Vector &k) const override;
 
-   /** Solve for k in F(u + gam*k, k, t) = G(u + gam*k, t), i.e.,
-       [ M + @a gam K(u_n) ] @a k = - K(u_n) @a u .
-       Note that K(u_n) is an approximation to K(u). */
+   /** Solve for k in F(u + gam*k, k, t) = G(u + gam*k, t) for either EXPLICIT
+       or IMPLICIT expression forms of the ODE operator, i.e.,
+       [ M + @a gam K(u_n) ] @a k = - K(u_n) @a u . Note that K(u_n) is an
+       approximation to K(u). */
    void ImplicitSolve(const real_t gam, const Vector &u, Vector &k) override;
 
-      // ********* methods for ARKODE time integrators *********
-
-   // TODO: add comments
-   int ARKSize() const override;
-
-   // TODO: add comments
-   bool ARKInMassForm() const override;
-
-   // TODO: add comments
-   void ARKEvaluateRHS(const Vector &u, const real_t t, Vector &result) const override;
-
-   // TODO: add comments
-   int ARKImplicitSetup(const Vector &u, const real_t t, const Vector &fu,
-                        int jok, int *jcur, real_t gam) override;
-
-   /** Solve for @a dk in the system in SUNImplicitSetup to the given tolerance,
-       with the residual @a r providing either
-        1. @a r = G - F = inv(M) f(u) - k       (MFEM form)
-        1. @a r = G - F = f(u) - M k            (mass form)
-       */
-   int ARKImplicitSolve(const Vector &r, Vector &dk, real_t tol) override;
-
-   int ARKMassSetup(const real_t t) override;
-
-   int ARKMassSolve(const Vector &b, Vector &x, real_t tol) override;
-
-   int ARKMassMult(const Vector &x, Vector &v) override;
-
-   // ********* methods for CVODE time integrators *********
-   // note these methods merely call the corresponding ARKStepODE methods until
-   // the CVODESolver is refactored to use specialized interface like ARKStepODE
-
-   /** Setup to solve for dk in [dF/dk + gam*dF/du - gam*dG/du] dk = G - F, i.e.,
+   /** Setup to solve for dk in [dF/dk + gam*dF/du - gam*dG/du] dk = G - F for
+       either EXPLICIT or IMPLICIT expression forms of the ODE operator, i.e.,
        [M - @a gam Jf(u)] dk = G - F, where Jf(u) is an approximation of the
        Jacobian of -K(u) u. The approximation chosen here is Jf(u) = -K(u_n). */
    int SUNImplicitSetup(const Vector &u, const Vector &fu, int jok, int *jcur,
-                        real_t gam) override
-   {
-      return ARKImplicitSetup(u, 0.0, fu, jok, jcur, gam); // the ODE is autonomous
-   }
+                        real_t gam) override;
 
    /** Solve for @a dk in the system in SUNImplicitSetup to the given tolerance,
-       with the residual @a r providing @a r = G - F = inv(M) f(u) - k. */
-   int SUNImplicitSolve(const Vector &r, Vector &dk, real_t tol) override
-   {
-      return ARKImplicitSolve(r, dk, tol);
-   }
+       with the residual @a r providing either
+        1. @a r = G - F = inv(M) f(u) - k       (EXPLICIT expression form)
+        1. @a r = G - F = f(u) - M k            (IMPLICIT expression form)
+       */
+   int SUNImplicitSolve(const Vector &r, Vector &dk, real_t tol) override;
 
-   int SUNMassSetup() override
-   {
-      return ARKMassSetup(0.0); // the ODE is autonomous
-   }
+   int SUNMassSetup() override;
 
-   int SUNMassSolve(const Vector &b, Vector &x, real_t tol) override
-   {
-      return ARKMassSolve(b, x, tol);
-   }
+   int SUNMassSolve(const Vector &b, Vector &x, real_t tol) override;
 
-   int SUNMassMult(const Vector &x, Vector &v) override
-   {
-      return ARKMassMult(x, v);
-   }
+   int SUNMassMult(const Vector &x, Vector &v) override;
 };
 
 real_t InitialTemperature(const Vector &x)
@@ -284,7 +245,16 @@ int main(int argc, char *argv[])
    u_gf.GetTrueDofs(u);
 
    // 6. Initialize the conduction ODE operator and the visualization.
-   ConductionOperator oper(fespace, alpha, kappa, u, use_mass_solver);
+   ConductionOperator::Type ode_expression_type;
+   if (use_mass_solver)
+   {
+      ode_expression_type = ConductionOperator::Type::IMPLICIT;
+   }
+   else
+   {
+      ode_expression_type = ConductionOperator::Type::EXPLICIT;
+   }
+   ConductionOperator oper(fespace, alpha, kappa, u, ode_expression_type);
 
    u_gf.SetFromTrueDofs(u);
    {
@@ -382,7 +352,7 @@ int main(int argc, char *argv[])
          }
          std::unique_ptr<ARKStepSolver> arkode(
             new ARKStepSolver(arkode_solver_type));
-         arkode->Init(&oper);
+         arkode->Init(oper);
          arkode->SetSStolerances(reltol, abstol);
          arkode->SetMaxStep(dt);
          if (ode_solver_type == 11 || ode_solver_type == 14)
@@ -475,10 +445,9 @@ int main(int argc, char *argv[])
 ConductionOperator::ConductionOperator(FiniteElementSpace &fes,
                                        const real_t alpha, const real_t kappa,
                                        const Vector &u,
-                                       const bool use_mass_form)
-   : TimeDependentOperator(fes.GetTrueVSize(), 0.0),
-     fespace(fes), M(&fespace), alpha(alpha), kappa(kappa), z(height),
-     use_mass_form(use_mass_form)
+                                       const Type &ode_expression_type)
+   : TimeDependentOperator(fes.GetTrueVSize(), 0.0, ode_expression_type),
+     fespace(fes), M(&fespace), alpha(alpha), kappa(kappa), z(height)
 {
    // specify a relative tolerance for all solves with MFEM integrators
    const real_t rel_tol = 1e-8;
@@ -505,16 +474,6 @@ ConductionOperator::ConductionOperator(FiniteElementSpace &fes,
    SetConductionTensor(u);
 }
 
-int ConductionOperator::ARKSize() const
-{
-   return z.Size();
-}
-
-bool ConductionOperator::ARKInMassForm() const
-{
-   return use_mass_form;
-}
-
 void ConductionOperator::SetConductionTensor(const Vector &u)
 {
    // Compute K(u_n).
@@ -532,27 +491,17 @@ void ConductionOperator::SetConductionTensor(const Vector &u)
    K->FormSystemMatrix(ess_tdof_list, Kmat);
 }
 
-void ConductionOperator::ARKEvaluateRHS(const Vector &u, const real_t t,
-                                        Vector &result) const
+void ConductionOperator::ExplicitMult(const Vector &u, Vector &v) const
 {
-   if (use_mass_form) // compute -K(u_n) u.
-   {
-      Kmat.Mult(u, result);
-      result.Neg();
-   }
-   else // compute -inv(M) K(u_n) u
-   {
-      Kmat.Mult(u, z);
-      z.Neg();
-      M_solver.Mult(z, result);
-   }
+   // Compute - K(u_n) u.
+   Kmat.Mult(u, v);
+   v.Neg();
 }
 
 void ConductionOperator::Mult(const Vector &u, Vector &k) const
 {
    // Compute - inv(M) K(u_n) u.
-   Kmat.Mult(u, z);
-   z.Neg();
+   ExplicitMult(u, z);
    M_solver.Mult(z, k);
 }
 
@@ -560,16 +509,14 @@ void ConductionOperator::ImplicitSolve(const real_t gam, const Vector &u,
                                        Vector &k)
 {
    // Solve for k in M k = - K(u_n) [u + gam*k].
-   Kmat.Mult(u, z);
-   z.Neg();
+   ExplicitMult(u, z);
    T = std::unique_ptr<SparseMatrix>(Add(1.0, Mmat, gam, Kmat));
    T_solver.SetOperator(*T);
    T_solver.Mult(z, k);
 }
 
-int ConductionOperator::ARKImplicitSetup(const Vector &u, const real_t t,
-                                         const Vector &fu, int jok, int *jcur,
-                                         real_t gam)
+int ConductionOperator::SUNImplicitSetup(const Vector &u, const Vector &fu,
+                                         int jok, int *jcur, real_t gam)
 {
    // Compute T = M + gamma K(u_n).
    T = std::unique_ptr<SparseMatrix>(Add(1.0, Mmat, gam, Kmat));
@@ -578,23 +525,23 @@ int ConductionOperator::ARKImplicitSetup(const Vector &u, const real_t t,
    return SUN_SUCCESS;
 }
 
-int ConductionOperator::ARKImplicitSolve(const Vector &r, Vector &dk,
+int ConductionOperator::SUNImplicitSolve(const Vector &r, Vector &dk,
                                          real_t tol)
 {
    // Solve the system [M + gamma K(u_n)] dk = - K(u_n) u - M k.
    // What value r is providing depends on the ODE expression form:
-   //   MFEM form: r = -inv(M) K(u_n) u - k
-   //   mass form: r = -K(u_n) u - M k
+   //   EXPLICIT form: r = -inv(M) K(u_n) u - k
+   //   IMPLICIT form: r = -K(u_n) u - M k
    T_solver.SetRelTol(tol);
-   if (use_mass_form)
-   {
-      T_solver.Mult(r, dk);
-   }
-   else
+   if (isExplicit())
    {
       Mmat.Mult(r, z);
       T_solver.Mult(z, dk);
    }
+   else
+   {
+      T_solver.Mult(r, dk);
+   }
    if (T_solver.GetConverged())
    {
       return SUN_SUCCESS;
@@ -605,13 +552,13 @@ int ConductionOperator::ARKImplicitSolve(const Vector &r, Vector &dk,
    }
 }
 
-int ConductionOperator::ARKMassSetup(const real_t t)
+int ConductionOperator::SUNMassSetup()
 {
    // Do nothing b/c mass solver was setup in constructor.
    return SUN_SUCCESS;
 }
 
-int ConductionOperator::ARKMassSolve(const Vector &b, Vector &x, real_t tol)
+int ConductionOperator::SUNMassSolve(const Vector &b, Vector &x, real_t tol)
 {
    // Solve the system M x = b.
    M_solver.SetRelTol(tol);
@@ -626,7 +573,7 @@ int ConductionOperator::ARKMassSolve(const Vector &b, Vector &x, real_t tol)
    }
 }
 
-int ConductionOperator::ARKMassMult(const Vector &x, Vector &v)
+int ConductionOperator::SUNMassMult(const Vector &x, Vector &v)
 {
    // Compute M x.
    Mmat.Mult(x, v);

examples/sundials/ex16p.cpp

@@ -29,8 +29,10 @@
 //
 //               The example demonstrates the use of nonlinear operators (the
 //               class ConductionOperator defining C(u)), as well as their
-//               implicit time integration. By default, this example uses the
-//               SUNDIALS ODE solvers from CVODE and ARKODE.
+//               implicit time integration. Note that implementing the method
+//               ConductionOperator::ImplicitSolve is the only requirement for
+//               high-order implicit (SDIRK) time integration. By default, this
+//               example uses the SUNDIALS ODE solvers from CVODE and ARKODE.
 //
 //               We recommend viewing examples 2, 9 and 10 before viewing this
 //               example.
@@ -50,16 +52,15 @@ using namespace mfem;
  *  and K(u) is the diffusion operator with diffusivity depending on u:
  *  (\kappa + \alpha u).
  *
- *  Class ConductionOperator represents the above ODE operator as a
- *  TimeDependentOperator for use with native MFEM integrators and CVODE
- *  integrators, i.e., F(u, k, t) = G(u, t) with F(u, du/dt, t) = du/dt and
- *  G(u, t) = -K(u) u
+ *  Class ConductionOperatorOperator represents the above ODE operator in the
+ *  general form F(u, k, t) = G(u, t) where either
  *
- *  Class ConductionOperator represents the above ODE operator as an
- *  ARKStepODE for use with ARKODE integrators, i.e., either M du/dt = -K(u) u
- *  (mass form) or du/dt = -inv(M) K(u) u (MFEM form)
+ *    1. F(u, du/dt, t) = du/dt            (ODE is expressed in EXPLICIT form)
+ *       G(u, t) = - inv(M) K(u) u
+ *    2. F(u, du/dt, t) = M du/dt          (ODE is expressed in IMPLICIT form)
+ *       G(u, t) = - K(u) u
  */
-class ConductionOperator : public TimeDependentOperator, public ARKStepODE
+class ConductionOperator : public TimeDependentOperator
 {
    ParFiniteElementSpace &fespace;
    Array<int> ess_tdof_list; // this list remains empty for pure Neumann b.c.
@@ -81,90 +82,50 @@ class ConductionOperator : public TimeDependentOperator, public ARKStepODE
 
    mutable Vector z; // auxiliary vector
 
-   const bool use_mass_form;
-
 public:
 
    ConductionOperator(ParFiniteElementSpace &f, const real_t alpha,
                       const real_t kappa, const Vector &u,
-                      const bool use_mass_form);
+                      const Type &ode_expression_type);
 
    // Compute K(u_n) for use as an approximation in - K(u) u
    void SetConductionTensor(const Vector &u);
 
-   // ********* methods for MFEM native time integrators *********
+   /** Compute G(u, t) as defined in the IMPLICIT expression form of the ODE
+       operator, i.e., @a v = - K(u_n) @a u. Note that K(u_n) is an
+       approximation to K(u). */
+   void ExplicitMult(const Vector &u, Vector &v) const override;
 
-   /** Solve for k in F(u, k, t) = G(u, t), i.e., @a k = - inv(M) K(u_n) @a u.
+   /** Solve for k in F(u, k, t) = G(u, t) for either EXPLICIT or IMPLICIT
+       expression forms of the ODE operator, i.e., @a k = - inv(M) K(u_n) @a u.
        Note that K(u_n) is an approximation to K(u). */
    void Mult(const Vector &u, Vector &k) const override;
 
-   /** Solve for k in F(u + gam*k, k, t) = G(u + gam*k, t), i.e.,
-       [ M + @a gam K(u_n) ] @a k = - K(u_n) @a u .
-       Note that K(u_n) is an approximation to K(u). */
+   /** Solve for k in F(u + gam*k, k, t) = G(u + gam*k, t) for either EXPLICIT
+       or IMPLICIT expression forms of the ODE operator, i.e.,
+       [ M + @a gam K(u_n) ] @a k = - K(u_n) @a u . Note that K(u_n) is an
+       approximation to K(u). */
    void ImplicitSolve(const real_t gam, const Vector &u, Vector &k) override;
 
-   // ********* methods for ARKODE time integrators *********
-
-   // TODO: add comments
-   int ARKSize() const override;
-
-   // TODO: add comments
-   bool ARKInMassForm() const override;
-
-   // TODO: add comments
-   void ARKEvaluateRHS(const Vector &u, const real_t t, Vector &result) const override;
-
-   // TODO: add comments
-   int ARKImplicitSetup(const Vector &u, const real_t t, const Vector &fu,
-                        int jok, int *jcur, real_t gam) override;
-
-   /** Solve for @a dk in the system in SUNImplicitSetup to the given tolerance,
-       with the residual @a r providing either
-        1. @a r = G - F = inv(M) f(u) - k       (MFEM form)
-        1. @a r = G - F = f(u) - M k            (mass form)
-       */
-   int ARKImplicitSolve(const Vector &r, Vector &dk, real_t tol) override;
-
-   int ARKMassSetup(const real_t t) override;
-
-   int ARKMassSolve(const Vector &b, Vector &x, real_t tol) override;
-
-   int ARKMassMult(const Vector &x, Vector &v) override;
-
-   // ********* methods for CVODE time integrators *********
-   // note these methods merely call the corresponding ARKStepODE methods until
-   // the CVODESolver is refactored to use specialized interface like ARKStepODE
-
-   /** Setup to solve for dk in [dF/dk + gam*dF/du - gam*dG/du] dk = G - F, i.e.,
+   /** Setup to solve for dk in [dF/dk + gam*dF/du - gam*dG/du] dk = G - F for
+       either EXPLICIT or IMPLICIT expression forms of the ODE operator, i.e.,
        [M - @a gam Jf(u)] dk = G - F, where Jf(u) is an approximation of the
        Jacobian of -K(u) u. The approximation chosen here is Jf(u) = -K(u_n). */
    int SUNImplicitSetup(const Vector &u, const Vector &fu, int jok, int *jcur,
-                        real_t gam) override
-   {
-      return ARKImplicitSetup(u, 0.0, fu, jok, jcur, gam); // the ODE is autonomous
-   }
+                        real_t gam) override;
 
    /** Solve for @a dk in the system in SUNImplicitSetup to the given tolerance,
-       with the residual @a r providing @a r = G - F = inv(M) f(u) - k. */
-   int SUNImplicitSolve(const Vector &r, Vector &dk, real_t tol) override
-   {
-      return ARKImplicitSolve(r, dk, tol);
-   }
+       with the residual @a r providing either
+        1. @a r = G - F = inv(M) f(u) - k       (EXPLICIT expression form)
+        1. @a r = G - F = f(u) - M k            (IMPLICIT expression form)
+       */
+   int SUNImplicitSolve(const Vector &r, Vector &dk, real_t tol) override;
 
-   int SUNMassSetup() override
-   {
-      return ARKMassSetup(0.0); // the ODE is autonomous
-   }
+   int SUNMassSetup() override;
 
-   int SUNMassSolve(const Vector &b, Vector &x, real_t tol) override
-   {
-      return ARKMassSolve(b, x, tol);
-   }
+   int SUNMassSolve(const Vector &b, Vector &x, real_t tol) override;
 
-   int SUNMassMult(const Vector &x, Vector &v) override
-   {
-      return ARKMassMult(x, v);
-   }
+   int SUNMassMult(const Vector &x, Vector &v) override;
 };
 
 real_t InitialTemperature(const Vector &x)
@@ -312,7 +273,16 @@ int main(int argc, char *argv[])
    u_gf.GetTrueDofs(u);
 
    // 8. Initialize the conduction ODE operator and the visualization.
-   ConductionOperator oper(fespace, alpha, kappa, u, use_mass_solver);
+   ConductionOperator::Type ode_expression_type;
+   if (use_mass_solver)
+   {
+      ode_expression_type = ConductionOperator::Type::IMPLICIT;
+   }
+   else
+   {
+      ode_expression_type = ConductionOperator::Type::EXPLICIT;
+   }
+   ConductionOperator oper(fespace, alpha, kappa, u, ode_expression_type);
 
    u_gf.SetFromTrueDofs(u);
    {
@@ -424,7 +394,7 @@ int main(int argc, char *argv[])
          }
          std::unique_ptr<ARKStepSolver> arkode(
             new ARKStepSolver(MPI_COMM_WORLD, arkode_solver_type));
-         arkode->Init(&oper);
+         arkode->Init(oper);
          arkode->SetSStolerances(reltol, abstol);
          arkode->SetMaxStep(dt);
          if (ode_solver_type == 11 || ode_solver_type == 14)
@@ -527,11 +497,10 @@ int main(int argc, char *argv[])
 ConductionOperator::ConductionOperator(ParFiniteElementSpace &fes,
                                        const real_t alpha, const real_t kappa,
                                        const Vector &u,
-                                       const bool use_mass_form)
-   : TimeDependentOperator(fes.GetTrueVSize(), 0.0),
+                                       const Type &ode_expression_type)
+   : TimeDependentOperator(fes.GetTrueVSize(), 0.0, ode_expression_type),
      fespace(fes), M(&fespace), alpha(alpha), kappa(kappa),
-     M_solver(fes.GetComm()), T_solver(fes.GetComm()), z(height),
-     use_mass_form(use_mass_form)
+     M_solver(fes.GetComm()), T_solver(fes.GetComm()), z(height)
 {
    // specify a relative tolerance for all solves with MFEM integrators
    const real_t rel_tol = 1e-8;
@@ -559,16 +528,6 @@ ConductionOperator::ConductionOperator(ParFiniteElementSpace &fes,
    SetConductionTensor(u);
 }
 
-int ConductionOperator::ARKSize() const
-{
-   return z.Size();
-}
-
-bool ConductionOperator::ARKInMassForm() const
-{
-   return use_mass_form;
-}
-
 void ConductionOperator::SetConductionTensor(const Vector &u)
 {
    // Compute K(u_n).
@@ -586,27 +545,17 @@ void ConductionOperator::SetConductionTensor(const Vector &u)
    K->FormSystemMatrix(ess_tdof_list, Kmat);
 }
 
-void ConductionOperator::ARKEvaluateRHS(const Vector &u, const real_t t,
-                                        Vector &result) const
+void ConductionOperator::ExplicitMult(const Vector &u, Vector &v) const
 {
-   if (use_mass_form) // compute -K(u_n) u.
-   {
-      Kmat.Mult(u, result);
-      result.Neg();
-   }
-   else // compute -inv(M) K(u_n) u
-   {
-      Kmat.Mult(u, z);
-      z.Neg();
-      M_solver.Mult(z, result);
-   }
+   // Compute - K(u_n) u.
+   Kmat.Mult(u, v);
+   v.Neg();
 }
 
 void ConductionOperator::Mult(const Vector &u, Vector &k) const
 {
    // Compute - inv(M) K(u_n) u.
-   Kmat.Mult(u, z);
-   z.Neg();
+   ExplicitMult(u, z);
    M_solver.Mult(z, k);
 }
 
@@ -614,16 +563,14 @@ void ConductionOperator::ImplicitSolve(const real_t gam, const Vector &u,
                                        Vector &k)
 {
    // Solve for k in M k = - K(u_n) [u + gam*k].
-   Kmat.Mult(u, z);
-   z.Neg();
+   ExplicitMult(u, z);
    T = std::unique_ptr<HypreParMatrix>(Add(1.0, Mmat, gam, Kmat));
    T_solver.SetOperator(*T);
    T_solver.Mult(z, k);
 }
 
-int ConductionOperator::ARKImplicitSetup(const Vector &u, const real_t t,
-                                         const Vector &fu, int jok, int *jcur,
-                                         real_t gam)
+int ConductionOperator::SUNImplicitSetup(const Vector &u, const Vector &fu,
+                                         int jok, int *jcur, real_t gam)
 {
    // Compute T = M + gamma K(u_n).
    T = std::unique_ptr<HypreParMatrix>(Add(1.0, Mmat, gam, Kmat));
@@ -632,23 +579,23 @@ int ConductionOperator::ARKImplicitSetup(const Vector &u, const real_t t,
    return SUN_SUCCESS;
 }
 
-int ConductionOperator::ARKImplicitSolve(const Vector &r, Vector &dk,
+int ConductionOperator::SUNImplicitSolve(const Vector &r, Vector &dk,
                                          real_t tol)
 {
    // Solve the system [M + gamma K(u_n)] dk = - K(u_n) u - M k.
    // What value r is providing depends on the ODE expression form:
-   //   MFEM form: r = -inv(M) K(u_n) u - k
-   //   mass form: r = -K(u_n) u - M k
+   //   EXPLICIT form: r = -inv(M) K(u_n) u - k
+   //   IMPLICIT form: r = -K(u_n) u - M k
    T_solver.SetRelTol(tol);
-   if (use_mass_form)
-   {
-      T_solver.Mult(r, dk);
-   }
-   else
+   if (isExplicit())
    {
       Mmat.Mult(r, z);
       T_solver.Mult(z, dk);
    }
+   else
+   {
+      T_solver.Mult(r, dk);
+   }
    if (T_solver.GetConverged())
    {
       return SUN_SUCCESS;
@@ -659,13 +606,13 @@ int ConductionOperator::ARKImplicitSolve(const Vector &r, Vector &dk,
    }
 }
 
-int ConductionOperator::ARKMassSetup(const real_t t)
+int ConductionOperator::SUNMassSetup()
 {
    // Do nothing b/c mass solver was setup in constructor.
    return SUN_SUCCESS;
 }
 
-int ConductionOperator::ARKMassSolve(const Vector &b, Vector &x, real_t tol)
+int ConductionOperator::SUNMassSolve(const Vector &b, Vector &x, real_t tol)
 {
    // Solve the system M x = b.
    M_solver.SetRelTol(tol);
@@ -680,7 +627,7 @@ int ConductionOperator::ARKMassSolve(const Vector &b, Vector &x, real_t tol)
    }
 }
 
-int ConductionOperator::ARKMassMult(const Vector &x, Vector &v)
+int ConductionOperator::SUNMassMult(const Vector &x, Vector &v)
 {
    // Compute M x.
    Mmat.Mult(x, v);

examples/sundials/ex9.cpp

@@ -119,7 +119,7 @@ public:
     and advection matrices, and b describes the flow on the boundary. This can
     be written as a general ODE, du/dt = M^{-1} (K u + b), and this class is
     used to evaluate the right-hand side. */
-class FE_Evolution : public TimeDependentOperator, public ARKStepODE
+class FE_Evolution : public TimeDependentOperator
 {
 private:
    BilinearForm &M, &K;
@@ -133,14 +133,9 @@ private:
 public:
    FE_Evolution(BilinearForm &M_, BilinearForm &K_, const Vector &b_);
 
-   // TimeDependentOperator methods for MFEM native and CVODE time integrators
    virtual void Mult(const Vector &x, Vector &y) const;
    virtual void ImplicitSolve(const double dt, const Vector &x, Vector &k);
 
-   // ARKStepODE methods for ARKODE time integrators
-   int ARKSize() const override;
-   void ARKEvaluateRHS(const Vector &u, const real_t t, Vector& result) const override;
-
    virtual ~FE_Evolution();
 };
 
@@ -409,14 +404,14 @@ int main(int argc, char *argv[])
          ode_solver = cvode; break;
       case 8:
          arkode = new ARKStepSolver(ARKStepSolver::EXPLICIT);
-         arkode->Init(&adv);
+         arkode->Init(adv);
          arkode->SetSStolerances(reltol, abstol);
          arkode->SetMaxStep(dt);
          arkode->SetOrder(4);
          ode_solver = arkode; break;
       case 9:
          arkode = new ARKStepSolver(ARKStepSolver::EXPLICIT);
-         arkode->Init(&adv);
+         arkode->Init(adv);
          arkode->SetSStolerances(reltol, abstol);
          arkode->SetMaxStep(dt);
          arkode->SetERKTableNum(ARKODE_FEHLBERG_13_7_8);
@@ -525,19 +520,6 @@ void FE_Evolution::ImplicitSolve(const double dt, const Vector &x, Vector &k)
    dg_solver->Mult(z, k);
 }
 
-int FE_Evolution::ARKSize() const
-{
-   return z.Size();
-}
-
-void FE_Evolution::ARKEvaluateRHS(const Vector &u, const real_t t, Vector &result) const
-{
-   // y = M^{-1} (K x + b)
-   K.Mult(u, z);
-   z += b;
-   M_solver.Mult(z, result);
-}
-
 FE_Evolution::~FE_Evolution()
 {
    delete M_prec;

examples/sundials/ex9p.cpp

@@ -206,7 +206,7 @@ public:
     and advection matrices, and b describes the flow on the boundary. This can
     be written as a general ODE, du/dt = M^{-1} (K u + b), and this class is
     used to evaluate the right-hand side. */
-class FE_Evolution : public TimeDependentOperator, public ARKStepODE
+class FE_Evolution : public TimeDependentOperator
 {
 private:
    OperatorHandle M, K;
@@ -221,14 +221,9 @@ public:
    FE_Evolution(ParBilinearForm &M_, ParBilinearForm &K_, const Vector &b_,
                 PrecType prec_type);
 
-   // TimeDependentOperator methods for MFEM native and CVODE time integrators
    virtual void Mult(const Vector &x, Vector &y) const;
    virtual void ImplicitSolve(const double dt, const Vector &x, Vector &k);
 
-   // ARKStepODE methods for ARKODE time integrators
-   int ARKSize() const override;
-   void ARKEvaluateRHS(const Vector &u, const real_t t, Vector& result) const override;
-
    virtual ~FE_Evolution();
 };
 
@@ -580,7 +575,7 @@ int main(int argc, char *argv[])
       case 8:
       case 9:
          arkode = new ARKStepSolver(MPI_COMM_WORLD, ARKStepSolver::EXPLICIT);
-         arkode->Init(&adv);
+         arkode->Init(adv);
          arkode->SetSStolerances(reltol, abstol);
          arkode->SetMaxStep(dt);
          if (ode_solver_type == 9)
@@ -748,19 +743,6 @@ void FE_Evolution::Mult(const Vector &x, Vector &y) const
    M_solver.Mult(z, y);
 }
 
-int FE_Evolution::ARKSize() const
-{
-   return z.Size();
-}
-
-void FE_Evolution::ARKEvaluateRHS(const Vector &u, const real_t t, Vector &result) const
-{
-   // y = M^{-1} (K x + b)
-   K->Mult(u, z);
-   z += b;
-   M_solver.Mult(z, result);
-}
-
 FE_Evolution::~FE_Evolution()
 {
    delete M_prec;

fem/CMakeLists.txt

@@ -82,8 +82,6 @@ set(SRCS
   fe/fe_ser.cpp
   fe_coll.cpp
   fespace.cpp
-  derefmat_op.cpp
-  pderefmat_op.cpp
   geom.cpp
   gridfunc.cpp
   hybridization.cpp
@@ -164,18 +162,12 @@ set(SRCS
   transfer.cpp
   hyperbolic.cpp
   integrator.cpp
-  bounds.cpp
   )
 
 set(HDRS
   bilinearform.hpp
   bilinearform_ext.hpp
   bilininteg.hpp
-  integ/lininteg_domain_kernels.hpp
-  integ/bilininteg_dgdiffusion_kernels.hpp
-  integ/bilininteg_dgtrace_kernels.hpp
-  integ/bilininteg_vecdiffusion_kernels.hpp
-  integ/bilininteg_convection_kernels.hpp
   integ/bilininteg_diffusion_kernels.hpp
   integ/bilininteg_elasticity_kernels.hpp
   integ/bilininteg_hcurl_kernels.hpp
@@ -246,20 +238,14 @@ set(HDRS
   lor/lor_ams.hpp
   lor/lor_batched.hpp
   lor/lor_h1.hpp
-  lor/lor_dg.hpp
   lor/lor_nd.hpp
   lor/lor_rt.hpp
-  lor/lor_h1_impl.hpp
-  lor/lor_dg_impl.hpp
-  lor/lor_nd_impl.hpp
-  lor/lor_rt_impl.hpp
   lor/lor_util.hpp
   multigrid.hpp
   nonlinearform.hpp
   nonlinearform_ext.hpp
   nonlininteg.hpp
   qfunction.hpp
-  qinterp/det.hpp
   qinterp/eval.hpp
   qinterp/eval_hdiv.hpp
   qinterp/grad.hpp
@@ -286,7 +272,6 @@ set(HDRS
   transfer.hpp
   hyperbolic.hpp
   integrator.hpp
-  bounds.hpp
   )
 
 if (MFEM_USE_SIDRE)

fem/batchitrans.cpp

@@ -515,7 +515,6 @@ struct InvTNewtonSolver<Geometry::SEGMENT, SDim, SType, max_team_x>
             phys_tol += pptr[idx + d * npts] * pptr[idx + d * npts];
          }
          phys_tol = fmax(phys_rtol * phys_rtol, phys_tol * phys_rtol * phys_rtol);
-         hit_bdr[0] = prev_hit_bdr[0] = false;
       }
       // for each iteration
       while (true)

fem/bilinearform_ext.cpp

@@ -78,7 +78,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
       {
@@ -266,7 +266,11 @@ void PABilinearFormExtension::SetupRestrictionOperators(const L2FaceValues m)
 
       // Gather the attributes on the host from all the elements
       const Mesh &mesh = *trial_fes->GetMesh();
-      elem_attributes = &mesh.GetElementAttributes();
+      elem_attributes.SetSize(mesh.GetNE());
+      for (int i = 0; i < mesh.GetNE(); ++i)
+      {
+         elem_attributes[i] = mesh.GetAttribute(i);
+      }
    }
 
    // Construct face restriction operators only if the bilinear form has
@@ -325,7 +329,45 @@ void PABilinearFormExtension::SetupRestrictionOperators(const L2FaceValues m)
          bdr_face_dYdn.SetSize(bdr_face_restrict_lex->Height());
       }
 
-      bdr_face_attributes = &trial_fes->GetMesh()->GetBdrFaceAttributes();
+      const Mesh &mesh = *trial_fes->GetMesh();
+      // See LinearFormExtension::Update for explanation of f_to_be logic.
+      std::unordered_map<int,int> f_to_be;
+      for (int i = 0; i < mesh.GetNBE(); ++i)
+      {
+         const int f = mesh.GetBdrElementFaceIndex(i);
+         f_to_be[f] = i;
+      }
+      const int nf_bdr = trial_fes->GetNFbyType(FaceType::Boundary);
+      bdr_attributes.SetSize(nf_bdr);
+      int f_ind = 0;
+      int missing_bdr_elems = 0;
+      for (int f = 0; f < mesh.GetNumFaces(); ++f)
+      {
+         if (!mesh.GetFaceInformation(f).IsOfFaceType(FaceType::Boundary))
+         {
+            continue;
+         }
+         int attribute = 1; // default value
+         if (f_to_be.find(f) != f_to_be.end())
+         {
+            const int be = f_to_be[f];
+            attribute = mesh.GetBdrAttribute(be);
+         }
+         else
+         {
+            // If a boundary face does not correspond to the a boundary element,
+            // we assign it the default attribute of 1. We also generate a
+            // warning at runtime with the number of such missing elements.
+            ++missing_bdr_elems;
+         }
+         bdr_attributes[f_ind] = attribute;
+         ++f_ind;
+      }
+      if (missing_bdr_elems)
+      {
+         MFEM_WARNING("Missing " << missing_bdr_elems << " boundary elements "
+                      "for boundary faces.");
+      }
    }
 }
 
@@ -387,7 +429,7 @@ void PABilinearFormExtension::AssembleDiagonal(Vector &y) const
          mfem::forall(ne, [=] MFEM_HOST_DEVICE (int e)
          {
             const int attr = d_attr[e];
-            if (attr <= 0 || d_m[attr - 1] == 0)
+            if (d_m[attr - 1] == 0)
             {
                for (int i = 0; i < nd; ++i)
                {
@@ -408,13 +450,13 @@ void PABilinearFormExtension::AssembleDiagonal(Vector &y) const
          for (int i = 0; i < iSz; ++i)
          {
             assemble_diagonal_with_markers(*integrators[i], elem_markers[i],
-                                           *elem_attributes, localY);
+                                           elem_attributes, localY);
          }
          const ElementRestriction* H1elem_restrict =
             dynamic_cast<const ElementRestriction*>(elem_restrict);
          if (H1elem_restrict)
          {
-            H1elem_restrict->AbsMultTranspose(localY, y);
+            H1elem_restrict->MultTransposeUnsigned(localY, y);
          }
          else
          {
@@ -434,7 +476,7 @@ void PABilinearFormExtension::AssembleDiagonal(Vector &y) const
       for (int i = 0; i < iSz; ++i)
       {
          assemble_diagonal_with_markers(*integrators[i], elem_markers[i],
-                                        *elem_attributes, y);
+                                        elem_attributes, y);
       }
    }
 
@@ -447,9 +489,9 @@ void PABilinearFormExtension::AssembleDiagonal(Vector &y) const
       for (int i = 0; i < n_bdr_integs; ++i)
       {
          assemble_diagonal_with_markers(*bdr_integs[i], bdr_markers[i],
-                                        *bdr_face_attributes, bdr_face_Y);
+                                        bdr_attributes, bdr_face_Y);
       }
-      bdr_face_restrict_lex->AddAbsMultTranspose(bdr_face_Y, y);
+      bdr_face_restrict_lex->AddMultTransposeUnsigned(bdr_face_Y, y);
    }
 }
 
@@ -484,8 +526,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();
 
@@ -517,13 +558,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);
          }
       }
    }
@@ -532,30 +571,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
       {
@@ -567,7 +590,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
@@ -629,7 +651,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);
@@ -648,8 +669,8 @@ void PABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
          }
          for (int i = 0; i < n_bdr_integs; ++i)
          {
-            AddMultWithMarkers(*bdr_integs[i], bdr_face_X, bdr_markers[i],
-                               *bdr_face_attributes, false, bdr_face_Y);
+            AddMultWithMarkers(*bdr_integs[i], bdr_face_X, bdr_markers[i], bdr_attributes,
+                               false, bdr_face_Y);
          }
          for (int i = 0; i < n_bdr_face_integs; ++i)
          {
@@ -657,14 +678,12 @@ void PABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
             {
                AddMultNormalDerivativesWithMarkers(
                   *bdr_face_integs[i], bdr_face_X, bdr_face_dXdn,
-                  bdr_face_markers[i], *bdr_face_attributes, bdr_face_Y,
-                  bdr_face_dYdn);
+                  bdr_face_markers[i], bdr_attributes, bdr_face_Y, bdr_face_dYdn);
             }
             else
             {
-               AddMultWithMarkers(*bdr_face_integs[i], bdr_face_X,
-                                  bdr_face_markers[i], *bdr_face_attributes, false,
-                                  bdr_face_Y);
+               AddMultWithMarkers(*bdr_face_integs[i], bdr_face_X, bdr_face_markers[i],
+                                  bdr_attributes, false, bdr_face_Y);
             }
          }
          bdr_face_restrict_lex->AddMultTransposeInPlace(bdr_face_Y, y);
@@ -687,7 +706,7 @@ void PABilinearFormExtension::MultTranspose(const Vector &x, Vector &y) const
       localY = 0.0;
       for (int i = 0; i < iSz; ++i)
       {
-         AddMultWithMarkers(*integrators[i], localX, elem_markers[i], *elem_attributes,
+         AddMultWithMarkers(*integrators[i], localX, elem_markers[i], elem_attributes,
                             true, localY);
       }
       elem_restrict->MultTranspose(localY, y);
@@ -734,14 +753,13 @@ void PABilinearFormExtension::MultTranspose(const Vector &x, Vector &y) const
          bdr_face_Y = 0.0;
          for (int i = 0; i < n_bdr_integs; ++i)
          {
-            AddMultWithMarkers(*bdr_integs[i], bdr_face_X, bdr_markers[i],
-                               *bdr_face_attributes, true, bdr_face_Y);
+            AddMultWithMarkers(*bdr_integs[i], bdr_face_X, bdr_markers[i], bdr_attributes,
+                               true, bdr_face_Y);
          }
          for (int i = 0; i < n_bdr_face_integs; ++i)
          {
-            AddMultWithMarkers(*bdr_face_integs[i], bdr_face_X,
-                               bdr_face_markers[i], *bdr_face_attributes, true,
-                               bdr_face_Y);
+            AddMultWithMarkers(*bdr_face_integs[i], bdr_face_X, bdr_face_markers[i],
+                               bdr_attributes, true, bdr_face_Y);
          }
          bdr_face_restrict_lex->AddMultTransposeInPlace(bdr_face_Y, y);
       }
@@ -765,7 +783,7 @@ static void AddWithMarkers_(
    mfem::forall(ne, [=] MFEM_HOST_DEVICE (int e)
    {
       const int attr = d_attr[e];
-      if (attr <= 0 || d_m[attr - 1] == 0) { return; }
+      if (d_m[attr - 1] == 0) { return; }
       for (int i = 0; i < nd; ++i)
       {
          d_y(i, e) += d_x(i, e);
@@ -810,39 +828,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); }
    }
 }
 
@@ -881,8 +882,7 @@ void EABilinearFormExtension::Assemble()
       {
          const int i = idx % sz;
          const int e = idx / sz;
-         const real_t val =
-            d_a[e] > 0 ? (d_m[d_a[e] - 1] ? d_ea_1(i, e) : 0) : 0;
+         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;
@@ -915,7 +915,7 @@ void EABilinearFormExtension::Assemble()
             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);
+                             elem_attributes, add);
          }
       }
    }
@@ -944,7 +944,7 @@ void EABilinearFormExtension::Assemble()
             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_face_attributes, add);
+                             bdr_attributes, add);
          }
       }
    }
@@ -993,7 +993,7 @@ void EABilinearFormExtension::Assemble()
                                                         ea_data_tmp,
                                                         add);
             add_with_markers(ea_data_tmp, ea_data_bdr, nf_bdr, *markers,
-                             *bdr_face_attributes, add);
+                             bdr_attributes, add);
          }
       }
    }
@@ -1010,13 +1010,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)
@@ -1024,11 +1019,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);
@@ -1036,55 +1026,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);
       }
    }
 
@@ -1093,7 +1053,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)
@@ -1105,65 +1064,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;
@@ -1171,37 +1072,35 @@ 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);
       }
@@ -1210,9 +1109,7 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
    // Treatment of boundary faces
    if (!factorize_face_terms && bdr_face_restrict_lex && ea_data_bdr.Size() > 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
@@ -1220,38 +1117,141 @@ void EABilinearFormExtension::MultInternal(const Vector &x, Vector &y,
       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)
+      mfem::forall(nf_bdr*NDOFS, [=] MFEM_HOST_DEVICE (int glob_j)
       {
-         // TODO: useAbs
-         mfem::forall(nf_bdr*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(i, j, f)*X(i, f);
-            }
-            Y(j, f) += res;
-         });
-      }
-      else
-      {
-         // TODO: useAbs
-         mfem::forall(nf_bdr*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(j, i, f)*X(i, f);
-            }
-            Y(j, f) += res;
-         });
-      }
+            res += A(i, j, f)*X(i, f);
+         }
+         Y(j, f) += res;
+      });
+      // Apply the Boundary Face Restriction transposed
+      bdr_face_restrict_lex->AddMultTransposeInPlace(bdr_face_Y, y);
+   }
+}
+
+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)
+      {
+         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
+   if (!factorize_face_terms && bdr_face_restrict_lex && ea_data_bdr.Size() > 0)
+   {
+      // Apply the Boundary Face Restriction
+      bdr_face_restrict_lex->Mult(x, bdr_face_X);
+      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;
+         const int j = glob_j%NDOFS;
+         real_t res = 0.0;
+         for (int i = 0; i < NDOFS; i++)
+         {
+            res += A(j, i, f)*X(i, f);
+         }
+         Y(j, f) += res;
+      });
       // Apply the Boundary Face Restriction transposed
-      // TODO: AbsMultTranspose if needed
       bdr_face_restrict_lex->AddMultTransposeInPlace(bdr_face_Y, y);
    }
 }
@@ -1911,7 +1911,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
       {
@@ -1937,7 +1937,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
       {
@@ -1993,7 +1993,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
    {

fem/bilinearform_ext.hpp

@@ -69,8 +69,7 @@ class PABilinearFormExtension : public BilinearFormExtension
 protected:
    const FiniteElementSpace *trial_fes, *test_fes; // Not owned
    /// Attributes of all mesh elements.
-   const Array<int> *elem_attributes; // Not owned
-   const Array<int> *bdr_face_attributes; // Not owned
+   Array<int> elem_attributes, bdr_attributes;
    mutable Vector tmp_evec; // Work array
    mutable Vector localX, localY;
    mutable Vector int_face_X, int_face_Y;
@@ -92,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.
@@ -116,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.
@@ -160,15 +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); }
+   void Mult(const Vector &x, Vector &y) const override;
+   void MultTranspose(const Vector &x, Vector &y) const override;
 
    /// @brief Populates @a element_matrices with the element matrices.
    ///
@@ -180,10 +165,6 @@ public:
    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;
 };
 
 /// Data and methods for fully-assembled bilinear forms

fem/bilininteg.cpp

@@ -121,12 +121,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 +133,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 +418,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 +426,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++)

fem/bilininteg.hpp

@@ -23,8 +23,6 @@
 
 namespace mfem
 {
-class QuadratureSpace;
-class FaceQuadratureSpace;
 
 /// Abstract base class BilinearFormIntegrator
 class BilinearFormIntegrator : public NonlinearFormIntegrator
@@ -80,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;
 
@@ -94,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. */
@@ -502,12 +496,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;
@@ -814,7 +804,7 @@ protected:
       const FiniteElement & test_fe) const
    {
       return (trial_fe.GetDim() == 1 && test_fe.GetDim() == 1 &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD  &&
               test_fe.GetRangeType()  == mfem::FiniteElement::SCALAR );
    }
 
@@ -886,7 +876,7 @@ protected:
       const FiniteElement & trial_fe,
       const FiniteElement & test_fe) const
    {
-      return (trial_fe.GetDerivType() == mfem::FiniteElement::DIV &&
+      return (trial_fe.GetDerivType() == mfem::FiniteElement::DIV  &&
               test_fe.GetRangeType()  == mfem::FiniteElement::SCALAR );
    }
 
@@ -921,7 +911,7 @@ protected:
       const FiniteElement & trial_fe,
       const FiniteElement & test_fe) const
    {
-      return (trial_fe.GetDerivType() == mfem::FiniteElement::DIV &&
+      return (trial_fe.GetDerivType() == mfem::FiniteElement::DIV  &&
               test_fe.GetRangeType()  == mfem::FiniteElement::VECTOR );
    }
 
@@ -1602,7 +1592,7 @@ public:
    {
       return (trial_fe.GetCurlDim() == 3 && test_fe.GetRangeDim() == 3 &&
               trial_fe.GetRangeType() == mfem::FiniteElement::VECTOR &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::CURL  &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::CURL   &&
               test_fe.GetRangeType()  == mfem::FiniteElement::VECTOR );
    }
 
@@ -1637,7 +1627,7 @@ public:
    {
       return (trial_fe.GetDim() == 2 && test_fe.GetDim() == 2 &&
               trial_fe.GetRangeType() == mfem::FiniteElement::VECTOR &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::CURL  &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::CURL   &&
               test_fe.GetRangeType()  == mfem::FiniteElement::VECTOR );
    }
 
@@ -1671,7 +1661,7 @@ public:
    {
       return (trial_fe.GetDim() == 2 && test_fe.GetDim() == 2 &&
               trial_fe.GetRangeType() == mfem::FiniteElement::SCALAR &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD  &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD   &&
               test_fe.GetRangeType()  == mfem::FiniteElement::SCALAR );
    }
 
@@ -1762,7 +1752,7 @@ public:
       const FiniteElement & test_fe) const
    {
       return (trial_fe.GetRangeType() == mfem::FiniteElement::SCALAR &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD  &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD   &&
               test_fe.GetRangeType()  == mfem::FiniteElement::SCALAR );
    }
 
@@ -1795,7 +1785,7 @@ public:
       const FiniteElement & test_fe) const
    {
       return (trial_fe.GetRangeType() == mfem::FiniteElement::SCALAR &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD  &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::GRAD   &&
               test_fe.GetRangeType()  == mfem::FiniteElement::VECTOR &&
               test_fe.GetDerivType()  == mfem::FiniteElement::DIV   );
    }
@@ -1834,7 +1824,7 @@ public:
       const FiniteElement & test_fe) const
    {
       return (trial_fe.GetRangeType() == mfem::FiniteElement::VECTOR &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::DIV   &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::DIV    &&
               test_fe.GetRangeType()  == mfem::FiniteElement::SCALAR &&
               test_fe.GetDerivType()  == mfem::FiniteElement::GRAD
              );
@@ -1975,7 +1965,7 @@ protected:
       const FiniteElement & test_fe) const override
    {
       return (trial_fe.GetCurlDim() == 3 && test_fe.GetRangeDim() == 3 &&
-              trial_fe.GetDerivType() == mfem::FiniteElement::CURL &&
+              trial_fe.GetDerivType() == mfem::FiniteElement::CURL  &&
               test_fe.GetRangeType()  == mfem::FiniteElement::VECTOR );
    }
 
@@ -2330,12 +2320,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;
@@ -2433,12 +2419,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);
@@ -2496,7 +2478,8 @@ private:
 #endif
 
 public:
-   ConvectionIntegrator(VectorCoefficient &q, real_t a = 1.0);
+   ConvectionIntegrator(VectorCoefficient &q, real_t a = 1.0)
+      : Q(&q) { alpha = a; }
 
    void AssembleElementMatrix(const FiniteElement &,
                               ElementTransformation &,
@@ -2529,28 +2512,6 @@ public:
 
    bool SupportsCeed() const override { return DeviceCanUseCeed(); }
 
-   /// arguments: NE, B, G, Bt, Gt, pa_data, x, y, D1D, Q1D
-   using ApplyKernelType = void (*)(const int, const Array<real_t> &,
-                                    const Array<real_t> &,
-                                    const Array<real_t> &,
-                                    const Array<real_t> &, const Vector &,
-                                    const Vector &, Vector &, const int,
-                                    const int);
-
-   /// arguments: DIMS, D1D, Q1D
-   MFEM_REGISTER_KERNELS(ApplyPAKernels, ApplyKernelType, (int, int, int));
-   /// arguments: DIMS, D1D, Q1D
-   MFEM_REGISTER_KERNELS(ApplyPATKernels, ApplyKernelType, (int, int, int));
-
-   template <int DIM, int D1D, int Q1D>
-   static void AddSpecialization()
-   {
-      ApplyPAKernels::Specialization<DIM, D1D, Q1D>::Add();
-      ApplyPATKernels::Specialization<DIM, D1D, Q1D>::Add();
-   }
-
-   struct Kernels { Kernels(); };
-
 protected:
    const IntegrationRule* GetDefaultIntegrationRule(
       const FiniteElement& trial_fe,
@@ -2821,13 +2782,15 @@ protected:
    bool symmetric = true; ///< False if using a nonsymmetric matrix coefficient
 
 public:
-   CurlCurlIntegrator();
+   CurlCurlIntegrator() { Q = NULL; DQ = NULL; MQ = NULL; }
    /// Construct a bilinear form integrator for Nedelec elements
-   CurlCurlIntegrator(Coefficient &q, const IntegrationRule *ir = nullptr);
+   CurlCurlIntegrator(Coefficient &q, const IntegrationRule *ir = NULL) :
+      BilinearFormIntegrator(ir), Q(&q), DQ(NULL), MQ(NULL) { }
    CurlCurlIntegrator(DiagonalMatrixCoefficient &dq,
-                      const IntegrationRule *ir = nullptr);
-   CurlCurlIntegrator(MatrixCoefficient &mq,
-                      const IntegrationRule *ir = nullptr);
+                      const IntegrationRule *ir = NULL) :
+      BilinearFormIntegrator(ir), Q(NULL), DQ(&dq), MQ(NULL) { }
+   CurlCurlIntegrator(MatrixCoefficient &mq, const IntegrationRule *ir = NULL) :
+      BilinearFormIntegrator(ir), Q(NULL), DQ(NULL), MQ(&mq) { }
 
    /* Given a particular Finite Element, compute the
       element curl-curl matrix elmat */
@@ -2853,38 +2816,9 @@ 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; }
-
-   /// arguments: d1d, q1d, symmetric, NE, bo, bc, bot, bct, gc, gct, pa_data,
-   /// x, y, useAbs
-   using ApplyKernelType = void (*)(
-                              const int, const int, const bool, const int, const Array<real_t> &,
-                              const Array<real_t> &, const Array<real_t> &, const Array<real_t> &,
-                              const Array<real_t> &, const Array<real_t> &, const Vector &,
-                              const Vector &, Vector &, const bool);
-
-   /// arguments: d1d, q1d, symmetric, ne, Bo, Bc, Go, Gc, pa_data, diag
-   using DiagonalKernelType = void (*)(const int, const int, const bool,
-                                       const int, const Array<real_t> &,
-                                       const Array<real_t> &,
-                                       const Array<real_t> &,
-                                       const Array<real_t> &, const Vector &,
-                                       Vector &);
-
-   /// parameters: dim, d1d, q1d
-   MFEM_REGISTER_KERNELS(ApplyPAKernels, ApplyKernelType, (int, int, int));
-   /// parameters: dim, d1d, q1d
-   MFEM_REGISTER_KERNELS(DiagonalPAKernels, DiagonalKernelType, (int, int, int));
-   struct Kernels { Kernels(); };
-
-   template <int DIM, int D1D, int Q1D> static void AddSpecialization()
-   {
-      ApplyPAKernels::Specialization<DIM, D1D, Q1D>::Add();
-      DiagonalPAKernels::Specialization<DIM, D1D, Q1D>::Add();
-   }
 };
 
 /** Integrator for $(\mathrm{curl}(u), \mathrm{curl}(v))$ for FE spaces defined by 'dim' copies of a
@@ -2999,7 +2933,6 @@ 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,
@@ -3138,18 +3071,21 @@ private:
    Vector vcoeff;
 
 public:
-   VectorDiffusionIntegrator(const IntegrationRule *ir = nullptr);
+   VectorDiffusionIntegrator() { }
 
    /** \brief Integrator with unit coefficient for caller-specified vector
        dimension.
 
        If the vector dimension does not match the true dimension of the space,
        the resulting element matrix will be mathematically invalid. */
-   VectorDiffusionIntegrator(int vector_dimension);
+   VectorDiffusionIntegrator(int vector_dimension)
+      : vdim(vector_dimension) { }
 
-   VectorDiffusionIntegrator(Coefficient &q);
+   VectorDiffusionIntegrator(Coefficient &q)
+      : Q(&q) { }
 
-   VectorDiffusionIntegrator(Coefficient &q, const IntegrationRule *ir);
+   VectorDiffusionIntegrator(Coefficient &q, const IntegrationRule *ir)
+      : BilinearFormIntegrator(ir), Q(&q) { }
 
    /** \brief Integrator with scalar coefficient for caller-specified vector
        dimension.
@@ -3159,7 +3095,8 @@ public:
 
        If the vector dimension does not match the true dimension of the space,
        the resulting element matrix will be mathematically invalid. */
-   VectorDiffusionIntegrator(Coefficient &q, int vector_dimension);
+   VectorDiffusionIntegrator(Coefficient &q, int vector_dimension)
+      : Q(&q), vdim(vector_dimension) { }
 
    /** \brief Integrator with \c VectorCoefficient. The vector dimension of the
        \c FiniteElementSpace is assumed to be the same as the dimension of the
@@ -3170,7 +3107,8 @@ public:
 
        If the vector dimension does not match the true dimension of the space,
        the resulting element matrix will be mathematically invalid. */
-   VectorDiffusionIntegrator(VectorCoefficient &vq);
+   VectorDiffusionIntegrator(VectorCoefficient &vq)
+      : VQ(&vq), vdim(vq.GetVDim()) { }
 
    /** \brief Integrator with \c MatrixCoefficient. The vector dimension of the
        \c FiniteElementSpace is assumed to be the same as the dimension of the
@@ -3181,7 +3119,8 @@ public:
 
        If the vector dimension does not match the true dimension of the space,
        the resulting element matrix will be mathematically invalid. */
-   VectorDiffusionIntegrator(MatrixCoefficient& mq);
+   VectorDiffusionIntegrator(MatrixCoefficient& mq)
+      : MQ(&mq), vdim(mq.GetVDim()) { }
 
    void AssembleElementMatrix(const FiniteElement &el,
                               ElementTransformation &Trans,
@@ -3197,28 +3136,6 @@ public:
    void AddMultPA(const Vector &x, Vector &y) const override;
    void AddMultMF(const Vector &x, Vector &y) const override;
    bool SupportsCeed() const override { return DeviceCanUseCeed(); }
-
-   /// arguments: ne, B, G, Bt, Gt, pa_data, x, y, d1d, q1d, vdim
-   using ApplyKernelType = void (*)(const int, const Array<real_t> &,
-                                    const Array<real_t> &,
-                                    const Array<real_t> &,
-                                    const Array<real_t> &, const Vector &,
-                                    const Vector &, Vector &, const int,
-                                    const int, const int);
-
-   /// arguments: dim, vdim, d1d, q1d
-   MFEM_REGISTER_KERNELS(ApplyPAKernels, ApplyKernelType, (int, int, int, int));
-
-   template <int DIM, int VDIM, int D1D, int Q1D>
-   static void AddSpecialization()
-   {
-      ApplyPAKernels::Specialization<DIM, VDIM, D1D, Q1D>::Add();
-   }
-
-   struct Kernels
-   {
-      Kernels();
-   };
 };
 
 /** Integrator for the linear elasticity form:
@@ -3372,8 +3289,8 @@ public:
 class DGTraceIntegrator : public BilinearFormIntegrator
 {
 protected:
-   Coefficient *rho = nullptr;
-   VectorCoefficient *u = nullptr;
+   Coefficient *rho;
+   VectorCoefficient *u;
    real_t alpha, beta;
    // PA extension
    Vector pa_data;
@@ -3386,16 +3303,17 @@ private:
    Vector tr_shape1, te_shape1, tr_shape2, te_shape2;
 
 public:
-   DGTraceIntegrator(real_t a, real_t b);
-
    /// Construct integrator with $\rho = 1$, $\beta = \alpha/2$.
-   DGTraceIntegrator(VectorCoefficient &u_, real_t a);
+   DGTraceIntegrator(VectorCoefficient &u_, real_t a)
+   { rho = NULL; u = &u_; alpha = a; beta = 0.5*a; }
 
    /// Construct integrator with $\rho = 1$.
-   DGTraceIntegrator(VectorCoefficient &u_, real_t a, real_t b);
+   DGTraceIntegrator(VectorCoefficient &u_, real_t a, real_t b)
+   { rho = NULL; u = &u_; alpha = a; beta = b; }
 
    DGTraceIntegrator(Coefficient &rho_, VectorCoefficient &u_,
-                     real_t a, real_t b);
+                     real_t a, real_t b)
+   { rho = &rho_; u = &u_; alpha = a; beta = b; }
 
    using BilinearFormIntegrator::AssembleFaceMatrix;
    void AssembleFaceMatrix(const FiniteElement &el1,
@@ -3434,26 +3352,6 @@ public:
    static const IntegrationRule &GetRule(Geometry::Type geom, int order,
                                          const ElementTransformation &T);
 
-   /// arguments: nf, B, Bt, pa_data, x, y, dofs1D, quad1D
-   using ApplyKernelType = void (*)(const int, const Array<real_t> &,
-                                    const Array<real_t> &, const Vector &,
-                                    const Vector &, Vector &, const int,
-                                    const int);
-
-   /// arguments: DIM, d1d, q1d
-   MFEM_REGISTER_KERNELS(ApplyPAKernels, ApplyKernelType, (int, int, int));
-   /// arguments: DIM, d1d, q1d
-   MFEM_REGISTER_KERNELS(ApplyPATKernels, ApplyKernelType, (int, int, int));
-
-   template <int DIM, int D1D, int Q1D> static void AddSpecialization()
-   {
-      ApplyPAKernels::Specialization<DIM, D1D, Q1D>::Add();
-      ApplyPATKernels::Specialization<DIM, D1D, Q1D>::Add();
-   }
-
-   struct Kernels { Kernels(); };
-
-
 private:
    void SetupPA(const FiniteElementSpace &fes, FaceType type);
 };
@@ -3500,8 +3398,8 @@ public:
 class DGDiffusionIntegrator : public BilinearFormIntegrator
 {
 protected:
-   Coefficient *Q = nullptr;
-   MatrixCoefficient *MQ = nullptr;
+   Coefficient *Q;
+   MatrixCoefficient *MQ;
    real_t sigma, kappa;
 
    // these are not thread-safe!
@@ -3516,11 +3414,15 @@ protected:
    IntegrationRules irs{0, Quadrature1D::GaussLobatto};
 
 public:
-   DGDiffusionIntegrator(const real_t s, const real_t k);
-   DGDiffusionIntegrator(Coefficient &q, const real_t s, const real_t k);
-   DGDiffusionIntegrator(MatrixCoefficient &q, const real_t s, const real_t k);
+   DGDiffusionIntegrator(const real_t s, const real_t k)
+      : Q(NULL), MQ(NULL), sigma(s), kappa(k) { }
+   DGDiffusionIntegrator(Coefficient &q, const real_t s, const real_t k)
+      : Q(&q), MQ(NULL), sigma(s), kappa(k) { }
+   DGDiffusionIntegrator(MatrixCoefficient &q, const real_t s, const real_t k)
+      : Q(NULL), MQ(&q), sigma(s), kappa(k) { }
    using BilinearFormIntegrator::AssembleFaceMatrix;
-   void AssembleFaceMatrix(const FiniteElement &el1, const FiniteElement &el2,
+   void AssembleFaceMatrix(const FiniteElement &el1,
+                           const FiniteElement &el2,
                            FaceElementTransformations &Trans,
                            DenseMatrix &elmat) override;
 
@@ -3539,28 +3441,6 @@ public:
 
    const IntegrationRule &GetRule(int order, Geometry::Type geom);
 
-   real_t GetPenaltyParameter() const { return kappa; }
-
-   /// arguments: nf, B, Bt, G, Gt, sigma, pa_data, x, dxdn, y, dydn, dofs1D,
-   /// quad1D
-   using ApplyKernelType = void (*)(const int, const Array<real_t> &,
-                                    const Array<real_t> &,
-                                    const Array<real_t> &,
-                                    const Array<real_t> &, const real_t,
-                                    const Vector &, const Vector &_,
-                                    const Vector &, Vector &, Vector &,
-                                    const int, const int);
-
-   /// arguments: DIM, d1d, q1d
-   MFEM_REGISTER_KERNELS(ApplyPAKernels, ApplyKernelType, (int, int, int));
-
-   template <int DIM, int D1D, int Q1D> static void AddSpecialization()
-   {
-      ApplyPAKernels::Specialization<DIM, D1D, Q1D>::Add();
-   }
-
-   struct Kernels { Kernels(); };
-
 private:
    void SetupPA(const FiniteElementSpace &fes, FaceType type);
 };

fem/bounds.cpp

@@ -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);
-}
-
-}

fem/bounds.hpp

@@ -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

fem/ceed/integrators/convection/convection_qf.h

@@ -8,7 +8,6 @@
 // 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 <ceed/types.h>
 
 /// A structure used to pass additional data to f_build_conv and f_apply_conv
 struct ConvectionContext {
@@ -92,7 +91,7 @@ CEED_QFUNCTION(f_build_conv_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for building quadrature data for a convection operator
@@ -168,7 +167,7 @@ CEED_QFUNCTION(f_build_conv_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a conv operator
@@ -234,7 +233,7 @@ CEED_QFUNCTION(f_apply_conv)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a conv operator
@@ -382,7 +381,7 @@ CEED_QFUNCTION(f_apply_conv_mf_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 CEED_QFUNCTION(f_apply_conv_mf_quad)(void *ctx, CeedInt Q,
@@ -526,5 +525,5 @@ CEED_QFUNCTION(f_apply_conv_mf_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }

fem/ceed/integrators/diffusion/diffusion_qf.h

@@ -8,7 +8,7 @@
 // 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 <ceed/types.h>
+
 
 /// A structure used to pass additional data to f_build_diff and f_apply_diff
 struct DiffusionContext { CeedInt dim, space_dim, vdim; CeedScalar coeff; };
@@ -85,7 +85,7 @@ CEED_QFUNCTION(f_build_diff_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for building quadrature data for a diffusion operator
@@ -161,7 +161,7 @@ CEED_QFUNCTION(f_build_diff_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a diff operator
@@ -241,7 +241,7 @@ CEED_QFUNCTION(f_apply_diff)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a diff operator
@@ -394,7 +394,7 @@ CEED_QFUNCTION(f_apply_diff_mf_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 CEED_QFUNCTION(f_apply_diff_mf_quad)(void *ctx, CeedInt Q,
@@ -549,5 +549,5 @@ CEED_QFUNCTION(f_apply_diff_mf_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }

fem/ceed/integrators/mass/mass_qf.h

@@ -8,7 +8,7 @@
 // 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 <ceed/types.h>
+
 
 /// A structure used to pass additional data to f_build_diff and f_apply_diff
 struct MassContext { CeedInt dim, space_dim, vdim; CeedScalar coeff; };
@@ -53,7 +53,7 @@ CEED_QFUNCTION(f_build_mass_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for building quadrature data for a mass operator with a
@@ -95,7 +95,7 @@ CEED_QFUNCTION(f_build_mass_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a mass operator
@@ -135,7 +135,7 @@ CEED_QFUNCTION(f_apply_mass)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a diff operator
@@ -199,7 +199,7 @@ CEED_QFUNCTION(f_apply_mass_mf_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 CEED_QFUNCTION(f_apply_mass_mf_quad)(void *ctx, CeedInt Q,
@@ -266,5 +266,5 @@ CEED_QFUNCTION(f_apply_mass_mf_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }

fem/ceed/integrators/nlconvection/nlconvection_qf.h

@@ -8,7 +8,6 @@
 // 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 <ceed/types.h>
 
 /// A structure used to pass additional data to f_build_conv and f_apply_conv
 struct NLConvectionContext { CeedInt dim, space_dim, vdim; CeedScalar coeff; };
@@ -88,7 +87,7 @@ CEED_QFUNCTION(f_build_conv_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for building quadrature data for a convection operator
@@ -168,7 +167,7 @@ CEED_QFUNCTION(f_build_conv_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a conv operator
@@ -248,7 +247,7 @@ CEED_QFUNCTION(f_apply_conv)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 /// libCEED Q-function for applying a conv operator
@@ -363,7 +362,7 @@ CEED_QFUNCTION(f_apply_conv_mf_const)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }
 
 CEED_QFUNCTION(f_apply_conv_mf_quad)(void *ctx, CeedInt Q,
@@ -476,5 +475,5 @@ CEED_QFUNCTION(f_apply_conv_mf_quad)(void *ctx, CeedInt Q,
          }
          break;
    }
-   return CEED_ERROR_SUCCESS;
+   return 0;
 }

fem/ceed/interface/ceed.hpp

@@ -18,21 +18,10 @@
 
 #include <ceed.h>
 
-#if !CEED_VERSION_GE(0, 12, 0)
+#if !CEED_VERSION_GE(0,12,0)
 #error MFEM requires a libCEED version >= 0.12.0
 #endif
 
-#if !CEED_VERSION_GE(0, 13, 0)
-#define CeedOperatorCreateComposite(ceed, op)                                  \
-    CeedCompositeOperatorCreate((ceed), (op))
-#define CeedOperatorCompositeAddSub(op, sub)                                   \
-    CeedCompositeOperatorAddSub((op), (sub))
-#define CeedOperatorCompositeGetNumSub(op, num)                                \
-    CeedCompositeOperatorGetNumSub((op), (num))
-#define CeedOperatorCompositeGetSubList(op, list)                              \
-    CeedCompositeOperatorGetSubList((op), (list))
-#endif
-
 namespace mfem
 {
 

fem/ceed/interface/mixed_integrator.hpp

@@ -83,7 +83,7 @@ public:
       }
 
       // Create composite CeedOperator
-      CeedOperatorCreateComposite(internal::ceed, &oper);
+      CeedCompositeOperatorCreate(internal::ceed, &oper);
 
       // Create each sub-CeedOperator
       sub_ops.reserve(element_indices.size());
@@ -101,7 +101,7 @@ public:
          int nelem = *count[value.first];
          sub_op->Assemble(info, fes, ir, nelem, indices, Q);
          sub_ops.push_back(sub_op);
-         CeedOperatorCompositeAddSub(oper, sub_op->GetCeedOperator());
+         CeedCompositeOperatorAddSub(oper, sub_op->GetCeedOperator());
       }
 
       const int ndofs = fes.GetVDim() * fes.GetNDofs();

fem/ceed/interface/util.cpp

@@ -140,7 +140,11 @@ int CeedOperatorGetActiveField(CeedOperator oper, CeedOperatorField *field)
    CeedOperator *subops;
    if (isComposite)
    {
-      ierr = CeedOperatorCompositeGetSubList(oper, &subops); PCeedChk(ierr);
+#if CEED_VERSION_GE(0, 10, 2)
+      ierr = CeedCompositeOperatorGetSubList(oper, &subops); PCeedChk(ierr);
+#else
+      ierr = CeedOperatorGetSubList(oper, &subops); PCeedChk(ierr);
+#endif
       ierr = CeedOperatorGetQFunction(subops[0], &qf); PCeedChk(ierr);
    }
    else
@@ -167,11 +171,7 @@ int CeedOperatorGetActiveField(CeedOperator oper, CeedOperatorField *field)
    for (int i = 0; i < numinputfields; ++i)
    {
       ierr = CeedOperatorFieldGetVector(inputfields[i], &if_vector); PCeedChk(ierr);
-      bool is_active = if_vector == CEED_VECTOR_ACTIVE;
-#if CEED_VERSION_GE(0, 13, 0)
-      ierr = CeedVectorDestroy(&if_vector); PCeedChk(ierr);
-#endif
-      if (is_active)
+      if (if_vector == CEED_VECTOR_ACTIVE)
       {
          if (found)
          {

fem/ceed/solvers/algebraic.cpp

@@ -228,7 +228,7 @@ void AddToCompositeOperator(BilinearFormIntegrator *integ, CeedOperator op)
 {
    if (integ->SupportsCeed())
    {
-      CeedOperatorCompositeAddSub(op, integ->GetCeedOp().GetCeedOperator());
+      CeedCompositeOperatorAddSub(op, integ->GetCeedOp().GetCeedOperator());
    }
    else
    {
@@ -240,7 +240,7 @@ CeedOperator CreateCeedCompositeOperatorFromBilinearForm(BilinearForm &form)
 {
    int ierr;
    CeedOperator op;
-   ierr = CeedOperatorCreateComposite(internal::ceed, &op); PCeedChk(ierr);
+   ierr = CeedCompositeOperatorCreate(internal::ceed, &op); PCeedChk(ierr);
 
    MFEM_VERIFY(form.GetBBFI()->Size() == 0,
                "Not implemented for this integrator!");
@@ -271,13 +271,18 @@ CeedOperator CoarsenCeedCompositeOperator(
    MFEM_ASSERT(isComposite, "");
 
    CeedOperator op_coarse;
-   ierr = CeedOperatorCreateComposite(internal::ceed,
+   ierr = CeedCompositeOperatorCreate(internal::ceed,
                                       &op_coarse); PCeedChk(ierr);
 
    int nsub;
    CeedOperator *subops;
-   ierr = CeedOperatorCompositeGetNumSub(op, &nsub); PCeedChk(ierr);
-   ierr = CeedOperatorCompositeGetSubList(op, &subops); PCeedChk(ierr);
+#if CEED_VERSION_GE(0, 10, 2)
+   ierr = CeedCompositeOperatorGetNumSub(op, &nsub); PCeedChk(ierr);
+   ierr = CeedCompositeOperatorGetSubList(op, &subops); PCeedChk(ierr);
+#else
+   ierr = CeedOperatorGetNumSub(op, &nsub); PCeedChk(ierr);
+   ierr = CeedOperatorGetSubList(op, &subops); PCeedChk(ierr);
+#endif
    for (int isub=0; isub<nsub; ++isub)
    {
       CeedOperator subop = subops[isub];
@@ -289,7 +294,7 @@ CeedOperator CoarsenCeedCompositeOperator(
       // refcounted by existing objects
       ierr = CeedBasisDestroy(&basis_coarse); PCeedChk(ierr);
       ierr = CeedBasisDestroy(&basis_c2f); PCeedChk(ierr);
-      ierr = CeedOperatorCompositeAddSub(op_coarse, subop_coarse);
+      ierr = CeedCompositeOperatorAddSub(op_coarse, subop_coarse);
       PCeedChk(ierr);
       ierr = CeedOperatorDestroy(&subop_coarse); PCeedChk(ierr);
    }

fem/ceed/solvers/full-assembly.cpp

@@ -81,27 +81,12 @@ int CeedSingleOperatorFullAssemble(CeedOperator op, SparseMatrix *out)
       ierr = CeedOperatorFieldGetVector(input_fields[i], &vec); PCeedChk(ierr);
       if (vec == CEED_VECTOR_ACTIVE)
       {
-         CeedBasis basis;
-         ierr = CeedOperatorFieldGetBasis(input_fields[i], &basis); PCeedChk(ierr);
-         if (!basisin)
-         {
-            ierr = CeedBasisReferenceCopy(basis, &basisin); PCeedChk(ierr);
-         }
-#if CEED_VERSION_GE(0, 13, 0)
-         ierr = CeedBasisDestroy(&basis); PCeedChk(ierr);
-#endif
+         ierr = CeedOperatorFieldGetBasis(input_fields[i], &basisin);
+         PCeedChk(ierr);
          ierr = CeedBasisGetNumComponents(basisin, &ncomp); PCeedChk(ierr);
          ierr = CeedBasisGetDimension(basisin, &dim); PCeedChk(ierr);
-         CeedElemRestriction rstr;
-         ierr = CeedOperatorFieldGetElemRestriction(input_fields[i], &rstr);
+         ierr = CeedOperatorFieldGetElemRestriction(input_fields[i], &rstrin);
          PCeedChk(ierr);
-         if (!rstrin)
-         {
-            ierr = CeedElemRestrictionReferenceCopy(rstr, &rstrin); PCeedChk(ierr);
-         }
-#if CEED_VERSION_GE(0, 13, 0)
-         ierr = CeedElemRestrictionDestroy(&rstr); PCeedChk(ierr);
-#endif
          CeedEvalMode emode;
          ierr = CeedQFunctionFieldGetEvalMode(qffields[i], &emode);
          PCeedChk(ierr);
@@ -127,9 +112,6 @@ int CeedSingleOperatorFullAssemble(CeedOperator op, SparseMatrix *out)
                break; // Caught by QF Assembly
          }
       }
-#if CEED_VERSION_GE(0, 13, 0)
-      ierr = CeedVectorDestroy(&vec); PCeedChk(ierr);
-#endif
    }
 
    // Determine active output basis
@@ -145,25 +127,11 @@ int CeedSingleOperatorFullAssemble(CeedOperator op, SparseMatrix *out)
       ierr = CeedOperatorFieldGetVector(output_fields[i], &vec); PCeedChk(ierr);
       if (vec == CEED_VECTOR_ACTIVE)
       {
-         CeedBasis basis;
-         ierr = CeedOperatorFieldGetBasis(output_fields[i], &basis); PCeedChk(ierr);
-         if (!basisout)
-         {
-            ierr = CeedBasisReferenceCopy(basis, &basisout); PCeedChk(ierr);
-         }
-#if CEED_VERSION_GE(0, 13, 0)
-         ierr = CeedBasisDestroy(&basis); PCeedChk(ierr);
-#endif
-         CeedElemRestriction rstr;
-         ierr = CeedOperatorFieldGetElemRestriction(output_fields[i], &rstr);
+         ierr = CeedOperatorFieldGetBasis(output_fields[i], &basisout);
+         PCeedChk(ierr);
+         ierr = CeedOperatorFieldGetElemRestriction(output_fields[i], &rstrout);
+         PCeedChk(ierr);
          PCeedChk(ierr);
-         if (!rstrout)
-         {
-            ierr = CeedElemRestrictionReferenceCopy(rstr, &rstrout); PCeedChk(ierr);
-         }
-#if CEED_VERSION_GE(0, 13, 0)
-         ierr = CeedElemRestrictionDestroy(&rstr); PCeedChk(ierr);
-#endif
          CeedEvalMode emode;
          ierr = CeedQFunctionFieldGetEvalMode(qffields[i], &emode);
          PCeedChk(ierr);
@@ -189,9 +157,6 @@ int CeedSingleOperatorFullAssemble(CeedOperator op, SparseMatrix *out)
                break; // Caught by QF Assembly
          }
       }
-#if CEED_VERSION_GE(0, 13, 0)
-      ierr = CeedVectorDestroy(&vec); PCeedChk(ierr);
-#endif
    }
 
    CeedInt nelem, elemsize, nqpts;
@@ -235,11 +200,7 @@ int CeedSingleOperatorFullAssemble(CeedOperator op, SparseMatrix *out)
    PCeedChk(ierr);
 
    CeedInt layout[3];
-#if CEED_VERSION_GE(0, 13, 0)
-   ierr = CeedElemRestrictionGetELayout(rstr_q, layout); PCeedChk(ierr);
-#else
    ierr = CeedElemRestrictionGetELayout(rstr_q, &layout); PCeedChk(ierr);
-#endif
    ierr = CeedElemRestrictionDestroy(&rstr_q); PCeedChk(ierr);
 
    // enforce structurally symmetric for later elimination
@@ -324,10 +285,6 @@ int CeedSingleOperatorFullAssemble(CeedOperator op, SparseMatrix *out)
    ierr = CeedVectorRestoreArrayRead(assembledqf, &assembledqfarray);
    PCeedChk(ierr);
    ierr = CeedVectorDestroy(&assembledqf); PCeedChk(ierr);
-   ierr = CeedElemRestrictionDestroy(&rstrin); PCeedChk(ierr);
-   ierr = CeedElemRestrictionDestroy(&rstrout); PCeedChk(ierr);
-   ierr = CeedBasisDestroy(&basisin); PCeedChk(ierr);
-   ierr = CeedBasisDestroy(&basisout); PCeedChk(ierr);
    ierr = CeedHackFree(&emodein); PCeedChk(ierr);
    ierr = CeedHackFree(&emodeout); PCeedChk(ierr);
 
@@ -353,8 +310,13 @@ int CeedOperatorFullAssemble(CeedOperator op, SparseMatrix **mat)
    {
       CeedInt numsub;
       CeedOperator *subops;
-      ierr = CeedOperatorCompositeGetNumSub(op, &numsub); PCeedChk(ierr);
-      ierr = CeedOperatorCompositeGetSubList(op, &subops); PCeedChk(ierr);
+#if CEED_VERSION_GE(0, 10, 2)
+      CeedCompositeOperatorGetNumSub(op, &numsub);
+      ierr = CeedCompositeOperatorGetSubList(op, &subops); PCeedChk(ierr);
+#else
+      CeedOperatorGetNumSub(op, &numsub);
+      ierr = CeedOperatorGetSubList(op, &subops); PCeedChk(ierr);
+#endif
       for (int i = 0; i < numsub; ++i)
       {
          ierr = CeedSingleOperatorFullAssemble(subops[i], out); PCeedChk(ierr);

fem/ceed/solvers/solvers-atpmg.cpp

@@ -120,11 +120,7 @@ int CeedATPMGElemRestriction(int order,
    }
    ierr = CeedVectorRestoreArray(in_lvec, &lvec_data); PCeedChk(ierr);
    CeedInt in_layout[3];
-#if CEED_VERSION_GE(0, 13, 0)
-   ierr = CeedElemRestrictionGetELayout(er_in, in_layout); PCeedChk(ierr);
-#else
    ierr = CeedElemRestrictionGetELayout(er_in, &in_layout); PCeedChk(ierr);
-#endif
    if (in_layout[0] == 0 && in_layout[1] == 0 && in_layout[2] == 0)
    {
       return CeedError(ceed, 1, "Cannot interpret e-vector ordering of given"
@@ -668,11 +664,7 @@ int CeedATPMGOperator(CeedOperator oper, int order_reduction,
 
    for (int i = 0; i < numinputfields; ++i)
    {
-#if CEED_VERSION_GE(0, 13, 0)
-      const char * fieldname;
-#else
       char * fieldname;
-#endif
       ierr = CeedQFunctionFieldGetName(inputqfields[i], &fieldname); PCeedChk(ierr);
       if (if_vector[i] == CEED_VECTOR_ACTIVE)
       {
@@ -684,19 +676,10 @@ int CeedATPMGOperator(CeedOperator oper, int order_reduction,
          ierr = CeedOperatorSetField(coper, fieldname, er_input[i], basis_input[i],
                                      if_vector[i]); PCeedChk(ierr);
       }
-#if CEED_VERSION_GE(0, 13, 0)
-      ierr = CeedVectorDestroy(&if_vector[i]); PCeedChk(ierr);
-      ierr = CeedElemRestrictionDestroy(&er_input[i]); PCeedChk(ierr);
-      ierr = CeedBasisDestroy(&basis_input[i]); PCeedChk(ierr);
-#endif
    }
    for (int i = 0; i < numoutputfields; ++i)
    {
-#if CEED_VERSION_GE(0, 13, 0)
-      const char * fieldname;
-#else
       char * fieldname;
-#endif
       ierr = CeedQFunctionFieldGetName(outputqfields[i], &fieldname); PCeedChk(ierr);
       if (of_vector[i] == CEED_VECTOR_ACTIVE)
       {
@@ -708,11 +691,6 @@ int CeedATPMGOperator(CeedOperator oper, int order_reduction,
          ierr = CeedOperatorSetField(coper, fieldname, er_output[i], basis_output[i],
                                      of_vector[i]); PCeedChk(ierr);
       }
-#if CEED_VERSION_GE(0, 13, 0)
-      ierr = CeedVectorDestroy(&of_vector[i]); PCeedChk(ierr);
-      ierr = CeedElemRestrictionDestroy(&er_output[i]); PCeedChk(ierr);
-      ierr = CeedBasisDestroy(&basis_output[i]); PCeedChk(ierr);
-#endif
    }
    delete [] er_input;
    delete [] er_output;
@@ -763,9 +741,7 @@ int CeedOperatorGetOrder(CeedOperator oper, CeedInt * order)
    int P1d;
    ierr = CeedBasisGetNumNodes1D(basis, &P1d); PCeedChk(ierr);
    *order = P1d - 1;
-#if CEED_VERSION_GE(0, 13, 0)
-   ierr = CeedBasisDestroy(&basis); PCeedChk(ierr);
-#endif
+
    return 0;
 }
 

fem/coefficient.cpp

@@ -12,7 +12,6 @@
 // Implementation of Coefficient class
 
 #include "fem.hpp"
-#include "../general/forall.hpp"
 
 #include <cmath>
 #include <limits>
@@ -81,49 +80,6 @@ real_t PWConstCoefficient::Eval(ElementTransformation & T,
    return (constants(att-1));
 }
 
-void PWConstCoefficient::Project(QuadratureFunction &qf)
-{
-   auto &qs = *qf.GetSpace();
-
-   const bool compressed =
-      qs.Offsets(QSpaceOffsetStorage::COMPRESSED).Size() == 1;
-   const int *offsets = qs.Offsets(QSpaceOffsetStorage::COMPRESSED).Read();
-   const int ne = qs.GetNE();
-
-   const int *attributes = [&]()
-   {
-      if (dynamic_cast<QuadratureSpace*>(&qs) != nullptr)
-      {
-         return qs.GetMesh()->GetElementAttributes().Read();
-      }
-      else if (auto *qs_f = dynamic_cast<FaceQuadratureSpace*>(&qs))
-      {
-         MFEM_VERIFY(qs_f->GetFaceType() == FaceType::Boundary,
-                     "Interior faces do not have attributes.");
-         return qs.GetMesh()->GetBdrFaceAttributes().Read();
-      }
-      else
-      {
-         MFEM_ABORT("Unsupported case.");
-      }
-   }();
-
-   const real_t *d_c = constants.Read();
-   real_t *d_qf = qf.Write();
-
-   mfem::forall(ne, [=] MFEM_HOST_DEVICE (int e)
-   {
-      const int a = attributes[e];
-      const real_t elementConstant = d_c[a - 1];
-      const int begin = compressed ? e*offsets[0] : offsets[e];
-      const int end = compressed ? (e+1)*offsets[0] : offsets[e+1];
-      for (int i = begin; i < end; ++i)
-      {
-         d_qf[i] = elementConstant;
-      }
-   });
-}
-
 void PWCoefficient::InitMap(const Array<int> & attr,
                             const Array<Coefficient*> & coefs)
 {
@@ -563,26 +519,6 @@ void GradientGridFunctionCoefficient::Eval(
    }
 }
 
-void GradientGridFunctionCoefficient::Project(QuadratureFunction &qf)
-{
-   const FiniteElementSpace &fes = *GridFunc->FESpace();
-   const Mesh &mesh = *fes.GetMesh();
-   const int sdim = mesh.SpaceDimension();
-   const int gf_vdim = fes.GetVDim(); // assumed to be 1 in this class
-   qf.SetVDim(sdim*gf_vdim);
-   if (mesh.GetNE() == 0) { return; }
-   // All mesh element must be the same type:
-   MFEM_VERIFY(mesh.GetNumGeometries(mesh.Dimension()) == 1,
-               "All mesh elements must be the same type!");
-   const IntegrationRule &ir = qf.GetIntRule(0);
-   // All elements must use the same quadrature rule:
-   MFEM_VERIFY(qf.Size() == sdim*gf_vdim*ir.GetNPoints()*mesh.GetNE(),
-               "All mesh elements must use the same quadrature rule!");
-   // QuadratureFunction uses the layout qf_vdim x nq x ne, i.e.
-   // gf_vdim x sdim x nq x nq, so we need to request QVectorLayout::byVDIM:
-   GridFunc->GetGradients(ir, qf, QVectorLayout::byVDIM);
-}
-
 CurlGridFunctionCoefficient::CurlGridFunctionCoefficient(
    const GridFunction *gf)
    : VectorCoefficient(0)
@@ -1129,41 +1065,6 @@ real_t InnerProductCoefficient::Eval(ElementTransformation &T,
    return va * vb;
 }
 
-void InnerProductCoefficient::Project(QuadratureFunction &qf)
-{
-   MFEM_VERIFY(a->GetVDim() == b->GetVDim(),
-               "Incompatible vector coefficients: a->GetVDim(): "
-               << a->GetVDim() << ", b->GetVDim(): " << b->GetVDim());
-
-   const int vdim = a->GetVDim();
-   MFEM_VERIFY(vdim >= 1, "invalid vdim: " << vdim);
-
-   // When running on device, make sure the output data is allocated before any
-   // local temporary data to reduce potential heap fragmentation:
-   auto dot_d = qf.Write();
-
-   QuadratureFunction qf_a(qf.GetSpace(), vdim);
-   QuadratureFunction qf_b(qf.GetSpace(), vdim);
-
-   a->Project(qf_a);
-   b->Project(qf_b);
-
-   auto a_d = qf_a.Read();
-   auto b_d = qf_b.Read();
-
-   mfem::forall(qf.GetSpace()->GetSize(), [=] MFEM_HOST_DEVICE (int i)
-   {
-      const real_t *ai = a_d + i*vdim;
-      const real_t *bi = b_d + i*vdim;
-      real_t dot = ai[0]*bi[0];
-      for (int d = 1; d < vdim; d++)
-      {
-         dot += ai[d]*bi[d];
-      }
-      dot_d[i] = dot;
-   });
-}
-
 VectorRotProductCoefficient::VectorRotProductCoefficient(VectorCoefficient &A,
                                                          VectorCoefficient &B)
    : a(&A), b(&B), va(A.GetVDim()), vb(B.GetVDim())

fem/coefficient.hpp

@@ -132,9 +132,6 @@ public:
    /// Evaluate the coefficient.
    real_t Eval(ElementTransformation &T,
                const IntegrationPoint &ip) override;
-
-   /// Fill the QuadratureFunction @a qf with the piecewise constant values.
-   void Project(QuadratureFunction &qf) override;
 };
 
 /** @brief A piecewise coefficient with the pieces keyed off the element
@@ -897,9 +894,6 @@ public:
    void Eval(DenseMatrix &M, ElementTransformation &T,
              const IntegrationRule &ir) override;
 
-   /// @copydoc VectorCoefficient::Project(QuadratureFunction &)
-   void Project(QuadratureFunction &qf) override;
-
    virtual ~GradientGridFunctionCoefficient() { }
 };
 
@@ -1777,9 +1771,6 @@ public:
    /// Evaluate the coefficient at @a ip.
    real_t Eval(ElementTransformation &T,
                const IntegrationPoint &ip) override;
-
-   /// @copydoc Coefficient::Project(QuadratureFunction &)
-   void Project(QuadratureFunction &qf) override;
 };
 
 /// Scalar coefficient defined as a cross product of two vectors in the xy-plane.

fem/conduitdatacollection.cpp

@@ -912,7 +912,7 @@ ConduitDataCollection::GridFunctionToBlueprintField(mfem::GridFunction *gf,
 
    if (vdim == 1) // scalar case
    {
-      n_field["values"].set_external(const_cast<real_t *>(gf->HostRead()),
+      n_field["values"].set_external(gf->GetData(),
                                      ndofs);
    }
    else // vector case
@@ -925,18 +925,18 @@ ConduitDataCollection::GridFunctionToBlueprintField(mfem::GridFunction *gf,
       int vdim_stride  = (ordering == Ordering::byNODES ? ndofs : 1);
 
       index_t offset = 0;
-      index_t stride = sizeof(real_t) * entry_stride;
+      index_t stride = sizeof(double) * entry_stride;
 
       for (int d = 0;  d < vdim; d++)
       {
          std::ostringstream oss;
          oss << "v" << d;
          std::string comp_name = oss.str();
-         n_field["values"][comp_name].set_external(const_cast<real_t *>(gf->HostRead()),
+         n_field["values"][comp_name].set_external(gf->GetData(),
                                                    ndofs,
                                                    offset,
                                                    stride);
-         offset +=  sizeof(real_t) * vdim_stride;
+         offset +=  sizeof(double) * vdim_stride;
       }
    }
 

fem/datacollection.cpp

@@ -764,9 +764,9 @@ ParaViewDataCollectionBase::ParaViewDataCollectionBase(
 {
    cycle = 0;
 #ifdef MFEM_USE_ZLIB
-   // If we have zlib, enable compression. Otherwise, compression is disabled in
-   // the DataCollection base class constructor.
-   compression = true;
+   compression = true; // if we have zlib, enable compression
+#else
+   compression = false; // otherwise, disable compression
 #endif
 }
 
@@ -784,8 +784,13 @@ void ParaViewDataCollectionBase::SetCompressionLevel(int compression_level_)
 {
    MFEM_ASSERT(compression_level_ >= -1 && compression_level_ <= 9,
                "Compression level must be between -1 and 9 (inclusive).");
-   if (compression_level_ != 0) { SetCompression(true);}
    compression_level = compression_level_;
+   compression = compression_level_ != 0;
+}
+
+void ParaViewDataCollectionBase::SetCompression(bool compression_)
+{
+   compression = compression_;
 }
 
 int ParaViewDataCollectionBase::GetCompressionLevel() const
@@ -1169,14 +1174,7 @@ const char *ParaViewDataCollection::GetDataTypeString() const
 ParaViewHDFDataCollection::ParaViewHDFDataCollection(
    const std::string &collection_name, Mesh *mesh)
    : ParaViewDataCollectionBase(collection_name, mesh)
-{
-   compression = true;
-}
-
-void ParaViewHDFDataCollection::SetCompression(bool compression_)
-{
-   compression = compression_;
-}
+{ }
 
 void ParaViewHDFDataCollection::EnsureVTKHDF()
 {

fem/datacollection.hpp

@@ -537,6 +537,13 @@ public:
    /// Any nonzero compression level will enable compression.
    void SetCompressionLevel(int compression_level_);
 
+   /// @brief Enable or disable zlib compression.
+   ///
+   /// If the input is true, use the default zlib compression level (unless the
+   /// compression level has previously been set by calling
+   /// SetCompressionLevel()).
+   void SetCompression(bool compression_) override;
+
    /// @brief Sets whether or not to output the data as high-order elements
    /// (false by default).
    ///
@@ -626,12 +633,6 @@ public:
    ParaViewHDFDataCollection(const std::string& collection_name,
                              Mesh *mesh_ = nullptr);
 
-   /// @brief Enable or disable compression.
-   ///
-   /// The compression level can be set with SetCompressionLevel()). VTKHDF
-   /// compression does not require MFEM to be compiled with zlib support.
-   void SetCompression(bool compression_) override;
-
    /// Save the collection.
    void Save() override;
 

fem/derefmat_op.cpp

@@ -1,266 +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 "derefmat_op.hpp"
-#include "fes_kernels.hpp"
-
-/// \cond DO_NOT_DOCUMENT
-namespace mfem
-{
-
-namespace internal
-{
-template <Ordering::Type Order, bool Atomic>
-static void DerefMultKernelImpl(const DerefineMatrixOp &op, const Vector &x,
-                                Vector &y)
-{
-   DerefineMatrixOpMultFunctor<Order, Atomic> func;
-   func.xptr = x.Read();
-   y.UseDevice();
-   y = 0.;
-   func.yptr = y.ReadWrite();
-   func.bsptr = op.block_storage.Read();
-   func.boptr = op.block_offsets.Read();
-   func.brptr = op.block_row_idcs_offsets.Read();
-   func.bcptr = op.block_col_idcs_offsets.Read();
-   func.rptr = op.row_idcs.Read();
-   func.cptr = op.col_idcs.Read();
-   func.vdims = op.fespace->GetVDim();
-   func.nblocks = op.block_offsets.Size();
-   func.width = op.Width() / func.vdims;
-   func.height = op.Height() / func.vdims;
-   func.Run(op.max_rows);
-}
-
-} // namespace internal
-
-DerefineMatrixOp::DerefineMatrixOp(FiniteElementSpace &fespace_, int old_ndofs,
-                                   const Table *old_elem_dof,
-                                   const Table *old_elem_fos)
-   : Operator(fespace_.GetVSize(), old_ndofs * fespace_.GetVDim()),
-     fespace(&fespace_)
-{
-   static Kernels kernels;
-   constexpr int max_team_size = 256;
-   /// TODO: Implement DofTransformation support
-
-   MFEM_VERIFY(fespace->Nonconforming(),
-               "Not implemented for conforming meshes.");
-   MFEM_VERIFY(old_ndofs, "Missing previous (finer) space.");
-   MFEM_VERIFY(fespace->GetNDofs() <= old_ndofs,
-               "Previous space is not finer.");
-
-   const CoarseFineTransformations &dtrans =
-      fespace->GetMesh()->ncmesh->GetDerefinementTransforms();
-
-   MFEM_ASSERT(dtrans.embeddings.Size() == old_elem_dof->Size(), "");
-
-   const bool is_dg = fespace->FEColl()->GetContType()
-                      == FiniteElementCollection::DISCONTINUOUS;
-   DenseMatrix localRVO; // for variable-order only
-
-   DenseTensor localR[Geometry::NumGeom];
-   int total_rows = 0;
-   int total_cols = 0;
-   block_offsets.SetSize(dtrans.embeddings.Size());
-   block_offsets.HostWrite();
-   if (fespace->IsVariableOrder())
-   {
-      // TODO: any potential for some compression here?
-      // determine storage size and offsets
-      block_offsets[0] = 0;
-      int total_size = 0;
-      for (int k = 0; k < dtrans.embeddings.Size(); ++k)
-      {
-         const Embedding &emb = dtrans.embeddings[k];
-         const FiniteElement *fe = fespace->GetFE(emb.parent);
-         const int ldof = fe->GetDof();
-         if (k + 1 < dtrans.embeddings.Size())
-         {
-            block_offsets[k + 1] = block_offsets[k] + ldof * ldof;
-         }
-         total_rows += ldof;
-         total_cols += ldof;
-         total_size += ldof * ldof;
-      }
-      block_storage.SetSize(total_size);
-   }
-   else
-   {
-      // compression scheme:
-      // block_offsets is the start of each block, potentially repeated
-      // only need to store localR for used shapes
-      Mesh::GeometryList elem_geoms(*fespace->GetMesh());
-
-      int geom_offsets[Geometry::NumGeom];
-      {
-         int size = 0;
-         for (int i = 0; i < elem_geoms.Size(); ++i)
-         {
-            fespace->GetLocalDerefinementMatrices(elem_geoms[i],
-                                                  localR[elem_geoms[i]]);
-            geom_offsets[elem_geoms[i]] = size;
-            size += localR[elem_geoms[i]].TotalSize();
-         }
-         block_storage.SetSize(size);
-         // copy blocks into block_storage
-         auto bs_ptr = block_storage.HostWrite();
-         for (int i = 0; i < elem_geoms.Size(); ++i)
-         {
-            std::copy(localR[elem_geoms[i]].Data(),
-                      localR[elem_geoms[i]].Data()
-                      + localR[elem_geoms[i]].TotalSize(),
-                      bs_ptr);
-            bs_ptr += localR[elem_geoms[i]].TotalSize();
-         }
-      }
-      for (int k = 0; k < dtrans.embeddings.Size(); ++k)
-      {
-         const Embedding &emb = dtrans.embeddings[k];
-         Geometry::Type geom =
-            fespace->GetMesh()->GetElementBaseGeometry(emb.parent);
-
-         auto size = localR[geom].SizeI() * localR[geom].SizeJ();
-         total_rows += localR[geom].SizeI();
-         total_cols += localR[geom].SizeJ();
-         // set block offsets and sizes
-         block_offsets[k] = geom_offsets[geom] + size * emb.matrix;
-      }
-   }
-   row_idcs.SetSize(total_rows);
-   row_idcs.HostWrite();
-   col_idcs.SetSize(total_cols);
-   col_idcs.HostWrite();
-   block_row_idcs_offsets.SetSize(dtrans.embeddings.Size() + 1);
-   block_row_idcs_offsets.HostWrite();
-   block_col_idcs_offsets.SetSize(dtrans.embeddings.Size() + 1);
-   block_col_idcs_offsets.HostWrite();
-   block_row_idcs_offsets[0] = 0;
-   block_col_idcs_offsets[0] = 0;
-
-   // compute index information
-   Array<int> dofs, old_dofs;
-   max_rows = 1;
-
-   {
-      Array<int> mark(fespace->GetNDofs());
-      mark = 0;
-      auto bs_ptr = block_storage.HostWrite();
-      int ridx = 0;
-      int cidx = 0;
-      int num_marked = 0;
-      for (int k = 0; k < dtrans.embeddings.Size(); k++)
-      {
-         const Embedding &emb = dtrans.embeddings[k];
-         Geometry::Type geom =
-            fespace->GetMesh()->GetElementBaseGeometry(emb.parent);
-
-         if (fespace->IsVariableOrder())
-         {
-            const FiniteElement *fe = fespace->GetFE(emb.parent);
-            const DenseTensor &pmats = dtrans.point_matrices[geom];
-            const int ldof = fe->GetDof();
-
-            IsoparametricTransformation isotr;
-            isotr.SetIdentityTransformation(geom);
-
-            localRVO.SetSize(ldof, ldof);
-            isotr.SetPointMat(pmats(emb.matrix));
-            // Local restriction is size ldofxldof assuming that the parent
-            // and child are of same polynomial order.
-            fe->GetLocalRestriction(isotr, localRVO);
-            // copy block
-            auto size = localRVO.Height() * localRVO.Width();
-            std::copy(localRVO.Data(), localRVO.Data() + size, bs_ptr);
-            bs_ptr += size;
-         }
-         DenseMatrix &lR =
-            fespace->IsVariableOrder() ? localRVO : localR[geom](emb.matrix);
-         block_row_idcs_offsets[k + 1] =
-            block_row_idcs_offsets[k] + lR.Height();
-         block_col_idcs_offsets[k + 1] = block_col_idcs_offsets[k] + lR.Width();
-         max_rows = std::max(lR.Height(), max_rows);
-         // index information
-         fespace->elem_dof->GetRow(emb.parent, dofs);
-         old_elem_dof->GetRow(k, old_dofs);
-         MFEM_VERIFY(old_dofs.Size() == dofs.Size(),
-                     "Parent and child must have same #dofs.");
-         for (int i = 0; i < lR.Height(); ++i, ++ridx)
-         {
-            if (!std::isfinite(lR(i, 0)))
-            {
-               row_idcs[ridx] = INT_MAX;
-               continue;
-            }
-            int r = dofs[i];
-            int m = (r >= 0) ? r : (-1 - r);
-            if (is_dg || !mark[m])
-            {
-               row_idcs[ridx] = r;
-               mark[m] = 1;
-               ++num_marked;
-            }
-            else
-            {
-               row_idcs[ridx] = INT_MAX;
-            }
-         }
-         for (int i = 0; i < lR.Width(); ++i, ++cidx)
-         {
-            col_idcs[cidx] = old_dofs[i];
-         }
-      }
-      if (!is_dg && !fespace->IsVariableOrder())
-      {
-         MFEM_VERIFY(num_marked * fespace->GetVDim() == Height(),
-                     "internal error: not all rows were set.");
-      }
-   }
-   // if not using GPU, set max_rows/max_cols to zero
-   if (Device::Allows(Backend::DEVICE_MASK))
-   {
-      max_rows = std::min(max_rows, max_team_size);
-   }
-   else
-   {
-      max_rows = 1;
-   }
-}
-
-void DerefineMatrixOp::Mult(const Vector &x, Vector &y) const
-{
-   const bool is_dg = fespace->FEColl()->GetContType()
-                      == FiniteElementCollection::DISCONTINUOUS;
-   // DG needs atomic summation
-   MultKernel::Run(fespace->GetOrdering(), is_dg, *this, x, y);
-}
-
-DerefineMatrixOp::Kernels::Kernels()
-{
-   MultKernel::Specialization<Ordering::byNODES, false>::Add();
-   MultKernel::Specialization<Ordering::byVDIM, false>::Add();
-   MultKernel::Specialization<Ordering::byNODES, true>::Add();
-   MultKernel::Specialization<Ordering::byVDIM, true>::Add();
-}
-
-template <Ordering::Type Order, bool Atomic>
-DerefineMatrixOp::MultKernelType DerefineMatrixOp::MultKernel::Kernel()
-{
-   return internal::DerefMultKernelImpl<Order, Atomic>;
-}
-
-DerefineMatrixOp::MultKernelType
-DerefineMatrixOp::MultKernel::Fallback(Ordering::Type, bool)
-{
-   MFEM_ABORT("invalid MultKernel parameters");
-}
-} // namespace mfem
-/// \endcond DO_NOT_DOCUMENT

fem/derefmat_op.hpp

@@ -1,65 +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_DEREFMAT_OP
-#define MFEM_DEREFMAT_OP
-
-#include "fespace.hpp"
-
-#include "kernel_dispatch.hpp"
-
-namespace mfem
-{
-
-/// \cond DO_NOT_DOCUMENT
-
-struct DerefineMatrixOp : public Operator
-{
-   FiniteElementSpace *fespace;
-   /// offsets into block_storage
-   Array<int> block_offsets;
-   /// offsets into row_idcs
-   Array<int> block_row_idcs_offsets;
-   /// offsets into col_idcs
-   Array<int> block_col_idcs_offsets;
-   /// mapping for row dofs, INT_MAX indicates the block row should be ignored.
-   /// negative means the row data should be negated.
-   Array<int> row_idcs;
-   /// mapping for col dofs, negative means the col data should be negated.
-   Array<int> col_idcs;
-   /// dense block matrices which can be reused to construct the full matrix
-   /// operation. These are stored contiguously and blocks have no restrictions
-   /// on shape (can be rectangle and differ from block to block).
-   Vector block_storage;
-   /// maximum height of any block in block_storage for GPU
-   /// parallelization, or 1 for CPU runs.
-   int max_rows;
-
-   using MultKernelType = void (*)(const DerefineMatrixOp &, const Vector &,
-                                   Vector &);
-   /// template args: ordering, atomic
-   MFEM_REGISTER_KERNELS(MultKernel, MultKernelType, (Ordering::Type, bool));
-
-   struct Kernels
-   {
-      Kernels();
-   };
-
-   void Mult(const Vector &x, Vector &y) const;
-
-   DerefineMatrixOp(FiniteElementSpace &fespace_, int old_ndofs,
-                    const Table *old_elem_dof, const Table *old_elem_fos);
-};
-
-/// \endcond DO_NOT_DOCUMENT
-
-} // namespace mfem
-#endif

fem/dfem/doperator.hpp

@@ -231,53 +231,21 @@ public:
       const std::vector<FieldDescriptor> &parameters,
       const ParMesh &mesh);
 
-   /// MultLevel enum to indicate if the T->L Operators are used in the
-   /// Mult method.
-   enum MultLevel
-   {
-      TVECTOR,
-      LVECTOR
-   };
-
-   /// @brief Set the MultLevel mode for the DifferentiableOperator.
-   /// The default is TVECTOR, which means that the Operator will use
-   /// T->L before Mult and L->T Operators after.
-   void SetMultLevel(MultLevel level)
-   {
-      mult_level = level;
-   }
-
    /// @brief Compute the action of the operator on a given vector.
    ///
-   /// @param solutions_in The solution vector in which to compute the action.
-   /// This has to be a T-dof vector if MultLevel is set to TVECTOR, or L-dof
-   /// Vector if MultLevel is set to LVECTOR.
-   /// @param result_in Result vector of the action of the operator on
-   /// solutions. The result is a T-dof vector or L-dof vector depending on
-   /// the MultLevel.
-   void Mult(const Vector &solutions_in, Vector &result_in) const override
+   /// @param solutions_t The solution vector in which to compute the action.
+   /// This has to be a T-dof vector.
+   /// @param result_t Result vector of the action of the operator on
+   /// solutions_t. The result is a T-dof vector.
+   void Mult(const Vector &solutions_t, Vector &result_t) const override
    {
       MFEM_ASSERT(!action_callbacks.empty(), "no integrators have been set");
-
-      if (mult_level == MultLevel::LVECTOR)
+      prolongation(solutions, solutions_t, solutions_l);
+      for (auto &action : action_callbacks)
       {
-         get_lvectors(solutions, solutions_in, solutions_l);
-         result_in = 0.0;
-         for (auto &action : action_callbacks)
-         {
-            action(solutions_l, parameters_l, result_in);
-         }
-      }
-      else
-      {
-         prolongation(solutions, solutions_in, solutions_l);
-         residual_l = 0.0;
-         for (auto &action : action_callbacks)
-         {
-            action(solutions_l, parameters_l, residual_l);
-         }
-         prolongation_transpose(residual_l, result_in);
+         action(solutions_l, parameters_l, residual_l);
       }
+      prolongation_transpose(residual_l, result_t);
    }
 
    /// @brief Add a domain integrator to the operator.
@@ -376,8 +344,6 @@ public:
 private:
    const ParMesh &mesh;
 
-   MultLevel mult_level = TVECTOR;
-
    std::vector<action_t> action_callbacks;
    std::map<size_t,
        std::vector<derivative_action_t>> derivative_action_callbacks;
@@ -387,6 +353,7 @@ private:
        std::vector<assemble_derivative_hypreparmatrix_callback_t>>
        assemble_derivative_hypreparmatrix_callbacks;
 
+
    std::vector<FieldDescriptor> solutions;
    std::vector<FieldDescriptor> parameters;
    // solutions and parameters
@@ -400,9 +367,16 @@ private:
    mutable Vector residual_e;
 
    std::function<void(Vector &, Vector &)> prolongation_transpose;
+
+   // TODO: This can probably be removed, as it is only used in
+   // the callbacks so they can copy it during the capture.
    std::function<void(Vector &, Vector &)> output_restriction_transpose;
+
    restriction_callback_t restriction_callback;
 
+   std::map<size_t, std::function<void(const Vector &, Vector &)>>
+                                                                daction_prolongation_transpose;
+
    std::map<size_t, size_t> assembled_vector_sizes;
 
    bool use_tensor_product_structure = true;
@@ -545,7 +519,7 @@ void DifferentiableOperator::AddDomainIntegrator(
    const int num_entities = GetNumEntities<entity_t>(mesh);
    const int num_qp = integration_rule.GetNPoints();
 
-   if constexpr (is_sum_fop<decltype(output_fop)>::value)
+   if constexpr (is_sum_fop<std::remove_cv_t<decltype(output_fop)>>::value)
    {
       residual_l.SetSize(1);
       height = 1;
@@ -579,8 +553,19 @@ void DifferentiableOperator::AddDomainIntegrator(
 
    const int test_vdim = output_fop.vdim;
    const int test_op_dim = output_fop.size_on_qp / output_fop.vdim;
-   const int num_test_dof =
-      num_entities ? (output_e_size / output_fop.vdim / num_entities) : 0;
+
+   int num_test_dof = 0;
+   if (num_entities)
+   {
+      if constexpr (is_sum_fop<std::decay_t<decltype(output_fop)>>::value)
+      {
+         num_test_dof = 1;
+      }
+      else
+      {
+         num_test_dof = output_e_size / output_fop.vdim / num_entities;
+      }
+   }
 
    auto ir_weights = Reshape(integration_rule.GetWeights().Read(), num_qp);
 
@@ -698,11 +683,16 @@ void DifferentiableOperator::AddDomainIntegrator(
    if constexpr (derivative_ids_t::size() != 0)
    {
       // Create the action of the derivatives
-      for_constexpr([&, &or_transpose =
-                        this->output_restriction_transpose](const std::size_t derivative_id)
+      for_constexpr([&,
+                     &or_transpose = this->output_restriction_transpose,
+                     &dapr_transpose = this->daction_prolongation_transpose]
+                    (const std::size_t derivative_id)
       {
          const size_t d_field_idx = FindIdx(derivative_id, fields);
          const auto direction = fields[d_field_idx];
+
+         dapr_transpose[derivative_id] = get_generic_prolongation_transpose(direction);
+
          const int da_size_on_qp =
             GetSizeOnQP<entity_t>(output_fop, fields[test_space_field_idx]);
 

fem/dfem/integrate.hpp

@@ -225,6 +225,17 @@ void map_quadrature_data_to_fields_tensor_impl_2d(
          MFEM_SYNC_THREAD;
       }
    }
+   else if constexpr (is_sum_fop<std::decay_t<output_t>>::value)
+   {
+      const auto [q1d, unused, d1d] = B.GetShape();
+      auto fqp = Reshape(&f(0, 0, 0), q1d * q1d);
+      auto yqp = Reshape(&y(0, 0), output.size_on_qp);
+      for (int i = 0; i < q1d * q1d; i++)
+      {
+         yqp(0) += fqp(i);
+      }
+      MFEM_SYNC_THREAD;
+   }
    else
    {
       MFEM_ABORT("quadrature data mapping to field is not implemented for"
@@ -411,6 +422,17 @@ void map_quadrature_data_to_fields_tensor_impl_3d(
          MFEM_SYNC_THREAD;
       }
    }
+   else if constexpr (is_sum_fop<std::decay_t<output_t>>::value)
+   {
+      const auto [q1d, unused, d1d] = B.GetShape();
+      auto fqp = Reshape(&f(0, 0, 0), q1d * q1d * q1d);
+      auto yqp = Reshape(&y(0, 0), output.size_on_qp);
+      for (int i = 0; i < q1d * q1d * q1d; i++)
+      {
+         yqp(0) += fqp(i);
+      }
+      MFEM_SYNC_THREAD;
+   }
    else
    {
       MFEM_ABORT("quadrature data mapping to field is not implemented for"

fem/dfem/parameterspace.hpp

@@ -101,11 +101,10 @@ public:
       // Setup DofToQuad information
       dtq.nqpt = (int)floor(std::pow(ir.GetNPoints(), 1.0 / mesh.Dimension()) + 0.5);
       dtq.ndof = dtq.nqpt;
-      dtq.mode = used_in_tensor_product ? DofToQuad::TENSOR : DofToQuad::FULL;
 
       // Calculate sizes
       const int num_qp = used_in_tensor_product ?
-                         static_cast<int>(std::pow(dtq.nqpt, mesh.Dimension())) :
+                         std::pow(dtq.nqpt, mesh.Dimension()) :
                          ir.GetNPoints();
 
       tsize = vdim * num_qp * mesh.GetNE();

fem/dfem/qfunction_transform.hpp

@@ -181,6 +181,14 @@ void process_derivative_from_native_dual(
    }
 }
 
+template <typename T>
+MFEM_HOST_DEVICE inline
+void process_derivative_from_native_dual(
+   DeviceTensor<1, T> &r,
+   const dual<T, T> &x)
+{
+   r(0) = x.gradient;
+}
 
 template <typename T0, typename T1>
 MFEM_HOST_DEVICE inline

fem/dfem/util.hpp

@@ -327,8 +327,8 @@ void print_mpi_sync(const std::string& msg)
    // First gather string lengths
    size_t msg_len = msg.length();
    std::vector<size_t> lengths(nranks);
-   MPI_Gather(&msg_len, 1, MPITypeMap<size_t>::mpi_type,
-              lengths.data(), 1, MPITypeMap<size_t>::mpi_type,
+   MPI_Gather(&msg_len, 1, MPI_INT,
+              lengths.data(), 1, MPI_INT,
               0, MPI_COMM_WORLD);
 
    if (myrank == 0)
@@ -568,7 +568,7 @@ struct ThreadBlocks
    int z = 1;
 };
 
-#if defined(MFEM_USE_CUDA_OR_HIP)
+#if (defined(MFEM_USE_CUDA) || defined(MFEM_USE_HIP))
 template <typename func_t>
 __global__ void forall_kernel_shmem(func_t f, int n)
 {
@@ -591,7 +591,7 @@ void forall(func_t f,
    if (Device::Allows(Backend::CUDA_MASK) ||
        Device::Allows(Backend::HIP_MASK))
    {
-#if defined(MFEM_USE_CUDA_OR_HIP)
+#if (defined(MFEM_USE_CUDA) || defined(MFEM_USE_HIP))
       // int gridsize = (N + Z - 1) / Z;
       int num_bytes = num_shmem * sizeof(decltype(shmem));
       dim3 block_size(blocks.x, blocks.y, blocks.z);
@@ -892,6 +892,37 @@ int GetDimension(const FieldDescriptor &f)
    }, f.data);
 }
 
+/// @brief Get the number of elements from a field descriptor.
+///
+/// @param f the field descriptor.
+/// @tparam entity_t the entity type (see Entity).
+/// @returns the number of elements from the field descriptor.
+template <typename entity_t>
+int GetNumElements(const FieldDescriptor &f)
+{
+   return std::visit([](auto && arg)
+   {
+      using T = std::decay_t<decltype(arg)>;
+      if constexpr (std::is_same_v<T, const FiniteElementSpace *> ||
+                    std::is_same_v<T, const ParFiniteElementSpace *>)
+      {
+         if constexpr (std::is_same_v<entity_t, Entity::Element>)
+         {
+            return arg->GetMesh()->GetNE();
+         }
+      }
+      else if constexpr (std::is_same_v<T, const ParameterSpace *>)
+      {
+         // TODO: Implement GetNumElements for ParameterSpace
+         return 0;
+      }
+      else
+      {
+         static_assert(dfem::always_false<T>, "can't use GetDimension on type");
+      }
+      return 0; // Unreachable, but avoids compiler warning
+   }, f.data);
+}
 
 /// @brief Get the prolongation operator for a field descriptor.
 ///
@@ -987,16 +1018,18 @@ get_restriction_transpose(
    {
       auto RT = [=](const Vector &v_e, Vector &v_l)
       {
-         v_l += v_e;
+         v_l = v_e;
       };
-      return std::make_tuple(RT, 1);
+      // The size is always 1 * number of elements for sum operators, e.g.
+      // each element is reduced to a single value on the E-vector level.
+      return std::make_tuple(RT, GetNumElements<entity_t>(f));
    }
    else
    {
       const Operator *R = get_restriction<entity_t>(f, o);
       std::function<void(const Vector&, Vector&)> RT = [=](const Vector &x, Vector &y)
       {
-         R->AddMultTranspose(x, y);
+         R->MultTranspose(x, y);
       };
       return std::make_tuple(RT, R->Height());
    }
@@ -1077,21 +1110,15 @@ void prolongation(const std::vector<FieldDescriptor> fields,
 }
 
 inline
-void get_lvectors(const std::vector<FieldDescriptor> fields,
-                  const Vector &x,
-                  std::vector<Vector> &fields_l)
+std::function<void(const Vector&, Vector&)> get_generic_prolongation_transpose(
+   const FieldDescriptor &f)
 {
-   int data_offset = 0;
-   for (std::size_t i = 0; i < fields.size(); i++)
+   const Operator *P = get_prolongation(f);
+   auto PT = [=](const Vector &r_local, Vector &y)
    {
-      const int sz = GetVSize(fields[i]);
-      fields_l[i].SetSize(sz);
-
-      const Vector x_i(const_cast<Vector&>(x), data_offset, sz);
-      fields_l[i] = x_i;
-
-      data_offset += sz;
-   }
+      P->MultTranspose(r_local, y);
+   };
+   return PT;
 }
 
 /// @brief Get a transpose prolongation callback for a field descriptor.
@@ -1128,11 +1155,8 @@ std::function<void(const Vector&, Vector&)> get_prolongation_transpose(
       };
       return PT;
    }
-   const Operator *P = get_prolongation(f);
-   auto PT = [=](const Vector &r_local, Vector &y)
-   {
-      P->MultTranspose(r_local, y);
-   };
+
+   auto PT = get_generic_prolongation_transpose(f);
    return PT;
 }
 
@@ -1720,13 +1744,12 @@ std::array<DofToQuadMap, N> load_dtq_mem(
    std::array<DofToQuadMap, N> f;
    for (std::size_t i = 0; i < N; i++)
    {
+      const auto [nqp_b, dim_b, ndof_b] = dtq[i].B.GetShape();
+      const auto B = Reshape(&dtq[i].B[0], nqp_b, dim_b, ndof_b);
+      auto mem_Bi = Reshape(reinterpret_cast<real_t *>(mem) + offset, nqp_b, dim_b,
+                            ndof_b);
       if (dtq[i].which_input != -1)
       {
-         const auto [nqp_b, dim_b, ndof_b] = dtq[i].B.GetShape();
-         const auto B = Reshape(&dtq[i].B[0], nqp_b, dim_b, ndof_b);
-         auto mem_Bi = Reshape(reinterpret_cast<real_t *>(mem) + offset, nqp_b, dim_b,
-                               ndof_b);
-
          MFEM_FOREACH_THREAD(q, x, nqp_b)
          {
             MFEM_FOREACH_THREAD(d, y, ndof_b)
@@ -2177,7 +2200,7 @@ template <
    std::size_t... Is>
 std::array<DofToQuadMap, N> create_dtq_maps_impl(
    field_operator_ts &fops,
-   std::vector<const DofToQuad*> &dtqs,
+   std::vector<const DofToQuad*> dtqs,
    const std::array<int, N> &field_map,
    std::index_sequence<Is...>)
 {
@@ -2262,7 +2285,7 @@ template <
    std::size_t num_fields>
 std::array<DofToQuadMap, num_fields> create_dtq_maps(
    field_operator_ts &fops,
-   std::vector<const DofToQuad*> &dtqmaps,
+   std::vector<const DofToQuad*> dtqmaps,
    const std::array<int, num_fields> &to_field_map)
 {
    return create_dtq_maps_impl<entity_t>(

fem/fe/face_map_utils.hpp

@@ -259,30 +259,6 @@ inline void FaceIdxToVolIdx3D(const int index, const int size1d,
    i = yz_plane ? level : _i;
 }
 
-MFEM_HOST_DEVICE
-inline int FaceIdxToVolIdx(int dim, int i, int size1d, int face0, int face1,
-                           int side, int orientation)
-{
-   if (dim == 2)
-   {
-      int ix, iy;
-      internal::FaceIdxToVolIdx2D(i, size1d, face0, face1, side, ix, iy);
-      return ix + iy*size1d;
-   }
-   else if (dim == 3)
-   {
-      int ix, iy, iz;
-      internal::FaceIdxToVolIdx3D(i, size1d, face0, face1, side, orientation,
-                                  ix, iy, iz);
-      return ix + size1d*iy + size1d*size1d*iz;
-   }
-   else
-   {
-      MFEM_ABORT_KERNEL("Invalid dimension");
-      return -1;
-   }
-};
-
 } // namespace internal
 
 } // namespace mfem

fem/fe/fe_base.cpp

@@ -20,16 +20,6 @@ namespace mfem
 
 using namespace std;
 
-DofToQuad DofToQuad::Abs() const
-{
-   DofToQuad d2q(*this);
-   d2q.B.Abs();
-   d2q.Bt.Abs();
-   d2q.G.Abs();
-   d2q.Gt.Abs();
-   return d2q;
-}
-
 FiniteElement::FiniteElement(int D, Geometry::Type G,
                              int Do, int O, int F)
    : Nodes(Do)

fem/fe/fe_base.hpp

@@ -219,9 +219,6 @@ public:
        - #ndof x #nqpt, for H(div) vector elements, or
        - #ndof x #nqpt x cdim, for H(curl) vector elements. */
    Array<real_t> Gt;
-
-   /// Returns absolute value of the maps
-   DofToQuad Abs() const;
 };
 
 /// Describes the function space on each element

fem/fe_coll.cpp

@@ -401,6 +401,9 @@ FiniteElementCollection *FiniteElementCollection::New(const char *name)
    {
       MFEM_ABORT("unknown FiniteElementCollection: " << name);
    }
+   MFEM_VERIFY(!strcmp(fec->Name(), name), "input name: \"" << name
+               << "\" does not match the created collection name: \""
+               << fec->Name() << '"');
 
    return fec;
 }
@@ -2456,7 +2459,8 @@ RT_FECollection::RT_FECollection(const int order, const int dim,
       const char *cb_name = BasisType::Name(cb_type); // this may abort
       MFEM_ABORT("unknown closed BasisType: " << cb_name);
    }
-   if (Quadrature1D::CheckOpen(op_type) == Quadrature1D::Invalid)
+   if (Quadrature1D::CheckOpen(op_type) == Quadrature1D::Invalid &&
+       ob_type != BasisType::IntegratedGLL)
    {
       const char *ob_name = BasisType::Name(ob_type); // this may abort
       MFEM_ABORT("unknown open BasisType: " << ob_name);
@@ -2514,7 +2518,6 @@ RT_FECollection::RT_FECollection(const int p, const int dim,
                                  const int map_type, const bool signs,
                                  const int ob_type)
    : FiniteElementCollection(p + 1)
-   , dim(dim)
    , ob_type(ob_type)
 {
    if (Quadrature1D::CheckOpen(BasisType::GetQuadrature1D(ob_type)) ==
@@ -2783,7 +2786,8 @@ ND_FECollection::ND_FECollection(const int p, const int dim,
    int cp_type = BasisType::GetQuadrature1D(cb_type);
 
    // Error checking
-   if (Quadrature1D::CheckOpen(op_type) == Quadrature1D::Invalid)
+   if (Quadrature1D::CheckOpen(op_type) == Quadrature1D::Invalid &&
+       ob_type != BasisType::IntegratedGLL)
    {
       const char *ob_name = BasisType::Name(ob_type);
       MFEM_ABORT("Invalid open basis point type: " << ob_name);

fem/fe_coll.hpp

@@ -464,13 +464,6 @@ public:
    RT_Trace_FECollection(const int p, const int dim,
                          const int map_type = FiniteElement::INTEGRAL,
                          const int ob_type = BasisType::GaussLegendre);
-
-   FiniteElementCollection *Clone(int p) const override
-   {
-      const int map_type = (strncmp(rt_name, "RT_Trace", 8) == 0)?
-                           (FiniteElement::INTEGRAL):(FiniteElement::VALUE);
-      return new RT_Trace_FECollection(p, dim, map_type, ob_type);
-   }
 };
 
 /** Arbitrary order discontinuous finite elements defined on the interface
@@ -482,13 +475,6 @@ public:
    DG_Interface_FECollection(const int p, const int dim,
                              const int map_type = FiniteElement::VALUE,
                              const int ob_type = BasisType::GaussLegendre);
-
-   FiniteElementCollection *Clone(int p) const override
-   {
-      const int map_type = (strncmp(rt_name, "DG_Iface", 8) == 0)?
-                           (FiniteElement::VALUE):(FiniteElement::INTEGRAL);
-      return new DG_Interface_FECollection(p, dim, map_type, ob_type);
-   }
 };
 
 /// Arbitrary order H(curl)-conforming Nedelec finite elements.

fem/fem.hpp

@@ -49,7 +49,6 @@
 #include "lor/lor.hpp"
 #include "dgmassinv.hpp"
 #include "hyperbolic.hpp"
-#include "bounds.hpp"
 
 #include "dfem/doperator.hpp"
 

fem/fes_kernels.hpp

@@ -1,249 +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_FES_KERNELS_HPP
-#define MFEM_FES_KERNELS_HPP
-
-#include "../general/forall.hpp"
-
-#include <climits>
-
-namespace mfem
-{
-/// \cond DO_NOT_DOCUMENT
-namespace internal
-{
-
-///
-/// Implements matrix-vector multiply $y = A x$ for a sparse matrix composed of
-/// a sum of smaller dense blocks. There is additional permutation/sign
-/// information associated with each block. The base class only implements
-/// helper routines such as computing block widths, index into x, index into y,
-/// and column in A given sub-block information.
-/// @sa DerefineMatrixOpMultFunctor
-///
-/// @tparam Order vdim ordering for x and y. Note that for Diag = false this is
-/// ignored for x as x has a special interleaved order.
-/// @tparam Base used for the curious recurring template pattern (CRTP) so the
-/// base class can access child class fields without virtual functions
-/// @tparam Diag true if this corresponds to the diagonal block (coarse element
-/// and fine element are on our rank), false otherwise (coarse element is on our
-/// rank, fine element is on a different rank).
-///
-template <Ordering::Type Order, class Base, bool Diag = true>
-struct DerefineMatrixOpFunctorBase;
-
-template <class Base>
-struct DerefineMatrixOpFunctorBase<Ordering::byNODES, Base, true>
-{
-   /// block column indices offsets
-   const int *bcptr;
-   /// column indices
-   const int *cptr;
-
-   int MFEM_HOST_DEVICE BlockWidth(int k) const
-   {
-      return bcptr[k + 1] - bcptr[k];
-   }
-
-   void MFEM_HOST_DEVICE Col(int j, int k, int &col, int &sign) const
-   {
-      col = cptr[bcptr[k] + j];
-      if (col < 0)
-      {
-         col = -1 - col;
-         sign = -sign;
-      }
-   }
-
-   int MFEM_HOST_DEVICE IndexX(int col, int vdim, int) const
-   {
-      return col + vdim * static_cast<const Base *>(this)->width;
-   }
-   int MFEM_HOST_DEVICE IndexY(int row, int vdim) const
-   {
-      return row + vdim * static_cast<const Base *>(this)->height;
-   }
-};
-
-template <class Base>
-struct DerefineMatrixOpFunctorBase<Ordering::byVDIM, Base, true>
-{
-   /// block column indices offsets
-   const int *bcptr;
-   /// column indices
-   const int *cptr;
-
-   int MFEM_HOST_DEVICE BlockWidth(int k) const
-   {
-      return bcptr[k + 1] - bcptr[k];
-   }
-
-   void MFEM_HOST_DEVICE Col(int j, int k, int &col, int &sign) const
-   {
-      col = cptr[bcptr[k] + j];
-      if (col < 0)
-      {
-         col = -1 - col;
-         sign = -sign;
-      }
-   }
-
-   int MFEM_HOST_DEVICE IndexX(int col, int vdim, int) const
-   {
-      return vdim + col * static_cast<const Base *>(this)->vdims;
-   }
-   int MFEM_HOST_DEVICE IndexY(int row, int vdim) const
-   {
-      return vdim + row * static_cast<const Base *>(this)->vdims;
-   }
-};
-
-template <class Base>
-struct DerefineMatrixOpFunctorBase<Ordering::byNODES, Base, false>
-{
-   /// receive segment offsets
-   const int *segptr;
-   /// receive segment index
-   const int *rsptr;
-   /// off-diagonal block column offsets
-   const int *coptr;
-   /// off-diagonal block widths
-   const int *bwptr;
-
-   int MFEM_HOST_DEVICE BlockWidth(int k) const { return bwptr[k]; }
-
-   void MFEM_HOST_DEVICE Col(int j, int k, int &col, int &sign) const
-   {
-      col = coptr[k] + j;
-   }
-
-   int MFEM_HOST_DEVICE IndexX(int col, int vdim, int k) const
-   {
-      int tmp = rsptr[k];
-      int segwidth = segptr[tmp + 1] - segptr[tmp];
-      return segptr[tmp] * static_cast<const Base *>(this)->vdims + col +
-             vdim * segwidth;
-   }
-   int MFEM_HOST_DEVICE IndexY(int row, int vdim) const
-   {
-      return row + vdim * static_cast<const Base *>(this)->height;
-   }
-};
-
-template <class Base>
-struct DerefineMatrixOpFunctorBase<Ordering::byVDIM, Base, false>
-{
-   /// receive segment offsets
-   const int *segptr;
-   /// receive segment index
-   const int *rsptr;
-   /// off-diagonal block column offsets
-   const int *coptr;
-   /// off-diagonal block widths
-   const int *bwptr;
-
-   int MFEM_HOST_DEVICE BlockWidth(int k) const { return bwptr[k]; }
-
-   void MFEM_HOST_DEVICE Col(int j, int k, int &col, int &sign) const
-   {
-      col = coptr[k] + j;
-   }
-
-   int MFEM_HOST_DEVICE IndexX(int col, int vdim, int k) const
-   {
-      int tmp = rsptr[k];
-      int segwidth = segptr[tmp + 1] - segptr[tmp];
-      return segptr[tmp] * static_cast<const Base *>(this)->vdims + col +
-             vdim * segwidth;
-   }
-   int MFEM_HOST_DEVICE IndexY(int row, int vdim) const
-   {
-      return vdim + row * static_cast<const Base *>(this)->vdims;
-   }
-};
-
-/// internally used to implement the derefinement operator Mult diagonal
-/// block
-template <Ordering::Type Order, bool Atomic, bool Diag = true>
-struct DerefineMatrixOpMultFunctor
-   : public DerefineMatrixOpFunctorBase<
-     Order, DerefineMatrixOpMultFunctor<Order, Atomic, Diag>, Diag>
-{
-   const real_t *xptr;
-   real_t *yptr;
-   /// block storage
-   const real_t *bsptr;
-   /// block offsets
-   const int *boptr;
-   /// block row index offsets
-   const int *brptr;
-   /// row indices
-   const int *rptr;
-
-   // number of blocks
-   int nblocks;
-   // number of components
-   int vdims;
-   /// overall operator height (for vdim = 1)
-   int height;
-   /// overall operator width (for vdim = 1)
-   int width;
-   void MFEM_HOST_DEVICE operator()(int kidx) const
-   {
-      int k = kidx % nblocks;
-      int vdim = kidx / nblocks;
-
-      int block_height = brptr[k + 1] - brptr[k];
-      int block_width = this->BlockWidth(k);
-      MFEM_FOREACH_THREAD(i, x, block_height)
-      {
-         int row = rptr[brptr[k] + i];
-         int rsign = 1;
-         if (row < 0)
-         {
-            row = -1 - row;
-            rsign = -1;
-         }
-         if (row < INT_MAX)
-         {
-            // row not marked as unused
-            real_t sum = 0;
-            for (int j = 0; j < block_width; ++j)
-            {
-               int col, sign = rsign;
-               this->Col(j, k, col, sign);
-               sum += sign * bsptr[boptr[k] + i + j * block_height] *
-                      xptr[this->IndexX(col, vdim, k)];
-            }
-#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
-            if (Atomic)
-            {
-               atomicAdd(yptr + this->IndexY(row, vdim), sum);
-            }
-            else
-#endif
-            {
-               yptr[this->IndexY(row, vdim)] += sum;
-            }
-         }
-      }
-   }
-
-   /// N is the max block row size (doesn't have to be a power of 2)
-   void Run(int N) const { forall_2D(nblocks * vdims, N, 1, *this); }
-};
-
-} // namespace internal
-/// \endcond DO_NOT_DOCUMENT
-} // namespace mfem
-
-#endif

fem/fespace.cpp

@@ -17,9 +17,6 @@
 #include "fem.hpp"
 #include "ceed/interface/util.hpp"
 
-#include "derefmat_op.hpp"
-
-#include <algorithm>
 #include <cmath>
 #include <cstdarg>
 
@@ -27,9 +24,9 @@ using namespace std;
 
 namespace mfem
 {
-template <>
-void Ordering::DofsToVDofs<Ordering::byNODES>(int ndofs, int vdim,
-                                              Array<int> &dofs)
+
+template <> void Ordering::
+DofsToVDofs<Ordering::byNODES>(int ndofs, int vdim, Array<int> &dofs)
 {
    // static method
    int size = dofs.Size();
@@ -43,9 +40,8 @@ void Ordering::DofsToVDofs<Ordering::byNODES>(int ndofs, int vdim,
    }
 }
 
-template <>
-void Ordering::DofsToVDofs<Ordering::byVDIM>(int ndofs, int vdim,
-                                             Array<int> &dofs)
+template <> void Ordering::
+DofsToVDofs<Ordering::byVDIM>(int ndofs, int vdim, Array<int> &dofs)
 {
    // static method
    int size = dofs.Size();
@@ -59,6 +55,7 @@ void Ordering::DofsToVDofs<Ordering::byVDIM>(int ndofs, int vdim,
    }
 }
 
+
 FiniteElementSpace::FiniteElementSpace()
    : mesh(NULL), fec(NULL), vdim(0), ordering(Ordering::byNODES),
      ndofs(0), nvdofs(0), nedofs(0), nfdofs(0), nbdofs(0),
@@ -4247,11 +4244,7 @@ void FiniteElementSpace::Update(bool want_transform)
          case Mesh::DEREFINE:
          {
             BuildConformingInterpolation();
-#if 0
             Th.Reset(DerefinementMatrix(old_ndofs, old_elem_dof, old_elem_fos));
-#else
-            Th.Reset(new DerefineMatrixOp(*this, old_ndofs, old_elem_dof, old_elem_fos));
-#endif
             if (IsVariableOrder())
             {
                if (cP && cR_hp)
@@ -4285,6 +4278,9 @@ void FiniteElementSpace::Update(bool want_transform)
 void FiniteElementSpace::PRefineAndUpdate(const Array<pRefinement> & refs,
                                           bool want_transfer)
 {
+   MFEM_VERIFY(PRefinementSupported(),
+               "p-refinement is not supported in this space");
+
    if (want_transfer)
    {
       fesPrev.reset(new FiniteElementSpace(mesh, fec, vdim, ordering));

fem/fespace.hpp

@@ -113,7 +113,7 @@ class QuadratureSpace;
 class QuadratureInterpolator;
 class FaceQuadratureInterpolator;
 class PRefinementTransferOperator;
-struct DerefineMatrixOp;
+
 
 /** @brief Class FiniteElementSpace - responsible for providing FEM view of the
     mesh, mainly managing the set of degrees of freedom.
@@ -246,7 +246,6 @@ class FiniteElementSpace
    friend class PRefinementTransferOperator;
    friend void Mesh::Swap(Mesh &, bool);
    friend class LORBase;
-   friend struct DerefineMatrixOp;
 
 protected:
    /// The mesh that FE space lives on (not owned).
@@ -683,12 +682,8 @@ public:
    NURBSExtension *GetNURBSext() { return NURBSext; }
    NURBSExtension *StealNURBSext();
 
-   bool Conforming() const
-   {
-      return NURBSext != NULL ||
-             (mesh->Conforming() && cP == NULL);
-   }
-   bool Nonconforming() const { return !Conforming(); }
+   bool Conforming() const { return mesh->Conforming() && cP == NULL; }
+   bool Nonconforming() const { return mesh->Nonconforming() || cP != NULL; }
 
    /** Set the prolongation operator of the space to an arbitrary sparse matrix,
        creating a copy of the argument. */
@@ -926,9 +921,6 @@ public:
    { return mesh->GetBdrElementType(i); }
 
    /// Returns ElementTransformation for the @a i-th element.
-   /// @note The returned pointer references an object owned by the associated
-   /// @a Mesh that will be modified by other calls to `GetElementTransformation`.
-   /// As such, this pointer should @b not be deleted by the caller.
    ElementTransformation *GetElementTransformation(int i) const
    { return mesh->GetElementTransformation(i); }
 

fem/gridfunc.cpp

@@ -68,7 +68,7 @@ GridFunction::GridFunction(Mesh *m, std::istream &input)
       Vector::Load(input, fes->GetVSize());
 
       // if the mesh is a legacy (v1.1) NC mesh, it has old vertex ordering
-      if (fes->Nonconforming() && fes->GetMesh()->ncmesh &&
+      if (fes->Nonconforming() &&
           fes->GetMesh()->ncmesh->IsLegacyLoaded())
       {
          LegacyNCReorder();
@@ -1374,50 +1374,6 @@ void GridFunction::GetVectorGradientHat(
    MultAtB(loc_data_mat, dshape, gh);
 }
 
-void GridFunction::GetGradients(const IntegrationRule &ir, Vector &grad,
-                                QVectorLayout ql, MemoryType d_mt) const
-{
-   const FiniteElement &fe = *fes->GetTypicalFE();
-   const int dim  = fe.GetDim();
-   const int vdim = fes->GetVDim();
-   const int NE   = fes->GetNE();
-   const int ND   = fe.GetDof();
-   const int NQ   = ir.GetNPoints();
-
-   MemoryType my_d_mt = (d_mt != MemoryType::DEFAULT) ? d_mt :
-                        Device::GetDeviceMemoryType();
-
-   // ql == QVectorLayout::byNODES :   NQ x VDIM x  DIM x NE
-   // ql == QVectorLayout::byVDIM  : VDIM x  DIM x NQPT x NE
-   grad.SetSize(dim*vdim*NQ*NE, my_d_mt);
-
-   const QuadratureInterpolator &qi = *fes->GetQuadratureInterpolator(ir);
-   qi.SetOutputLayout(ql);
-
-   const bool use_tensor_products = UsesTensorBasis(*fes);
-   qi.DisableTensorProducts(!use_tensor_products);
-   const ElementDofOrdering e_ordering = use_tensor_products ?
-                                         ElementDofOrdering::LEXICOGRAPHIC :
-                                         ElementDofOrdering::NATIVE;
-   const Operator *elem_restr = fes->GetElementRestriction(e_ordering);
-
-   // Pre-compute the geometric factors in order to set the desired MemoryType
-   // they use:
-   fes->GetMesh()->GetGeometricFactors(
-      ir, GeometricFactors::JACOBIANS, my_d_mt);
-
-   if (elem_restr) // currently, always true
-   {
-      Vector f_e(vdim*ND*NE, my_d_mt);
-      elem_restr->Mult(*this, f_e);
-      qi.PhysDerivatives(f_e, grad);
-   }
-   else
-   {
-      qi.PhysDerivatives(*this, grad);
-   }
-}
-
 real_t GridFunction::GetDivergence(ElementTransformation &T) const
 {
    DofTransformation doftrans;
@@ -2668,7 +2624,7 @@ void GridFunction::ProjectBdrCoefficient(Coefficient *coeff[],
    }
    for (int i = 0; i < values_counter.Size(); i++)
    {
-      MFEM_ASSERT(bool(values_counter[i]) == bool(ess_vdofs_marker[i]),
+      MFEM_ASSERT(bool(values_counter[i]) == ess_vdofs_marker[i],
                   "internal error");
    }
 #endif
@@ -4378,7 +4334,7 @@ real_t LSZZErrorEstimator(BilinearFormIntegrator &blfi,  // input
          u.GetSubVector(udofs, ul);
          utrans.InvTransformPrimal(ul);
          Transf = ufes->GetElementTransformation(ielem);
-         const auto *dummy = ufes->GetFE(ielem);
+         FiniteElement *dummy = nullptr;
          blfi.ComputeElementFlux(*ufes->GetFE(ielem), *Transf, ul,
                                  *dummy, fl, with_coeff, ir);
 
@@ -4607,135 +4563,4 @@ GridFunction *Extrude1DGridFunction(Mesh *mesh, Mesh *mesh2d,
    return sol2d;
 }
 
-void GridFunction::GetElementBoundsAtControlPoints(const int elem,
-                                                   const PLBound &plb,
-                                                   Vector &lower, Vector &upper,
-                                                   const int vdim)
-{
-   const FiniteElement *fe = fes->GetFE(elem);
-   int fes_dim  = fes->GetVDim();
-   int rdim  = fe->GetDim();
-
-   const TensorBasisElement *tbe =
-      dynamic_cast<const TensorBasisElement *>(fe);
-   MFEM_VERIFY(tbe != NULL, "TensorBasis FiniteElement expected.");
-   const Array<int> &dof_map = tbe->GetDofMap();
-
-   Vector loc_data;
-   Array<int> dof_idx;
-   fes->GetElementDofs(elem, dof_idx);
-   int ndofs = dof_idx.Size();
-
-   int n_c_pts = std::pow(plb.GetNControlPoints(), rdim);
-   lower.SetSize(n_c_pts*(vdim > 0 ? 1 : fes_dim));
-   upper.SetSize(n_c_pts*(vdim > 0 ? 1 : fes_dim));
-
-   for (int d = 0; d < fes_dim; d++)
-   {
-      if (vdim > 0 && d != vdim-1) { continue; }
-      const int d_off = vdim > 0 ? 0 : d;
-      Array<int> dof_idx_c = dof_idx;
-      Vector lowerT(lower, d_off*n_c_pts, n_c_pts);
-      Vector upperT(upper, d_off*n_c_pts, n_c_pts);
-      fes->DofsToVDofs(vdim > 0 ? vdim-1 : d, dof_idx_c);
-      GetSubVector(dof_idx_c, loc_data);
-      Vector nodal_data;
-      if (dof_map.Size() == 0)
-      {
-         nodal_data.SetDataAndSize(loc_data.GetData(), ndofs);
-      }
-      else
-      {
-         nodal_data.SetSize(ndofs);
-         for (int j = 0; j < ndofs; j++)
-         {
-            nodal_data(j) = loc_data(dof_map[j]);
-         }
-      }
-      plb.GetNDBounds(rdim, nodal_data, lowerT, upperT);
-   }
 }
-
-void GridFunction::GetElementBounds(const int elem, const PLBound &plb,
-                                    Vector &lower, Vector &upper,
-                                    const int vdim)
-{
-   Vector lowerC, upperC;
-   GetElementBoundsAtControlPoints(elem, plb, lowerC, upperC, vdim);
-   const FiniteElement *fe = fes->GetFE(elem);
-   int rdim  = fe->GetDim();
-   int n_c_pts = std::pow(plb.GetNControlPoints(), rdim);
-   int fes_dim  = fes->GetVDim();
-   lower.SetSize((vdim > 0 ? 1 :fes_dim));
-   upper.SetSize((vdim > 0 ? 1 :fes_dim));
-   for (int d = 0; d < fes_dim; d++)
-   {
-      if (vdim > 0 && d != vdim-1) { continue; }
-      const int d_off = vdim > 0 ? 0 : d;
-      Vector lowerT(lowerC, d_off*n_c_pts, n_c_pts);
-      Vector upperT(upperC, d_off*n_c_pts, n_c_pts);
-      lower(d_off) = lowerT.Min();
-      upper(d_off) = upperT.Max();
-   }
-}
-
-void GridFunction::GetElementBounds(const PLBound &plb,
-                                    Vector &lower, Vector &upper,
-                                    const int vdim)
-{
-   int nel  = fes->GetNE();
-   int fes_dim  = fes->GetVDim();
-   lower.SetSize(nel*(vdim > 0 ? 1 :fes_dim));
-   upper.SetSize(nel*(vdim > 0 ? 1 :fes_dim));
-   for (int e = 0; e < nel; e++)
-   {
-      Vector lt, ut;
-      GetElementBounds(e, plb, lt, ut, vdim);
-      for (int d = 0; d < fes_dim ; d++)
-      {
-         if (vdim > 0 && d != vdim-1) { continue; }
-         const int d_off = vdim > 0 ? 0 : d;
-         lower(e + d_off*nel) = lt(d_off);
-         upper(e + d_off*nel) = ut(d_off);
-      }
-   }
-}
-
-PLBound GridFunction::GetElementBounds(Vector &lower,
-                                       Vector &upper,
-                                       const int ref_factor,
-                                       const int vdim)
-{
-   int max_order = fes->GetMaxElementOrder();
-   PLBound plb(fes, ref_factor*(max_order+1));
-   GetElementBounds(plb, lower, upper, vdim);
-   return plb;
-}
-
-PLBound GridFunction::GetBounds(Vector &lower, Vector &upper,
-                                const int ref_factor, const int vdim)
-{
-   int max_order = fes->GetMaxElementOrder();
-   PLBound plb(fes, ref_factor*(max_order+1));
-   Vector lel, uel;
-   GetElementBounds(plb, lel, uel, vdim);
-
-   int nel  = fes->GetNE();
-   int fes_dim  = fes->GetVDim();
-   lower.SetSize(vdim > 0 ? 1 : fes_dim);
-   upper.SetSize(vdim > 0 ? 1 : fes_dim);
-   for (int d = 0; d < fes_dim; d++)
-   {
-      if (vdim > 0 && d != vdim-1) { continue; }
-      const int d_off = vdim > 0 ? 0 : d;
-      Vector lelt(lel, d_off*nel, nel);
-      Vector uelt(uel, d_off*nel, nel);
-      lower(d_off) = lelt.Min();
-      upper(d_off) = uelt.Max();
-   }
-   return plb;
-}
-
-}
-
-

fem/gridfunc.hpp

@@ -16,7 +16,6 @@
 #include "fespace.hpp"
 #include "coefficient.hpp"
 #include "bilininteg.hpp"
-#include "bounds.hpp"
 #ifdef MFEM_USE_ADIOS2
 #include "../general/adios2stream.hpp"
 #endif
@@ -153,8 +152,7 @@ public:
    /// Shortcut for calling SetFromTrueDofs() with GetTrueVector() as argument.
    void SetFromTrueVector() { SetFromTrueDofs(GetTrueVector()); }
 
-   /** @brief Returns the values at the vertices of element @a i for the 1-based
-       dimension vdim. */
+   /// Returns the values in the vertices of i'th element for dimension vdim.
    void GetNodalValues(int i, Array<real_t> &nval, int vdim = 1) const;
 
    /** @name Element index Get Value Methods
@@ -309,8 +307,7 @@ public:
    /// For a vector grid function, makes sure that the ordering is byNODES.
    void ReorderByNodes();
 
-   /** @brief Returns the values as a vector at mesh vertices, for the 1-based
-       dimension vdim. */
+   /// Return the values as a vector on mesh vertices for dimension vdim.
    void GetNodalValues(Vector &nval, int vdim = 1) const;
 
    void GetVectorFieldNodalValues(Vector &val, int comp) const;
@@ -361,33 +358,6 @@ public:
        variable. */
    void GetVectorGradientHat(ElementTransformation &T, DenseMatrix &gh) const;
 
-   /** @brief Evaluate the gradients of the GridFunction at the given quadrature
-       points, @a ir, in all mesh elements. */
-   /** This method assumes that all mesh elements are the same type and that the
-       IntegrationRule @a ir is consistent with that type of element.
-
-       @param[in] ir     Quadrature points at which the gradients are to be
-                         evaluated.
-       @param[out] grad  Output vector of size `SDIM*VDIM*NQ*NE` where `SDIM` is
-                         the spatial dimention of the mesh, `VDIM` is the vector
-                         dimension of the GridFunction, `NQ` is the number of
-                         quadrature points in @a ir, and `NE` is the number of
-                         elements in the mesh. The layout of @a grad is
-                         determined by the parameter @a ql: when @a ql is
-                         QVectorLayout::byNODES, the layout is
-                         `NQ x VDIM x SDIM x NE`; when @a ql is
-                         QVectorLayout::byVDIM, the layout is
-                         `VDIM x SDIM x NQ x NE`.
-       @param[in] ql     Determines the layout of the output vector @a grad; see
-                         the description of @a grad for details.
-       @param[in] d_mt   MemoryType to use for allocating the output vector
-                         @a grad, as well the GeometricFactors and temporary
-                         vector used by the method. By default, the current
-                         device memory type is used. */
-   void GetGradients(const IntegrationRule &ir, Vector &grad,
-                     QVectorLayout ql = QVectorLayout::byNODES,
-                     MemoryType d_mt = MemoryType::DEFAULT) const;
-
    /** Compute $ (\int_{\Omega} (*this) \psi_i)/(\int_{\Omega} \psi_i) $,
        where $ \psi_i $ are the basis functions for the FE space of avgs.
        Both FE spaces should be scalar and on the same mesh. */
@@ -1591,56 +1561,11 @@ public:
        must be 2 and that quad elements will be broken into two triangles.*/
    void SaveSTL(std::ostream &out, int TimesToRefine = 1);
 
-   /** @name Methods to compute bounds on the grid function
-       \brief See bounds.hpp for \ref PLBound that constructs piecewise linear
-       bounds for a given set of bases. These piecewise bounds can be used to compute bounds on a grid function. Currently tensor-product elements are
-       supported with Lagrange interpolants on Gauss Legendre nodes and Gauss Lobatto Legendre nodes, and Bernstein bases.
-    */
-   ///@{
-   /// Computes the \ref PLBound for the gridfunction with number of control
-   /// points based on @a ref_factor, and returns the overall bounds for each
-   /// vdim (across all elements) in @b lower and @b upper. We also return the
-   /// PLBound object used to compute the bounds.
-   /// We compute the bounds for each vdim if @a vdim < 1.
-   /// Note: For most cases, this method/interface will be sufficient.
-   virtual PLBound GetBounds(Vector &lower, Vector &upper,
-                             const int ref_factor=1, const int vdim=-1);
-
-   /// Computes the \ref PLBound for the gridfunction with number of control
-   /// points based on @a ref_factor, and returns the bounds for each element
-   /// ordered byVDim:
-   /// lower_{0,0}, lower_{1,0}, ..., lower_{ne-1,0},
-   /// lower_{0,1}, ..., lower_{ne-1,vdim-1}. We also return the
-   /// PLBound object used to compute the bounds.
-   /// We compute the bounds for each vdim if @a vdim < 1.
-   PLBound GetElementBounds(Vector &lower, Vector &upper,
-                            const int ref_factor=1, const int vdim=-1);
-
-   /// Compute piecewise linear bounds on the given element at the grid of
-   /// [plb.ncp x plb.ncp x plb.ncp] control points for each of the vdim
-   /// components of the gridfunction.
-   void GetElementBoundsAtControlPoints(const int elem, const PLBound &plb,
-                                        Vector &lower, Vector &upper,
-                                        const int vdim = -1);
-
-   /// Compute bounds on the grid function for the given element.
-   /// The bounds are stored in @b lower and @b upper.
-   void GetElementBounds(const int elem, const PLBound &plb,
-                         Vector &lower, Vector &upper,
-                         const int vdim = -1);
-
-   /// Compute bounds on the grid function for all the elements. The bounds
-   /// are returned in @b lower and @b upper, ordered byVDim:
-   /// lower_{0,0}, lower_{1,0}, ..., lower_{ne-1,0},
-   /// lower_{0,1}, ..., lower_{ne-1,vdim-1}
-   void GetElementBounds(const PLBound &plb, Vector &lower, Vector &upper,
-                         const int vdim=-1);
-   ///@}
-
    /// Destroys grid function.
    virtual ~GridFunction() { Destroy(); }
 };
 
+
 /** Overload operator<< for std::ostream and GridFunction; valid also for the
     derived class ParGridFunction */
 std::ostream &operator<<(std::ostream &out, const GridFunction &sol);

fem/gslib.cpp

@@ -85,9 +85,9 @@ namespace mfem
 {
 
 FindPointsGSLIB::FindPointsGSLIB()
-   : mesh(nullptr),
-     fec_map_lin(nullptr),
-     fdataD(nullptr), cr(nullptr), gsl_comm(nullptr),
+   : mesh(NULL),
+     fec_map_lin(NULL),
+     fdataD(NULL), cr(NULL), gsl_comm(NULL),
      dim(-1), points_cnt(-1), setupflag(false), default_interp_value(0),
      avgtype(AvgType::ARITHMETIC), bdr_tol(1e-8)
 {
@@ -97,10 +97,10 @@ FindPointsGSLIB::FindPointsGSLIB()
    gf_rst_map.SetSize(4);
    for (int i = 0; i < mesh_split.Size(); i++)
    {
-      mesh_split[i] = nullptr;
-      ir_split[i] = nullptr;
-      fes_rst_map[i] = nullptr;
-      gf_rst_map[i] = nullptr;
+      mesh_split[i] = NULL;
+      ir_split[i] = NULL;
+      fes_rst_map[i] = NULL;
+      gf_rst_map[i] = NULL;
    }
 
    gsl_comm = new gslib::comm;
@@ -117,40 +117,27 @@ FindPointsGSLIB::FindPointsGSLIB()
    crystal_init(cr, gsl_comm);
 }
 
-FindPointsGSLIB::FindPointsGSLIB(Mesh &mesh_in, const double bb_t,
-                                 const double newt_tol, const int npt_max)
-   : FindPointsGSLIB()
-{
-   Setup(mesh_in, bb_t, newt_tol, npt_max);
-}
-
 FindPointsGSLIB::~FindPointsGSLIB()
 {
-   FreeData();
-#ifdef MFEM_USE_MPI
-   if (!Mpi::IsFinalized())  // currently segfaults inside gslib otherwise
-#endif
+   crystal_free(cr);
+   comm_free(gsl_comm);
+   delete gsl_comm;
+   delete cr;
+   for (int i = 0; i < 4; i++)
    {
-      crystal_free(cr);
-      comm_free(gsl_comm);
-      delete gsl_comm;
-      delete cr;
+      if (mesh_split[i]) { delete mesh_split[i]; mesh_split[i] = NULL; }
+      if (ir_split[i]) { delete ir_split[i]; ir_split[i] = NULL; }
+      if (fes_rst_map[i]) { delete fes_rst_map[i]; fes_rst_map[i] = NULL; }
+      if (gf_rst_map[i]) { delete gf_rst_map[i]; gf_rst_map[i] = NULL; }
    }
-   for (int i = 0; i < mesh_split.Size(); i++)
-   {
-      if (mesh_split[i]) { delete mesh_split[i]; mesh_split[i] = nullptr; }
-      if (ir_split[i]) { delete ir_split[i]; ir_split[i] = nullptr; }
-      if (fes_rst_map[i]) { delete fes_rst_map[i]; fes_rst_map[i] = nullptr; }
-      if (gf_rst_map[i]) { delete gf_rst_map[i]; gf_rst_map[i] = nullptr; }
-   }
-   if (fec_map_lin) { delete fec_map_lin; fec_map_lin = nullptr; }
+   if (fec_map_lin) { delete fec_map_lin; fec_map_lin = NULL; }
 }
 
 #ifdef MFEM_USE_MPI
 FindPointsGSLIB::FindPointsGSLIB(MPI_Comm comm_)
-   : mesh(nullptr),
-     fec_map_lin(nullptr),
-     fdataD(nullptr), cr(nullptr), gsl_comm(nullptr),
+   : mesh(NULL),
+     fec_map_lin(NULL),
+     fdataD(NULL), cr(NULL), gsl_comm(NULL),
      dim(-1), points_cnt(-1), setupflag(false), default_interp_value(0),
      avgtype(AvgType::ARITHMETIC), bdr_tol(1e-8)
 {
@@ -160,10 +147,10 @@ FindPointsGSLIB::FindPointsGSLIB(MPI_Comm comm_)
    gf_rst_map.SetSize(4);
    for (int i = 0; i < mesh_split.Size(); i++)
    {
-      mesh_split[i] = nullptr;
-      ir_split[i] = nullptr;
-      fes_rst_map[i] = nullptr;
-      gf_rst_map[i] = nullptr;
+      mesh_split[i] = NULL;
+      ir_split[i] = NULL;
+      fes_rst_map[i] = NULL;
+      gf_rst_map[i] = NULL;
    }
 
    gsl_comm = new gslib::comm;
@@ -171,21 +158,12 @@ FindPointsGSLIB::FindPointsGSLIB(MPI_Comm comm_)
    comm_init(gsl_comm, comm_);
    crystal_init(cr, gsl_comm);
 }
-
-FindPointsGSLIB::FindPointsGSLIB(ParMesh &mesh_in, const double bb_t,
-                                 const double newt_tol, const int npt_max)
-   : FindPointsGSLIB(mesh_in.GetComm())
-{
-   Setup(mesh_in, bb_t, newt_tol, npt_max);
-}
 #endif
 
 void FindPointsGSLIB::Setup(Mesh &m, const double bb_t, const double newt_tol,
                             const int npt_max)
 {
    MFEM_VERIFY(m.GetNodes() != NULL, "Mesh nodes are required.");
-   MFEM_VERIFY(m.SpaceDimension() == m.Dimension(),
-               "Mesh spatial dimension and reference element dimension must be the same");
    const int meshOrder = m.GetNodes()->FESpace()->GetMaxElementOrder();
 
    // call FreeData if FindPointsGSLIB::Setup has been called already
@@ -193,9 +171,37 @@ void FindPointsGSLIB::Setup(Mesh &m, const double bb_t, const double newt_tol,
 
    mesh = &m;
    dim  = mesh->Dimension();
-   const unsigned int dof1D = meshOrder+1;
+   unsigned dof1D = meshOrder + 1;
 
-   SetupSplitMeshesAndIntegrationRules(meshOrder);
+   SetupSplitMeshes();
+   if (dim == 2)
+   {
+      if (ir_split[0]) { delete ir_split[0]; ir_split[0] = NULL; }
+      ir_split[0] = new IntegrationRule(3*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[0], ir_split[0], meshOrder);
+
+      if (ir_split[1]) { delete ir_split[1]; ir_split[1] = NULL; }
+      ir_split[1] = new IntegrationRule(pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[1], ir_split[1], meshOrder);
+   }
+   else if (dim == 3)
+   {
+      if (ir_split[0]) { delete ir_split[0]; ir_split[0] = NULL; }
+      ir_split[0] = new IntegrationRule(pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[0], ir_split[0], meshOrder);
+
+      if (ir_split[1]) { delete ir_split[1]; ir_split[1] = NULL; }
+      ir_split[1] = new IntegrationRule(4*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[1], ir_split[1], meshOrder);
+
+      if (ir_split[2]) { delete ir_split[2]; ir_split[2] = NULL; }
+      ir_split[2] = new IntegrationRule(3*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[2], ir_split[2], meshOrder);
+
+      if (ir_split[3]) { delete ir_split[3]; ir_split[3] = NULL; }
+      ir_split[3] = new IntegrationRule(8*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[3], ir_split[3], meshOrder);
+   }
 
    GetNodalValues(mesh->GetNodes(), gsl_mesh);
 
@@ -1122,18 +1128,13 @@ void FindPointsGSLIB::Interpolate(Mesh &m, const Vector &point_pos,
 void FindPointsGSLIB::FreeData()
 {
    if (!setupflag) { return; }
-#ifdef MFEM_USE_MPI
-   if (!Mpi::IsFinalized())  // currently segfaults inside gslib otherwise
-#endif
+   if (dim == 2)
    {
-      if (dim == 2)
-      {
-         findpts_free_2((gslib::findpts_data_2 *)this->fdataD);
-      }
-      else
-      {
-         findpts_free_3((gslib::findpts_data_3 *)this->fdataD);
-      }
+      findpts_free_2((gslib::findpts_data_2 *)this->fdataD);
+   }
+   else
+   {
+      findpts_free_3((gslib::findpts_data_3 *)this->fdataD);
    }
    gsl_code.DeleteAll();
    gsl_proc.DeleteAll();
@@ -1157,8 +1158,8 @@ void FindPointsGSLIB::FreeData()
 
 void FindPointsGSLIB::SetupSplitMeshes()
 {
-   if (fec_map_lin == nullptr) { fec_map_lin = new H1_FECollection(1, dim); }
-   if (dim == 2)
+   fec_map_lin = new H1_FECollection(1, dim);
+   if (mesh->Dimension() == 2)
    {
       int Nvert = 7;
       int NEsplit = 3;
@@ -1200,7 +1201,7 @@ void FindPointsGSLIB::SetupSplitMeshes()
       mesh_split[1] = new Mesh(Mesh::MakeCartesian2D(1, 1,
                                                      Element::QUADRILATERAL));
    }
-   else if (dim == 3)
+   else if (mesh->Dimension() == 3)
    {
       mesh_split[0] = new Mesh(Mesh::MakeCartesian3D(1, 1, 1,
                                                      Element::HEXAHEDRON));
@@ -1345,6 +1346,41 @@ void FindPointsGSLIB::SetupSplitMeshes()
          }
       }
    }
+
+   NE_split_total = 0;
+   split_element_map.SetSize(0);
+   split_element_index.SetSize(0);
+   int NEsplit = 0;
+   for (int e = 0; e < mesh->GetNE(); e++)
+   {
+      const Geometry::Type gt   = mesh->GetElement(e)->GetGeometryType();
+      if (gt == Geometry::TRIANGLE || gt == Geometry::PRISM)
+      {
+         NEsplit = 3;
+      }
+      else if (gt == Geometry::TETRAHEDRON)
+      {
+         NEsplit = 4;
+      }
+      else if (gt == Geometry::PYRAMID)
+      {
+         NEsplit = 8;
+      }
+      else if (gt == Geometry::SQUARE || gt == Geometry::CUBE)
+      {
+         NEsplit = 1;
+      }
+      else
+      {
+         MFEM_ABORT("Unsupported geometry type.");
+      }
+      NE_split_total += NEsplit;
+      for (int i = 0; i < NEsplit; i++)
+      {
+         split_element_map.Append(e);
+         split_element_index.Append(i);
+      }
+   }
 }
 
 void FindPointsGSLIB::SetupIntegrationRuleForSplitMesh(Mesh *meshin,
@@ -1395,79 +1431,6 @@ void FindPointsGSLIB::SetupIntegrationRuleForSplitMesh(Mesh *meshin,
    }
 }
 
-void FindPointsGSLIB::SetupSplitMeshesAndIntegrationRules(const int order)
-{
-   MFEM_VERIFY(mesh, "Setup FindPointsGSLIB with mesh first.");
-   const int dof1D = order+1;
-   const int dim = mesh->Dimension();
-
-   SetupSplitMeshes();
-   if (dim == 2)
-   {
-      if (ir_split[0]) { delete ir_split[0]; ir_split[0] = NULL; }
-      ir_split[0] = new IntegrationRule(3*pow(dof1D, dim));
-      SetupIntegrationRuleForSplitMesh(mesh_split[0], ir_split[0], order);
-
-      if (ir_split[1]) { delete ir_split[1]; ir_split[1] = NULL; }
-      ir_split[1] = new IntegrationRule(pow(dof1D, dim));
-      SetupIntegrationRuleForSplitMesh(mesh_split[1], ir_split[1], order);
-   }
-   else if (dim == 3)
-   {
-      if (ir_split[0]) { delete ir_split[0]; ir_split[0] = NULL; }
-      ir_split[0] = new IntegrationRule(pow(dof1D, dim));
-      SetupIntegrationRuleForSplitMesh(mesh_split[0], ir_split[0], order);
-
-      if (ir_split[1]) { delete ir_split[1]; ir_split[1] = NULL; }
-      ir_split[1] = new IntegrationRule(4*pow(dof1D, dim));
-      SetupIntegrationRuleForSplitMesh(mesh_split[1], ir_split[1], order);
-
-      if (ir_split[2]) { delete ir_split[2]; ir_split[2] = NULL; }
-      ir_split[2] = new IntegrationRule(3*pow(dof1D, dim));
-      SetupIntegrationRuleForSplitMesh(mesh_split[2], ir_split[2], order);
-
-      if (ir_split[3]) { delete ir_split[3]; ir_split[3] = NULL; }
-      ir_split[3] = new IntegrationRule(8*pow(dof1D, dim));
-      SetupIntegrationRuleForSplitMesh(mesh_split[3], ir_split[3], order);
-   }
-
-   // Setup map for non tensor-product elements
-   NE_split_total = 0;
-   split_element_map.SetSize(0);
-   split_element_index.SetSize(0);
-   int NEsplit = 0;
-   for (int e = 0; e < mesh->GetNE(); e++)
-   {
-      const Geometry::Type gt   = mesh->GetElement(e)->GetGeometryType();
-      if (gt == Geometry::TRIANGLE || gt == Geometry::PRISM)
-      {
-         NEsplit = 3;
-      }
-      else if (gt == Geometry::TETRAHEDRON)
-      {
-         NEsplit = 4;
-      }
-      else if (gt == Geometry::PYRAMID)
-      {
-         NEsplit = 8;
-      }
-      else if (gt == Geometry::SQUARE || gt == Geometry::CUBE)
-      {
-         NEsplit = 1;
-      }
-      else
-      {
-         MFEM_ABORT("Unsupported geometry type.");
-      }
-      NE_split_total += NEsplit;
-      for (int i = 0; i < NEsplit; i++)
-      {
-         split_element_map.Append(e);
-         split_element_index.Append(i);
-      }
-   }
-}
-
 void FindPointsGSLIB::GetNodalValues(const GridFunction *gf_in,
                                      Vector &node_vals)
 {
@@ -2118,19 +2081,6 @@ void FindPointsGSLIB::InterpolateGeneral(const GridFunction &field_in,
    } // parallel
 }
 
-Array<unsigned int> FindPointsGSLIB::GetPointsNotFoundIndices() const
-{
-   Array<unsigned int> nf_idxs;
-   for (int i = 0; i < gsl_code.Size(); i++)
-   {
-      if (gsl_code[i] == 2)
-      {
-         nf_idxs.Append(i);
-      }
-   }
-   return nf_idxs;
-}
-
 void FindPointsGSLIB::DistributePointInfoToOwningMPIRanks(
    Array<unsigned int> &recv_elem, Vector &recv_ref,
    Array<unsigned int> &recv_code)
@@ -2436,10 +2386,6 @@ void OversetFindPointsGSLIB::Setup(Mesh &m, const int meshid,
 {
    MFEM_VERIFY(m.GetNodes() != NULL, "Mesh nodes are required.");
    const int meshOrder = m.GetNodes()->FESpace()->GetMaxElementOrder();
-   const int gfOrder = gfmax ? gfmax->FESpace()->GetMaxElementOrder() :
-                       meshOrder;
-   MFEM_VERIFY(meshOrder == gfOrder,
-               "Mesh order must match gfmax order in OversetFindPointsGSLIB.");
 
    // FreeData if OversetFindPointsGSLIB::Setup has been called already
    if (setupflag) { FreeData(); }
@@ -2449,7 +2395,35 @@ void OversetFindPointsGSLIB::Setup(Mesh &m, const int meshid,
    const FiniteElement *fe = mesh->GetNodalFESpace()->GetTypicalFE();
    unsigned dof1D = fe->GetOrder() + 1;
 
-   SetupSplitMeshesAndIntegrationRules(meshOrder);
+   SetupSplitMeshes();
+   if (dim == 2)
+   {
+      if (ir_split[0]) { delete ir_split[0]; ir_split[0] = NULL; }
+      ir_split[0] = new IntegrationRule(3*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[0], ir_split[0], meshOrder);
+
+      if (ir_split[1]) { delete ir_split[1]; ir_split[1] = NULL; }
+      ir_split[1] = new IntegrationRule(pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[1], ir_split[1], meshOrder);
+   }
+   else if (dim == 3)
+   {
+      if (ir_split[0]) { delete ir_split[0]; ir_split[0] = NULL; }
+      ir_split[0] = new IntegrationRule(pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[0], ir_split[0], meshOrder);
+
+      if (ir_split[1]) { delete ir_split[1]; ir_split[1] = NULL; }
+      ir_split[1] = new IntegrationRule(4*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[1], ir_split[1], meshOrder);
+
+      if (ir_split[2]) { delete ir_split[2]; ir_split[2] = NULL; }
+      ir_split[2] = new IntegrationRule(3*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[2], ir_split[2], meshOrder);
+
+      if (ir_split[3]) { delete ir_split[3]; ir_split[3] = NULL; }
+      ir_split[3] = new IntegrationRule(8*pow(dof1D, dim));
+      SetupIntegrationRuleForSplitMesh(mesh_split[3], ir_split[3], meshOrder);
+   }
 
    GetNodalValues(mesh->GetNodes(), gsl_mesh);
 
@@ -2506,7 +2480,7 @@ void OversetFindPointsGSLIB::FindPoints(const Vector &point_pos,
 {
    MFEM_VERIFY(setupflag, "Use OversetFindPointsGSLIB::Setup before "
                "finding points.");
-   MFEM_VERIFY(overset, "Please use OversetFindPoints for overlapping grids.");
+   MFEM_VERIFY(overset, "Please setup FindPoints for overlapping grids.");
    points_cnt = point_pos.Size() / dim;
    unsigned int match = 0; // Don't find points in the mesh if point_id=mesh_id
 

fem/gslib.hpp

@@ -13,11 +13,7 @@
 #define MFEM_GSLIB
 
 #include "../config/config.hpp"
-#ifdef MFEM_USE_MPI
-#include "pgridfunc.hpp"
-#else
 #include "gridfunc.hpp"
-#endif
 
 #ifdef MFEM_USE_GSLIB
 
@@ -34,9 +30,7 @@ namespace mfem
 {
 
 /** \brief FindPointsGSLIB can robustly evaluate a GridFunction on an arbitrary
- *  collection of points. See Mittal et al., "General Field Evaluation in
- *  High-Order Meshes on GPUs". (2025). Computers & Fluids. for technical
- *  details.
+ *  collection of points.
  *
  *  There are three key functions in FindPointsGSLIB:
  *
@@ -135,10 +129,6 @@ protected:
                                                  IntegrationRule *irule,
                                                  int order);
 
-   /// Helper function that calls \ref SetupSplitMeshes and
-   /// \ref SetupIntegrationRuleForSplitMesh.
-   virtual void SetupSplitMeshesAndIntegrationRules(const int order);
-
    /// Get GridFunction value at the points expected by GSLIB.
    virtual void GetNodalValues(const GridFunction *gf_in, Vector &node_vals);
 
@@ -198,23 +188,14 @@ protected:
    void InterpolateOnDevice(const Vector &field_in_evec, Vector &field_out,
                             const int nel, const int ncomp,
                             const int dof1dsol, const int ordering);
-
 public:
    FindPointsGSLIB();
-   FindPointsGSLIB(Mesh &mesh_in, const double bb_t = 0.1,
-                   const double newt_tol = 1.0e-12,
-                   const int npt_max = 256);
 
 #ifdef MFEM_USE_MPI
    FindPointsGSLIB(MPI_Comm comm_);
-   FindPointsGSLIB(ParMesh &mesh_in, const double bb_t = 0.1,
-                   const double newt_tol = 1.0e-12,
-                   const int npt_max = 256);
 #endif
 
    virtual ~FindPointsGSLIB();
-   FindPointsGSLIB(const FindPointsGSLIB&) = delete;
-   FindPointsGSLIB& operator=(const FindPointsGSLIB&) = delete;
 
    /** Initializes the internal mesh in gslib, by sending the positions of the
        Gauss-Lobatto nodes of the input Mesh object \p m.
@@ -229,8 +210,8 @@ public:
        @param[in] npt_max   (Optional) Number of points for simultaneous
                             iteration. This alters performance and
                             memory footprint.*/
-
-   void Setup(Mesh &m, const double bb_t = 0.1, const double newt_tol = 1.0e-12,
+   void Setup(Mesh &m, const double bb_t = 0.1,
+              const double newt_tol = 1.0e-12,
               const int npt_max = 256);
    /** Searches positions given in physical space by \p point_pos.
        These positions can be ordered byNodes: (XXX...,YYY...,ZZZ) or
@@ -306,12 +287,7 @@ public:
 
    /** Cleans up memory allocated internally by gslib.
        Note that in parallel, this must be called before MPI_Finalize(), as it
-       calls MPI_Comm_free() for internal gslib communicators. FreeData is
-       also called by the class destructor and there are no memory leaks if the
-       destructor is called before MPI_Finalize(). If the destructor is called
-       after MPI_Finalize(), there will be an error because gslib will try to
-       invoke some MPI functions.
-   */
+       calls MPI_Comm_free() for internal gslib communicators. */
    virtual void FreeData();
 
    /// Return code for each point searched by FindPoints: inside element (0), on
@@ -334,9 +310,6 @@ public:
    /// point found by FindPoints.
    virtual const Vector &GetGSLIBReferencePosition() const { return gsl_ref; }
 
-   /// Get array of indices of not-found points.
-   Array<unsigned int> GetPointsNotFoundIndices() const;
-
    /** @name Methods to support a custom interpolation procedure.
        \brief The physical-space point that the user seeks to interpolate at
        could be located inside an element on another mpi rank.

fem/hyperbolic.cpp

@@ -181,7 +181,7 @@ void HyperbolicFormIntegrator::AssembleFaceVector(
    // current elements' the number of degrees of freedom
    // does not consider the number of equations
    const int dof1 = el1.GetDof();
-   const int dof2 = (Tr.Elem2No >= 0)?(el2.GetDof()):(0);
+   const int dof2 = el2.GetDof();
 
 #ifdef MFEM_THREAD_SAFE
    // Local storage for element integration
@@ -219,9 +219,7 @@ void HyperbolicFormIntegrator::AssembleFaceVector(
    const IntegrationRule *ir = IntRule;
    if (!ir)
    {
-      const int max_el_order = dof2 ? std::max(el1.GetOrder(),
-                                               el2.GetOrder()) : el1.GetOrder();
-      const int order = 2*max_el_order + IntOrderOffset;
+      const int order = 2*std::max(el1.GetOrder(), el2.GetOrder()) + IntOrderOffset;
       ir = &IntRules.Get(Tr.GetGeometryType(), order);
    }
    // loop over integration points
@@ -233,22 +231,18 @@ void HyperbolicFormIntegrator::AssembleFaceVector(
 
       // Calculate basis functions on both elements at the face
       el1.CalcShape(Tr.GetElement1IntPoint(), shape1);
+      el2.CalcShape(Tr.GetElement2IntPoint(), shape2);
 
       // Interpolate elfun at the point
       elfun1_mat.MultTranspose(shape1, state1);
-
-      if (dof2)
-      {
-         // Calculate basis functions on both elements at the face
-         el2.CalcShape(Tr.GetElement2IntPoint(), shape2);
-         // Interpolate elfun at the point
-         elfun2_mat.MultTranspose(shape2, state2);
-      }
+      elfun2_mat.MultTranspose(shape2, state2);
 
       // Get the normal vector and the flux on the face
       if (nor.Size() == 1)  // if 1D, use 1 or -1.
       {
-         nor(0) = 2*Tr.GetElement1IntPoint().x - 1.;
+         // This assume the 1D integration point is in (0,1). This may not work
+         // if this changes.
+         nor(0) = (Tr.GetElement1IntPoint().x - 0.5) * 2.0;
       }
       else
       {
@@ -256,18 +250,14 @@ void HyperbolicFormIntegrator::AssembleFaceVector(
       }
       // Compute F(u+, x) and F(u-, x) with maximum characteristic speed
       // Compute hat(F) using evaluated quantities
-      const real_t speed = (dof2) ? numFlux.Eval(state1, state2, nor, Tr, fluxN):
-                           fluxFunction.ComputeFluxDotN(state1, nor, Tr, fluxN);
+      const real_t speed = numFlux.Eval(state1, state2, nor, Tr, fluxN);
 
       // Update the global max char speed
       max_char_speed = std::max(speed, max_char_speed);
 
       // pre-multiply integration weight to flux
       AddMult_a_VWt(-ip.weight*sign, shape1, fluxN, elvect1_mat);
-      if (dof2)
-      {
-         AddMult_a_VWt(+ip.weight*sign, shape2, fluxN, elvect2_mat);
-      }
+      AddMult_a_VWt(+ip.weight*sign, shape2, fluxN, elvect2_mat);
    }
 }
 
@@ -278,7 +268,7 @@ void HyperbolicFormIntegrator::AssembleFaceGrad(
    // current elements' the number of degrees of freedom
    // does not consider the number of equations
    const int dof1 = el1.GetDof();
-   const int dof2 = (Tr.Elem2No >= 0)?(el2.GetDof()):(0);
+   const int dof2 = el2.GetDof();
 
 #ifdef MFEM_THREAD_SAFE
    // Local storage for element integration
@@ -312,9 +302,7 @@ void HyperbolicFormIntegrator::AssembleFaceGrad(
    const IntegrationRule *ir = IntRule;
    if (!ir)
    {
-      const int max_el_order = dof2 ? std::max(el1.GetOrder(),
-                                               el2.GetOrder()) : el1.GetOrder();
-      const int order = 2*max_el_order + IntOrderOffset;
+      const int order = 2*std::max(el1.GetOrder(), el2.GetOrder()) + IntOrderOffset;
       ir = &IntRules.Get(Tr.GetGeometryType(), order);
    }
    // loop over integration points
@@ -324,25 +312,20 @@ void HyperbolicFormIntegrator::AssembleFaceGrad(
 
       Tr.SetAllIntPoints(&ip); // set face and element int. points
 
-      // Calculate basis functions of the first element at the face
+      // Calculate basis functions on both elements at the face
       el1.CalcShape(Tr.GetElement1IntPoint(), shape1);
+      el2.CalcShape(Tr.GetElement2IntPoint(), shape2);
 
       // Interpolate elfun at the point
       elfun1_mat.MultTranspose(shape1, state1);
-
-      if (dof2)
-      {
-         // Calculate basis function of the second element at the face
-         el2.CalcShape(Tr.GetElement2IntPoint(), shape2);
-
-         // Interpolate elfun at the point
-         elfun2_mat.MultTranspose(shape2, state2);
-      }
+      elfun2_mat.MultTranspose(shape2, state2);
 
       // Get the normal vector and the flux on the face
       if (nor.Size() == 1)  // if 1D, use 1 or -1.
       {
-         nor(0) = 2*Tr.GetElement1IntPoint().x - 1.;
+         // This assume the 1D integration point is in (0,1). This may not work
+         // if this changes.
+         nor(0) = (Tr.GetElement1IntPoint().x - 0.5) * 2.0;
       }
       else
       {
@@ -352,14 +335,7 @@ void HyperbolicFormIntegrator::AssembleFaceGrad(
       // Trial side 1
 
       // Compute hat(J) using evaluated quantities
-      if (dof2)
-      {
-         numFlux.Grad(1, state1, state2, nor, Tr, JDotN);
-      }
-      else
-      {
-         fluxFunction.ComputeFluxJacobianDotN(state1, nor, Tr, JDotN);
-      }
+      numFlux.Grad(1, state1, state2, nor, Tr, JDotN);
 
       const int ioff = fluxFunction.num_equations * dof1;
 
@@ -384,325 +360,36 @@ void HyperbolicFormIntegrator::AssembleFaceGrad(
             }
          }
 
-      if (dof2)
-      {
-         // Trial side 2
-
-         // Compute hat(J) using evaluated quantities
-         numFlux.Grad(2, state1, state2, nor, Tr, JDotN);
-
-         const int joff = ioff;
-
-         for (int di = 0; di < fluxFunction.num_equations; di++)
-            for (int dj = 0; dj < fluxFunction.num_equations; dj++)
-            {
-               // pre-multiply integration weight to Jacobian
-               const real_t w = +ip.weight * sign * JDotN(di,dj);
-               for (int j = 0; j < dof2; j++)
-               {
-                  // Test side 1
-                  for (int i = 0; i < dof1; i++)
-                  {
-                     elmat(i+dof1*di, joff+j+dof2*dj) += w * shape1(i) * shape2(j);
-                  }
-
-                  // Test side 2
-                  for (int i = 0; i < dof2; i++)
-                  {
-                     elmat(ioff+i+dof2*di, joff+j+dof2*dj) -= w * shape2(i) * shape2(j);
-                  }
-               }
-            }
-      }
-   }
-}
-
-BdrHyperbolicDirichletIntegrator::BdrHyperbolicDirichletIntegrator(
-   const NumericalFlux &numFlux,
-   VectorCoefficient &bdrState,
-   const int IntOrderOffset,
-   real_t sign)
-   : NonlinearFormIntegrator(),
-     numFlux(numFlux),
-     fluxFunction(numFlux.GetFluxFunction()),
-     u_vcoeff(bdrState),
-     IntOrderOffset(IntOrderOffset),
-     sign(sign),
-     num_equations(fluxFunction.num_equations)
-{
-   MFEM_VERIFY(fluxFunction.num_equations == bdrState.GetVDim(),
-               "Flux function does not match the vector dimension of the coefficient!");
-#ifndef MFEM_THREAD_SAFE
-   state_in.SetSize(num_equations);
-   state_out.SetSize(num_equations);
-   fluxN.SetSize(num_equations);
-   JDotN.SetSize(num_equations);
-   nor.SetSize(fluxFunction.dim);
-#endif
-   ResetMaxCharSpeed();
-}
-
-void BdrHyperbolicDirichletIntegrator::AssembleFaceVector(
-   const FiniteElement &el, const FiniteElement &,
-   FaceElementTransformations &Tr, const Vector &elfun, Vector &elvect)
-{
-   MFEM_ASSERT(Tr.Elem2No < 0, "Not a boundary face!");
-
-   // current elements' the number of degrees of freedom
-   // does not consider the number of equations
-   const int dof = el.GetDof();
-
-#ifdef MFEM_THREAD_SAFE
-   // Local storage for element integration
-
-   // shape function value at an integration point
-   Vector shape(dof);
-   // normal vector (usually not a unit vector)
-   Vector nor(Tr.GetSpaceDim());
-   // state value at an integration point - interior
-   Vector state_in(num_equations);
-   // state value at an integration point - boundary
-   Vector state_out(num_equations);
-   // hat(F)(u,x)
-   Vector fluxN(num_equations);
-#else
-   shape.SetSize(dof);
-#endif
-
-   elvect.SetSize(dof * num_equations);
-   elvect = 0.0;
-
-   const DenseMatrix elfun_mat(elfun.GetData(), dof, num_equations);
-
-   DenseMatrix elvect_mat(elvect.GetData(), dof, num_equations);
-
-   // Obtain integration rule. If integration is rule is given, then use it.
-   // Otherwise, get (2*p + IntOrderOffset) order integration rule
-   const IntegrationRule *ir = IntRule;
-   if (!ir)
-   {
-      const int order = 2*el.GetOrder() + IntOrderOffset;
-      ir = &IntRules.Get(Tr.GetGeometryType(), order);
-   }
-   // loop over integration points
-   for (int i = 0; i < ir->GetNPoints(); i++)
-   {
-      const IntegrationPoint &ip = ir->IntPoint(i);
-
-      Tr.SetAllIntPoints(&ip); // set face and element int. points
-
-      // Calculate basis functions at the face
-      el.CalcShape(Tr.GetElement1IntPoint(), shape);
-
-      // Interpolate elfun at the point
-      elfun_mat.MultTranspose(shape, state_in);
-
-      // Evaluate boundary state at the point
-      u_vcoeff.Eval(state_out, Tr, ip);
-
-      // Get the normal vector and the flux on the face
-      if (nor.Size() == 1)  // if 1D, use 1 or -1.
-      {
-         nor(0) = 2*Tr.GetElement1IntPoint().x - 1.;
-      }
-      else
-      {
-         CalcOrtho(Tr.Jacobian(), nor);
-      }
-      // Compute F(u+, x) and F(u_b, x) with maximum characteristic speed
-      // Compute hat(F) using evaluated quantities
-      const real_t speed = numFlux.Eval(state_in, state_out, nor, Tr, fluxN);
-
-      // Update the global max char speed
-      max_char_speed = std::max(speed, max_char_speed);
-
-      // pre-multiply integration weight to flux
-      AddMult_a_VWt(-ip.weight*sign, shape, fluxN, elvect_mat);
-   }
-}
-
-void BdrHyperbolicDirichletIntegrator::AssembleFaceGrad(
-   const FiniteElement &el, const FiniteElement &,
-   FaceElementTransformations &Tr, const Vector &elfun, DenseMatrix &elmat)
-{
-   // current elements' the number of degrees of freedom
-   // does not consider the number of equations
-   const int dof = el.GetDof();
-
-#ifdef MFEM_THREAD_SAFE
-   // Local storage for element integration
-
-   // shape function value at an integration point
-   Vector shape(dof);
-   // normal vector (usually not a unit vector)
-   Vector nor(Tr.GetSpaceDim());
-   // state value at an integration point - interior
-   Vector state_in(num_equations);
-   // state value at an integration point - boundary
-   Vector state_out(num_equations);
-   // hat(J)(u,x)
-   DenseMatrix JDotN(num_equations);
-#else
-   shape.SetSize(dof);
-#endif
-
-   elmat.SetSize(dof * num_equations);
-   elmat = 0.0;
-
-   const DenseMatrix elfun_mat(elfun.GetData(), dof, num_equations);
-
-   // Obtain integration rule. If integration is rule is given, then use it.
-   // Otherwise, get (2*p + IntOrderOffset) order integration rule
-   const IntegrationRule *ir = IntRule;
-   if (!ir)
-   {
-      const int order = 2*el.GetOrder() + IntOrderOffset;
-      ir = &IntRules.Get(Tr.GetGeometryType(), order);
-   }
-   // loop over integration points
-   for (int q = 0; q < ir->GetNPoints(); q++)
-   {
-      const IntegrationPoint &ip = ir->IntPoint(q);
-
-      Tr.SetAllIntPoints(&ip); // set face and element int. points
-
-      // Calculate basis functions at the face
-      el.CalcShape(Tr.GetElement1IntPoint(), shape);
-
-      // Interpolate elfun at the point
-      elfun_mat.MultTranspose(shape, state_in);
-
-      // Evaluate boundary state at the point
-      u_vcoeff.Eval(state_out, Tr, ip);
-
-      // Get the normal vector and the flux on the face
-      if (nor.Size() == 1)  // if 1D, use 1 or -1.
-      {
-         nor(0) = 2*Tr.GetElement1IntPoint().x - 1.;
-      }
-      else
-      {
-         CalcOrtho(Tr.Jacobian(), nor);
-      }
+      // Trial side 2
 
       // Compute hat(J) using evaluated quantities
-      numFlux.Grad(1, state_in, state_out, nor, Tr, JDotN);
+      numFlux.Grad(2, state1, state2, nor, Tr, JDotN);
+
+      const int joff = ioff;
 
       for (int di = 0; di < fluxFunction.num_equations; di++)
          for (int dj = 0; dj < fluxFunction.num_equations; dj++)
          {
             // pre-multiply integration weight to Jacobian
-            const real_t w = -ip.weight * sign * JDotN(di,dj);
-            for (int j = 0; j < dof; j++)
-               for (int i = 0; i < dof; i++)
+            const real_t w = +ip.weight * sign * JDotN(di,dj);
+            for (int j = 0; j < dof2; j++)
+            {
+               // Test side 1
+               for (int i = 0; i < dof1; i++)
                {
-                  elmat(i+dof*di, j+dof*dj) += w * shape(i) * shape(j);
+                  elmat(i+dof1*di, joff+j+dof2*dj) += w * shape1(i) * shape2(j);
                }
+
+               // Test side 2
+               for (int i = 0; i < dof2; i++)
+               {
+                  elmat(ioff+i+dof2*di, joff+j+dof2*dj) -= w * shape2(i) * shape2(j);
+               }
+            }
          }
    }
 }
 
-BoundaryHyperbolicFlowIntegrator::BoundaryHyperbolicFlowIntegrator(
-   const FluxFunction &flux, VectorCoefficient &u, real_t alpha_, real_t beta_,
-   const int IntOrderOffset_)
-   : fluxFunction(flux), u_vcoeff(u), alpha(alpha_), beta(beta_),
-     IntOrderOffset(IntOrderOffset_)
-{
-   MFEM_VERIFY(fluxFunction.num_equations == u_vcoeff.GetVDim(),
-               "Flux function does not match the vector dimension of the coefficient!");
-#ifndef MFEM_THREAD_SAFE
-   state.SetSize(fluxFunction.num_equations);
-   nor.SetSize(fluxFunction.dim);
-   fluxN.SetSize(fluxFunction.num_equations);
-#endif
-   ResetMaxCharSpeed();
-}
-
-void BoundaryHyperbolicFlowIntegrator::AssembleRHSElementVect(
-   const FiniteElement &el, ElementTransformation &Tr, Vector &elvect)
-{
-   mfem_error("BoundaryHyperbolicFlowIntegrator::AssembleRHSElementVect\n"
-              "  is not implemented as boundary integrator!\n"
-              "  Use LinearForm::AddBdrFaceIntegrator instead of\n"
-              "  LinearForm::AddBoundaryIntegrator.");
-}
-
-void BoundaryHyperbolicFlowIntegrator::AssembleRHSElementVect(
-   const FiniteElement &el, FaceElementTransformations &Tr, Vector &elvect)
-{
-   // current elements' the number of degrees of freedom
-   // does not consider the number of equations
-   const int dof = el.GetDof();
-
-#ifdef MFEM_THREAD_SAFE
-   // Local storage for element integration
-
-   // shape function value at an integration point
-   Vector shape(dof);
-   // state value at an integration point
-   Vector state(fluxFunction.num_equations);
-   // normal vector (usually not a unit vector)
-   Vector nor(Tr.GetSpaceDim());
-   // hat(F)(u,x)
-   Vector fluxN(fluxFunction.num_equations);
-#else
-   shape.SetSize(dof);
-#endif
-
-   elvect.SetSize(dof * fluxFunction.num_equations);
-   elvect = 0.0;
-
-   DenseMatrix elvect_mat(elvect.GetData(), dof, fluxFunction.num_equations);
-
-   // Obtain integration rule. If integration is rule is given, then use it.
-   // Otherwise, get (2*p + IntOrderOffset) order integration rule
-   const IntegrationRule *ir = IntRule;
-   if (!ir)
-   {
-      const int order = 2*el.GetOrder() + IntOrderOffset;
-      ir = &IntRules.Get(Tr.GetGeometryType(), order);
-   }
-   // loop over integration points
-   for (int i = 0; i < ir->GetNPoints(); i++)
-   {
-      const IntegrationPoint &ip = ir->IntPoint(i);
-
-      Tr.SetAllIntPoints(&ip); // set face and element int. points
-
-      // Calculate basis functions on both elements at the face
-      el.CalcShape(Tr.GetElement1IntPoint(), shape);
-
-      // Evaluate the coefficient at the point
-      u_vcoeff.Eval(state, Tr, ip);
-
-      // Get the normal vector and the flux on the face
-      if (nor.Size() == 1)  // if 1D, use 1 or -1.
-      {
-         nor(0) = 2*Tr.GetElement1IntPoint().x - 1.;
-      }
-      else
-      {
-         CalcOrtho(Tr.Jacobian(), nor);
-      }
-      // Compute F(u, x) with maximum characteristic speed
-      const real_t speed = fluxFunction.ComputeFluxDotN(state, nor, Tr, fluxN);
-
-      // Update the global max char speed
-      max_char_speed = std::max(speed, max_char_speed);
-
-      // pre-multiply integration weight to flux
-      const real_t a = 0.5 * alpha  * ip.weight;
-      const real_t b = beta * ip.weight;
-
-      for (int n = 0; n < fluxFunction.num_equations; n++)
-      {
-         fluxN(n) = a * fluxN(n) - b * fabs(fluxN(n));
-      }
-
-      AddMultVWt(shape, fluxN, elvect_mat);
-   }
-}
-
 real_t FluxFunction::ComputeFluxDotN(const Vector &U,
                                      const Vector &normal,
                                      FaceElementTransformations &Tr,

fem/hyperbolic.hpp

@@ -306,14 +306,12 @@ MFEM_DEPRECATED typedef NumericalFlux RiemannSolver;
 class HyperbolicFormIntegrator : public NonlinearFormIntegrator
 {
 private:
+   // The maximum characteristic speed, updated during element/face vector assembly
+   real_t max_char_speed;
    const NumericalFlux &numFlux;   // Numerical flux that maps F(u±,x) to F̂
    const FluxFunction &fluxFunction;
    const int IntOrderOffset; // integration order offset, 2*p + IntOrderOffset.
    const real_t sign;
-
-   // The maximum characteristic speed, updated during element/face vector assembly
-   real_t max_char_speed;
-
 #ifndef MFEM_THREAD_SAFE
    // Local storage for element integration
    Vector shape;              // shape function value at an integration point
@@ -333,9 +331,8 @@ private:
 
 public:
    const int num_equations;  // the number of equations
-
    /**
-    * @brief Construct a new HyperbolicFormIntegrator object
+    * @brief Construct a new Hyperbolic Form Integrator object
     *
     * @param[in] numFlux numerical flux
     * @param[in] IntOrderOffset integration order offset
@@ -346,14 +343,21 @@ public:
       const int IntOrderOffset = 0,
       const real_t sign = 1.);
 
-   /// Reset the maximum characteristic speed to zero
-   void ResetMaxCharSpeed() { max_char_speed = 0.0; }
+   /**
+    * @brief Reset the Max Char Speed 0
+    *
+    */
+   void ResetMaxCharSpeed()
+   {
+      max_char_speed = 0.0;
+   }
 
-   /// Get the maximum characteristic speed
-   real_t GetMaxCharSpeed() const { return max_char_speed; }
+   real_t GetMaxCharSpeed()
+   {
+      return max_char_speed;
+   }
 
-   /// Get the associated flux function
-   const FluxFunction &GetFluxFunction() const { return fluxFunction; }
+   const FluxFunction &GetFluxFunction() { return fluxFunction; }
 
    /**
     * @brief Implements (F(u), ∇v) with abstract F computed by
@@ -412,182 +416,6 @@ public:
                          const Vector &elfun, DenseMatrix &elmat) override;
 };
 
-/**
- * @brief Abstract boundary hyperbolic form integrator, assembling
- * <F̂(u⁻,u_b,x) n, [v]> term for scalar finite elements at the boundary.
- *
- * This form integrator is coupled with a NumericalFlux that implements the
- * numerical flux F̂ at the boundary faces. The flux F is obtained from the
- * FluxFunction assigned to the aforementioned NumericalFlux with the given
- * boundary coefficient for the state u_b.
- *
- * Note the class can be used for imposing conditions on interior interfaces.
- */
-class BdrHyperbolicDirichletIntegrator : public NonlinearFormIntegrator
-{
-private:
-   const NumericalFlux &numFlux;    // Numerical flux that maps F to F̂
-   const FluxFunction &fluxFunction;
-   VectorCoefficient &u_vcoeff;     // Boundary state vector coefficient
-   const int IntOrderOffset; // integration order offset, 2*p + IntOrderOffset.
-   const real_t sign;
-
-   // The maximum characteristic speed, updated during element/face vector assembly
-   real_t max_char_speed;
-
-#ifndef MFEM_THREAD_SAFE
-   // Local storage for element integration
-   Vector shape;  // shape function value at an integration point
-   Vector state_in;  // state value at an integration point - interior
-   Vector state_out;  // state value at an integration point - boundary
-   Vector nor;     // normal vector, see mfem::CalcOrtho()
-   Vector fluxN;   // F̂(u⁻,u_b,x) n
-   DenseMatrix JDotN;   // Ĵ(u⁻,u_b,x) n
-#endif
-
-public:
-   const int num_equations;  // the number of equations
-
-   /**
-    * @brief Construct a new BdrHyperbolicDirichletIntegrator object
-    *
-    * @param[in] numFlux numerical flux
-    * @param[in] bdrState boundary state coefficient
-    * @param[in] IntOrderOffset integration order offset
-    * @param[in] sign sign of the convection term
-    */
-   BdrHyperbolicDirichletIntegrator(
-      const NumericalFlux &numFlux,
-      VectorCoefficient &bdrState,
-      const int IntOrderOffset = 0,
-      const real_t sign = 1.);
-
-   /// Reset the maximum characteristic speed to zero
-   void ResetMaxCharSpeed() { max_char_speed = 0.0; }
-
-   /// Get the maximum characteristic speed
-   real_t GetMaxCharSpeed() const { return max_char_speed; }
-
-   /// Get the associated flux function
-   const FluxFunction &GetFluxFunction() const { return fluxFunction; }
-
-   /**
-    * @brief Implements <-F̂(u⁻,u_b,x) n, [v]> with abstract F̂ computed by
-    * NumericalFlux::Eval() of the numerical flux object
-    *
-    * @param[in] el1 finite element of the interior element
-    * @param[in] el2 not used
-    * @param[in] Tr face element transformations
-    * @param[in] elfun local coefficient of basis for the interior element
-    * @param[out] elvect evaluated dual vector <-F̂(u⁻,u_b,x) n, [v]>
-    */
-   void AssembleFaceVector(const FiniteElement &el1,
-                           const FiniteElement &el2,
-                           FaceElementTransformations &Tr,
-                           const Vector &elfun, Vector &elvect) override;
-
-   /**
-    * @brief Implements <-Ĵ(u⁻,u_b,x) n, [v]> with abstract Ĵ computed by
-    * NumericalFlux::Grad() of the numerical flux object
-    *
-    * @param[in] el1 finite element of the interior element
-    * @param[in] el2 not used
-    * @param[in] Tr face element transformations
-    * @param[in] elfun local coefficient of basis for the interior element
-    * @param[out] elmat evaluated Jacobian matrix <-Ĵ(u⁻,u_b,x) n, [v]>
-    */
-   void AssembleFaceGrad(const FiniteElement &el1,
-                         const FiniteElement &el2,
-                         FaceElementTransformations &Tr,
-                         const Vector &elfun, DenseMatrix &elmat) override;
-};
-
-/**
- * @brief Abstract boundary hyperbolic linear form integrator, assembling
- * <ɑ/2 F(u,x) n - β |F(u,x) n|, v> terms for scalar finite elements.
- *
- * This form integrator is coupled with a FluxFunction that evaluates the
- * flux F at the boundary.
- *
- * Note the upwinding is performed component-wise. For general boundary
- * integration with a numerical flux, see BdrHyperbolicDirichletIntegrator.
- */
-class BoundaryHyperbolicFlowIntegrator : public LinearFormIntegrator
-{
-   const FluxFunction &fluxFunction;
-   VectorCoefficient &u_vcoeff;
-   const real_t alpha, beta;
-   const int IntOrderOffset; // integration order offset, 2*p + IntOrderOffset.
-
-   // The maximum characteristic speed, updated during face vector assembly
-   real_t max_char_speed;
-
-#ifndef MFEM_THREAD_SAFE
-   // Local storage for element integration
-   Vector shape;   // shape function value at an integration point
-   Vector state;   // state value at an integration point
-   Vector nor;     // normal vector, see mfem::CalcOrtho()
-   Vector fluxN;   // F(u,x) n
-#endif
-
-public:
-   /**
-    * @brief Construct a new BoundaryHyperbolicFlowIntegrator object
-    *
-    * @param[in] flux flux function
-    * @param[in] u vector state coefficient
-    * @param[in] alpha ɑ coefficient (β = ɑ/2)
-    * @param[in] IntOrderOffset integration order offset
-    */
-   BoundaryHyperbolicFlowIntegrator(const FluxFunction &flux, VectorCoefficient &u,
-                                    real_t alpha = -1., int IntOrderOffset = 0)
-      : BoundaryHyperbolicFlowIntegrator(flux, u, alpha, alpha/2., IntOrderOffset) { }
-
-   /**
-    * @brief Construct a new BoundaryHyperbolicFlowIntegrator object
-    *
-    * @param[in] flux flux function
-    * @param[in] u vector state coefficient
-    * @param[in] alpha ɑ coefficient
-    * @param[in] beta β coefficient
-    * @param[in] IntOrderOffset integration order offset
-    */
-   BoundaryHyperbolicFlowIntegrator(const FluxFunction &flux, VectorCoefficient &u,
-                                    real_t alpha, real_t beta, int IntOrderOffset = 0);
-
-   /// Reset the maximum characteristic speed to zero
-   void ResetMaxCharSpeed() { max_char_speed = 0.0; }
-
-   /// Get the maximum characteristic speed
-   real_t GetMaxCharSpeed() const { return max_char_speed; }
-
-   /// Get the associated flux function
-   const FluxFunction &GetFluxFunction() const { return fluxFunction; }
-
-   using LinearFormIntegrator::AssembleRHSElementVect;
-
-   /**
-    * @warning Boundary element integration not implemented, use
-    * AssembleRHSElementVect(const FiniteElement&,
-    * FaceElementTransformations &, Vector &) instead
-    */
-   void AssembleRHSElementVect(const FiniteElement &el,
-                               ElementTransformation &Tr,
-                               Vector &elvect) override;
-
-   /**
-    * @brief Implements <-F(u,x) n, v> with abstract F computed by
-    * FluxFunction::ComputeFluxDotN() of the flux function object
-    *
-    * @param[in] el finite element
-    * @param[in] Tr face element transformations
-    * @param[out] elvect evaluated dual vector <F(u,x) n, v>
-    */
-   void AssembleRHSElementVect(const FiniteElement &el,
-                               FaceElementTransformations &Tr,
-                               Vector &elvect) override;
-};
-
 
 /**
  * @brief Rusanov flux, also known as local Lax-Friedrichs,

fem/integ/bilininteg_curlcurl_pa.cpp

@@ -15,86 +15,6 @@
 namespace mfem
 {
 
-CurlCurlIntegrator::CurlCurlIntegrator() : Q(nullptr), DQ(nullptr), MQ(nullptr)
-{
-   static Kernels kernels;
-}
-
-CurlCurlIntegrator::CurlCurlIntegrator(Coefficient &q,
-                                       const IntegrationRule *ir)
-   : BilinearFormIntegrator(ir), Q(&q), DQ(nullptr), MQ(nullptr)
-{
-   static Kernels kernels;
-}
-
-CurlCurlIntegrator::CurlCurlIntegrator(DiagonalMatrixCoefficient &dq,
-                                       const IntegrationRule *ir)
-   : BilinearFormIntegrator(ir), Q(nullptr), DQ(&dq), MQ(nullptr)
-{
-   static Kernels kernels;
-}
-
-CurlCurlIntegrator::CurlCurlIntegrator(MatrixCoefficient &mq,
-                                       const IntegrationRule *ir)
-   : BilinearFormIntegrator(ir), Q(nullptr), DQ(nullptr), MQ(&mq)
-{
-   static Kernels kernels;
-}
-
-/// \cond DO_NOT_DOCUMENT
-
-CurlCurlIntegrator::Kernels::Kernels()
-{
-   CurlCurlIntegrator::AddSpecialization<3, 2, 3>();
-   CurlCurlIntegrator::AddSpecialization<3, 3, 4>();
-   CurlCurlIntegrator::AddSpecialization<3, 4, 5>();
-   CurlCurlIntegrator::AddSpecialization<3, 5, 6>();
-}
-
-CurlCurlIntegrator::ApplyKernelType
-CurlCurlIntegrator::ApplyPAKernels::Fallback(int DIM, int, int)
-{
-   if (DIM == 2) { return internal::PACurlCurlApply2D; }
-   else if (DIM == 3)
-   {
-      if (Device::Allows(Backend::DEVICE_MASK))
-      {
-         return internal::SmemPACurlCurlApply3D;
-      }
-      else
-      {
-         return internal::PACurlCurlApply3D;
-      }
-   }
-   else { MFEM_ABORT(""); }
-}
-
-CurlCurlIntegrator::DiagonalKernelType
-CurlCurlIntegrator::DiagonalPAKernels::Fallback(int DIM, int, int)
-{
-   if (DIM == 2)
-   {
-      return internal::PACurlCurlAssembleDiagonal2D;
-   }
-   else if (DIM == 3)
-   {
-      if (Device::Allows(Backend::DEVICE_MASK))
-      {
-         return internal::SmemPACurlCurlAssembleDiagonal3D;
-      }
-      else
-      {
-         return internal::PACurlCurlAssembleDiagonal3D;
-      }
-   }
-   else
-   {
-      MFEM_ABORT("");
-   }
-}
-
-/// \endcond DO_NOT_DOCUMENT
-
 void CurlCurlIntegrator::AssemblePA(const FiniteElementSpace &fes)
 {
    // Assumes tensor-product elements
@@ -157,28 +77,129 @@ void CurlCurlIntegrator::AssemblePA(const FiniteElementSpace &fes)
 
 void CurlCurlIntegrator::AssembleDiagonalPA(Vector& diag)
 {
-   DiagonalPAKernels::Run(dim, dofs1D, quad1D, dofs1D, quad1D, symmetric, ne,
-                          mapsO->B, mapsC->B, mapsO->G, mapsC->G, pa_data,
-                          diag);
+   if (dim == 3)
+   {
+      if (Device::Allows(Backend::DEVICE_MASK))
+      {
+         const int ID = (dofs1D << 4) | quad1D;
+         switch (ID)
+         {
+            case 0x23:
+               return internal::SmemPACurlCurlAssembleDiagonal3D<2,3>(
+                         dofs1D,
+                         quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B,
+                         mapsO->G, mapsC->G,
+                         pa_data, diag);
+            case 0x34:
+               return internal::SmemPACurlCurlAssembleDiagonal3D<3,4>(
+                         dofs1D,
+                         quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B,
+                         mapsO->G, mapsC->G,
+                         pa_data, diag);
+            case 0x45:
+               return internal::SmemPACurlCurlAssembleDiagonal3D<4,5>(
+                         dofs1D,
+                         quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B,
+                         mapsO->G, mapsC->G,
+                         pa_data, diag);
+            case 0x56:
+               return internal::SmemPACurlCurlAssembleDiagonal3D<5,6>(
+                         dofs1D,
+                         quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B,
+                         mapsO->G, mapsC->G,
+                         pa_data, diag);
+            default:
+               return internal::SmemPACurlCurlAssembleDiagonal3D(
+                         dofs1D, quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B,
+                         mapsO->G, mapsC->G,
+                         pa_data, diag);
+         }
+      }
+      else
+      {
+         internal::PACurlCurlAssembleDiagonal3D(dofs1D, quad1D, symmetric, ne,
+                                                mapsO->B, mapsC->B,
+                                                mapsO->G, mapsC->G,
+                                                pa_data, diag);
+      }
+   }
+   else if (dim == 2)
+   {
+      internal::PACurlCurlAssembleDiagonal2D(dofs1D, quad1D, ne,
+                                             mapsO->B, mapsC->G, pa_data, diag);
+   }
+   else
+   {
+      MFEM_ABORT("Unsupported dimension!");
+   }
 }
 
 void CurlCurlIntegrator::AddMultPA(const Vector &x, Vector &y) const
 {
-   ApplyPAKernels::Run(dim, dofs1D, quad1D, dofs1D, quad1D, symmetric, ne,
-                       mapsO->B, mapsC->B, mapsO->Bt, mapsC->Bt, mapsC->G,
-                       mapsC->Gt, pa_data, x, y, false);
-}
-
-void CurlCurlIntegrator::AddAbsMultPA(const Vector &x, Vector &y) const
-{
-   Vector abs_pa_data(pa_data);
-   abs_pa_data.Abs();
-   auto absO = mapsO->Abs();
-   auto absC = mapsC->Abs();
-
-   ApplyPAKernels::Run(dim, dofs1D, quad1D, dofs1D, quad1D, symmetric, ne,
-                       absO.B, absC.B, absO.Bt, absC.Bt, absC.G, absC.Gt,
-                       abs_pa_data, x, y, true);
+   if (dim == 3)
+   {
+      if (Device::Allows(Backend::DEVICE_MASK))
+      {
+         const int ID = (dofs1D << 4) | quad1D;
+         switch (ID)
+         {
+            case 0x23:
+               return internal::SmemPACurlCurlApply3D<2,3>(
+                         dofs1D, quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B, mapsO->Bt, mapsC->Bt,
+                         mapsC->G, mapsC->Gt, pa_data, x, y);
+            case 0x34:
+               return internal::SmemPACurlCurlApply3D<3,4>(
+                         dofs1D, quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B, mapsO->Bt, mapsC->Bt,
+                         mapsC->G, mapsC->Gt, pa_data, x, y);
+            case 0x45:
+               return internal::SmemPACurlCurlApply3D<4,5>(
+                         dofs1D, quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B, mapsO->Bt, mapsC->Bt,
+                         mapsC->G, mapsC->Gt, pa_data, x, y);
+            case 0x56:
+               return internal::SmemPACurlCurlApply3D<5,6>(
+                         dofs1D, quad1D,
+                         symmetric, ne,
+                         mapsO->B, mapsC->B, mapsO->Bt, mapsC->Bt,
+                         mapsC->G, mapsC->Gt, pa_data, x, y);
+            default:
+               return internal::SmemPACurlCurlApply3D(
+                         dofs1D, quad1D, symmetric, ne,
+                         mapsO->B, mapsC->B, mapsO->Bt, mapsC->Bt,
+                         mapsC->G, mapsC->Gt, pa_data, x, y);
+         }
+      }
+      else
+      {
+         internal::PACurlCurlApply3D(dofs1D, quad1D, symmetric, ne, mapsO->B, mapsC->B,
+                                     mapsO->Bt, mapsC->Bt, mapsC->G, mapsC->Gt,
+                                     pa_data, x, y);
+      }
+   }
+   else if (dim == 2)
+   {
+      internal::PACurlCurlApply2D(dofs1D, quad1D, ne, mapsO->B, mapsO->Bt,
+                                  mapsC->G, mapsC->Gt, pa_data, x, y);
+   }
+   else
+   {
+      MFEM_ABORT("Unsupported dimension!");
+   }
 }
 
 } // namespace mfem