Merge branch 'master' into lor-consistent-mass-dev

.github/workflows/README.md

@@ -29,12 +29,16 @@ 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`)
+
+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`
 
 Runs a matrix of builds and tests runs with different compilers, OS, mfem/hypre settings, etc. Also processes and upload Codecov reports.
 
-One matrix job runs `tests/scripts/gitignore` after `make test-noclean` to check generated artifacts against `.gitignore`.
-
 Uses the following GitHub Actions from <https://github.com/mfem/github-actions>:
 
 - `mfem/github-actions/build-hypre`

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

@@ -111,7 +111,6 @@ jobs:
             build-system: make
             hypre-target: int64
             precision: fp64
-            gitignore-check: YES
           - os: ubuntu-latest
             target: opt
             codecov: NO
@@ -142,10 +141,6 @@ jobs:
 
     continue-on-error: ${{ matrix.enzyme && true || false }}
 
-    # Enable ccache for all jobs except Windows (would need sccache).
-    env:
-      USE_CCACHE: ${{ matrix.os != 'windows-latest' }}
-
     steps:
       # Fix 'No space left on device' errors for Ubuntu builds.
       - name: Run Actions Cleaner
@@ -294,52 +289,6 @@ jobs:
           echo "OMPI_CC=$LLVM_PREFIX/bin/clang" >> $GITHUB_ENV
           echo "OMPI_CXX=$LLVM_PREFIX/bin/clang++" >> $GITHUB_ENV
 
-      # Restore the compiler cache (ccache). The key embeds the run id, so new
-      # runs save a fresh snapshot; the restore-keys prefix warm-starts from the
-      # most recent prior run (incl. the base branch for PRs).
-      - name: cache ccache
-        if: ${{ env.USE_CCACHE == 'true' }}
-        uses: actions/cache@v5
-        with:
-          path: .ccache
-          key: ccache-${{ matrix.os }}-${{ matrix.build-system }}-${{ matrix.target }}-${{ matrix.mpi }}-${{ matrix.hypre-target }}-${{ matrix.precision }}${{ matrix.enzyme && '-enzyme' || '' }}-${{ github.run_id }}
-          restore-keys: |
-            ccache-${{ matrix.os }}-${{ matrix.build-system }}-${{ matrix.target }}-${{ matrix.mpi }}-${{ matrix.hypre-target }}-${{ matrix.precision }}${{ matrix.enzyme && '-enzyme' || '' }}-
-
-      # Configure ccache and select how it is injected into the MFEM build:
-      # - make:  set CXX="ccache g++"; for MPI, OMPI_CXX="ccache g++" so mpicxx
-      #          runs ccache around g++ (not ccache around the mpicxx wrapper).
-      # - cmake: set CMAKE_<LANG>_COMPILER_LAUNCHER=ccache.
-      # - enzyme: wrap the brew clang++ via OMPI_CXX.
-      # The chosen options are passed through build-mfem's 'config-options'
-      # input (see the build step below).
-      - name: configure ccache
-        if: ${{ env.USE_CCACHE == 'true' }}
-        run: |
-          command -v ccache >/dev/null 2>&1 || {
-            if [[ "${{ runner.os }}" == "Linux" ]]; then
-              sudo apt-get update && sudo apt-get install -y ccache
-            else
-              brew install ccache
-            fi
-          }
-          echo "CCACHE_DIR=${{ github.workspace }}/.ccache" >> $GITHUB_ENV
-          echo "CCACHE_MAXSIZE=1G" >> $GITHUB_ENV
-          echo "CCACHE_COMPILERCHECK=content" >> $GITHUB_ENV
-          # Ignore header timestamps (restamped by each checkout) so direct mode hits.
-          echo "CCACHE_SLOPPINESS=include_file_mtime,include_file_ctime,time_macros" >> $GITHUB_ENV
-          # Hash absolute paths relative to the workspace.
-          echo "CCACHE_BASEDIR=${{ github.workspace }}" >> $GITHUB_ENV
-          if [[ "${{ matrix.enzyme }}" == "true" ]]; then
-            echo "OMPI_CXX=ccache $LLVM_PREFIX/bin/clang++" >> $GITHUB_ENV
-          elif [[ "${{ matrix.build-system }}" == "cmake" ]]; then
-            echo 'CCACHE_CONFIG_OPTS=-DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache' >> $GITHUB_ENV
-          else
-            echo "OMPI_CXX=ccache g++" >> $GITHUB_ENV
-            echo 'CCACHE_CONFIG_OPTS=CXX="ccache g++" MPICXX="mpicxx"' >> $GITHUB_ENV
-          fi
-        shell: bash
-
       # MFEM build and test
       - name: build
         uses: mfem/github-actions/build-mfem@v2.7
@@ -355,14 +304,9 @@ jobs:
           metis-dir: ${{ env.METIS_TOP_DIR }}
           mfem-dir: ${{ env.MFEM_TOP_DIR }}
           precision: ${{ matrix.precision }}
-          config-options: ${{ matrix.config-opts }} ${{ env.CCACHE_CONFIG_OPTS }}
+          config-options: ${{ matrix.config-opts }}
           library-only: ${{ matrix.target == 'dbg' && matrix.os != 'ubuntu-latest' }}
 
-      - name: ccache stats
-        if: ${{ env.USE_CCACHE == 'true' }}
-        run: ccache -s
-        shell: bash
-
       # Run checks (and only checks) on debug targets
       - name: checks
         if: matrix.build-system == 'make' && matrix.target == 'dbg'
@@ -373,13 +317,7 @@ jobs:
       - name: tests
         if: matrix.build-system == 'make' && (matrix.target == 'opt' || matrix.os == 'ubuntu-latest')
         run: |
-          cd ${{ env.MFEM_TOP_DIR }}
-          if [[ "${{ matrix.gitignore-check }}" == "YES" ]]; then
-            make test-noclean
-          else
-            make test
-          fi
-        shell: bash
+          cd ${{ env.MFEM_TOP_DIR }} && make test
 
       - name: cmake checks
         if: matrix.build-system == 'cmake' && matrix.target == 'dbg'
@@ -431,9 +369,3 @@ jobs:
           directories: "fem general linalg mesh"
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-      - name: gitignore
-        if: matrix.gitignore-check == 'YES'
-        run: |
-          cd ${{ env.MFEM_TOP_DIR }}/tests/scripts
-          ./runtest gitignore

.github/workflows/cleanup-pr-caches.yml

@@ -1,42 +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.
----
-# A closed PR's caches can never be restored again, so delete them to free
-# space against the 10 GB per-repo cache limit.
-name: Cleanup PR caches
-
-on:
-  pull_request:
-    types: [closed]
-
-permissions:
-  actions: write
-
-jobs:
-  cleanup:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Delete caches for the closed PR
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          PR_REF: refs/pull/${{ github.event.pull_request.number }}/merge
-        run: |
-          echo "Deleting caches for $PR_REF"
-          while :; do
-            ids=$(gh cache list --ref "$PR_REF" --limit 100 --json id --jq '.[].id')
-            [ -n "$ids" ] || break
-            echo "$ids" | while read -r id; do
-              [ -n "$id" ] || continue
-              echo "Deleting cache $id"
-              gh cache delete "$id" || echo "  (already gone)"
-            done
-          done

.github/workflows/codeql-analysis.yml

@@ -14,19 +14,9 @@ name: "Static Analysis"
 on:
   push:
     branches: ["master", "next"]
-    paths-ignore: &docs-only-paths
-      - "**/*.md"
-      - "doc/**"
-      - ".binder/**"
-      - "CITATION.cff"
-      - "LICENSE"
-      - "NOTICE"
-      - "CHANGELOG"
-      - "INSTALL"
   pull_request:
     # The branches below must be a subset of the branches above
     branches: ["master"]
-    paths-ignore: *docs-only-paths
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

.github/workflows/mfem-analysis.yml

@@ -0,0 +1,102 @@
+# 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 Analysis"
+
+permissions:
+  actions: write
+
+on:
+  push:
+    branches:
+      - master
+      - next
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  HYPRE_ARCHIVE: v2.19.0.tar.gz
+  HYPRE_TOP_DIR: hypre-2.19.0
+  METIS_ARCHIVE: metis-4.0.3.tar.gz
+  METIS_TOP_DIR: metis-4.0.3
+  COVERAGE_ENV: mfem-coverage
+  MFEM_ACTIONS_VERSION: v2.7
+
+jobs:
+  gitignore:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout MFEM
+        uses: actions/checkout@v6
+        with:
+          path: mfem
+
+      - name: Get MPI (Linux)
+        run: |
+          sudo apt-get install openmpi-bin libopenmpi-dev
+          export OMPI_MCA_rmaps_base_oversubscribe=1
+
+      - name: Cache Hypre Install
+        id: hypre-cache
+        uses: actions/cache@v5
+        with:
+          path: ${{ env.HYPRE_TOP_DIR }}
+          key: ${{ runner.os }}-ompi-build-${{ env.HYPRE_TOP_DIR }}-int32-fp64-${{ env.MFEM_ACTIONS_VERSION }}
+
+      - name: Get Hypre
+        if: steps.hypre-cache.outputs.cache-hit != 'true'
+        uses: mfem/github-actions/build-hypre@v2.7
+        with:
+          archive: ${{ env.HYPRE_ARCHIVE }}
+          dir: ${{ env.HYPRE_TOP_DIR }}
+          target: int32
+          precision: fp64
+
+      - name: Cache Metis Install
+        id: metis-cache
+        uses: actions/cache@v5
+        with:
+          path: ${{ env.METIS_TOP_DIR }}
+          key: ${{ runner.os }}-build-${{ env.METIS_TOP_DIR }}-${{ env.MFEM_ACTIONS_VERSION }}
+
+      - name: Install Metis
+        if: steps.metis-cache.outputs.cache-hit != 'true'
+        uses: mfem/github-actions/build-metis@v2.7
+        with:
+          archive: ${{ env.METIS_ARCHIVE }}
+          dir: ${{ env.METIS_TOP_DIR }}
+
+      # MFEM build and test
+      - name: build-mfem
+        uses: mfem/github-actions/build-mfem@v2.7
+        with:
+          os: ${{ runner.os }}
+          target: opt
+          codecov: NO
+          mpi: par
+          build-system: make
+          hypre-dir: ${{ env.HYPRE_TOP_DIR }}
+          metis-dir: ${{ env.METIS_TOP_DIR }}
+          mfem-dir: mfem
+
+      - name: test (no clean)
+        run: |
+          cd mfem && make test-noclean
+
+      - name: gitignore
+        run: |
+          cd mfem/tests/scripts
+          ./runtest gitignore

.github/workflows/repo-check.yml

@@ -13,7 +13,6 @@ name: "Checks"
 
 permissions:
   actions: write
-  pull-requests: read
 
 on:
   push:
@@ -30,11 +29,6 @@ concurrency:
 # by checking if the workflow trigger is 'push' ("github.event_name == 'push'")
 # and if we are in a fork ("github.event.pull_request.head.repo.full_name !=
 # github.repository").
-#
-# The logic for the branch-history check is slightly different, since that check
-# also inspects the PR's labels to allow for overriding failures. In this case,
-# we run on all 'pull_request' triggers, but only run for 'push' triggers that
-# do not correspond to any open PRs.
 
 jobs:
   file-headers-check:
@@ -134,7 +128,10 @@ jobs:
 
   branch-history:
     if: |
-      github.ref != 'refs/heads/next' && github.ref != 'refs/heads/master'
+      github.ref != 'refs/heads/next' &&
+      github.ref != 'refs/heads/master' &&
+      (github.event_name == 'push' ||
+       github.event.pull_request.head.repo.full_name != github.repository)
     runs-on: ubuntu-latest
     steps:
       - name: checkout mfem
@@ -142,27 +139,7 @@ jobs:
         with:
           fetch-depth: 0
 
-      - name: check for pull request
-        id: check_pr
-        if: github.event_name == 'push'
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          pr_exists=$(gh pr list --repo "$GITHUB_REPOSITORY" \
-            --head "$GITHUB_REF_NAME" \
-            --state open \
-            --json number \
-            --jq 'length > 0')
-          echo "pr_exists=$pr_exists" >> "$GITHUB_OUTPUT"
-
       - name: branch-history
-        id: branch_history
-        if: |
-          (github.event_name == 'pull_request' ||
-           github.event_name == 'workflow_dispatch' ||
-           steps.check_pr.outputs.pr_exists == 'false')
-        continue-on-error: ${{ contains(github.event.pull_request.labels.*.name,
-                                        'branch-history-override') }}
         run: |
           # We override origin to make sure we point to the main repo.
           # This is to have consistent test results on PRs from forks.
@@ -170,9 +147,3 @@ jobs:
           git remote add origin https://github.com/mfem/mfem.git
           git checkout -b gh-actions-branch-history
           ./config/githooks/pre-push --history
-
-      - name: report branch-history override
-        if: steps.branch_history.outcome == 'failure'
-        run: |
-          echo "::warning::branch-history check failed, but the" \
-            "'branch-history-override' label is set."

.github/workflows/sanitizers.yml

@@ -17,17 +17,7 @@ permissions:
 on:
   push:
     branches: ["master", "next"]
-    paths-ignore: &docs-only-paths
-      - "**/*.md"
-      - "doc/**"
-      - ".binder/**"
-      - "CITATION.cff"
-      - "LICENSE"
-      - "NOTICE"
-      - "CHANGELOG"
-      - "INSTALL"
   pull_request:
-    paths-ignore: *docs-only-paths
   workflow_dispatch:
 
 concurrency:

CHANGELOG

@@ -15,10 +15,6 @@ Version 4.9.1 (development)
 
 Discretization improvements
 ---------------------------
-- Improved FindPointsGSLIB surface mesh capability with support for simplices
-  and an option to specify axis-aligned bounding box padding for near-surface
-  point queries.
-
 - Added GPU-enabled partial assembly for simplicial Bernstein H1 basis based on
   ragged tensor algorithms (see DOI: 10.1137/11082539X) for mass and diffusion
   integrators.
@@ -68,14 +64,8 @@ Linear and nonlinear solvers
   PRefinement multigrid methods for problems posed on trace spaces (see e.g. the
   DPG miniapps).
 
-- Added interface to MUMPS direct solver for complex-valued problems.
-  Its usage is demonstrated in ex25p. See http://mumps.enseeiht.fr/ for more details.
-  Supported versions >= 5.1.1.
-
 GPU computing
 -------------
-- Added device assembly support for 3D H(curl) VectorFEDomainLFIntegrator.
-
 - Added NVIDIA cuDSS library interface. Implementation examples have been
   added to ex1 and ex1p. See https://developer.nvidia.com/cudss for more
   details. Supported versions >= 0.6.0.

CMakeLists.txt

@@ -76,9 +76,7 @@ set(XSDK_ENABLE_Fortran OFF)
 # Check if we need to enable C or Fortran.
 if (MFEM_USE_CONDUIT OR
     MFEM_USE_SIDRE OR
-    MFEM_USE_PETSC OR
-    MFEM_USE_MUMPS OR
-    MFEM_USE_COMPLEX_MUMPS)
+    MFEM_USE_PETSC)
    # This seems to be needed by:
    #  * find_package(BLAS REQUIRED) and
    #  * find_package(HDF5 REQUIRED) needed, in turn, by:
@@ -86,7 +84,7 @@ if (MFEM_USE_CONDUIT OR
    #  * find_package(PETSc REQUIRED)
    set(XSDK_ENABLE_C ON)
 endif()
-if (MFEM_USE_STRUMPACK OR MFEM_USE_MUMPS OR MFEM_USE_COMPLEX_MUMPS)
+if (MFEM_USE_STRUMPACK OR MFEM_USE_MUMPS)
   # Just needed to find the MPI_Fortran libraries to link with
   set(XSDK_ENABLE_Fortran ON)
 endif()
@@ -344,7 +342,7 @@ if (MFEM_USE_MPI)
     endif()
   endif()
 else()
-  set(PKGS_NEED_MPI SUPERLU MUMPS COMPLEX_MUMPS PETSC SLEPC STRUMPACK PUMI)
+  set(PKGS_NEED_MPI SUPERLU MUMPS PETSC SLEPC STRUMPACK PUMI)
   foreach(PKG IN LISTS PKGS_NEED_MPI)
     if (MFEM_USE_${PKG})
       message(STATUS "Disabling package ${PKG} - requires MPI")
@@ -417,7 +415,7 @@ if (MFEM_USE_SUPERLU)
 endif()
 
 # MUMPS can only be enabled in parallel
-if (MFEM_USE_MUMPS OR MFEM_USE_COMPLEX_MUMPS)
+if (MFEM_USE_MUMPS)
   if (MFEM_USE_MPI)
     find_package(MUMPS REQUIRED mumps_common pord)
     set(MFEM_MUMPS_VERSION ${MUMPS_VERSION})

CONTRIBUTING.md

@@ -6,6 +6,7 @@
 <a href="https://github.com/mfem/mfem/blob/master/LICENSE"><img alt="License" src="https://img.shields.io/badge/License-BSD-blue.svg"></a>
 <a href="https://github.com/mfem/mfem/releases/latest"><img alt="GitHub release" src="https://img.shields.io/github/v/release/mfem/mfem"></a>
 <a href="https://github.com/mfem/mfem/actions/workflows/repo-check.yml?query=branch%3Amaster"><img alt="Repo check" src="https://github.com/mfem/mfem/actions/workflows/repo-check.yml/badge.svg?branch=master"></a>
+<a href="https://github.com/mfem/mfem/actions/workflows/mfem-analysis.yml?query=branch%3Amaster"><img alt="Build Analysis" src="https://github.com/mfem/mfem/actions/workflows/mfem-analysis.yml/badge.svg?branch=master"></a>
 <a href="https://github.com/mfem/mfem/actions/workflows/builds-and-tests.yml?query=branch%3Amaster"><img alt="Builds and Tests" src="https://github.com/mfem/mfem/actions/workflows/builds-and-tests.yml/badge.svg?branch=master"></a>
 <a href="https://ci.appveyor.com/project/mfem/mfem"><img alt="Build Status" src="https://ci.appveyor.com/api/projects/status/19non9sqm6msi2wy?svg=true"></a>
 <a href="https://docs.mfem.org/html/index.html"><img alt="Documentation" src="https://img.shields.io/badge/code-documented-brightgreen.svg"></a>

config/cmake/MFEMConfig.cmake.in

@@ -34,7 +34,6 @@ set(MFEM_USE_SUNDIALS @MFEM_USE_SUNDIALS@)
 set(MFEM_USE_SUITESPARSE @MFEM_USE_SUITESPARSE@)
 set(MFEM_USE_SUPERLU @MFEM_USE_SUPERLU@)
 set(MFEM_USE_MUMPS @MFEM_USE_MUMPS@)
-set(MFEM_USE_COMPLEX_MUMPS @MFEM_USE_COMPLEX_MUMPS@)
 set(MFEM_USE_STRUMPACK @MFEM_USE_STRUMPACK@)
 set(MFEM_USE_CUDSS @MFEM_USE_CUDSS@)
 set(MFEM_USE_GINKGO @MFEM_USE_GINKGO@)

config/cmake/config.hpp.in

@@ -103,7 +103,6 @@
 
 // Enable MFEM functionality based on the MUMPS library.
 #cmakedefine MFEM_USE_MUMPS
-#cmakedefine MFEM_USE_COMPLEX_MUMPS
 #cmakedefine MFEM_MUMPS_VERSION @MFEM_MUMPS_VERSION@
 
 // Enable MFEM functionality based on the STRUMPACK library.

config/cmake/modules/FindGSLIB.cmake

@@ -18,17 +18,19 @@
 
 if (MFEM_FETCH_GSLIB OR MFEM_FETCH_TPLS)
   enable_language(C)
-  set(GSLIB_FETCH_VERSION 1.0.9)
-  add_library(GSLIB STATIC IMPORTED)
-  # set options (technically flags because GSLIB does not use cmake)
   string(TOUPPER "${CMAKE_BUILD_TYPE}" BUILD_TYPE)
-  set(GSLIB_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${BUILD_TYPE}}")
-  if (BUILD_SHARED_LIBS)
-    set(GSLIB_FLAGS "${GSLIB_FLAGS} -fPIC")
+  set(GSLIB_FETCH_VERSION 1.0.9)
+  set(GSLIB_C_FLAGS ${CMAKE_C_FLAGS_${BUILD_TYPE}})
+  if (CMAKE_C_FLAGS)
+    set(GSLIB_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${BUILD_TYPE}}")
   endif()
+  if (BUILD_SHARED_LIBS)
+    set(GSLIB_C_FLAGS "${GSLIB_C_FLAGS} -fPIC")
+  endif()
+  add_library(GSLIB STATIC IMPORTED)
   # 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 GSLIB ${GSLIB_FETCH_VERSION} to be built with ${GSLIB_FLAGS}")
+  message(STATUS "Will fetch GSLIB ${GSLIB_FETCH_VERSION} to be built with ${GSLIB_C_FLAGS}")
   set(PREFIX ${CMAKE_BINARY_DIR}/fetch/gslib)
   include(ExternalProject)
   ExternalProject_Add(gslib
@@ -38,7 +40,7 @@ if (MFEM_FETCH_GSLIB OR MFEM_FETCH_TPLS)
     UPDATE_DISCONNECTED TRUE
     PREFIX ${PREFIX}
     CONFIGURE_COMMAND ""
-    BUILD_COMMAND cd ${PREFIX}/src/gslib && $(MAKE) clean && $(MAKE) DESTDIR=${PREFIX} MPI=$<BOOL:${MFEM_USE_MPI}> "CFLAGS=${GSLIB_FLAGS}"
+    BUILD_COMMAND cd ${PREFIX}/src/gslib && $(MAKE) clean && $(MAKE) DESTDIR=${PREFIX} MPI=$<BOOL:${MFEM_USE_MPI}> "CFLAGS= ${GSLIB_C_FLAGS}"
     INSTALL_COMMAND "")
   file(MAKE_DIRECTORY ${PREFIX}/include)
   # set imported library target properties

config/cmake/modules/FindHYPRE.cmake

@@ -44,9 +44,6 @@ if (MFEM_FETCH_HYPRE OR MFEM_FETCH_TPLS)
   # set options and associated dependencies
   set(HYPRE_CMAKE_OPTIONS "")
   list(APPEND HYPRE_CMAKE_OPTIONS -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE})
-  if (BUILD_SHARED_LIBS)
-    list(APPEND HYPRE_CMAKE_OPTIONS -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON)
-  endif()
   # collect all HYPRE_ENABLE variables and pass them to hypre, assuming they are BOOL.
   get_cmake_property(all_vars VARIABLES)
   foreach(var ${all_vars})
@@ -98,6 +95,7 @@ if (MFEM_FETCH_HYPRE OR MFEM_FETCH_TPLS)
     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

config/cmake/modules/FindMETIS.cmake

@@ -19,18 +19,10 @@
 #   - METIS_VERSION_5 (cache variable)
 
 if (MFEM_FETCH_METIS OR MFEM_FETCH_TPLS)
-  enable_language(C)
   set(METIS_FETCH_VERSION 4.0.3)
   add_library(METIS STATIC IMPORTED)
-  # set options (technically flags because METIS does not use cmake)
-  set(METIS_FLAGS "-Wno-implicit-int -Wno-incompatible-pointer-types")
-  string(TOUPPER "${CMAKE_BUILD_TYPE}" BUILD_TYPE)
-  set(METIS_FLAGS "${METIS_FLAGS} ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${BUILD_TYPE}}")
-  if (BUILD_SHARED_LIBS)
-    set(METIS_FLAGS "${METIS_FLAGS} -fPIC")
-  endif()
   # define external project
-  message(STATUS "Will fetch METIS ${METIS_FETCH_VERSION} to be built with ${METIS_FLAGS}")
+  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
@@ -40,7 +32,7 @@ if (MFEM_FETCH_METIS OR MFEM_FETCH_TPLS)
     UPDATE_DISCONNECTED TRUE
     PREFIX ${PREFIX}
     CONFIGURE_COMMAND tar -xzf ../metis/metis-${METIS_FETCH_VERSION}-mac.tgz --strip=1
-    BUILD_COMMAND $(MAKE) clean && $(MAKE) "OPTFLAGS=${METIS_FLAGS}"
+    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)

config/cmake/modules/FindMUMPS.cmake

@@ -17,31 +17,13 @@
 
 include(MfemCmakeUtilities)
 
-# Decide headers/libs by MFEM precision
+# Toggle which precision of MUMPS to use depending on the precision of MFEM.
 if (MFEM_USE_DOUBLE)
-  set(_rmumps_header dmumps_c.h)
-  set(_rmumps_lib    dmumps)
-  set(_cmumps_header zmumps_c.h)
-  set(_cmumps_lib    zmumps)
-elseif (MFEM_USE_SINGLE)
-  set(_rmumps_header smumps_c.h)
-  set(_rmumps_lib    smumps)
-  set(_cmumps_header cmumps_c.h)
-  set(_cmumps_lib    cmumps)
-endif()
-
-# Choose which header/lib mfem_find_package should use as the "primary" one.
-# If both enabled, prefer the real one as primary (either is fine).
-if (MFEM_USE_MUMPS)
-  set(_mumps_header ${_rmumps_header})
-  set(_mumps_lib    ${_rmumps_lib})
-elseif (MFEM_USE_COMPLEX_MUMPS)
-  set(_mumps_header ${_cmumps_header})
-  set(_mumps_lib    ${_cmumps_lib})
-else()
-  # Should not happen in practice because FindMUMPS is only called when enabled,
-  set(_mumps_header ${_rmumps_header})
-  set(_mumps_lib    ${_rmumps_lib})
+  set(_mumps_header dmumps_c.h)
+  set(_mumps_lib dmumps)
+elseif(MFEM_USE_SINGLE)
+  set(_mumps_header smumps_c.h)
+  set(_mumps_lib smumps)
 endif()
 
 mfem_find_package(MUMPS MUMPS MUMPS_DIR
@@ -49,35 +31,8 @@ mfem_find_package(MUMPS MUMPS MUMPS_DIR
   "Paths to headers required by MUMPS."
   "Libraries required by MUMPS."
   ADD_COMPONENT mumps_common "include" ${_mumps_header} "lib" mumps_common
-  ADD_COMPONENT pord        "include" ${_mumps_header} "lib" pord)
+  ADD_COMPONENT pord "include" ${_mumps_header} "lib" pord)
 
-# If BOTH real and complex are enabled, ensure BOTH solver libs are linked.
-if (MUMPS_FOUND AND MFEM_USE_MUMPS AND MFEM_USE_COMPLEX_MUMPS)
-  # Find the "other" solver library and append it.
-  find_library(_mfem_other_mumps_solver
-    NAMES ${_cmumps_lib}   
-    HINTS ${MUMPS_DIR}
-    PATH_SUFFIXES lib lib64
-    NO_DEFAULT_PATH)
-
-  if (NOT _mfem_other_mumps_solver)
-    # Fall back to system search
-    find_library(_mfem_other_mumps_solver NAMES ${_cmumps_lib})
-  endif()
-
-  if (NOT _mfem_other_mumps_solver)
-    message(FATAL_ERROR
-      "MFEM_USE_MUMPS=ON and MFEM_USE_COMPLEX_MUMPS=ON, but could not find "
-      "the complex solver library '${_cmumps_lib}' in MUMPS_DIR='${MUMPS_DIR}'.")
-  endif()
-
-  # Put solver libs first (important for static link order)
-  # MUMPS_LIBRARIES contains the primary solver already + common + pord.
-  # We prepend the other solver.
-  list(INSERT MUMPS_LIBRARIES 0 ${_mfem_other_mumps_solver})
-endif()
-
-# Version detection 
 if (MUMPS_FOUND AND (NOT MUMPS_VERSION))
   try_run(MUMPS_VERSION_RUN_RESULT MUMPS_VERSION_COMPILE_RESULT
           ${CMAKE_CURRENT_BINARY_DIR}/config

config/cmake/modules/FindSuiteSparse.cmake

@@ -22,15 +22,15 @@ include(MfemCmakeUtilities)
 mfem_find_package(SuiteSparse SuiteSparse SuiteSparse_DIR "" "" "" ""
   "Paths to headers required by SuiteSparse."
   "Libraries required by SuiteSparse."
-  ADD_COMPONENT "UMFPACK" "include;include/suitesparse;suitesparse" umfpack.h "lib" umfpack
-  ADD_COMPONENT "KLU" "include;include/suitesparse;suitesparse" klu.h "lib" klu
-  ADD_COMPONENT "AMD" "include;include/suitesparse;suitesparse" amd.h "lib" amd
-  ADD_COMPONENT "BTF" "include;include/suitesparse;suitesparse" btf.h "lib" btf
-  ADD_COMPONENT "CHOLMOD" "include;include/suitesparse;suitesparse" cholmod.h "lib" cholmod
-  ADD_COMPONENT "COLAMD" "include;include/suitesparse;suitesparse" colamd.h "lib" colamd
-  ADD_COMPONENT "CAMD" "include;include/suitesparse;suitesparse" camd.h "lib" camd
-  ADD_COMPONENT "CCOLAMD" "include;include/suitesparse;suitesparse" ccolamd.h "lib" ccolamd
-  ADD_COMPONENT "config" "include;include/suitesparse;suitesparse" SuiteSparse_config.h "lib"
+  ADD_COMPONENT "UMFPACK" "include;suitesparse" umfpack.h "lib" umfpack
+  ADD_COMPONENT "KLU" "include;suitesparse" klu.h "lib" klu
+  ADD_COMPONENT "AMD" "include;suitesparse" amd.h "lib" amd
+  ADD_COMPONENT "BTF" "include;suitesparse" btf.h "lib" btf
+  ADD_COMPONENT "CHOLMOD" "include;suitesparse" cholmod.h "lib" cholmod
+  ADD_COMPONENT "COLAMD" "include;suitesparse" colamd.h "lib" colamd
+  ADD_COMPONENT "CAMD" "include;suitesparse" camd.h "lib" camd
+  ADD_COMPONENT "CCOLAMD" "include;suitesparse" ccolamd.h "lib" ccolamd
+  ADD_COMPONENT "config" "include;suitesparse" SuiteSparse_config.h "lib"
     suitesparseconfig)
 
 if (SuiteSparse_FOUND AND METIS_VERSION_5)

config/cmake/modules/MfemCmakeUtilities.cmake

@@ -876,12 +876,12 @@ function(mfem_export_mk_files)
       MFEM_USE_ZLIB MFEM_USE_LIBUNWIND MFEM_USE_LAPACK MFEM_THREAD_SAFE
       MFEM_USE_LEGACY_OPENMP MFEM_USE_OPENMP MFEM_USE_MEMALLOC MFEM_USE_SUNDIALS
       MFEM_USE_SUITESPARSE MFEM_USE_SUPERLU MFEM_USE_SUPERLU5 MFEM_USE_MUMPS
-      MFEM_USE_COMPLEX_MUMPS MFEM_USE_STRUMPACK MFEM_USE_GINKGO MFEM_USE_AMGX
-      MFEM_USE_MAGMA MFEM_USE_GNUTLS MFEM_USE_NETCDF MFEM_USE_PETSC
-      MFEM_USE_SLEPC MFEM_USE_MPFR MFEM_USE_SIDRE MFEM_USE_FMS MFEM_USE_CONDUIT
-      MFEM_USE_PUMI MFEM_USE_HIOP MFEM_USE_GSLIB MFEM_USE_CUDA MFEM_USE_HIP
-      MFEM_USE_RAJA MFEM_USE_OCCA MFEM_USE_CEED MFEM_USE_CALIPER MFEM_USE_UMPIRE
-      MFEM_USE_SIMD MFEM_USE_ADIOS2 MFEM_USE_MKL_CPARDISO MFEM_USE_MKL_PARDISO
+      MFEM_USE_STRUMPACK MFEM_USE_GINKGO MFEM_USE_AMGX MFEM_USE_MAGMA
+      MFEM_USE_GNUTLS MFEM_USE_NETCDF MFEM_USE_PETSC MFEM_USE_SLEPC
+      MFEM_USE_MPFR MFEM_USE_SIDRE MFEM_USE_FMS MFEM_USE_CONDUIT MFEM_USE_PUMI
+      MFEM_USE_HIOP MFEM_USE_GSLIB MFEM_USE_CUDA MFEM_USE_HIP MFEM_USE_RAJA
+      MFEM_USE_OCCA MFEM_USE_CEED MFEM_USE_CALIPER MFEM_USE_UMPIRE MFEM_USE_SIMD
+      MFEM_USE_ADIOS2 MFEM_USE_MKL_CPARDISO MFEM_USE_MKL_PARDISO
       MFEM_USE_ADFORWARD MFEM_USE_CODIPACK MFEM_USE_BENCHMARK MFEM_USE_PARELAG
       MFEM_USE_TRIBOL MFEM_USE_MOONOLITH MFEM_USE_ALGOIM MFEM_USE_ENZYME
       MFEM_USE_HDF5)

config/config.hpp

@@ -140,9 +140,6 @@ constexpr real_t operator""_r(unsigned long long v)
 #ifdef MFEM_USE_MUMPS
 #error Building with MUMPS (MFEM_USE_MUMPS=YES) requires MPI (MFEM_USE_MPI=YES)
 #endif
-#ifdef MFEM_USE_COMPLEX_MUMPS
-#error Building with COMPLEX_MUMPS (MFEM_USE_COMPLEX_MUMPS=YES) requires MPI (MFEM_USE_MPI=YES)
-#endif
 #ifdef MFEM_USE_STRUMPACK
 #error Building with STRUMPACK (MFEM_USE_STRUMPACK=YES) requires MPI (MFEM_USE_MPI=YES)
 #endif

config/config.hpp.in

@@ -103,7 +103,6 @@
 
 // Enable MFEM functionality based on the MUMPS library.
 // #define MFEM_USE_MUMPS
-// #define MFEM_USE_COMPLEX_MUMPS
 // #define MFEM_MUMPS_VERSION @MFEM_MUMPS_VERSION@
 
 // Enable MFEM functionality based on the STRUMPACK library.

config/defaults.cmake

@@ -37,7 +37,6 @@ option(MFEM_USE_SUITESPARSE "Enable SuiteSparse usage" OFF)
 option(MFEM_USE_SUPERLU "Enable SuperLU_DIST usage" OFF)
 option(MFEM_USE_SUPERLU5 "Use the old SuperLU_DIST 5.1 version" OFF)
 option(MFEM_USE_MUMPS "Enable MUMPS usage" OFF)
-option(MFEM_USE_COMPLEX_MUMPS "Enable COMPLEX_MUMPS usage" OFF)
 option(MFEM_USE_STRUMPACK "Enable STRUMPACK usage" OFF)
 option(MFEM_USE_CUDSS "Enable cuDSS usage" OFF)
 option(MFEM_USE_GINKGO "Enable Ginkgo usage" OFF)
@@ -154,7 +153,7 @@ set(SuperLUDist_REQUIRED_PACKAGES "MPI" "ParMETIS" "METIS"
 set(MUMPS_DIR "${MFEM_DIR}/../MUMPS_5.5.0" CACHE PATH
     "Path to the MUMPS library.")
 # MUMPS may also depend on "OpenMP", depending on how it was compiled.
-set(MUMPS_REQUIRED_PACKAGES "MPI" "MPI_Fortran" "METIS"
+set(MUMPS_REQUIRED_PACKAGES "MPI" "MPI_Fortran" "ParMETIS" "METIS"
     "ScaLAPACK" "LAPACK" "BLAS" CACHE STRING
     "Additional packages required by MUMPS.")
 # If the MPI package does not find all required Fortran libraries:

config/defaults.mk

@@ -152,7 +152,6 @@ MFEM_USE_SUITESPARSE   = NO
 MFEM_USE_SUPERLU       = NO
 MFEM_USE_SUPERLU5      = NO
 MFEM_USE_MUMPS         = NO
-MFEM_USE_COMPLEX_MUMPS = NO
 MFEM_USE_STRUMPACK     = NO
 MFEM_USE_CUDSS         = NO
 MFEM_USE_GINKGO        = NO
@@ -250,7 +249,7 @@ ifeq (YES,$(MFEM_USE_HIP))
 endif
 
 # METIS library configuration
-ifeq ($(MFEM_USE_SUPERLU)$(MFEM_USE_STRUMPACK)$(MFEM_USE_MUMPS)$(MFEM_USE_COMPLEX_MUMPS),NONONONO)
+ifeq ($(MFEM_USE_SUPERLU)$(MFEM_USE_STRUMPACK)$(MFEM_USE_MUMPS),NONONO)
    ifeq ($(MFEM_USE_METIS_5),NO)
      METIS_DIR = @MFEM_DIR@/../metis-4.0
      METIS_OPT =
@@ -354,19 +353,13 @@ MPI_FORTRAN_LIB = -lmpifort
 # MUMPS library configuration
 MUMPS_DIR = @MFEM_DIR@/../MUMPS_5.5.0
 MUMPS_OPT = -I$(MUMPS_DIR)/include
-COMPLEX_MUMPS_OPT = $(MUMPS_OPT)
-
-MUMPS_COMMON_PATH = $(XLINKER)-rpath,$(MUMPS_DIR)/lib -L$(MUMPS_DIR)/lib
-MUMPS_COMMON_LIB = -lmumps_common -lpord $(SCALAPACK_LIB) $(LAPACK_LIB) $(MPI_FORTRAN_LIB)
+MUMPS_LIB = $(XLINKER)-rpath,$(MUMPS_DIR)/lib -L$(MUMPS_DIR)/lib
 ifeq ($(MFEM_USE_SINGLE),YES)
-  MUMPS_SOLVER_LIB         = -lsmumps
-  COMPLEX_MUMPS_SOLVER_LIB = -lcmumps
+   MUMPS_LIB += -lsmumps
 else
-  MUMPS_SOLVER_LIB         = -ldmumps
-  COMPLEX_MUMPS_SOLVER_LIB = -lzmumps
+   MUMPS_LIB += -ldmumps
 endif
-MUMPS_LIB         = $(MUMPS_COMMON_PATH) $(MUMPS_SOLVER_LIB) $(MUMPS_COMMON_LIB)
-COMPLEX_MUMPS_LIB = $(MUMPS_COMMON_PATH) $(COMPLEX_MUMPS_SOLVER_LIB) $(MUMPS_COMMON_LIB)
+MUMPS_LIB += -lmumps_common -lpord $(SCALAPACK_LIB) $(LAPACK_LIB) $(MPI_FORTRAN_LIB)
 
 # STRUMPACK library configuration
 STRUMPACK_DIR = @MFEM_DIR@/../STRUMPACK-build

config/get_mumps_version.cpp

@@ -10,18 +10,10 @@
 // CONTRIBUTING.md for details.
 
 #ifdef MFEM_USE_SINGLE
-#ifdef MFEM_USE_COMPLEX_MUMPS
-#include "cmumps_c.h"
-#else
 #include "smumps_c.h"
-#endif
-#else
-#ifdef MFEM_USE_COMPLEX_MUMPS
-#include "zmumps_c.h"
 #else
 #include "dmumps_c.h"
 #endif
-#endif
 #include <string>
 #include <iostream>
 #include <algorithm>

config/githooks/README.md

@@ -39,8 +39,3 @@ when a picture was added for documentation.
 If that is the case, make sure the failure is indeed justified, and rerun the
 push command with the `--no-verify` option. This will skip the hooks, allowing
 you to push those changes.
-
-The `branch-history` check is run automatically through GitHub Actions. If a
-branch is known to have a large number of changes that are legitimate, the
-check can be overridden by setting  the label 'branch-history-override' on the
-pull request.

config/makefile

@@ -42,7 +42,7 @@ GHV_FLAGS = $(MFEM_CXXFLAGS) $(subst @MFEM_DIR@,$(if $(MFEM_DIR),$(MFEM_DIR),..)
 SMX = $(if $(MFEM_USE_PUMI:NO=),MFEM_USE_SIMMETRIX)
 SMX_PATH = $(PUMI_DIR)/include/gmi_sim.h
 SMX_FILE = $(subst @MFEM_DIR@,$(if $(MFEM_DIR),$(MFEM_DIR),..),$(SMX_PATH))
-MUMPS = $(if $(filter YES,$(MFEM_USE_MUMPS) $(MFEM_USE_COMPLEX_MUMPS)),YES,)
+MUMPS = $(MFEM_USE_MUMPS:NO=)
 GMV_CXX ?= $(MFEM_CXX)
 GMV = get_mumps_version
 GMV_FLAGS = $(MFEM_CXXFLAGS) $(subst @MFEM_DIR@,$(if $(MFEM_DIR),$(MFEM_DIR),..),$(MUMPS_OPT))

examples/ex25p.cpp

@@ -200,7 +200,7 @@ int main(int argc, char *argv[])
    args.AddOption(&slu_solver, "-slu", "--superlu", "-no-slu",
                   "--no-superlu", "Use the SuperLU Solver.");
 #endif
-#if defined(MFEM_USE_MUMPS) || defined(MFEM_USE_COMPLEX_MUMPS)
+#ifdef MFEM_USE_MUMPS
    args.AddOption(&mumps_solver, "-mumps", "--mumps-solver", "-no-mumps",
                   "--no-mumps-solver", "Use the MUMPS Solver.");
 #endif
@@ -502,24 +502,16 @@ int main(int argc, char *argv[])
       delete A;
    }
 #endif
-#if defined(MFEM_USE_MUMPS) || defined(MFEM_USE_COMPLEX_MUMPS)
+#ifdef MFEM_USE_MUMPS
    if (!pa && mumps_solver)
    {
-      ComplexHypreParMatrix *Ahc = Ah.As<ComplexHypreParMatrix>();
-#ifdef MFEM_USE_COMPLEX_MUMPS
-      ComplexMUMPSSolver mumps(MPI_COMM_WORLD);
-      mumps.SetPrintLevel(0);
-      mumps.SetOperator(*Ahc);
-      mumps.Mult(B, X);
-#else
-      HypreParMatrix *A = Ahc->GetSystemMatrix();
+      HypreParMatrix *A = Ah.As<ComplexHypreParMatrix>()->GetSystemMatrix();
       MUMPSSolver mumps(A->GetComm());
       mumps.SetPrintLevel(0);
       mumps.SetMatrixSymType(MUMPSSolver::MatType::UNSYMMETRIC);
       mumps.SetOperator(*A);
       mumps.Mult(B, X);
       delete A;
-#endif
    }
 #endif
    // 16a. Set up the parallel Bilinear form a(.,.) for the preconditioner

fem/CMakeLists.txt

@@ -133,7 +133,7 @@ set(SRCS
   tmop/assemble/diag2.cpp
   tmop/assemble/grad2_limit.cpp
   tmop/assemble/grad2.cpp
-  tmop/assemble/diag3_limit.cpp
+  tmop/assemble/diag3_limit.cpp  
   tmop/assemble/diag3.cpp
   tmop/assemble/grad3_limit.cpp
   tmop/assemble/grad3.cpp
@@ -311,7 +311,6 @@ set(HDRS
   tmop_tools.hpp
   tmop_amr.hpp
   gslib.hpp
-  gslib/gslib_kernel_helpers.hpp
   transfer.hpp
   hyperbolic.hpp
   integrator.hpp

fem/coefficient.cpp

@@ -54,8 +54,6 @@ void Coefficient::Project(QuadratureFunction &qf)
    QuadratureSpaceBase &qspace = *qf.GetSpace();
    const int ne = qspace.GetNE();
    Vector values;
-   // GetValues makes a reference, but we need it to be valid on Host
-   qf.HostWrite();
    for (int iel = 0; iel < ne; ++iel)
    {
       qf.GetValues(iel, values);
@@ -329,8 +327,6 @@ void VectorCoefficient::Project(QuadratureFunction &qf)
    const int ne = qspace.GetNE();
    DenseMatrix values;
    Vector col;
-   // GetValues makes a reference, but we need it to be valid on Host
-   qf.HostWrite();
    for (int iel = 0; iel < ne; ++iel)
    {
       qf.GetValues(iel, values);
@@ -699,8 +695,6 @@ void MatrixCoefficient::Project(QuadratureFunction &qf, bool transpose)
    QuadratureSpaceBase &qspace = *qf.GetSpace();
    const int ne = qspace.GetNE();
    DenseMatrix values, matrix;
-   // GetValues makes a reference, but we need it to be valid on Host
-   qf.HostWrite();
    for (int iel = 0; iel < ne; ++iel)
    {
       qf.GetValues(iel, values);

fem/complex_fem.cpp

@@ -237,81 +237,6 @@ ComplexGridFunction::ProjectBdrCoefficientTangent(VectorCoefficient
    gfi->SyncAliasMemory(*this);
 }
 
-real_t
-ComplexGridFunction::ComputeLpError(const real_t p,
-                                    Coefficient &exsolr,
-                                    Coefficient &exsoli,
-                                    Coefficient *weight,
-                                    const IntegrationRule *irs[],
-                                    const Array<int> *elems) const
-{
-   real_t error = 0.0;
-   const FiniteElement *fe;
-   ElementTransformation *T;
-   Vector valsr;
-   Vector valsi;
-
-   const GridFunction& gf_r = real();
-   const GridFunction& gf_i = imag();
-
-   for (int i = 0; i < fes->GetNE(); i++)
-   {
-      if (elems != NULL && (*elems)[i] == 0) { continue; }
-      fe = fes->GetFE(i);
-      const IntegrationRule *ir;
-      if (irs)
-      {
-         ir = irs[fe->GetGeomType()];
-      }
-      else
-      {
-         int intorder = 2*fe->GetOrder() + 3;
-         ir = &(IntRules.Get(fe->GetGeomType(), intorder));
-      }
-      real_t elem_error = 0.0;
-      gf_r.GetValues(i, *ir, valsr);
-      gf_i.GetValues(i, *ir, valsi);
-      T = fes->GetElementTransformation(i);
-      for (int j = 0; j < ir->GetNPoints(); j++)
-      {
-         const IntegrationPoint &ip = ir->IntPoint(j);
-         T->SetIntPoint(&ip);
-         real_t diffr = valsr(j) - exsolr.Eval(*T, ip);
-         real_t diffi = valsi(j) - exsoli.Eval(*T, ip);
-         real_t diff = hypot(diffr, diffi);
-         if (p < infinity())
-         {
-            diff = pow(diff, p);
-            if (weight)
-            {
-               diff *= weight->Eval(*T, ip);
-            }
-            elem_error += ip.weight * T->Weight() * diff;
-         }
-         else
-         {
-            if (weight)
-            {
-               diff *= weight->Eval(*T, ip);
-            }
-            error = std::max(error, diff);
-         }
-      }
-      if (p < infinity())
-      {
-         // negative quadrature weights may cause the error to be negative
-         error += fabs(elem_error);
-      }
-   }
-
-   if (p < infinity())
-   {
-      error = pow(error, 1./p);
-   }
-
-   return error;
-}
-
 void ComplexGridFunction::Save(std::ostream &os) const
 {
    os << "ComplexGridFunction\n";

fem/complex_fem.hpp

@@ -166,75 +166,6 @@ public:
       return sqrt(err_r * err_r + err_i * err_i);
    }
 
-   /// @brief Returns Max|u_ex - u_h| error for complex-valued H1 or L2 elements
-   ///
-   /// Compute the $L_\infty$ error across the entire domain.
-   ///
-   /// @param[in] exsolr  Coefficient object reproducing the real part of the
-   ///                    anticipated values of the scalar field, Re(u_ex).
-   /// @param[in] exsoli  Coefficient object reproducing the imaginary part of
-   ///                    the anticipated values of the scalar field, Im(u_ex).
-   /// @param[in] irs        Optional pointer to an array of custom integration
-   ///                       rules e.g. higher order than the default rules. If
-   ///                       present the array will be indexed by
-   ///                       Geometry::Type.
-   ///
-   /// @note Uses ComputeLpError internally. See the ComputeLpError
-   ///       documentation for generalizations of this error computation.
-   ///
-   /// @note If an array of integration rules is provided through @a irs, be
-   ///       sure to include valid rules for each element type that may occur
-   ///       in the list of elements.
-   ///
-   virtual real_t ComputeMaxError(Coefficient &exsolr,
-                                  Coefficient &exsoli,
-                                  const IntegrationRule *irs[] = NULL) const
-   {
-      return ComputeLpError(infinity(), exsolr, exsoli, NULL, irs);
-   }
-
-   /// @brief Returns ||u_ex - u_h||_Lp for complex-valued H1 or L2 elements
-   ///
-   /// Computes:
-   ///    $$(\sum_{elems} \int_{elem} w \, |u_{ex} - u_h|^p)^{1/p}$$
-   /// Where:
-   ///    $$|u_{ex} - u_h| = \sqrt{Re(u_{ex} - u_h)^2 + Im(u_{ex} - u_h)^2}$$
-   ///
-   /// @param[in] p       Real value indicating the exponent of the $L^p$ norm.
-   ///                    To avoid domain errors p should have a positive value,
-   ///                    either finite or infinite.
-   /// @param[in] exsolr  Coefficient object reproducing the real part of the
-   ///                    anticipated values of the scalar field, Re(u_ex).
-   /// @param[in] exsoli  Coefficient object reproducing the imaginary part of
-   ///                    the anticipated values of the scalar field, Im(u_ex).
-   /// @param[in] weight  Optional pointer to a Coefficient object reproducing
-   ///                    a weighting function, w.
-   /// @param[in] irs     Optional pointer to an array of custom integration
-   ///                    rules e.g. higher order than the default rules. If
-   ///                    present the array will be indexed by Geometry::Type.
-   /// @param[in] elems   Optional pointer to a marker array, with a length
-   ///                    equal to the number of local elements, indicating
-   ///                    which elements to integrate over. Only those elements
-   ///                    corresponding to non-zero entries in @a elems will
-   ///                    contribute to the computed L2 error.
-   ///
-   /// @note If an array of integration rules is provided through @a irs, be
-   ///       sure to include valid rules for each element type that may occur
-   ///       in the list of elements.
-   ///
-   /// @note Quadratures with negative weights (as in some simplex integration
-   ///       rules in MFEM) can produce negative integrals even with
-   ///       non-negative integrands. To avoid returning negative errors this
-   ///       function uses the absolute values of the element-wise integrals.
-   ///       This may lead to results which are not entirely consistent with
-   ///       such integration rules.
-   virtual real_t ComputeLpError(const real_t p,
-                                 Coefficient &exsolr,
-                                 Coefficient &exsoli,
-                                 Coefficient *weight = NULL,
-                                 const IntegrationRule *irs[] = NULL,
-                                 const Array<int> *elems = NULL) const;
-
    /// Save the ComplexGridFunction to an output stream.
    virtual void Save(std::ostream &out) const;
 

fem/datacollection.cpp

@@ -1181,14 +1181,12 @@ void ParaViewDataCollection::SaveGFieldVTU(std::ostream &os, int ref_,
    DenseMatrix vval, pmat;
    std::vector<char> buf;
    int vec_dim = it->second->VectorDim();
-   int map_type = it->second->FESpace()->GetTypicalFE()->GetMapType();
    os << "<DataArray type=\"" << GetDataTypeString()
       << "\" Name=\"" << it->first
       << "\" NumberOfComponents=\"" << vec_dim << "\" "
       << VTKComponentLabels(vec_dim) << " "
       << "format=\"" << GetDataFormatString() << "\" >" << '\n';
-   if (vec_dim == 1 && (map_type == FiniteElement::VALUE ||
-                        map_type == FiniteElement::INTEGRAL))
+   if (vec_dim == 1)
    {
       for (int i = 0; i < mesh->GetNE(); i++)
       {

fem/gslib.hpp

@@ -12,9 +12,6 @@
 #ifndef MFEM_GSLIB
 #define MFEM_GSLIB
 
-#include <map>
-#include <vector>
-
 #include "../config/config.hpp"
 #ifdef MFEM_USE_MPI
 #include "pgridfunc.hpp"
@@ -122,11 +119,6 @@ protected:
    // IntegrationRules for simplex->Quad/Hex and to project to p_max in-case of
    // p-refinement.
    Array<IntegrationRule *> ir_split;
-   /// Integration rules built at the field polynomial order (only for surface
-   /// meshes when mesh order is not the same as gridfunction order).
-   Array<IntegrationRule *> ir_split_sol;
-   /// Order at which #ir_split_sol was built; -1 means not built.
-   int ir_split_sol_order = -1;
    Array<FiniteElementSpace *> fes_rst_map; //FESpaces to map Quad/Hex->Simplex
    Array<GridFunction *> gf_rst_map; // GridFunctions to map Quad/Hex->Simplex
    FiniteElementCollection *fec_map_lin;
@@ -142,8 +134,6 @@ protected:
    AvgType avgtype;             // average type used for L2 functions
    Array<int> split_element_map;
    Array<int> split_element_index;
-   // Geometry::Type (as int) of the original element for each split quad.
-   Array<int> split_element_geom;
    int        NE_split_total;   // total number of elements after mesh splitting
    int        mesh_points_cnt;  // number of mesh nodes
    // Tolerance to ignore points found beyond the mesh boundary.
@@ -151,12 +141,6 @@ protected:
    double     bdr_tol;
    // Use CPU functions for Mesh/GridFunction on device for gslib1.0.7
    bool       gpu_to_cpu_fallback = false;
-   // Check if a point is inside the oriented bounding box of an
-   // element before the Newton iteration.
-   // Note: only used in MFEM implementation (not in gslib) which currently
-   // supports GPU kernels for area meshes in 2D, volume meshes in 3D,
-   // and surface meshes in 1D/2D/3D.
-   bool       obb_check = true;
 
    // Device specific data used for FindPoints
    struct DEV_STRUCT
@@ -178,16 +162,11 @@ protected:
       mutable double surf_dist_tol;
    } DEV;
 
-   // Helper function to setup and free gslib's crystal router.
-   void SetupCrystal(); // Called inside Setup and SetupSurf_base
-   void FreeCrystal();  // Called inside FreeData
-
-   /// Use GSLIB for communication and interpolation. Updates field_out on
-   /// host.
+   /// Use GSLIB for communication and interpolation
    virtual void InterpolateH1(const GridFunction &field_in, Vector &field_out,
                               const int field_out_ordering);
    /// Uses GSLIB Crystal Router for communication followed by MFEM's
-   /// interpolation functions. Updates field_out on host.
+   /// interpolation functions
    virtual void InterpolateGeneral(const GridFunction &field_in,
                                    Vector &field_out,
                                    const int field_out_ordering);
@@ -202,26 +181,12 @@ protected:
                                                  IntegrationRule *irule,
                                                  int order);
 
-   /** @brief Build integration rules at the given @a order for each split mesh
-    *  and store them in @a ir_out. Requires that \ref SetupSplitMeshes has
-    *  already been called. */
-   virtual void SetupIntegrationRules(const int order,
-                                      Array<IntegrationRule *> &ir_out);
-
    /** @brief Helper function that calls \ref SetupSplitMeshes and
-    * \ref SetupIntegrationRules. */
+    * \ref SetupIntegrationRuleForSplitMesh. */
    virtual void SetupSplitMeshesAndIntegrationRules(const int order);
 
-   /** @brief Get GridFunction value at the points expected by GSLIB.
-    *  @param[in]  gf_in       Grid function to evaluate.
-    *  @param[out] node_vals   Output values.
-    *  @param[in]  ir_in       If non-null, use these rules instead of #ir_split.
-    *  @param[in]  by_element  If true, output has element-major layout
-    *                          [nel][vdim][ndofs]; otherwise component-major
-    *                          layout [vdim][total_pts]. */
-   virtual void GetNodalValues(const GridFunction *gf_in, Vector &node_vals,
-                               const Array<IntegrationRule *> *ir_in = nullptr,
-                               bool by_element = false) const;
+   /// Get GridFunction value at the points expected by GSLIB.
+   virtual void GetNodalValues(const GridFunction *gf_in, Vector &node_vals) const;
 
    /** @brief Map {r,s,t} coordinates from [-1,1] to [0,1] for MFEM. For
     *  simplices, find the original element number (that was split into
@@ -326,60 +291,29 @@ protected:
    void findptsedge_setup_2(DEV_STRUCT &devs,
                             const double *const elx[2],
                             const unsigned n,
-                            const unsigned int nel,
+                            const uint nel,
                             const unsigned m,
-                            const double bbox_rel_size_inc,
-                            const unsigned int local_hash_size,
-                            const unsigned int global_hash_size,
-                            const Vector *aabb_sz_inc);
+                            const double bbox_tol,
+                            const uint local_hash_size,
+                            const uint global_hash_size);
 
    /// Preprocess 3D surface mesh needed for FindPoints.
    void findptssurf_setup_3(DEV_STRUCT &devs,
                             const double *const elx[3],
                             const unsigned n,
-                            const unsigned int nel,
+                            const uint nel,
                             const unsigned m,
-                            const double bbox_rel_size_inc,
-                            const unsigned int local_hash_size,
-                            const unsigned int global_hash_size,
-                            const int rD,
-                            const Vector *aabb_sz_inc);
+                            const double bbox_tol,
+                            const uint local_hash_size,
+                            const uint global_hash_size,
+                            const int rD);
 
-   /** @brief Shared implementation for the public surface-setup methods.
-    *
-    *  @details Initializes the surface-search data structures, builds the
-    *  split-element representation expected by gslib, and constructs the
-    *  element bounding boxes used by the MFEM surface kernels.
-    *
-    *  If @a aabb_sz_inc is null, the setup stores the default oriented
-    *  bounding boxes and uses @a bbox_rel_size_inc as their relative size
-    *  increase factor.
-    *
-    *  If @a aabb_sz_inc is non-null, the setup stores axis-aligned bounding
-    *  boxes only, applies the requested absolute AABB expansion in each
-    *  physical direction, and adjusts the tolerance @a bdr_tol so points
-    *  found in the expanded region are classified as border points.
-    *
-    *  @param[in] m                  Input surface mesh.
-    *  @param[in] bbox_rel_size_inc  Relative size increase applied when
-    *                                expanding each element bounding box during
-    *                                setup.
-    *  @param[in] aabb_sz_inc        Optional total absolute AABB expansion
-    *                                applied to the stored axis-aligned
-    *                                bounding boxes after construction.
-    *  @param[in] newt_tol           Newton tolerance for the point-search
-    *                                kernels.
-    */
-   void SetupSurf_Base(Mesh &m,
-                       const double bbox_rel_size_inc,
-                       const Vector *aabb_sz_inc,
-                       const double newt_tol);
 public:
    /// Serial constructor
    FindPointsGSLIB();
 
    /// Serial constructor + setup with given Mesh (see \ref Setup)
-   FindPointsGSLIB(Mesh &mesh_in, const double bbox_rel_size_inc = 0.1,
+   FindPointsGSLIB(Mesh &mesh_in, const double bb_t = 0.1,
                    const double newt_tol = 1.0e-12,
                    const int npt_max = 256);
 
@@ -388,7 +322,7 @@ public:
    FindPointsGSLIB(MPI_Comm comm_);
 
    /// Constructor + setup with given ParMesh (see \ref Setup)
-   FindPointsGSLIB(ParMesh &mesh_in, const double bbox_rel_size_inc = 0.1,
+   FindPointsGSLIB(ParMesh &mesh_in, const double bb_t = 0.1,
                    const double newt_tol = 1.0e-12,
                    const int npt_max = 256);
 #endif
@@ -404,59 +338,23 @@ public:
        Note: not tested with periodic (L2).
        Note: the input mesh \p m must have Nodes set.
 
-       @param[in] m                  Input mesh.
-       @param[in] bbox_rel_size_inc  (Optional) Relative size increase applied
-                                     when expanding each element bounding box.
-       @param[in] newt_tol           (Optional) Newton tolerance for the gslib
-                                     search methods.
-       @param[in] npt_max            (Optional) Number of points for
-                                     simultaneous iteration. This alters
-                                     performance and memory footprint.
+       @param[in] m         Input mesh.
+       @param[in] bb_t      (Optional) Relative size of bounding box around
+                            each element.
+       @param[in] newt_tol  (Optional) Newton tolerance for the gslib
+                            search methods.
+       @param[in] npt_max   (Optional) Number of points for simultaneous
+                            iteration. This alters performance and
+                            memory footprint.
    */
-   void Setup(Mesh &m, const double bbox_rel_size_inc = 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);
 
    /// Preprocess the surface mesh to compute data for FindPoints.
    void SetupSurf(Mesh &m,
-                  const double bbox_rel_size_inc = 0.1,
-                  const double newt_tol = 1.0e-12);
-
-   /** @brief Preprocess the surface mesh to compute data for FindPoints using
-    *  absolute AABB expansion.
-    *
-    *  @details This method computes only axis-aligned bounding boxes and
-    *  increases their total length by a user-specified amount in each
-    *  physical direction. The absolute AABB expansion is applied
-    *  symmetrically to the lower and upper bounds.
-    *
-    *  The size of @a aabb_sz_inc determines how the expansion values are
-    *  interpreted:
-    *  - `1`: one expansion value used in every direction for every element
-    *  - `NElements`: one expansion value per element, reused in x/y/z
-    *    directions
-    *  - `SpaceDim`: one expansion value per physical direction, reused for
-    *    every element
-    *  - `NElements*SpaceDim`: one expansion value per element and direction,
-    *    ordered as `(dx1,dy1,dz1, ... dxN,dyN,dzN)`
-    *
-    *  This method disables the oriented bounding-box precheck because the
-    *  stored boxes are modified only in their axis-aligned representation.
-    *
-    *  @param[in] m                  Input surface mesh.
-    *  @param[in] aabb_sz_inc        Total absolute AABB expansion applied in
-    *                                each physical direction to the stored
-    *                                axis-aligned bounding boxes.
-    *  @param[in] newt_tol           Newton tolerance for the point-search
-    *                                kernels.
-    *
-    *  @note We disable the oriented bounding box check with this setup.
-    *        @a bdr_tol is also adjusted so that all points in the AABBs can
-    *        be found.
-    */
-   void SetupSurfWithAABBExpansion(Mesh &m, const Vector &aabb_sz_inc,
-                                   const double newt_tol = 1.0e-12);
-
+                  const double bb_t = 0.1,
+                  const double newt_tol = 1.0e-12,
+                  const int npt_max = 256);
 
    /** @brief Searches positions given in physical space by \p point_pos.
 
@@ -503,8 +401,7 @@ public:
    /// Setup FindPoints and search positions
    void FindPoints(Mesh &m, const Vector &point_pos,
                    const int point_pos_ordering = Ordering::byNODES,
-                   const double bbox_rel_size_inc = 0.1,
-                   const double newt_tol = 1.0e-12,
+                   const double bb_t = 0.1, const double newt_tol = 1.0e-12,
                    const int npt_max = 256);
 
    /** @brief Interpolation of field values at prescribed reference space
@@ -516,11 +413,7 @@ public:
                               mesh that was given to Setup().
        @param[out] field_out  Interpolated values. For points that are not found
                               the value is set to #default_interp_value.
-                              The output ordering is determined from field_in.
-
-       @note: field_out is moved to device if field_in is on device. Otherwise,
-              field_out memory allocation is not changed.
-   */
+                              The output ordering is determined from field_in.*/
    virtual void Interpolate(const GridFunction &field_in, Vector &field_out);
 
    /// Interpolation of field values, with output ordering specification.
@@ -575,12 +468,7 @@ public:
     *  @details When using FindPoints, gslib may return points as found on the
     *  boundary even when they are slightly outside the domain. This tolerance
     *  is used to filter such points based on the distance^2 value and mark them
-    *  as not found.
-    *
-    *  @note When the SetupSurfWithAABBExpansion method is used for surface
-    *  meshes, this tolerance is automatically computed based on the size of
-    *  expanded AABBs. Using this method will override that computed tolerance.
-    *  */
+    *  as not found.*/
    virtual void SetDistanceToleranceForPointsFoundOnBoundary(double bdr_tol_)
    {
       bdr_tol = bdr_tol_;
@@ -715,28 +603,25 @@ public:
        Note: not tested with periodic meshes (L2).
        Note: the input mesh \p m must have Nodes set.
 
-       @param[in] m                  Input mesh.
-       @param[in] meshid             A unique # for each overlapping mesh.
-                                     This id is used to make sure that points
-                                     being searched are not looked for in the
-                                     mesh that they belong to.
-       @param[in] gfmax              (Optional) GridFunction in H1 that is used
-                                     as a discriminator when one point is
-                                     located in multiple meshes. The mesh that
-                                     maximizes gfmax is chosen. For example,
-                                     using the distance field based on the
-                                     overlapping boundaries is helpful for
-                                     convergence during Schwarz iterations.
-       @param[in] bbox_rel_size_inc  (Optional) Relative size increase applied
-                                     when expanding each element bounding box.
-       @param[in] newt_tol           (Optional) Newton tolerance for the gslib
-                                     search methods.
-       @param[in] npt_max            (Optional) Number of points for
-                                     simultaneous iteration. This alters
-                                     performance and memory footprint.*/
-   void Setup(Mesh &m, const int meshid, GridFunction *gfmax = nullptr,
-              const double bbox_rel_size_inc = 0.1,
-              const double newt_tol = 1.0e-12,
+       @param[in] m         Input mesh.
+       @param[in] meshid    A unique # for each overlapping mesh. This id is
+                            used to make sure that points being searched are not
+                            looked for in the mesh that they belong to.
+       @param[in] gfmax     (Optional) GridFunction in H1 that is used as a
+                            discriminator when one point is located in multiple
+                            meshes. The mesh that maximizes gfmax is chosen.
+                            For example, using the distance field based on the
+                            overlapping boundaries is helpful for convergence
+                            during Schwarz iterations.
+       @param[in] bb_t      (Optional) Relative size of bounding box around
+                            each element.
+       @param[in] newt_tol  (Optional) Newton tolerance for the gslib
+                            search methods.
+       @param[in] npt_max   (Optional) Number of points for simultaneous
+                            iteration. This alters performance and
+                            memory footprint.*/
+   void Setup(Mesh &m, const int meshid, GridFunction *gfmax = NULL,
+              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. All output
@@ -792,7 +677,7 @@ class GSOPGSLIB
 protected:
    struct gslib::crystal *cr;               // gslib's internal data
    struct gslib::comm *gsl_comm;            // gslib's internal data
-   struct gslib::gs_data *gsl_data = nullptr;
+   struct gslib::gs_data *gsl_data = NULL;
    int num_ids;
 
 public:

fem/gslib/findpts_local_2.cpp

@@ -11,7 +11,7 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
+#include "../../linalg/kernels.hpp"
 
 #ifdef MFEM_USE_GSLIB
 
@@ -27,6 +27,8 @@
 #pragma GCC diagnostic pop
 #endif
 
+#include <climits>
+
 namespace mfem
 {
 #if GSLIB_RELEASE_VERSION >= 10009
@@ -52,14 +54,127 @@ struct findptsElementGPT_t
    double x[DIM], jac[DIM * DIM], hes[4];
 };
 
-using dbl_range_t = gslib::dbl_range_t;
-using obbox_t = gslib::obbox_t<DIM>;
-using findptsLocalHashData_t = gslib::findptsLocalHashData_t<DIM>;
-using gslib::bbox_test;
-using gslib::hash_index;
-using gslib::l2norm2;
-using gslib::lag_eval_first_der;
-using gslib::lag_eval_second_der;
+struct dbl_range_t
+{
+   double min, max;
+};
+struct obbox_t
+{
+   double c0[DIM], A[DIM * DIM];
+   dbl_range_t x[DIM];
+};
+
+struct findptsLocalHashData_t
+{
+   int hash_n;
+   dbl_range_t bnd[DIM];
+   double fac[DIM];
+   unsigned int *offset;
+   int max;
+};
+
+// Eval the ith Lagrange interpolant and its first derivative at x.
+// Note: lCoeff stores pre-computed coefficients for fast evaluation.
+static MFEM_HOST_DEVICE inline void lag_eval_first_der(double *p0, double x,
+                                                       int i, const double *z,
+                                                       const double *lCoeff,
+                                                       int pN)
+{
+   double u0 = 1, u1 = 0;
+   for (int j = 0; j < pN; ++j)
+   {
+      if (i != j)
+      {
+         double d_j = 2 * (x - z[j]);
+         u1 = d_j * u1 + u0;
+         u0 = d_j * u0;
+      }
+   }
+   p0[i] = lCoeff[i] * u0;
+   p0[pN+i] = 2.0 * lCoeff[i] * u1;
+}
+
+// Eval the ith Lagrange interpolant and its first and second derivative at x.
+// Note: lCoeff stores pre-computed coefficients for fast evaluation.
+static MFEM_HOST_DEVICE inline void lag_eval_second_der(double *p0, double x,
+                                                        int i, const double *z,
+                                                        const double *lCoeff,
+                                                        int pN)
+{
+   double u0 = 1, u1 = 0, u2 = 0;
+   for (int j = 0; j < pN; ++j)
+   {
+      if (i != j)
+      {
+         double d_j = 2 * (x - z[j]);
+         u2 = d_j * u2 + u1;
+         u1 = d_j * u1 + u0;
+         u0 = d_j * u0;
+      }
+   }
+   p0[i] = lCoeff[i] * u0;
+   p0[pN+i] = 2.0 * lCoeff[i] * u1;
+   p0[2*pN+i] = 8.0 * lCoeff[i] * u2;
+}
+
+// Axis-aligned bounding box test.
+static MFEM_HOST_DEVICE inline double AABB_test(const obbox_t *const b,
+                                                const double x[2])
+{
+   double test = 1;
+   for (int d = 0; d < 2; ++d)
+   {
+      double b_d = (x[d] - b->x[d].min) * (b->x[d].max - x[d]);
+      test = test < 0 ? test : b_d;
+   }
+   return test;
+}
+
+// Axis-aligned bounding box test followed by oriented bounding-box test.
+static MFEM_HOST_DEVICE inline double bbox_test(const obbox_t *const b,
+                                                const double x[2])
+{
+   const double bxyz = AABB_test(b, x);
+   if (bxyz < 0)
+   {
+      return bxyz;
+   }
+   else
+   {
+      double dxyz[2];
+      for (int d = 0; d < 2; ++d)
+      {
+         dxyz[d] = x[d] - b->c0[d];
+      }
+      double test = 1;
+      for (int d = 0; d < 2; ++d)
+      {
+         double rst = 0;
+         for (int e = 0; e < 2; ++e)
+         {
+            rst += b->A[d * 2 + e] * dxyz[e];
+         }
+         double brst = (rst + 1) * (1 - rst);
+         test = test < 0 ? test : brst;
+      }
+      return test;
+   }
+}
+
+// Element index corresponding to hash mesh that the point is located in.
+static MFEM_HOST_DEVICE inline int hash_index(const findptsLocalHashData_t *p,
+                                              const double x[2])
+{
+   const int n = p->hash_n;
+   int sum = 0;
+   for (int d = 2 - 1; d >= 0; --d)
+   {
+      sum *= n;
+      int i = (int)floor((x[d] - p->bnd[d].min) * p->fac[d]);
+      sum += i < 0 ? 0 : (n - 1 < i ? n - 1 : i);
+   }
+   return sum;
+}
 
 /*Solve Ax=y. A is row-major */
 static MFEM_HOST_DEVICE inline void lin_solve_2(double x[2], const double A[4],
@@ -70,6 +185,12 @@ static MFEM_HOST_DEVICE inline void lin_solve_2(double x[2], const double A[4],
    x[1] = idet*(A[0]*y[1] - A[2]*y[0]);
 }
 
+/* L2 norm squared. */
+static MFEM_HOST_DEVICE inline double l2norm2(const double x[2])
+{
+   return x[0] * x[0] + x[1] * x[1];
+}
+
 /* the bit structure of flags is CSSRR
    the C bit --- 1<<4 --- is set when the point is converged
    RR is 0 = 00b if r is unconstrained,
@@ -231,7 +352,7 @@ static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *res,
                                                  const findptsElementPoint_t *p,
                                                  const double tol)
 {
-   const double dist2 = l2norm2<2>(resid);
+   const double dist2 = l2norm2(resid);
    const double decr = p->dist2 - dist2;
    const double pred = p->dist2p;
    for (int d = 0; d < 2; ++d)
@@ -574,25 +695,25 @@ static MFEM_HOST_DEVICE double tensor_ig2_j(double *g_partials,
 }
 
 template<int T_D1D = 0>
-static void FindPointsLocal2DKernel(const int npt,
-                                    const double tol,
-                                    const double *x,
-                                    const int point_pos_ordering,
-                                    const double *xElemCoord,
-                                    const int nel,
-                                    const double *wtend,
-                                    const double *boxinfo,
-                                    const int hash_n,
-                                    const double *hashMin,
-                                    const double *hashFac,
-                                    unsigned int *hashOffset,
-                                    unsigned int *const code_base,
-                                    unsigned int *const el_base,
-                                    double *const r_base,
-                                    double *const dist2_base,
-                                    const double *gll1D,
-                                    const double *lagcoeff,
-                                    const int pN = 0)
+static void FindPointsLocal2D_Kernel(const int npt,
+                                     const double tol,
+                                     const double *x,
+                                     const int point_pos_ordering,
+                                     const double *xElemCoord,
+                                     const int nel,
+                                     const double *wtend,
+                                     const double *boxinfo,
+                                     const int hash_n,
+                                     const double *hashMin,
+                                     const double *hashFac,
+                                     unsigned int *hashOffset,
+                                     unsigned int *const code_base,
+                                     unsigned int *const el_base,
+                                     double *const r_base,
+                                     double *const dist2_base,
+                                     const double *gll1D,
+                                     const double *lagcoeff,
+                                     const int pN = 0)
 {
    const int MD1 = T_D1D ? T_D1D : DofQuadLimits::MAX_D1D;
    const int D1D = T_D1D ? T_D1D : pN;
@@ -1054,45 +1175,30 @@ void FindPointsGSLIB::FindPointsLocal2(const Vector &point_pos,
    switch (DEV.dof1d)
    {
       case 2:
-         FindPointsLocal2DKernel<2>(npt, DEV.newt_tol, pp,
-                                    point_pos_ordering, pgslm,
-                                    NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist,
-                                    pgll1d, plc);
-         break;
+         return FindPointsLocal2D_Kernel<2>(
+                   npt, DEV.newt_tol, pp, point_pos_ordering, pgslm, NE_split_total, pwt,
+                   pbb, DEV.lh_nx, plhm, plhf, plho, pcode, pelem, pref, pdist,
+                   pgll1d, plc);
       case 3:
-         FindPointsLocal2DKernel<3>(npt, DEV.newt_tol, pp,
-                                    point_pos_ordering, pgslm,
-                                    NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist,
-                                    pgll1d, plc);
-         break;
+         return FindPointsLocal2D_Kernel<3>(
+                   npt, DEV.newt_tol, pp, point_pos_ordering, pgslm, NE_split_total, pwt,
+                   pbb, DEV.lh_nx, plhm, plhf, plho, pcode, pelem, pref, pdist,
+                   pgll1d, plc);
       case 4:
-         FindPointsLocal2DKernel<4>(npt, DEV.newt_tol, pp,
-                                    point_pos_ordering, pgslm,
-                                    NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist,
-                                    pgll1d, plc);
-         break;
+         return FindPointsLocal2D_Kernel<4>(
+                   npt, DEV.newt_tol, pp, point_pos_ordering, pgslm, NE_split_total, pwt,
+                   pbb, DEV.lh_nx, plhm, plhf, plho, pcode, pelem, pref, pdist,
+                   pgll1d, plc);
       case 5:
-         FindPointsLocal2DKernel<5>(npt, DEV.newt_tol, pp,
-                                    point_pos_ordering, pgslm,
-                                    NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist,
-                                    pgll1d, plc);
-         break;
+         return FindPointsLocal2D_Kernel<5>(
+                   npt, DEV.newt_tol, pp, point_pos_ordering, pgslm, NE_split_total, pwt,
+                   pbb, DEV.lh_nx, plhm, plhf, plho, pcode, pelem, pref, pdist,
+                   pgll1d, plc);
       default:
-         FindPointsLocal2DKernel(npt, DEV.newt_tol, pp,
-                                 point_pos_ordering, pgslm,
-                                 NE_split_total, pwt, pbb,
-                                 DEV.lh_nx, plhm, plhf, plho,
-                                 pcode, pelem, pref, pdist,
-                                 pgll1d, plc, DEV.dof1d);
-         break;
+         return FindPointsLocal2D_Kernel(npt, DEV.newt_tol, pp, point_pos_ordering,
+                                         pgslm, NE_split_total, pwt, pbb, DEV.lh_nx,
+                                         plhm, plhf, plho, pcode, pelem,
+                                         pref, pdist, pgll1d, plc, DEV.dof1d);
    }
 }
 #undef DIM2

fem/gslib/findpts_local_3.cpp

@@ -11,7 +11,9 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
+#include "../../linalg/kernels.hpp"
+
+#include <climits>
 
 #ifdef MFEM_USE_GSLIB
 
@@ -57,15 +59,128 @@ struct findptsElemPt
    double x[DIM], jac[DIM * DIM], hes[18];
 };
 
-using dbl_range_t = gslib::dbl_range_t;
-using obbox_t = gslib::obbox_t<DIM>;
-using findptsLocalHashData_t = gslib::findptsLocalHashData_t<DIM>;
-using gslib::bbox_test;
-using gslib::hash_index;
-using gslib::l2norm2;
-using gslib::lag_eval_first_der;
-using gslib::lag_eval_second_der;
-using gslib::lin_solve_sym_2;
+struct dbl_range_t
+{
+   double min, max;
+};
+
+struct obbox_t
+{
+   double c0[DIM], A[DIM * DIM];
+   dbl_range_t x[DIM];
+};
+
+struct findptsLocalHashData_t
+{
+   int hash_n;
+   dbl_range_t bnd[DIM];
+   double fac[DIM];
+   unsigned int *offset;
+   // int max;
+};
+
+// Eval the ith Lagrange interpolant and its first derivative at x.
+// Note: lCoeff stores pre-computed coefficients for fast evaluation.
+static MFEM_HOST_DEVICE inline void lag_eval_first_der(double *p0, double x,
+                                                       int i, const double *z,
+                                                       const double *lCoeff,
+                                                       int pN)
+{
+   double u0 = 1, u1 = 0;
+   for (int j = 0; j < pN; ++j)
+   {
+      if (i != j)
+      {
+         double d_j = 2*(x-z[j]);
+         u1 = d_j*u1+u0;
+         u0 = d_j*u0;
+      }
+   }
+   p0[i] = lCoeff[i]*u0;
+   p0[pN+i] = 2.0*lCoeff[i]*u1;
+}
+
+// Eval the ith Lagrange interpolant and its first and second derivative at x.
+// Note: lCoeff stores pre-computed coefficients for fast evaluation.
+static MFEM_HOST_DEVICE inline void lag_eval_second_der(double *p0, double x,
+                                                        int i, const double *z,
+                                                        const double *lCoeff,
+                                                        int pN)
+{
+   double u0 = 1, u1 = 0, u2 = 0;
+   for (int j = 0; j < pN; ++j)
+   {
+      if (i != j)
+      {
+         double d_j = 2*(x-z[j]);
+         u2 = d_j*u2+u1;
+         u1 = d_j*u1+u0;
+         u0 = d_j*u0;
+      }
+   }
+   p0[i] = lCoeff[i]*u0;
+   p0[pN+i] = 2.0*lCoeff[i]*u1;
+   p0[2*pN+i] = 8.0*lCoeff[i]*u2;
+}
+
+// Axis-aligned bounding box test.
+static MFEM_HOST_DEVICE inline double AABB_test(const obbox_t *const b,
+                                                const double x[3])
+{
+   double b_d;
+   for (int d = 0; d < 3; ++d)
+   {
+      b_d = (x[d]-b->x[d].min)*(b->x[d].max-x[d]);
+      if (b_d < 0) { return b_d; }
+   }
+   return b_d;
+}
+
+// Axis-aligned bounding box test followed by oriented bounding-box test.
+static MFEM_HOST_DEVICE inline double bbox_test(const obbox_t *const b,
+                                                const double x[3])
+{
+   const double bxyz = AABB_test(b, x);
+   if (bxyz < 0)
+   {
+      return bxyz;
+   }
+   else
+   {
+      double dxyz[3];
+      for (int d = 0; d < 3; ++d)
+      {
+         dxyz[d] = x[d]-b->c0[d];
+      }
+      double test = 1;
+      for (int d = 0; d < 3; ++d)
+      {
+         double rst = 0;
+         for (int e = 0; e < 3; ++e)
+         {
+            rst += b->A[d*3+e]*dxyz[e];
+         }
+         double brst = (rst+1)*(1-rst);
+         test = test < 0 ? test : brst;
+      }
+      return test;
+   }
+}
+
+// Element index corresponding to hash mesh that the point is located in.
+static MFEM_HOST_DEVICE inline int hash_index(const findptsLocalHashData_t *p,
+                                              const double x[3])
+{
+   const int n = p->hash_n;
+   int sum = 0;
+   for (int d = 3-1; d >= 0; --d)
+   {
+      sum *= n;
+      int i = (int)floor((x[d]-p->bnd[d].min)*p->fac[d]);
+      sum += i < 0 ? 0 : (n-1 < i ? n-1 : i);
+   }
+   return sum;
+}
 
 // Solve Ax=y. A is row-major.
 static MFEM_HOST_DEVICE inline void lin_solve_3(double x[3], const double A[9],
@@ -84,6 +199,22 @@ static MFEM_HOST_DEVICE inline void lin_solve_3(double x[3], const double A[9],
    x[2] = idet*(inv6*y[0]+inv7*y[1]+inv8*y[2]);
 }
 
+// Solve Ax=y. A is a symmetric 2x2 matrix.
+static MFEM_HOST_DEVICE inline void lin_solve_sym_2(double x[2],
+                                                    const double A[3],
+                                                    const double y[2])
+{
+   const double idet = 1 / (A[0]*A[2]-A[1]*A[1]);
+   x[0] = idet*(A[2]*y[0]-A[1]*y[1]);
+   x[1] = idet*(A[0]*y[1]-A[1]*y[0]);
+}
+
+// L2 norm.
+static MFEM_HOST_DEVICE inline double l2norm2(const double x[3])
+{
+   return x[0]*x[0]+x[1]*x[1]+x[2]*x[2];
+}
+
 /* the bit structure of flags is CTTSSRR
    the C bit --- 1<<6 --- is set when the point is converged
    RR is 0 = 00b if r is unconstrained,
@@ -328,7 +459,7 @@ static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsPt *res,
                                                  const findptsPt *p,
                                                  const double tol)
 {
-   const double dist2 = l2norm2<3>(resid);
+   const double dist2 = l2norm2(resid);
    const double decr = p->dist2-dist2;
    const double pred = p->dist2p;
    for (int d = 0; d < 3; ++d)
@@ -1678,36 +1809,33 @@ void FindPointsGSLIB::FindPointsLocal3(const Vector &point_pos,
    {
       case 2:
          FindPointsLocal3DKernel<2>(npt, DEV.newt_tol, pp, point_pos_ordering,
-                                    pgslm, NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist, pgll1d, plc);
+                                    pgslm, NE_split_total, pwt, pbb, DEV.lh_nx, plhm,
+                                    plhf, plho, pcode, pelem, pref, pdist, pgll1d,
+                                    plc);
          break;
       case 3:
          FindPointsLocal3DKernel<3>(npt, DEV.newt_tol, pp, point_pos_ordering,
-                                    pgslm, NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist, pgll1d, plc);
+                                    pgslm, NE_split_total, pwt, pbb, DEV.lh_nx, plhm,
+                                    plhf, plho, pcode, pelem, pref, pdist, pgll1d,
+                                    plc);
          break;
       case 4:
          FindPointsLocal3DKernel<4>(npt, DEV.newt_tol, pp, point_pos_ordering,
-                                    pgslm, NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist, pgll1d, plc);
+                                    pgslm, NE_split_total, pwt, pbb, DEV.lh_nx, plhm,
+                                    plhf, plho, pcode, pelem, pref, pdist, pgll1d,
+                                    plc);
          break;
       case 5:
          FindPointsLocal3DKernel<5>(npt, DEV.newt_tol, pp, point_pos_ordering,
-                                    pgslm, NE_split_total, pwt, pbb,
-                                    DEV.lh_nx, plhm, plhf, plho,
-                                    pcode, pelem, pref, pdist, pgll1d, plc);
+                                    pgslm, NE_split_total, pwt, pbb, DEV.lh_nx, plhm,
+                                    plhf, plho, pcode, pelem, pref, pdist, pgll1d,
+                                    plc);
          break;
       default:
-         FindPointsLocal3DKernel(npt, DEV.newt_tol, pp,
-                                 point_pos_ordering, pgslm,
-                                 NE_split_total, pwt, pbb,
-                                 DEV.lh_nx, plhm, plhf, plho,
-                                 pcode, pelem, pref, pdist, pgll1d, plc,
+         FindPointsLocal3DKernel(npt, DEV.newt_tol, pp, point_pos_ordering, pgslm,
+                                 NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                                 plho, pcode, pelem, pref, pdist, pgll1d, plc,
                                  DEV.dof1d);
-         break;
    }
 }
 #undef pMax

fem/gslib/findptsedge_local_2.cpp

@@ -11,7 +11,6 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
 
 #ifdef MFEM_USE_GSLIB
 
@@ -53,14 +52,113 @@ struct findptsElementGPT_t
    double x[sDIM], jac[sDIM*rDIM], hes[sDIM*rDIM];
 };
 
-using dbl_range_t = gslib::dbl_range_t;
-using obbox_t = gslib::obbox_t<sDIM>;
-using findptsLocalHashData_t = gslib::findptsLocalHashData_t<sDIM>;
-using gslib::AABB_test;
-using gslib::bbox_test;
-using gslib::hash_index;
-using gslib::l2norm2;
-using gslib::lag_eval_second_der;
+struct dbl_range_t
+{
+   double min, max;
+};
+
+struct obbox_t
+{
+   double c0[sDIM], A[sDIM*sDIM];
+   dbl_range_t x[sDIM];
+};
+
+struct findptsLocalHashData_t
+{
+   int hash_n;
+   dbl_range_t bnd[sDIM];
+   double fac[sDIM];
+   unsigned int *offset;
+};
+
+static MFEM_HOST_DEVICE inline void lag_eval_second_der(double *p0, double x,
+                                                        int i, const double *z,
+                                                        const double *lCoeff,
+                                                        int pN)
+{
+   double u0 = 1, u1 = 0, u2 = 0;
+   for (int j = 0; j < pN; ++j)
+   {
+      if (i != j)
+      {
+         double d_j = 2 * (x-z[j]);
+         u2 = d_j * u2 + u1;
+         u1 = d_j * u1 + u0;
+         u0 = d_j * u0;
+      }
+   }
+   double *p1 = p0 + pN, *p2 = p0 + 2 * pN;
+   p0[i] = lCoeff[i] * u0;
+   p1[i] = 2.0 * lCoeff[i] * u1;
+   p2[i] = 8.0 * lCoeff[i] * u2;
+}
+
+/* positive when possibly inside */
+static MFEM_HOST_DEVICE inline double obbox_axis_test(const obbox_t *const b,
+                                                      const double x[sDIM])
+{
+   double b_d;
+   for (int d=0; d<sDIM; ++d)
+   {
+      b_d = (x[d] - b->x[d].min) * (b->x[d].max - x[d]);
+      if (b_d < 0)   // if outside in any dimension
+      {
+         return b_d;
+      }
+   }
+   return b_d;       // only positive if inside
+}
+
+/* positive when given point is possibly inside given obbox b */
+static MFEM_HOST_DEVICE inline double obbox_test(const obbox_t *const b,
+                                                 const double x[sDIM])
+{
+   const double bxyz = obbox_axis_test(b,x);
+   if (bxyz<0)   // test if point is in AABB
+   {
+      return bxyz;
+   }
+   else   // test OBB only if inside AABB
+   {
+      double dxyz[sDIM];
+      for (int d=0; d<sDIM; ++d)
+      {
+         dxyz[d] = x[d] - b->c0[d];
+      }
+      double test = 1;
+      for (int d=0; d<sDIM; ++d)
+      {
+         double rst = 0;
+         for (int e=0; e<sDIM; ++e)
+         {
+            rst += b->A[d*2 + e] * dxyz[e];
+         }
+         double brst = (rst+1)*(1-rst);
+         test = test<0 ? test : brst;
+      }
+      return test;
+   }
+}
+
+/* Hash index in the hash table to the elements that possibly contain the point x */
+static MFEM_HOST_DEVICE inline int hash_index(const findptsLocalHashData_t *p,
+                                              const double x[2])
+{
+   const int n = p->hash_n;
+   int sum = 0;
+   for (int d=sDIM-1; d>=0; --d)
+   {
+      sum *= n;
+      int i = (int)floor((x[d] - p->bnd[d].min) * p->fac[d]);
+      sum += i<0 ? 0 : (n-1 < i ? n-1 : i);
+   }
+   return sum;
+}
+
+static MFEM_HOST_DEVICE inline double l2norm2(const double x[2])
+{
+   return x[0] * x[0] + x[1] * x[1];
+}
 
 /* the bit structure of flags is CRR
    the C bit --- 1<<2 --- is set when the point is converged
@@ -89,29 +187,29 @@ static MFEM_HOST_DEVICE inline int point_index(const int x)
 /* check reduction in objective against prediction, and adjust
    trust region radius (p->tr) accordingly;
    may reject the prior step, returning 1; otherwise returns 0
-   sets out_pt->dist2, out_pt->index, out_pt->x, out_pt->oldr in any event,
-   leaving out_pt->r, out_pt->dr, out_pt->flags to be set when returning 0 */
-static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out_pt,
+   sets out->dist2, out->index, out->x, out->oldr in any event,
+   leaving out->r, out->dr, out->flags to be set when returning 0 */
+static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out,
                                                  const double resid[2],
                                                  const findptsElementPoint_t *p,
                                                  const double tol)
 {
-   const double dist2 = l2norm2<2>(resid);
+   const double dist2 = l2norm2(resid);
    const double decr = p->dist2 - dist2;
    const double pred = p->dist2p;
-   out_pt->x[0] = p->x[0];
-   out_pt->x[1] = p->x[1];
-   out_pt->oldr = p->r;
-   out_pt->dist2 = dist2;
+   out->x[0] = p->x[0];
+   out->x[1] = p->x[1];
+   out->oldr = p->r;
+   out->dist2 = dist2;
    if (decr >= 0.01*pred)
    {
       if (decr >= 0.9*pred)   // very good iteration
       {
-         out_pt->tr = p->tr*2;
+         out->tr = p->tr*2;
       }
       else                    // somewhat good iteration
       {
-         out_pt->tr = p->tr;
+         out->tr = p->tr;
       }
       return false;
    }
@@ -122,21 +220,21 @@ static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out_pt,
          "very good iteration" --- this doubles the trust radius,
          which is why we divide by 4 below */
       double v0 = fabs(p->r - p->oldr);
-      out_pt->tr = v0/4.0;
-      out_pt->dist2 = p->dist2;
-      out_pt->r = p->oldr;
-      out_pt->flags = p->flags>>3;
-      out_pt->dist2p = -HUGE_VAL;
+      out->tr = v0/4.0;
+      out->dist2 = p->dist2;
+      out->r = p->oldr;
+      out->flags = p->flags>>3;
+      out->dist2p = -HUGE_VAL;
       if (pred < dist2*tol)
       {
-         out_pt->flags |= CONVERGED_FLAG;
+         out->flags |= CONVERGED_FLAG;
       }
       return true;
    }
 }
 
 static MFEM_HOST_DEVICE inline void newton_edge( findptsElementPoint_t *const
-                                                 out_pt,
+                                                 out,
                                                  const double jac[2],
                                                  const double rhess,
                                                  const double resid[2],
@@ -206,9 +304,9 @@ newton_edge_fin:
    {
       new_flags |= CONVERGED_FLAG;
    }
-   out_pt->r = newr;
-   out_pt->dist2p = -v;
-   out_pt->flags = flags | new_flags | ((p->flags & FLAG_MASK)<<3);
+   out->r = newr;
+   out->dist2p = -v;
+   out->flags = flags | new_flags | ((p->flags & FLAG_MASK)<<3);
 }
 
 static MFEM_HOST_DEVICE void seed_j( const double *elx[sDIM],
@@ -234,27 +332,26 @@ static MFEM_HOST_DEVICE void seed_j( const double *elx[sDIM],
 }
 
 template<int T_D1D = 0>
-static void FindPointsEdgeLocal2DKernel( const int     npt,
-                                         const double  tol,
-                                         const double  dist2tol,
-                                         const double  *x,
-                                         const int     point_pos_ordering,
-                                         const double  *xElemCoord,
-                                         const int     nel,
-                                         const double  *wtend,
-                                         const double  *boxinfo,
-                                         const bool    obb_check,
-                                         const int     hash_n,
-                                         const double  *hashMin,
-                                         const double  *hashFac,
-                                         unsigned int  *hashOffset,
-                                         unsigned int *const code_base,
-                                         unsigned int *const el_base,
-                                         double *const r_base,
-                                         double *const dist2_base,
-                                         const double  *gll1D,
-                                         const double  *lagcoeff,
-                                         const int     pN = 0 )
+static void FindPointsEdgeLocal2D_Kernel( const int     npt,
+                                          const double  tol,
+                                          const double  dist2tol,
+                                          const double  *x,
+                                          const int     point_pos_ordering,
+                                          const double  *xElemCoord,
+                                          const int     nel,
+                                          const double  *wtend,
+                                          const double  *boxinfo,
+                                          const int     hash_n,
+                                          const double  *hashMin,
+                                          const double  *hashFac,
+                                          unsigned int  *hashOffset,
+                                          unsigned int *const code_base,
+                                          unsigned int *const el_base,
+                                          double *const r_base,
+                                          double *const dist2_base,
+                                          const double  *gll1D,
+                                          const double  *lagcoeff,
+                                          const int     pN = 0 )
 {
    const int MD1   = T_D1D ? T_D1D : DofQuadLimits::MAX_D1D;
    const int D1D   = T_D1D ? T_D1D : pN;
@@ -315,34 +412,22 @@ static void FindPointsEdgeLocal2DKernel( const int     npt,
       {
          const unsigned int el = *elp;
 
-         const int n_box_ents = obb_check ? (3*sDIM + sDIM2) : (2*sDIM);
-         bool pass_bb = true;
          obbox_t box;
-         if (obb_check)
+         int n_box_ents = 3*sDIM + sDIM2;
+
+         for (int idx = 0; idx < sDIM; ++idx)
          {
-            for (int idx = 0; idx < sDIM; ++idx)
-            {
-               box.c0[idx] = boxinfo[n_box_ents*el + idx];
-               box.x[idx].min = boxinfo[n_box_ents*el + sDIM + idx];
-               box.x[idx].max = boxinfo[n_box_ents*el + 2*sDIM + idx];
-            }
-            for (int idx = 0; idx < sDIM2; ++idx)
-            {
-               box.A[idx] = boxinfo[n_box_ents*el + 3*sDIM + idx];
-            }
-            pass_bb = (bbox_test(&box, x_i) >= 0);
-         }
-         else
-         {
-            for (int d = 0; d < sDIM; ++d)
-            {
-               box.x[d].min = boxinfo[n_box_ents*el + d];
-               box.x[d].max = boxinfo[n_box_ents*el + sDIM + d];
-            }
-            pass_bb = (AABB_test(&box, x_i) >= 0);
+            box.c0[idx] = boxinfo[n_box_ents*el + idx];
+            box.x[idx].min = boxinfo[n_box_ents*el + sDIM + idx];
+            box.x[idx].max = boxinfo[n_box_ents*el + 2*sDIM + idx];
          }
 
-         if (pass_bb)
+         for (int idx = 0; idx < sDIM2; ++idx)
+         {
+            box.A[idx] = boxinfo[n_box_ents*el + 3*sDIM + idx];
+         }
+
+         if (obbox_test(&box,x_i)>=0)
          {
             //------------ findpts_local ------------------
             {
@@ -431,14 +516,11 @@ static void FindPointsEdgeLocal2DKernel( const int     npt,
                            double *hess = jac + sDIM*rDIM;
 
                            findptsElementGEdge_t edge;
-                           for (int d=0; d<sDIM; ++d)
-                           {
-                              edge.x[d] = constraint_workspace + d*D1D;
-                           }
                            MFEM_FOREACH_THREAD(j,x,D1D)
                            {
                               for (int d=0; d<sDIM; ++d)
                               {
+                                 edge.x[d] = constraint_workspace + d*D1D;
                                  edge.x[d][j] = elx[d][j];
                               }
                            }
@@ -599,41 +681,28 @@ void FindPointsGSLIB::FindPointsEdgeLocal2( const Vector &point_pos,
    auto pgll1d = DEV.gll1d.ReadWrite(use_dev);
    auto plc = DEV.lagcoeff.Read(use_dev);
    double dist2tol = DEV.surf_dist_tol;
-   const bool obb_chk = obb_check;
    switch (DEV.dof1d)
    {
       case 2:
-         FindPointsEdgeLocal2DKernel<2>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsEdgeLocal2D_Kernel<2>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       case 3:
-         FindPointsEdgeLocal2DKernel<3>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsEdgeLocal2D_Kernel<3>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       case 4:
-         FindPointsEdgeLocal2DKernel<4>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsEdgeLocal2D_Kernel<4>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       default:
-         FindPointsEdgeLocal2DKernel(npt, DEV.newt_tol, dist2tol, pp,
-                                     point_pos_ordering, pgslm,
-                                     NE_split_total, pwt, pbb, obb_chk,
-                                     DEV.lh_nx, plhm, plhf, plho,
-                                     pcode, pelem, pref, pdist,
-                                     pgll1d, plc, DEV.dof1d);
-         break;
+         return FindPointsEdgeLocal2D_Kernel(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc, DEV.dof1d);
    }
 }
 #undef sDIM

fem/gslib/findptsedge_local_3.cpp

@@ -11,7 +11,6 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
 
 #ifdef MFEM_USE_GSLIB
 
@@ -55,14 +54,117 @@ struct findptsElementGPT_t
    double x[sDIM], jac[sDIM], hes[sDIM*(1+1)];
 };
 
-using dbl_range_t = gslib::dbl_range_t;
-using obbox_t = gslib::obbox_t<sDIM>;
-using findptsLocalHashData_t = gslib::findptsLocalHashData_t<sDIM>;
-using gslib::AABB_test;
-using gslib::bbox_test;
-using gslib::hash_index;
-using gslib::l2norm2;
-using gslib::lag_eval_second_der;
+struct dbl_range_t
+{
+   double min, max;
+};
+
+struct obbox_t
+{
+   double c0[sDIM], A[sDIM*sDIM];
+   dbl_range_t x[sDIM];
+};
+
+struct findptsLocalHashData_t
+{
+   int hash_n;
+   dbl_range_t bnd[sDIM];
+   double fac[sDIM];
+   unsigned int *offset;
+};
+
+static MFEM_HOST_DEVICE inline void lag_eval_second_der(double *p0, double x,
+                                                        int i, const double *z,
+                                                        const double *lCoeff,
+                                                        int pN)
+{
+   double u0 = 1, u1 = 0, u2 = 0;
+   for (int j=0; j<pN; ++j)
+   {
+      if (i!=j)
+      {
+         double d_j = 2 * (x-z[j]);
+         u2 = d_j * u2 + u1;
+         u1 = d_j * u1 + u0;
+         u0 = d_j * u0;
+      }
+   }
+   double *p1 = p0 + pN, *p2 = p0 + 2 * pN;
+   p0[i] = lCoeff[i] * u0;
+   p1[i] = 2.0 * lCoeff[i] * u1;
+   p2[i] = 8.0 * lCoeff[i] * u2;
+}
+
+/* positive when possibly inside */
+static MFEM_HOST_DEVICE inline double obbox_axis_test(const obbox_t *const b,
+                                                      const double x[sDIM])
+{
+   double b_d;
+   for (int d=0; d<sDIM; ++d)
+   {
+      b_d = (x[d] - b->x[d].min) * (b->x[d].max - x[d]);
+      if (b_d < 0)   // if outside in any dimension
+      {
+         return b_d;
+      }
+   }
+   return b_d;       // only positive if inside in all dimensions
+}
+
+/* positive when possibly inside */
+static MFEM_HOST_DEVICE inline double obbox_test(const obbox_t *const b,
+                                                 const double x[sDIM])
+{
+   const double bxyz = obbox_axis_test(b, x);
+   if (bxyz<0)
+   {
+      return bxyz;
+   }
+   else
+   {
+      double dxyz[3];
+      // dxyz: distance of the point from the center of the OBB
+      for (int d=0; d<sDIM; ++d)
+      {
+         dxyz[d] = x[d] - b->c0[d];
+      }
+      // transform dxyz to the local coordinate system of the OBB,
+      // and check if the point is inside the OBB [-1,1]^sDIM
+      double test = 1;
+      for (int d=0; d<sDIM; ++d)
+      {
+         double rst = 0;
+         for (int e=0; e<sDIM; ++e)
+         {
+            rst += b->A[d*sDIM + e] * dxyz[e];
+         }
+         double brst = (rst+1)*(1-rst);
+         test = test<0 ? test : brst;
+      }
+      return test;
+   }
+}
+
+/* Hash index in the hash table to the elements that possibly contain the point x */
+static MFEM_HOST_DEVICE inline int hash_index(const findptsLocalHashData_t *p,
+                                              const double x[sDIM])
+{
+   const int n = p->hash_n;
+   int sum = 0;
+   for (int d=sDIM-1; d>=0; --d)
+   {
+      sum *= n;
+      int i = (int)floor((x[d] - p->bnd[d].min) * p->fac[d]);
+      sum += i<0 ? 0 : (n-1 < i ? n-1 : i);
+   }
+   return sum;
+}
+
+
+static MFEM_HOST_DEVICE inline double norm2(const double x[sDIM])
+{
+   return ( x[0]*x[0] + x[1]*x[1] + x[2]*x[2] );
+}
 
 /* the bit structure of flags is CRR
    the C bit --- 1<<2 --- is set when the point is converged
@@ -73,46 +175,47 @@ using gslib::lag_eval_second_der;
 #define CONVERGED_FLAG (1u<<2)
 #define FLAG_MASK 0x07u
 
-/* returns the number of constrained reference coordinates, max 1
+/* returns the number of constrained reference coordinates, max 2
 */
 static MFEM_HOST_DEVICE inline int num_constrained(const int flags)
 {
-   return ((flags | flags>>1) & 1u);
+   const int y = (flags | flags>>1);
+   return (y & 1u) + (y>>2 & 1u);
 }
 
 static MFEM_HOST_DEVICE inline int point_index(const int x)
 {
-   return ((x>>1)&1u);
+   return ((x>>1)&1u) | ((x>>2)&2u);
 }
 
 /* check reduction in objective against prediction, and adjust
    trust region radius (p->tr) accordingly;
    may reject the prior step, returning 1; otherwise returns 0
-   sets out_pt->dist2, out_pt->index, out_pt->x, out_pt->oldr in any event,
-   leaving out_pt->r, out_pt->dr, out_pt->flags to be set when returning 0 */
-static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out_pt,
+   sets out->dist2, out->index, out->x, out->oldr in any event,
+   leaving out->r, out->dr, out->flags to be set when returning 0 */
+static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out,
                                                  const double resid[3],
                                                  const findptsElementPoint_t *p,
                                                  const double tol)
 {
-   const double dist2 = l2norm2<sDIM>(resid);
+   const double dist2 = norm2(resid);
    const double decr  = p->dist2 - dist2;
    const double pred  = p->dist2p;
    for (int d=0; d<sDIM; ++d)
    {
-      out_pt->x[d] = p->x[d];
+      out->x[d] = p->x[d];
    }
-   out_pt->oldr = p->r;
-   out_pt->dist2 = dist2;
+   out->oldr = p->r;
+   out->dist2 = dist2;
    if (decr>=0.01*pred)
    {
       if (decr>=0.9*pred)   // very good iteration
       {
-         out_pt->tr = 2*p->tr;
+         out->tr = 2*p->tr;
       }
       else   // good iteration
       {
-         out_pt->tr = p->tr;
+         out->tr = p->tr;
       }
       return false;
    }
@@ -123,21 +226,21 @@ static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out_pt,
          "very good iteration" --- this doubles the trust radius,
          which is why we divide by 4 below */
       double v0 = fabs(p->r - p->oldr);
-      out_pt->tr = v0/4.0;
-      out_pt->dist2 = p->dist2;
-      out_pt->r = p->oldr;
-      out_pt->flags = p->flags>>3;
-      out_pt->dist2p = -HUGE_VAL;
+      out->tr = v0/4.0;
+      out->dist2 = p->dist2;
+      out->r = p->oldr;
+      out->flags = p->flags>>3;
+      out->dist2p = -HUGE_VAL;
       if (pred<dist2*tol)
       {
-         out_pt->flags |= CONVERGED_FLAG;
+         out->flags |= CONVERGED_FLAG;
       }
       return true;
    }
 }
 
 static MFEM_HOST_DEVICE inline void newton_edge(findptsElementPoint_t *const
-                                                out_pt,
+                                                out,
                                                 const double jac[sDIM*rDIM],
                                                 const double rhes,
                                                 const double resid[sDIM],
@@ -211,9 +314,9 @@ newton_edge_fin:
    {
       new_flags |= CONVERGED_FLAG;
    }
-   out_pt->r = nr;
-   out_pt->dist2p = -v;
-   out_pt->flags = flags | new_flags | ((p->flags & FLAG_MASK)<<3);
+   out->r = nr;
+   out->dist2p = -v;
+   out->flags = flags | new_flags | ((p->flags & FLAG_MASK)<<3);
 #undef EVAL
 }
 
@@ -235,32 +338,31 @@ static MFEM_HOST_DEVICE void seed_j(const double *elx[sDIM],
    {
       dx[d] = x[d] - elx[d][ir];
    }
-   dist2[ir] = l2norm2(dx);
+   dist2[ir] = norm2(dx);;
    r[ir] = z[ir];
 }
 
 template<int T_D1D = 0>
-static void FindPointsEdgeLocal3DKernel(const int npt,
-                                        const double tol,
-                                        const double dist2tol,
-                                        const double *x,
-                                        const int point_pos_ordering,
-                                        const double *xElemCoord,
-                                        const int nel,
-                                        const double *wtend,
-                                        const double *boxinfo,
-                                        const bool obb_check,
-                                        const int hash_n,
-                                        const double *hashMin,
-                                        const double *hashFac,
-                                        unsigned int *hashOffset,
-                                        unsigned int *const code_base,
-                                        unsigned int *const el_base,
-                                        double *const r_base,
-                                        double *const dist2_base,
-                                        const double *gll1D,
-                                        const double *lagcoeff,
-                                        const int pN = 0)
+static void FindPointsEdgeLocal3D_Kernel(const int npt,
+                                         const double tol,
+                                         const double dist2tol,
+                                         const double *x,
+                                         const int point_pos_ordering,
+                                         const double *xElemCoord,
+                                         const int nel,
+                                         const double *wtend,
+                                         const double *boxinfo,
+                                         const int hash_n,
+                                         const double *hashMin,
+                                         const double *hashFac,
+                                         unsigned int *hashOffset,
+                                         unsigned int *const code_base,
+                                         unsigned int *const el_base,
+                                         double *const r_base,
+                                         double *const dist2_base,
+                                         const double *gll1D,
+                                         const double *lagcoeff,
+                                         const int pN = 0)
 {
    const int MD1   = T_D1D ? T_D1D : DofQuadLimits::MAX_D1D;
    const int D1D   = T_D1D ? T_D1D : pN;
@@ -317,35 +419,21 @@ static void FindPointsEdgeLocal3DKernel(const int npt,
       for (; elp!=ele; ++elp)
       {
          const unsigned int el = *elp;
-
-         const int n_box_ents = obb_check ? (3*sDIM + sDIM2) : (2*sDIM);
-         bool pass_bb = true;
          obbox_t box;
-         if (obb_check)
+         int n_box_ents = 3*sDIM + sDIM2;
+
+         for (int idx = 0; idx < sDIM; ++idx)
          {
-            for (int idx = 0; idx < sDIM; ++idx)
-            {
-               box.c0[idx] = boxinfo[n_box_ents*el + idx];
-               box.x[idx].min = boxinfo[n_box_ents*el + sDIM + idx];
-               box.x[idx].max = boxinfo[n_box_ents*el + 2*sDIM + idx];
-            }
-            for (int idx = 0; idx < sDIM2; ++idx)
-            {
-               box.A[idx] = boxinfo[n_box_ents*el + 3*sDIM + idx];
-            }
-            pass_bb = (bbox_test(&box, x_i) >= 0);
+            box.c0[idx] = boxinfo[n_box_ents*el + idx];
+            box.x[idx].min = boxinfo[n_box_ents*el + sDIM + idx];
+            box.x[idx].max = boxinfo[n_box_ents*el + 2*sDIM + idx];
          }
-         else
+         for (int idx = 0; idx < sDIM2; ++idx)
          {
-            for (int d = 0; d < sDIM; ++d)
-            {
-               box.x[d].min = boxinfo[n_box_ents*el + d];
-               box.x[d].max = boxinfo[n_box_ents*el + sDIM + d];
-            }
-            pass_bb = (AABB_test(&box, x_i) >= 0);
+            box.A[idx] = boxinfo[n_box_ents*el + 3*sDIM + idx];
          }
 
-         if (pass_bb)
+         if (obbox_test(&box, x_i)>=0)
          {
             //// findpts_local ////
             {
@@ -433,14 +521,11 @@ static void FindPointsEdgeLocal3DKernel(const int npt,
                            double *hess = jac + sDIM*rDIM;
 
                            findptsElementGEdge_t edge;
-                           for (int d=0; d<sDIM; ++d)
-                           {
-                              edge.x[d] = constraint_workspace + d*D1D;
-                           }
                            MFEM_FOREACH_THREAD(j,x,D1D)
                            {
                               for (int d=0; d<sDIM; ++d)
                               {
+                                 edge.x[d] = constraint_workspace + d*D1D;
                                  edge.x[d][j] = elx[d][j];
                               }
                            }
@@ -603,41 +688,28 @@ void FindPointsGSLIB::FindPointsEdgeLocal3(const Vector &point_pos,
    auto pgll1d = DEV.gll1d.ReadWrite(use_dev);
    auto plc = DEV.lagcoeff.Read(use_dev);
    double dist2tol = DEV.surf_dist_tol;
-   const bool obb_chk = obb_check;
    switch (DEV.dof1d)
    {
       case 2:
-         FindPointsEdgeLocal3DKernel<2>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsEdgeLocal3D_Kernel<2>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       case 3:
-         FindPointsEdgeLocal3DKernel<3>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsEdgeLocal3D_Kernel<3>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       case 4:
-         FindPointsEdgeLocal3DKernel<4>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsEdgeLocal3D_Kernel<4>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       default:
-         FindPointsEdgeLocal3DKernel(npt, DEV.newt_tol, dist2tol, pp,
-                                     point_pos_ordering, pgslm,
-                                     NE_split_total, pwt, pbb, obb_chk,
-                                     DEV.lh_nx, plhm, plhf, plho,
-                                     pcode, pelem, pref, pdist,
-                                     pgll1d, plc, DEV.dof1d);
-         break;
+         return FindPointsEdgeLocal3D_Kernel(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc, DEV.dof1d);
    }
 }
 #undef rDIM2

fem/gslib/findptssurf_local_3.cpp

@@ -11,7 +11,6 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
 #ifdef MFEM_USE_GSLIB
 
 #ifdef MFEM_HAVE_GCC_PRAGMA_DIAGNOSTIC
@@ -52,15 +51,124 @@ struct findptsElementGPT_t
    double x[sDIM], jac[sDIM*rDIM], hes[sDIM*(rDIM+1)];
 };
 
-using dbl_range_t = gslib::dbl_range_t;
-using obbox_t = gslib::obbox_t<sDIM>;
-using findptsLocalHashData_t = gslib::findptsLocalHashData_t<sDIM>;
-using gslib::AABB_test;
-using gslib::bbox_test;
-using gslib::hash_index;
-using gslib::l2norm2;
-using gslib::lag_eval_second_der;
-using gslib::lin_solve_sym_2;
+struct dbl_range_t
+{
+   double min, max;
+};
+
+struct obbox_t
+{
+   double c0[sDIM], A[sDIM*sDIM];
+   dbl_range_t x[sDIM];
+};
+
+struct findptsLocalHashData_t
+{
+   int hash_n;
+   dbl_range_t bnd[sDIM];
+   double fac[sDIM];
+   unsigned int *offset;
+};
+
+static MFEM_HOST_DEVICE inline void lag_eval_second_der(double *p0, double x,
+                                                        int i, const double *z,
+                                                        const double *lCoeff,
+                                                        int pN)
+{
+   double u0 = 1, u1 = 0, u2 = 0;
+   for (int j = 0; j < pN; ++j)
+   {
+      if (i != j)
+      {
+         double d_j = 2 * (x - z[j]);
+         u2 = d_j * u2 + u1;
+         u1 = d_j * u1 + u0;
+         u0 = d_j * u0;
+      }
+   }
+   p0[i] = lCoeff[i] * u0;
+   p0[pN+i] = 2.0 * lCoeff[i] * u1;
+   p0[2*pN+i] = 8.0 * lCoeff[i] * u2;
+}
+
+/* positive when possibly inside */
+static MFEM_HOST_DEVICE inline double AABB_test(const obbox_t *const b,
+                                                const double x[sDIM])
+{
+   double b_d;
+   for (int d=0; d<sDIM; ++d)
+   {
+      b_d = (x[d] - b->x[d].min) * (b->x[d].max - x[d]);
+      if (b_d < 0)   // if outside in any dimension
+      {
+         return b_d;
+      }
+   }
+   return b_d;       // only positive if inside in all dimensions
+}
+
+/* positive when possibly inside */
+static MFEM_HOST_DEVICE inline double bbox_test(const obbox_t *const b,
+                                                const double x[sDIM])
+{
+   const double bxyz = AABB_test(b, x);
+   if (bxyz<0)
+   {
+      return bxyz;
+   }
+   else
+   {
+      double dxyz[3];
+      // dxyz: distance of the point from the center of the OBB
+      for (int d=0; d<sDIM; ++d)
+      {
+         dxyz[d] = x[d] - b->c0[d];
+      }
+      // tranform dxyz to the local coordinate system of the OBB,
+      // and check if the point is inside the OBB [-1,1]^sDIM
+      double test = 1;
+      for (int d=0; d<sDIM; ++d)
+      {
+         double rst = 0;
+         for (int e=0; e<sDIM; ++e)
+         {
+            rst += b->A[d*sDIM + e] * dxyz[e];
+         }
+         double brst = (rst+1)*(1-rst);
+         test = test<0 ? test : brst;
+      }
+      return test;
+   }
+}
+
+/* Hash index in the hash table to the elements that possibly contain the point x */
+static MFEM_HOST_DEVICE inline int hash_index(const findptsLocalHashData_t *p,
+                                              const double x[sDIM])
+{
+   const int n = p->hash_n;
+   int sum = 0;
+   for (int d=sDIM-1; d>=0; --d)
+   {
+      sum *= n;
+      int i = (int)floor((x[d] - p->bnd[d].min) * p->fac[d]);
+      sum += i<0 ? 0 : (n-1 < i ? n-1 : i);
+   }
+   return sum;
+}
+
+static MFEM_HOST_DEVICE inline void lin_solve_sym_2(double x[2],
+                                                    const double A[3],
+                                                    const double y[2])
+{
+   const double idet = 1 / (A[0] * A[2] - A[1] * A[1]);
+   x[0] = idet * (A[2] * y[0] - A[1] * y[1]);
+   x[1] = idet * (A[0] * y[1] - A[1] * y[0]);
+}
+
+static MFEM_HOST_DEVICE inline double l2norm2(const double x[sDIM])
+{
+   return ( x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
+}
 
 /* the bit structure of flags is CSSRR
    the C bit --- 1<<4 --- is set when the point is converged
@@ -111,10 +219,18 @@ static MFEM_HOST_DEVICE inline int point_index(const int x)
    return ((x>>1)&1u) | ((x>>2)&2u);
 }
 
-static MFEM_HOST_DEVICE inline void
+static MFEM_HOST_DEVICE inline findptsElementGEdge_t
 get_edge(const double *elx[3], const double *wtend, int ei,
-         int &side_init, int jidx, int pN, findptsElementGEdge_t &edge)
+         double *workspace, int &side_init, int jidx, int pN)
 {
+   findptsElementGEdge_t edge;
+   for (int d=0; d<sDIM; ++d)
+   {
+      edge.x[d]     = workspace             + d*pN;
+      edge.dxdn[d]  = workspace +   sDIM*pN + d*pN;
+      edge.d2xdn[d] = workspace + 2*sDIM*pN + d*pN;
+   }
+
    // given edge index, compute normal and tangential directions
    const int dn = ei>>1, //0 for rmin/rmax, 1 for smin/smax
              de = plus_1_mod_2(dn); // 1 for rmin/rmax, 0 for smin/smax
@@ -140,6 +256,7 @@ get_edge(const double *elx[3], const double *wtend, int ei,
       edge.d2xdn[dd][jj] = sums_k[1];
 #undef ELX
    }
+   return edge;
 }
 
 static MFEM_HOST_DEVICE inline findptsElementGPT_t get_pt(const double *elx[3],
@@ -195,34 +312,34 @@ static MFEM_HOST_DEVICE inline findptsElementGPT_t get_pt(const double *elx[3],
 /* check reduction in objective against prediction, and adjust
    trust region radius (p->tr) accordingly;
    may reject the prior step, returning 1; otherwise returns 0
-   sets out_pt->dist2, out_pt->index, out_pt->x, out_pt->oldr in any event,
-   leaving out_pt->r, out_pt->dr, out_pt->flags to be set when returning 0 */
-static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out_pt,
+   sets out->dist2, out->index, out->x, out->oldr in any event,
+   leaving out->r, out->dr, out->flags to be set when returning 0 */
+static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out,
                                                  const double resid[3],
                                                  const findptsElementPoint_t *p,
                                                  const double tol)
 {
-   const double dist2 = l2norm2<sDIM>(resid);
+   const double dist2 = l2norm2(resid);
    const double decr  = p->dist2 - dist2;
    const double pred  = p->dist2p;
    for (int d=0; d<sDIM; ++d)
    {
-      out_pt->x[d] = p->x[d];
+      out->x[d] = p->x[d];
    }
    for (int d=0; d<rDIM; ++d)
    {
-      out_pt->oldr[d] = p->r[d];
+      out->oldr[d] = p->r[d];
    }
-   out_pt->dist2 = dist2;
+   out->dist2 = dist2;
    if (decr>=0.01*pred)
    {
       if (decr>=0.9*pred)   // very good iteration
       {
-         out_pt->tr = 2*p->tr;
+         out->tr = 2*p->tr;
       }
       else   // good iteration
       {
-         out_pt->tr = p->tr;
+         out->tr = p->tr;
       }
       return false;
    }
@@ -234,17 +351,17 @@ static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out_pt,
          which is why we divide by 4 below */
       double v0 = fabs(p->r[0] - p->oldr[0]),
              v1 = fabs(p->r[1] - p->oldr[1]);
-      out_pt->tr     = ( v0>v1 ? v0 : v1 )/4;
-      out_pt->dist2  = p->dist2;
-      out_pt->flags   = p->flags >> 5;
-      out_pt->dist2p = -HUGE_VAL;
+      out->tr     = ( v0>v1 ? v0 : v1 )/4;
+      out->dist2  = p->dist2;
+      out->flags   = p->flags >> 5;
+      out->dist2p = -HUGE_VAL;
       for (int d=0; d<rDIM; ++d)
       {
-         out_pt->r[d] = p->oldr[d];
+         out->r[d] = p->oldr[d];
       }
       if (pred<dist2*tol)
       {
-         out_pt->flags |= CONVERGED_FLAG;
+         out->flags |= CONVERGED_FLAG;
       }
       return true;
    }
@@ -252,7 +369,7 @@ static MFEM_HOST_DEVICE bool reject_prior_step_q(findptsElementPoint_t *out_pt,
 
 /* minimize ||resid - jac * dr||_2, with |dr| <= tr, |r0+dr|<=1
    (exact solution of trust region problem) */
-static MFEM_HOST_DEVICE void newton_face( findptsElementPoint_t *const out_pt,
+static MFEM_HOST_DEVICE void newton_face( findptsElementPoint_t *const out,
                                           const double jac[sDIM*rDIM],
                                           const double rhes[3],
                                           const double resid[sDIM],
@@ -423,19 +540,19 @@ newton_face_constrained:
    }
 
 newton_face_fin:
-   out_pt->dist2p = -2*v;
+   out->dist2p = -2*v;
    dr[0] = r[0] - p->r[0];
    dr[1] = r[1] - p->r[1];
    if ( fabs(dr[0])+fabs(dr[1]) < tol)
    {
       new_flags |= CONVERGED_FLAG;
    }
-   out_pt->r[0] = r[0], out_pt->r[1] = r[1];
-   out_pt->flags = new_flags | ((p->flags & FLAG_MASK)<<5);
+   out->r[0] = r[0], out->r[1] = r[1];
+   out->flags = new_flags | ((p->flags & FLAG_MASK)<<5);
 }
 
 static MFEM_HOST_DEVICE inline void newton_edge(findptsElementPoint_t *const
-                                                out_pt,
+                                                out,
                                                 const double jac[sDIM*rDIM],
                                                 const double rhes,
                                                 const double resid[sDIM],
@@ -520,10 +637,10 @@ newton_edge_fin:
    {
       new_flags |= CONVERGED_FLAG;
    }
-   out_pt->r[de] = nr;
-   out_pt->r[dn] = p->r[dn];
-   out_pt->dist2p = -v;
-   out_pt->flags = flags | new_flags | ((p->flags & FLAG_MASK)<<5);
+   out->r[de] = nr;
+   out->r[dn] = p->r[dn];
+   out->dist2p = -v;
+   out->flags = flags | new_flags | ((p->flags & FLAG_MASK)<<5);
 #undef EVAL
 }
 
@@ -559,27 +676,26 @@ static MFEM_HOST_DEVICE void seed_j(const double *elx[sDIM],
 // global memory access of element coordinates.
 // Are the structs being stored in "local memory" or registers?
 template<int T_D1D = 0>
-static void FindPointsSurfLocal3DKernel(const int npt,
-                                        const double tol,
-                                        const double dist2tol,
-                                        const double *x,
-                                        const int point_pos_ordering,
-                                        const double *xElemCoord,
-                                        const int nel,
-                                        const double *wtend,
-                                        const double *boxinfo,
-                                        const bool obb_check,
-                                        const int hash_n,
-                                        const double *hashMin,
-                                        const double *hashFac,
-                                        unsigned int *hashOffset,
-                                        unsigned int *const code_base,
-                                        unsigned int *const el_base,
-                                        double *const r_base,
-                                        double *const dist2_base,
-                                        const double *gll1D,
-                                        const double *lagcoeff,
-                                        const int pN = 0)
+static void FindPointsSurfLocal3D_Kernel(const int npt,
+                                         const double tol,
+                                         const double dist2tol,
+                                         const double *x,
+                                         const int point_pos_ordering,
+                                         const double *xElemCoord,
+                                         const int nel,
+                                         const double *wtend,
+                                         const double *boxinfo,
+                                         const int hash_n,
+                                         const double *hashMin,
+                                         const double *hashFac,
+                                         unsigned int *hashOffset,
+                                         unsigned int *const code_base,
+                                         unsigned int *const el_base,
+                                         double *const r_base,
+                                         double *const dist2_base,
+                                         const double *gll1D,
+                                         const double *lagcoeff,
+                                         const int pN = 0)
 {
    const int MD1   = T_D1D ? T_D1D : DofQuadLimits::MAX_D1D;
    const int D1D   = T_D1D ? T_D1D : pN;
@@ -637,36 +753,22 @@ static void FindPointsSurfLocal3DKernel(const int npt,
       {
          const unsigned int el = *elp;
 
-         const int n_box_ents = obb_check ? (3*sDIM + sDIM2) : (2*sDIM);
-         bool pass_bb = true;
+         // construct obbox on the fly
          obbox_t box;
-         if (obb_check)
+         int n_box_ents = 3*sDIM + sDIM2;
+         for (int idx = 0; idx < sDIM; ++idx)
          {
-            // construct obbox on the fly
-            for (int idx = 0; idx < sDIM; ++idx)
-            {
-               box.c0[idx] = boxinfo[n_box_ents*el + idx];
-               box.x[idx].min = boxinfo[n_box_ents*el + sDIM + idx];
-               box.x[idx].max = boxinfo[n_box_ents*el + 2*sDIM + idx];
-            }
-
-            for (int idx = 0; idx < sDIM2; ++idx)
-            {
-               box.A[idx] = boxinfo[n_box_ents*el + 3*sDIM + idx];
-            }
-            pass_bb = (bbox_test(&box, x_i) >= 0);
-         }
-         else
-         {
-            for (int d = 0; d < sDIM; ++d)
-            {
-               box.x[d].min = boxinfo[n_box_ents*el + d];
-               box.x[d].max = boxinfo[n_box_ents*el + sDIM + d];
-            }
-            pass_bb = (AABB_test(&box, x_i) >= 0);
+            box.c0[idx] = boxinfo[n_box_ents*el + idx];
+            box.x[idx].min = boxinfo[n_box_ents*el + sDIM + idx];
+            box.x[idx].max = boxinfo[n_box_ents*el + 2*sDIM + idx];
          }
 
-         if (!pass_bb) { continue; }
+         for (int idx = 0; idx < sDIM2; ++idx)
+         {
+            box.A[idx] = boxinfo[n_box_ents*el + 3*sDIM + idx];
+         }
+
+         if (bbox_test(&box, x_i) < 0) { continue; }
 
          //// findpts_local ////
          {
@@ -866,19 +968,13 @@ static void FindPointsSurfLocal3DKernel(const int npt,
                         double *hes_T = jac + sDIM*rDIM;
                         double *hes   = hes_T + hes_count*sDIM;
                         findptsElementGEdge_t edge;
-                        for (int d=0; d<sDIM; ++d)
-                        {
-                           edge.x[d]     = constraint_workspace + d*D1D;
-                           edge.dxdn[d]  = constraint_workspace + d*D1D
-                                           + sDIM*D1D;
-                           edge.d2xdn[d] = constraint_workspace + d*D1D
-                                           + 2*sDIM*D1D;
-                        }
 
                         MFEM_FOREACH_THREAD(j,x,D1D*sDIM)
                         {
-                           // One thread per physical component and edge DOF.
-                           get_edge(elx, wtend, ei, edge_init, j, D1D, edge);
+                           // utilized first D1D threads
+                           edge = get_edge(elx, wtend, ei,
+                                           constraint_workspace, edge_init, j,
+                                           D1D);
                         }
                         MFEM_SYNC_THREAD;
 
@@ -949,15 +1045,7 @@ static void FindPointsSurfLocal3DKernel(const int npt,
                               steep *= tmp->r[dn];
                               if (steep<0)
                               {
-                                 double face_hes[3] =
-                                 {
-                                    dn == 0 ? hes[2] : hes[0],
-                                    hes[1],
-                                    dn == 0 ? hes[0] : hes[2]
-                                 };
-                                 newton_face(fpt, jac, face_hes, resid,
-                                             tmp->flags & CONVERGED_FLAG,
-                                             tmp, tol);
+                                 newton_face( fpt,jac,hes,resid,tmp->flags&CONVERGED_FLAG,tmp,tol);
                               }
                               else
                               {
@@ -1123,42 +1211,29 @@ void FindPointsGSLIB::FindPointsSurfLocal3(const Vector &point_pos,
    auto pgll1d = DEV.gll1d.ReadWrite(use_dev);
    auto plc = DEV.lagcoeff.Read(use_dev);
    double dist2tol = DEV.surf_dist_tol;
-   const bool obb_chk = obb_check;
 
    switch (DEV.dof1d)
    {
       case 2:
-         FindPointsSurfLocal3DKernel<2>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsSurfLocal3D_Kernel<2>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       case 3:
-         FindPointsSurfLocal3DKernel<3>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsSurfLocal3D_Kernel<3>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       case 4:
-         FindPointsSurfLocal3DKernel<4>(npt, DEV.newt_tol, dist2tol,
-                                        pp, point_pos_ordering, pgslm,
-                                        NE_split_total, pwt, pbb, obb_chk,
-                                        DEV.lh_nx, plhm, plhf, plho,
-                                        pcode, pelem, pref, pdist,
-                                        pgll1d, plc);
-         break;
+         return FindPointsSurfLocal3D_Kernel<4>(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc);
       default:
-         FindPointsSurfLocal3DKernel(npt, DEV.newt_tol, dist2tol, pp,
-                                     point_pos_ordering, pgslm,
-                                     NE_split_total, pwt, pbb, obb_chk,
-                                     DEV.lh_nx, plhm, plhf, plho,
-                                     pcode, pelem, pref, pdist,
-                                     pgll1d, plc, DEV.dof1d);
-         break;
+         return FindPointsSurfLocal3D_Kernel(
+                   npt, DEV.newt_tol, dist2tol, pp, point_pos_ordering, pgslm,
+                   NE_split_total, pwt, pbb, DEV.lh_nx, plhm, plhf,
+                   plho, pcode, pelem, pref, pdist, pgll1d, plc, DEV.dof1d);
    }
 }
 

fem/gslib/gslib_kernel_helpers.hpp

@@ -1,190 +0,0 @@
-#ifndef MFEM_GSLIB_KERNEL_HELPERS_HPP
-#define MFEM_GSLIB_KERNEL_HELPERS_HPP
-
-#include "../../config/config.hpp"
-
-#include <cmath>
-
-namespace mfem
-{
-
-namespace gslib
-{
-
-struct dbl_range_t
-{
-   double min, max;
-};
-
-template <int SDIM>
-struct obbox_t
-{
-   double c0[SDIM], A[SDIM * SDIM];
-   dbl_range_t x[SDIM];
-};
-
-template <int SDIM>
-struct findptsLocalHashData_t
-{
-   int hash_n;
-   dbl_range_t bnd[SDIM];
-   double fac[SDIM];
-   unsigned int *offset;
-};
-
-// Eval the ith Lagrange interpolant at x.
-MFEM_HOST_DEVICE inline void lagrange_eval(double *p0, double x,
-                                           int i, int p_Nq,
-                                           double *z, double *lagrangeCoeff)
-{
-   double p_i = (1 << (p_Nq - 1));
-   for (int j = 0; j < p_Nq; ++j)
-   {
-      const double d_j = x - z[j];
-      p_i *= j == i ? 1 : d_j;
-   }
-   p0[i] = lagrangeCoeff[i] * p_i;
-}
-
-// Eval the ith Lagrange interpolant and its first derivative at x.
-MFEM_HOST_DEVICE inline void lag_eval_first_der(double *p0, double x,
-                                                int i, const double *z,
-                                                const double *lCoeff,
-                                                int pN)
-{
-   double u0 = 1, u1 = 0;
-   for (int j = 0; j < pN; ++j)
-   {
-      if (i != j)
-      {
-         const double d_j = 2 * (x - z[j]);
-         u1 = d_j * u1 + u0;
-         u0 = d_j * u0;
-      }
-   }
-   p0[i] = lCoeff[i] * u0;
-   p0[pN + i] = 2.0 * lCoeff[i] * u1;
-}
-
-// Eval the ith Lagrange interpolant and its first and second derivative at x.
-MFEM_HOST_DEVICE inline void lag_eval_second_der(double *p0, double x,
-                                                 int i, const double *z,
-                                                 const double *lCoeff,
-                                                 int pN)
-{
-   double u0 = 1, u1 = 0, u2 = 0;
-   for (int j = 0; j < pN; ++j)
-   {
-      if (i != j)
-      {
-         const double d_j = 2 * (x - z[j]);
-         u2 = d_j * u2 + u1;
-         u1 = d_j * u1 + u0;
-         u0 = d_j * u0;
-      }
-   }
-   p0[i] = lCoeff[i] * u0;
-   p0[pN + i] = 2.0 * lCoeff[i] * u1;
-   p0[2 * pN + i] = 8.0 * lCoeff[i] * u2;
-}
-
-// Solve Ax=y where A is a symmetric 2x2 matrix packed as {a00, a01, a11}.
-MFEM_HOST_DEVICE inline void lin_solve_sym_2(double x[2],
-                                             const double A[3],
-                                             const double y[2])
-{
-   const double idet = 1 / (A[0] * A[2] - A[1] * A[1]);
-   x[0] = idet * (A[2] * y[0] - A[1] * y[1]);
-   x[1] = idet * (A[0] * y[1] - A[1] * y[0]);
-}
-
-// Positive when the point is inside the axis-aligned bounding box.
-template <int SDIM>
-MFEM_HOST_DEVICE inline double AABB_test(const obbox_t<SDIM> *const b,
-                                         const double (&x)[SDIM])
-{
-   double test = 1.0;
-   for (int d = 0; d < SDIM; ++d)
-   {
-      const double b_d = (x[d] - b->x[d].min) * (b->x[d].max - x[d]);
-      test = test < 0.0 ? test : b_d;
-   }
-   return test;
-}
-
-// Positive when the point is inside the oriented bounding box.
-template <int SDIM>
-MFEM_HOST_DEVICE inline double bbox_test(const obbox_t<SDIM> *const b,
-                                         const double (&x)[SDIM])
-{
-   const double bxyz = AABB_test(b, x);
-   if (bxyz < 0.0)
-   {
-      return bxyz;
-   }
-
-   double dxyz[SDIM];
-   for (int d = 0; d < SDIM; ++d)
-   {
-      dxyz[d] = x[d] - b->c0[d];
-   }
-
-   double test = 1.0;
-   for (int d = 0; d < SDIM; ++d)
-   {
-      double rst = 0.0;
-      for (int e = 0; e < SDIM; ++e)
-      {
-         rst += b->A[d * SDIM + e] * dxyz[e];
-      }
-      const double brst = (rst + 1.0) * (1.0 - rst);
-      test = test < 0.0 ? test : brst;
-   }
-   return test;
-}
-
-// Hash index in the hash table for the point x.
-template <int SDIM>
-MFEM_HOST_DEVICE inline int hash_index(
-   const findptsLocalHashData_t<SDIM> *const p,
-   const double (&x)[SDIM])
-{
-   const int n = p->hash_n;
-   int sum = 0;
-   for (int d = SDIM - 1; d >= 0; --d)
-   {
-      sum *= n;
-      const int i = (int)floor((x[d] - p->bnd[d].min) * p->fac[d]);
-      sum += i < 0 ? 0 : (n - 1 < i ? n - 1 : i);
-   }
-   return sum;
-}
-
-// Squared Euclidean norm.
-template <int SDIM>
-MFEM_HOST_DEVICE inline double l2norm2(const double (&x)[SDIM])
-{
-   double sum = 0.0;
-   for (int d = 0; d < SDIM; ++d)
-   {
-      sum += x[d] * x[d];
-   }
-   return sum;
-}
-
-template <int SDIM>
-MFEM_HOST_DEVICE inline double l2norm2(const double *x)
-{
-   double sum = 0.0;
-   for (int d = 0; d < SDIM; ++d)
-   {
-      sum += x[d] * x[d];
-   }
-   return sum;
-}
-
-} // namespace gslib
-
-} // namespace mfem
-
-#endif

fem/gslib/interpolate_local_1.cpp

@@ -11,7 +11,7 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
+#include "../../linalg/kernels.hpp"
 
 #ifdef MFEM_USE_GSLIB
 
@@ -33,7 +33,17 @@ namespace mfem
 #define CODE_BORDER 1
 #define CODE_NOT_FOUND 2
 
-using gslib::lagrange_eval;
+static MFEM_HOST_DEVICE void lagrange_eval(double *p0, double x,
+                                           int i, int p_Nq,
+                                           double *z, double *lagrangeCoeff)
+{
+   double p_i = (1 << (p_Nq - 1));
+   for (int j=0; j<p_Nq; ++j)
+   {
+      p_i *= j==i ? 1 : x-z[j];
+   }
+   p0[i] = lagrangeCoeff[i] * p_i;
+}
 
 template<int T_D1D = 0>
 static void InterpolateLocal1DKernel(const double *const gf_in,
@@ -113,26 +123,21 @@ void FindPointsGSLIB::InterpolateLocal1( const Vector &field_in,
    auto plcf = DEV.lagcoeff_sol.ReadWrite(use_dev);
    switch (dof1Dsol)
    {
-      case 2:
-         InterpolateLocal1DKernel<2>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 3:
-         InterpolateLocal1DKernel<3>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 4:
-         InterpolateLocal1DKernel<4>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 5:
-         InterpolateLocal1DKernel<5>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      default:
-         InterpolateLocal1DKernel(pfin, pgsl, pgslr, pfout,
-                                  npt, ncomp, pgll, plcf, dof1Dsol);
-         break;
+      case 2: return InterpolateLocal1DKernel<2>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 3: return InterpolateLocal1DKernel<3>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 4: return InterpolateLocal1DKernel<4>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 5: return InterpolateLocal1DKernel<5>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      default: return InterpolateLocal1DKernel(pfin, pgsl, pgslr, pfout,
+                                                  npt, ncomp,
+                                                  pgll, plcf, dof1Dsol);
    }
 }
 #undef CODE_INTERNAL

fem/gslib/interpolate_local_2.cpp

@@ -11,7 +11,6 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
 
 #ifdef MFEM_USE_GSLIB
 
@@ -33,7 +32,18 @@ namespace mfem
 #define CODE_BORDER 1
 #define CODE_NOT_FOUND 2
 
-using gslib::lagrange_eval;
+static MFEM_HOST_DEVICE void lagrange_eval(double *p0, double x,
+                                           int i, int p_Nq,
+                                           double *z, double *lagrangeCoeff)
+{
+   double p_i = (1 << (p_Nq - 1));
+   for (int j = 0; j < p_Nq; ++j)
+   {
+      double d_j = x - z[j];
+      p_i *= j == i ? 1 : d_j;
+   }
+   p0[i] = lagrangeCoeff[i] * p_i;
+}
 
 template<int T_D1D = 0>
 static void InterpolateLocal2DKernel(const double *const gf_in,
@@ -122,26 +132,21 @@ void FindPointsGSLIB::InterpolateLocal2(const Vector &field_in,
    auto plcf = DEV.lagcoeff_sol.ReadWrite(use_dev);
    switch (dof1Dsol)
    {
-      case 2:
-         InterpolateLocal2DKernel<2>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 3:
-         InterpolateLocal2DKernel<3>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 4:
-         InterpolateLocal2DKernel<4>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 5:
-         InterpolateLocal2DKernel<5>(pfin, pgsl, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      default:
-         InterpolateLocal2DKernel(pfin, pgsl, pgslr, pfout,
-                                  npt, ncomp, pgll, plcf, dof1Dsol);
-         break;
+      case 2: return InterpolateLocal2DKernel<2>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 3: return InterpolateLocal2DKernel<3>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 4: return InterpolateLocal2DKernel<4>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 5: return InterpolateLocal2DKernel<5>(pfin, pgsl, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      default: return InterpolateLocal2DKernel(pfin, pgsl, pgslr, pfout,
+                                                  npt, ncomp,
+                                                  pgll, plcf, dof1Dsol);
    }
 }
 

fem/gslib/interpolate_local_3.cpp

@@ -11,7 +11,6 @@
 
 #include "../gslib.hpp"
 #include "../../general/forall.hpp"
-#include "gslib_kernel_helpers.hpp"
 
 #ifdef MFEM_USE_GSLIB
 
@@ -33,7 +32,18 @@ namespace mfem
 #define CODE_BORDER 1
 #define CODE_NOT_FOUND 2
 
-using gslib::lagrange_eval;
+static MFEM_HOST_DEVICE void lagrange_eval(double *p0, double x,
+                                           int i, int p_Nq,
+                                           double *z, double *lagrangeCoeff)
+{
+   double p_i = (1 << (p_Nq - 1));
+   for (int j = 0; j < p_Nq; ++j)
+   {
+      double d_j = x - z[j];
+      p_i *= j == i ? 1 : d_j;
+   }
+   p0[i] = lagrangeCoeff[i] * p_i;
+}
 
 template<int T_D1D = 0>
 static void InterpolateLocal3DKernel(const double *const gf_in,
@@ -125,26 +135,21 @@ void FindPointsGSLIB::InterpolateLocal3(const Vector &field_in,
    auto plcf = DEV.lagcoeff_sol.ReadWrite(use_dev);
    switch (dof1Dsol)
    {
-      case 2:
-         InterpolateLocal3DKernel<2>(pfin, pgsle, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 3:
-         InterpolateLocal3DKernel<3>(pfin, pgsle, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 4:
-         InterpolateLocal3DKernel<4>(pfin, pgsle, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      case 5:
-         InterpolateLocal3DKernel<5>(pfin, pgsle, pgslr, pfout,
-                                     npt, ncomp, pgll, plcf);
-         break;
-      default:
-         InterpolateLocal3DKernel(pfin, pgsle, pgslr, pfout,
-                                  npt, ncomp, pgll, plcf, dof1Dsol);
-         break;
+      case 2: return InterpolateLocal3DKernel<2>(pfin, pgsle, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 3: return InterpolateLocal3DKernel<3>(pfin, pgsle, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 4: return InterpolateLocal3DKernel<4>(pfin, pgsle, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      case 5: return InterpolateLocal3DKernel<5>(pfin, pgsle, pgslr, pfout,
+                                                    npt, ncomp,
+                                                    pgll, plcf);
+      default: return InterpolateLocal3DKernel(pfin, pgsle, pgslr, pfout,
+                                                  npt, ncomp,
+                                                  pgll, plcf, dof1Dsol);
    }
 }
 

fem/integ/bilininteg_diffusion_kernels.hpp

@@ -19,8 +19,6 @@
 #include "../../linalg/vector.hpp"
 #include "../bilininteg.hpp"
 
-#include "bilininteg_diffusion_pa_simplices.hpp"
-
 namespace mfem
 {
 

fem/integ/bilininteg_mass_kernels.hpp

@@ -19,8 +19,6 @@
 #include "../../linalg/vector.hpp"
 #include "../bilininteg.hpp"
 
-#include "bilininteg_mass_pa_simplices.hpp"
-
 namespace mfem
 {
 

fem/integ/lininteg_domain_kernels.hpp

@@ -307,506 +307,6 @@ DomainLFIntegrator::AssembleKernels::Kernel()
    MFEM_ABORT("");
 }
 
-template <int T_D1D = 0, int T_Q1D = 0>
-static void HdivDLFAssemble2D(const int ne, const Array<int> &markers,
-                              const Vector &jac, const Array<real_t> &weights,
-                              const Array<real_t> &testBO,
-                              const Array<real_t> &testBC, const Vector &coeff,
-                              Vector &y, const int d, const int q)
-{
-   MFEM_VERIFY(T_D1D || d <= DeviceDofQuadLimits::Get().HDIV_MAX_D1D,
-               "Problem size too large.");
-   MFEM_VERIFY(T_Q1D || q <= DeviceDofQuadLimits::Get().HDIV_MAX_Q1D,
-               "Problem size too large.");
-   MFEM_VERIFY(y.Size() == 2 * (d - 1) * d * ne, "");
-
-   constexpr int vdim = 2;
-   const auto F = coeff.Read();
-   const auto M = markers.Read();
-   const auto BO = Reshape(testBO.Read(), q, d-1);
-   const auto BC = Reshape(testBC.Read(), q, d);
-   const auto J = Reshape(jac.Read(), q, q, vdim, vdim, ne);
-   const auto W = Reshape(weights.Read(), q, q);
-   const bool cst = coeff.Size() == vdim;
-   const auto C = cst ? Reshape(F,vdim,1,1,1) : Reshape(F,vdim,q,q,ne);
-   auto Y = y.ReadWrite();
-
-   mfem::forall_3D(ne, q, q, vdim, [=] MFEM_HOST_DEVICE (int e)
-   {
-      constexpr int vdim = 2;
-      if (M[e] == 0) { return; } // ignore
-
-      constexpr int Q = T_Q1D ? T_Q1D : DofQuadLimits::HDIV_MAX_Q1D;
-      constexpr int D = T_D1D ? T_D1D : DofQuadLimits::HDIV_MAX_D1D;
-
-      MFEM_SHARED real_t sBot[Q*D];
-      MFEM_SHARED real_t sBct[Q*D];
-      MFEM_SHARED real_t sQQ[vdim*Q*Q];
-      MFEM_SHARED real_t sQD[vdim*Q*D];
-
-      // Bo and Bc into shared memory
-      const DeviceMatrix Bot(sBot, d-1, q);
-      kernels::internal::LoadB<D,Q>(d-1, q, BO, sBot);
-      const DeviceMatrix Bct(sBct, d, q);
-      kernels::internal::LoadB<D,Q>(d, q, BC, sBct);
-
-      const DeviceCube QQ(sQQ, q, q, vdim);
-      const DeviceCube QD(sQD, q, d, vdim);
-
-      MFEM_FOREACH_THREAD(vd,z,vdim)
-      {
-         const real_t cst_val_0 = C(0,0,0,0);
-         const real_t cst_val_1 = C(1,0,0,0);
-         MFEM_FOREACH_THREAD(y,y,q)
-         {
-            MFEM_FOREACH_THREAD(x,x,q)
-            {
-               const real_t J0 = J(x,y,0,vd,e);
-               const real_t J1 = J(x,y,1,vd,e);
-               const real_t C0 = cst ? cst_val_0 : C(0,x,y,e);
-               const real_t C1 = cst ? cst_val_1 : C(1,x,y,e);
-               QQ(x,y,vd) = W(x,y)*(J0*C0 + J1*C1);
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      MFEM_FOREACH_THREAD(vd,z,vdim)
-      {
-         const int nx = (vd == 0) ? d : d-1;
-         DeviceMatrix Btx = (vd == 0) ? Bct : Bot;
-         MFEM_FOREACH_THREAD(qy,y,q)
-         {
-            MFEM_FOREACH_THREAD(dx,x,nx)
-            {
-               real_t qd = 0.0;
-               for (int qx = 0; qx < q; ++qx)
-               {
-                  qd += QQ(qx,qy,vd) * Btx(dx,qx);
-               }
-               QD(dx,qy,vd) = qd;
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      MFEM_FOREACH_THREAD(vd,z,vdim)
-      {
-         const int nx = (vd == 0) ? d : d-1;
-         const int ny = (vd == 1) ? d : d-1;
-         DeviceMatrix Bty = (vd == 1) ? Bct : Bot;
-         DeviceTensor<4> Yxy(Y, nx, ny, vdim, ne);
-         MFEM_FOREACH_THREAD(dy,y,ny)
-         {
-            MFEM_FOREACH_THREAD(dx,x,nx)
-            {
-               real_t dd = 0.0;
-               for (int qy = 0; qy < q; ++qy)
-               {
-                  dd += QD(dx,qy,vd) * Bty(dy,qy);
-               }
-               Yxy(dx,dy,vd,e) += dd;
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-   });
-}
-
-template <int T_D1D = 0, int T_Q1D = 0>
-static void HdivDLFAssemble3D(const int ne, const Array<int> &markers,
-                              const Vector &jac, const Array<real_t> &weights,
-                              const Array<real_t> &testBO,
-                              const Array<real_t> &testBC, const Vector &coeff,
-                              Vector &y, const int d, const int q)
-{
-   MFEM_VERIFY(T_D1D || d <= DeviceDofQuadLimits::Get().HDIV_MAX_D1D,
-               "Problem size too large.");
-   MFEM_VERIFY(T_Q1D || q <= DeviceDofQuadLimits::Get().HDIV_MAX_Q1D,
-               "Problem size too large.");
-   MFEM_VERIFY(y.Size() == 3 * (d - 1) * (d - 1) * d * ne, "y wrong length");
-
-   constexpr int vdim = 3;
-   const auto F = coeff.Read();
-   const auto M = markers.Read();
-   const auto BO = Reshape(testBO.Read(), q, d-1);
-   const auto BC = Reshape(testBC.Read(), q, d);
-   const auto J = Reshape(jac.Read(), q, q, q, vdim, vdim, ne);
-   const auto W = Reshape(weights.Read(), q, q, q);
-   const bool cst = coeff.Size() == vdim;
-   const auto C = cst ? Reshape(F,vdim,1,1,1,1) : Reshape(F,vdim,q,q,q,ne);
-   auto Y = y.ReadWrite();
-
-   mfem::forall_3D(ne, q, q, vdim, [=] MFEM_HOST_DEVICE (int e)
-   {
-      constexpr int vdim = 3;
-      if (M[e] == 0) { return; } // ignore
-
-      constexpr int Q = T_Q1D ? T_Q1D : DofQuadLimits::HDIV_MAX_Q1D;
-      constexpr int D = T_D1D ? T_D1D : DofQuadLimits::HDIV_MAX_D1D;
-
-      MFEM_SHARED real_t sBot[Q*D];
-      MFEM_SHARED real_t sBct[Q*D];
-
-      // Bo and Bc into shared memory
-      const DeviceMatrix Bot(sBot, d-1, q);
-      kernels::internal::LoadB<D,Q>(d-1, q, BO, sBot);
-      const DeviceMatrix Bct(sBct, d, q);
-      kernels::internal::LoadB<D,Q>(d, q, BC, sBct);
-
-      MFEM_SHARED real_t sm0[vdim*Q*Q*Q];
-      MFEM_SHARED real_t sm1[vdim*Q*Q*Q];
-      DeviceTensor<4> QQQ(sm1, q, q, q, vdim);
-      DeviceTensor<4> DQQ(sm0, d, q, q, vdim);
-      DeviceTensor<4> DDQ(sm1, d, d, q, vdim);
-
-      MFEM_FOREACH_THREAD(vd,z,vdim)
-      {
-         const real_t cst_val_0 = C(0,0,0,0,0);
-         const real_t cst_val_1 = C(1,0,0,0,0);
-         const real_t cst_val_2 = C(2,0,0,0,0);
-         MFEM_FOREACH_THREAD(y,y,q)
-         {
-            MFEM_FOREACH_THREAD(x,x,q)
-            {
-               for (int z = 0; z < q; ++z)
-               {
-                  const real_t J0 = J(x,y,z,0,vd,e);
-                  const real_t J1 = J(x,y,z,1,vd,e);
-                  const real_t J2 = J(x,y,z,2,vd,e);
-                  const real_t C0 = cst ? cst_val_0 : C(0,x,y,z,e);
-                  const real_t C1 = cst ? cst_val_1 : C(1,x,y,z,e);
-                  const real_t C2 = cst ? cst_val_2 : C(2,x,y,z,e);
-                  QQQ(x,y,z,vd) = W(x,y,z)*(J0*C0 + J1*C1 + J2*C2);
-               }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      // Apply Bt operator
-      MFEM_FOREACH_THREAD(vd,z,vdim)
-      {
-         const int nx = (vd == 0) ? d : d-1;
-         DeviceMatrix Btx = (vd == 0) ? Bct : Bot;
-         MFEM_FOREACH_THREAD(qy,y,q)
-         {
-            MFEM_FOREACH_THREAD(dx,x,nx)
-            {
-               real_t u[Q];
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz) { u[qz] = 0.0; }
-               MFEM_UNROLL(Q)
-               for (int qx = 0; qx < q; ++qx)
-               {
-                  MFEM_UNROLL(Q)
-                  for (int qz = 0; qz < q; ++qz)
-                  {
-                     u[qz] += QQQ(qx,qy,qz,vd) * Btx(dx,qx);
-                  }
-               }
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz) { DQQ(dx,qy,qz,vd) = u[qz]; }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      MFEM_FOREACH_THREAD(vd,z,vdim)
-      {
-         const int nx = (vd == 0) ? d : d-1;
-         const int ny = (vd == 1) ? d : d-1;
-         DeviceMatrix Bty = (vd == 1) ? Bct : Bot;
-         MFEM_FOREACH_THREAD(dy,y,ny)
-         {
-            MFEM_FOREACH_THREAD(dx,x,nx)
-            {
-               real_t u[Q];
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz) { u[qz] = 0.0; }
-               MFEM_UNROLL(Q)
-               for (int qy = 0; qy < q; ++qy)
-               {
-                  MFEM_UNROLL(Q)
-                  for (int qz = 0; qz < q; ++qz)
-                  {
-                     u[qz] += DQQ(dx,qy,qz,vd) * Bty(dy,qy);
-                  }
-               }
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz) { DDQ(dx,dy,qz,vd) = u[qz]; }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      MFEM_FOREACH_THREAD(vd,z,vdim)
-      {
-         const int nx = (vd == 0) ? d : d-1;
-         const int ny = (vd == 1) ? d : d-1;
-         const int nz = (vd == 2) ? d : d-1;
-         DeviceTensor<5> Yxyz(Y, nx, ny, nz, vdim, ne);
-         DeviceMatrix Btz = (vd == 2) ? Bct : Bot;
-         MFEM_FOREACH_THREAD(dy,y,ny)
-         {
-            MFEM_FOREACH_THREAD(dx,x,nx)
-            {
-               real_t u[D];
-               MFEM_UNROLL(D)
-               for (int dz = 0; dz < nz; ++dz) { u[dz] = 0.0; }
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz)
-               {
-                  MFEM_UNROLL(D)
-                  for (int dz = 0; dz < nz; ++dz)
-                  {
-                     u[dz] += DDQ(dx,dy,qz,vd) * Btz(dz,qz);
-                  }
-               }
-               MFEM_UNROLL(D)
-               for (int dz = 0; dz < nz; ++dz) { Yxyz(dx,dy,dz,vd,e) += u[dz]; }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-   });
-}
-
-/// @param ne number of elements
-/// @param markers array where entry markers[e] == 0 to skip assembly over
-/// element e element
-/// @param jac Spatial Jacobians evaluated at all quadrature points
-/// @param weights 1D quadrature weights
-/// @param testBO 1D open basis test functions
-/// @param testBC 1D closed basis test functions
-/// @param coeff coefficient values evaluated at quadrature points, possibly
-/// compressed.
-/// @param d number of 1D closed dofs
-/// @param q number of 1D quadrature points
-/// @tparam T_D1D maximum number of dofs along any direction, or 0
-/// @tparam T_Q1D maximum number of quadrature points along any direction, or 0
-template <int T_D1D = 0, int T_Q1D = 0>
-static void HcurlDLFAssemble3D(const int ne, const Array<int> &markers,
-                               const Vector &jac, const Array<real_t> &weights,
-                               const Array<real_t> &testBO,
-                               const Array<real_t> &testBC, const Vector &coeff,
-                               Vector &y, const int d, const int q)
-{
-   MFEM_VERIFY(T_D1D || d <= DeviceDofQuadLimits::Get().HCURL_MAX_D1D,
-               "Problem size too large.");
-   MFEM_VERIFY(T_Q1D || q <= DeviceDofQuadLimits::Get().HCURL_MAX_Q1D,
-               "Problem size too large.");
-   MFEM_VERIFY(y.Size() == 3 * (d - 1) * d * d * ne, "y wrong length");
-
-   constexpr int vdim = 3;
-   const auto F = coeff.Read();
-   const auto M = markers.Read();
-   const auto BO = Reshape(testBO.Read(), q, d-1);
-   const auto BC = Reshape(testBC.Read(), q, d);
-   const auto J = Reshape(jac.Read(), q, q, q, vdim, vdim, ne);
-   const auto W = Reshape(weights.Read(), q, q, q);
-   const bool cst = coeff.Size() == vdim;
-   const auto C = cst ? Reshape(F,vdim,1,1,1,1) : Reshape(F,vdim,q,q,q,ne);
-   auto Y = y.ReadWrite();
-
-   mfem::forall_3D(ne, q, q, vdim, [=] MFEM_HOST_DEVICE(int e)
-   {
-      if (M[e] == 0)
-      {
-         // ignore
-         return;
-      }
-
-      constexpr int vdim = 3;
-      constexpr int Q = T_Q1D ? T_Q1D : DofQuadLimits::HCURL_MAX_Q1D;
-      constexpr int D = T_D1D ? T_D1D : DofQuadLimits::HCURL_MAX_D1D;
-
-      MFEM_SHARED real_t sBot[Q * D];
-      MFEM_SHARED real_t sBct[Q * D];
-
-      // Bo and Bc into shared memory
-      const DeviceMatrix Bot(sBot, d - 1, q);
-      kernels::internal::LoadB<D, Q>(d - 1, q, BO, sBot);
-      const DeviceMatrix Bct(sBct, d, q);
-      kernels::internal::LoadB<D, Q>(d, q, BC, sBct);
-
-      MFEM_SHARED real_t sm0[vdim * Q * Q * Q];
-      MFEM_SHARED real_t sm1[vdim * Q * Q * Q];
-      DeviceTensor<4> QQQ(sm1, q, q, q, vdim);
-      DeviceTensor<4> DQQ(sm0, d, q, q, vdim);
-      DeviceTensor<4> DDQ(sm1, d, d, q, vdim);
-
-      const real_t cst_val_0 = C(0, 0, 0, 0, 0);
-      const real_t cst_val_1 = C(1, 0, 0, 0, 0);
-      const real_t cst_val_2 = C(2, 0, 0, 0, 0);
-
-      MFEM_FOREACH_THREAD(vd, z, vdim)
-      {
-         MFEM_FOREACH_THREAD(y, y, q)
-         {
-            MFEM_FOREACH_THREAD(x, x, q)
-            {
-               for (int z = 0; z < q; ++z)
-               {
-                  real_t curr[3];
-                  curr[0] = cst ? cst_val_0 : C(0, x, y, z, e);
-                  curr[1] = cst ? cst_val_1 : C(1, x, y, z, e);
-                  curr[2] = cst ? cst_val_2 : C(2, x, y, z, e);
-
-                  const real_t J11 = J(x, y, z, 0, 0, e);
-                  const real_t J21 = J(x, y, z, 1, 0, e);
-                  const real_t J31 = J(x, y, z, 2, 0, e);
-                  const real_t J12 = J(x, y, z, 0, 1, e);
-                  const real_t J22 = J(x, y, z, 1, 1, e);
-                  const real_t J32 = J(x, y, z, 2, 1, e);
-                  const real_t J13 = J(x, y, z, 0, 2, e);
-                  const real_t J23 = J(x, y, z, 1, 2, e);
-                  const real_t J33 = J(x, y, z, 2, 2, e);
-                  // adj(J)
-                  const real_t A11 = (J22 * J33) - (J23 * J32);
-                  const real_t A12 = (J32 * J13) - (J12 * J33);
-                  const real_t A13 = (J12 * J23) - (J22 * J13);
-                  const real_t A21 = (J31 * J23) - (J21 * J33);
-                  const real_t A22 = (J11 * J33) - (J13 * J31);
-                  const real_t A23 = (J21 * J13) - (J11 * J23);
-                  const real_t A31 = (J21 * J32) - (J31 * J22);
-                  const real_t A32 = (J31 * J12) - (J11 * J32);
-                  const real_t A33 = (J11 * J22) - (J12 * J21);
-                  const real_t A[9] = {A11, A12, A13, A21, A22,
-                                       A23, A31, A32, A33
-                                      };
-                  QQQ(x, y, z, vd) = W(x, y, z) * (A[vd * vdim] * curr[0] +
-                                                   A[vd * vdim + 1] * curr[1] +
-                                                   A[vd * vdim + 2] * curr[2]);
-               }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      // Apply Bt operator
-      MFEM_FOREACH_THREAD(vd, z, vdim)
-      {
-         const int nx = (vd == 0) ? d - 1 : d;
-         DeviceMatrix Btx = (vd == 0) ? Bot : Bct;
-         MFEM_FOREACH_THREAD(qy, y, q)
-         {
-            MFEM_FOREACH_THREAD(dx, x, nx)
-            {
-               real_t u[Q];
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz)
-               {
-                  u[qz] = 0.0;
-               }
-               MFEM_UNROLL(Q)
-               for (int qx = 0; qx < q; ++qx)
-               {
-                  MFEM_UNROLL(Q)
-                  for (int qz = 0; qz < q; ++qz)
-                  {
-                     u[qz] += QQQ(qx, qy, qz, vd) * Btx(dx, qx);
-                  }
-               }
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz)
-               {
-                  DQQ(dx, qy, qz, vd) = u[qz];
-               }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      MFEM_FOREACH_THREAD(vd, z, vdim)
-      {
-         const int nx = (vd == 0) ? d - 1 : d;
-         const int ny = (vd == 1) ? d - 1 : d;
-         DeviceMatrix Bty = (vd == 1) ? Bot : Bct;
-         MFEM_FOREACH_THREAD(dy, y, ny)
-         {
-            MFEM_FOREACH_THREAD(dx, x, nx)
-            {
-               real_t u[Q];
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz)
-               {
-                  u[qz] = 0.0;
-               }
-               MFEM_UNROLL(Q)
-               for (int qy = 0; qy < q; ++qy)
-               {
-                  MFEM_UNROLL(Q)
-                  for (int qz = 0; qz < q; ++qz)
-                  {
-                     u[qz] += DQQ(dx, qy, qz, vd) * Bty(dy, qy);
-                  }
-               }
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz)
-               {
-                  DDQ(dx, dy, qz, vd) = u[qz];
-               }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-      MFEM_FOREACH_THREAD(vd, z, vdim)
-      {
-         const int nx = (vd == 0) ? d - 1 : d;
-         const int ny = (vd == 1) ? d - 1 : d;
-         const int nz = (vd == 2) ? d - 1 : d;
-         DeviceTensor<5> Yxyz(Y, nx, ny, nz, vdim, ne);
-         DeviceMatrix Btz = (vd == 2) ? Bot : Bct;
-         MFEM_FOREACH_THREAD(dy, y, ny)
-         {
-            MFEM_FOREACH_THREAD(dx, x, nx)
-            {
-               real_t u[D];
-               MFEM_UNROLL(D)
-               for (int dz = 0; dz < nz; ++dz)
-               {
-                  u[dz] = 0.0;
-               }
-               MFEM_UNROLL(Q)
-               for (int qz = 0; qz < q; ++qz)
-               {
-                  MFEM_UNROLL(D)
-                  for (int dz = 0; dz < nz; ++dz)
-                  {
-                     u[dz] += DDQ(dx, dy, qz, vd) * Btz(dz, qz);
-                  }
-               }
-               MFEM_UNROLL(D)
-               for (int dz = 0; dz < nz; ++dz)
-               {
-                  Yxyz(dx, dy, dz, vd, e) += u[dz];
-               }
-            }
-         }
-      }
-      MFEM_SYNC_THREAD;
-   });
-}
-
-template <FiniteElement::DerivType TestType, int DIM, int TEST_D1D, int Q1D>
-VectorFEDomainLFIntegrator::AssembleKernelType
-VectorFEDomainLFIntegrator::AssembleKernels::Kernel()
-{
-   if constexpr (TestType == FiniteElement::DIV)
-   {
-      if constexpr (DIM == 2)
-      {
-         return HdivDLFAssemble2D<TEST_D1D, Q1D>;
-      }
-      if constexpr (DIM == 3)
-      {
-         return HdivDLFAssemble3D<TEST_D1D, Q1D>;
-      }
-   }
-   if constexpr (TestType == FiniteElement::CURL)
-   {
-      if constexpr (DIM == 3)
-      {
-         return HcurlDLFAssemble3D<TEST_D1D, Q1D>;
-      }
-   }
-   MFEM_ABORT("");
-}
-
 /// \endcond DO_NOT_DOCUMENT
 
 } // namespace mfem

fem/integ/lininteg_domain_vectorfe.cpp

@@ -13,76 +13,317 @@
 #include "../../fem/kernels.hpp"
 #include "../fem.hpp"
 
-#include "lininteg_domain_kernels.hpp"
-
 namespace mfem
 {
 
-VectorFEDomainLFIntegrator::Kernels::Kernels()
+template<int T_D1D = 0, int T_Q1D = 0>
+static void HdivDLFAssemble2D(
+   const int ne, const int d, const int q, const int *markers, const real_t *bo,
+   const real_t *bc, const real_t *j, const real_t *weights,
+   const Vector &coeff, real_t *y)
 {
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 1, 1>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 2, 2>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 3, 3>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 4, 4>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 5, 5>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 6, 6>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 7, 7>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 2, 8, 8>();
+   MFEM_VERIFY(T_D1D || d <= DeviceDofQuadLimits::Get().HDIV_MAX_D1D,
+               "Problem size too large.");
+   MFEM_VERIFY(T_Q1D || q <= DeviceDofQuadLimits::Get().HDIV_MAX_Q1D,
+               "Problem size too large.");
 
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 1, 1>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 2, 2>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 3, 3>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 4, 4>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 5, 5>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 6, 6>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 7, 7>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::DIV, 3, 8, 8>();
+   static constexpr int vdim = 2;
+   const auto F = coeff.Read();
+   const auto M = Reshape(markers, ne);
+   const auto BO = Reshape(bo, q, d-1);
+   const auto BC = Reshape(bc, q, d);
+   const auto J = Reshape(j, q, q, vdim, vdim, ne);
+   const auto W = Reshape(weights, q, q);
+   const bool cst = coeff.Size() == vdim;
+   const auto C = cst ? Reshape(F,vdim,1,1,1) : Reshape(F,vdim,q,q,ne);
+   auto Y = Reshape(y, 2*(d-1)*d, ne);
 
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 1, 1>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 2, 2>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 3, 3>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 4, 4>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 5, 5>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 6, 6>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 7, 7>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 8, 8>();
+   mfem::forall_3D(ne, q, q, vdim, [=] MFEM_HOST_DEVICE (int e)
+   {
+      if (M(e) == 0) { return; } // ignore
 
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 1, 2>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 2, 3>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 3, 4>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 4, 5>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 5, 6>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 6, 7>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 7, 8>();
-   VectorFEDomainLFIntegrator::AddSpecialization<FiniteElement::CURL, 3, 8, 9>();
+      constexpr int Q = T_Q1D ? T_Q1D : DofQuadLimits::HDIV_MAX_Q1D;
+      constexpr int D = T_D1D ? T_D1D : DofQuadLimits::HDIV_MAX_D1D;
+
+      MFEM_SHARED real_t sBot[Q*D];
+      MFEM_SHARED real_t sBct[Q*D];
+      MFEM_SHARED real_t sQQ[vdim*Q*Q];
+      MFEM_SHARED real_t sQD[vdim*Q*D];
+
+      // Bo and Bc into shared memory
+      const DeviceMatrix Bot(sBot, d-1, q);
+      kernels::internal::LoadB<D,Q>(d-1, q, BO, sBot);
+      const DeviceMatrix Bct(sBct, d, q);
+      kernels::internal::LoadB<D,Q>(d, q, BC, sBct);
+
+      const DeviceCube QQ(sQQ, q, q, vdim);
+      const DeviceCube QD(sQD, q, d, vdim);
+
+      MFEM_FOREACH_THREAD(vd,z,vdim)
+      {
+         const real_t cst_val_0 = C(0,0,0,0);
+         const real_t cst_val_1 = C(1,0,0,0);
+         MFEM_FOREACH_THREAD(y,y,q)
+         {
+            MFEM_FOREACH_THREAD(x,x,q)
+            {
+               const real_t J0 = J(x,y,0,vd,e);
+               const real_t J1 = J(x,y,1,vd,e);
+               const real_t C0 = cst ? cst_val_0 : C(0,x,y,e);
+               const real_t C1 = cst ? cst_val_1 : C(1,x,y,e);
+               QQ(x,y,vd) = W(x,y)*(J0*C0 + J1*C1);
+            }
+         }
+      }
+      MFEM_SYNC_THREAD;
+      MFEM_FOREACH_THREAD(vd,z,vdim)
+      {
+         const int nx = (vd == 0) ? d : d-1;
+         DeviceMatrix Btx = (vd == 0) ? Bct : Bot;
+         MFEM_FOREACH_THREAD(qy,y,q)
+         {
+            MFEM_FOREACH_THREAD(dx,x,nx)
+            {
+               real_t qd = 0.0;
+               for (int qx = 0; qx < q; ++qx)
+               {
+                  qd += QQ(qx,qy,vd) * Btx(dx,qx);
+               }
+               QD(dx,qy,vd) = qd;
+            }
+         }
+      }
+      MFEM_SYNC_THREAD;
+      MFEM_FOREACH_THREAD(vd,z,vdim)
+      {
+         const int nx = (vd == 0) ? d : d-1;
+         const int ny = (vd == 1) ? d : d-1;
+         DeviceMatrix Bty = (vd == 1) ? Bct : Bot;
+         DeviceTensor<4> Yxy(Y, nx, ny, vdim, ne);
+         MFEM_FOREACH_THREAD(dy,y,ny)
+         {
+            MFEM_FOREACH_THREAD(dx,x,nx)
+            {
+               real_t dd = 0.0;
+               for (int qy = 0; qy < q; ++qy)
+               {
+                  dd += QD(dx,qy,vd) * Bty(dy,qy);
+               }
+               Yxy(dx,dy,vd,e) += dd;
+            }
+         }
+      }
+      MFEM_SYNC_THREAD;
+   });
 }
 
-/// \cond DO_NOT_DOCUMENT
-VectorFEDomainLFIntegrator::AssembleKernelType
-VectorFEDomainLFIntegrator::AssembleKernels::Fallback(
-   FiniteElement::DerivType TestType, int DIM, int, int)
+template<int T_D1D = 0, int T_Q1D = 0>
+static void HdivDLFAssemble3D(
+   const int ne, const int d, const int q, const int *markers, const real_t *bo,
+   const real_t *bc, const real_t *j, const real_t *weights,
+   const Vector &coeff, real_t *y)
 {
-   if (TestType == FiniteElement::DIV)
+   MFEM_VERIFY(T_D1D || d <= DeviceDofQuadLimits::Get().HDIV_MAX_D1D,
+               "Problem size too large.");
+   MFEM_VERIFY(T_Q1D || q <= DeviceDofQuadLimits::Get().HDIV_MAX_Q1D,
+               "Problem size too large.");
+
+   static constexpr int vdim = 3;
+   const auto F = coeff.Read();
+   const auto M = Reshape(markers, ne);
+   const auto BO = Reshape(bo, q, d-1);
+   const auto BC = Reshape(bc, q, d);
+   const auto J = Reshape(j, q, q, q, vdim, vdim, ne);
+   const auto W = Reshape(weights, q, q, q);
+   const bool cst = coeff.Size() == vdim;
+   const auto C = cst ? Reshape(F,vdim,1,1,1,1) : Reshape(F,vdim,q,q,q,ne);
+   auto Y = Reshape(y, 2*(d-1)*(d-1)*d, ne);
+
+   mfem::forall_3D(ne, q, q, vdim, [=] MFEM_HOST_DEVICE (int e)
    {
-      if (DIM == 2)
+      if (M(e) == 0) { return; } // ignore
+
+      constexpr int Q = T_Q1D ? T_Q1D : DofQuadLimits::HDIV_MAX_Q1D;
+      constexpr int D = T_D1D ? T_D1D : DofQuadLimits::HDIV_MAX_D1D;
+
+      MFEM_SHARED real_t sBot[Q*D];
+      MFEM_SHARED real_t sBct[Q*D];
+
+      // Bo and Bc into shared memory
+      const DeviceMatrix Bot(sBot, d-1, q);
+      kernels::internal::LoadB<D,Q>(d-1, q, BO, sBot);
+      const DeviceMatrix Bct(sBct, d, q);
+      kernels::internal::LoadB<D,Q>(d, q, BC, sBct);
+
+      MFEM_SHARED real_t sm0[vdim*Q*Q*Q];
+      MFEM_SHARED real_t sm1[vdim*Q*Q*Q];
+      DeviceTensor<4> QQQ(sm1, q, q, q, vdim);
+      DeviceTensor<4> DQQ(sm0, d, q, q, vdim);
+      DeviceTensor<4> DDQ(sm1, d, d, q, vdim);
+
+      MFEM_FOREACH_THREAD(vd,z,vdim)
       {
-         return HdivDLFAssemble2D<0, 0>;
+         const real_t cst_val_0 = C(0,0,0,0,0);
+         const real_t cst_val_1 = C(1,0,0,0,0);
+         const real_t cst_val_2 = C(2,0,0,0,0);
+         MFEM_FOREACH_THREAD(y,y,q)
+         {
+            MFEM_FOREACH_THREAD(x,x,q)
+            {
+               for (int z = 0; z < q; ++z)
+               {
+                  const real_t J0 = J(x,y,z,0,vd,e);
+                  const real_t J1 = J(x,y,z,1,vd,e);
+                  const real_t J2 = J(x,y,z,2,vd,e);
+                  const real_t C0 = cst ? cst_val_0 : C(0,x,y,z,e);
+                  const real_t C1 = cst ? cst_val_1 : C(1,x,y,z,e);
+                  const real_t C2 = cst ? cst_val_2 : C(2,x,y,z,e);
+                  QQQ(x,y,z,vd) = W(x,y,z)*(J0*C0 + J1*C1 + J2*C2);
+               }
+            }
+         }
       }
-      if (DIM == 3)
+      MFEM_SYNC_THREAD;
+      // Apply Bt operator
+      MFEM_FOREACH_THREAD(vd,z,vdim)
       {
-         return HdivDLFAssemble3D<0, 0>;
+         const int nx = (vd == 0) ? d : d-1;
+         DeviceMatrix Btx = (vd == 0) ? Bct : Bot;
+         MFEM_FOREACH_THREAD(qy,y,q)
+         {
+            MFEM_FOREACH_THREAD(dx,x,nx)
+            {
+               real_t u[Q];
+               MFEM_UNROLL(Q)
+               for (int qz = 0; qz < q; ++qz) { u[qz] = 0.0; }
+               MFEM_UNROLL(Q)
+               for (int qx = 0; qx < q; ++qx)
+               {
+                  MFEM_UNROLL(Q)
+                  for (int qz = 0; qz < q; ++qz)
+                  {
+                     u[qz] += QQQ(qx,qy,qz,vd) * Btx(dx,qx);
+                  }
+               }
+               MFEM_UNROLL(Q)
+               for (int qz = 0; qz < q; ++qz) { DQQ(dx,qy,qz,vd) = u[qz]; }
+            }
+         }
       }
-   }
-   else if (TestType == FiniteElement::CURL)
-   {
-      if (DIM == 3)
+      MFEM_SYNC_THREAD;
+      MFEM_FOREACH_THREAD(vd,z,vdim)
       {
-         return HcurlDLFAssemble3D<0, 0>;
+         const int nx = (vd == 0) ? d : d-1;
+         const int ny = (vd == 1) ? d : d-1;
+         DeviceMatrix Bty = (vd == 1) ? Bct : Bot;
+         MFEM_FOREACH_THREAD(dy,y,ny)
+         {
+            MFEM_FOREACH_THREAD(dx,x,nx)
+            {
+               real_t u[Q];
+               MFEM_UNROLL(Q)
+               for (int qz = 0; qz < q; ++qz) { u[qz] = 0.0; }
+               MFEM_UNROLL(Q)
+               for (int qy = 0; qy < q; ++qy)
+               {
+                  MFEM_UNROLL(Q)
+                  for (int qz = 0; qz < q; ++qz)
+                  {
+                     u[qz] += DQQ(dx,qy,qz,vd) * Bty(dy,qy);
+                  }
+               }
+               MFEM_UNROLL(Q)
+               for (int qz = 0; qz < q; ++qz) { DDQ(dx,dy,qz,vd) = u[qz]; }
+            }
+         }
       }
-   }
-   MFEM_ABORT("");
+      MFEM_SYNC_THREAD;
+      MFEM_FOREACH_THREAD(vd,z,vdim)
+      {
+         const int nx = (vd == 0) ? d : d-1;
+         const int ny = (vd == 1) ? d : d-1;
+         const int nz = (vd == 2) ? d : d-1;
+         DeviceTensor<5> Yxyz(Y, nx, ny, nz, vdim, ne);
+         DeviceMatrix Btz = (vd == 2) ? Bct : Bot;
+         MFEM_FOREACH_THREAD(dy,y,ny)
+         {
+            MFEM_FOREACH_THREAD(dx,x,nx)
+            {
+               real_t u[D];
+               MFEM_UNROLL(D)
+               for (int dz = 0; dz < nz; ++dz) { u[dz] = 0.0; }
+               MFEM_UNROLL(Q)
+               for (int qz = 0; qz < q; ++qz)
+               {
+                  MFEM_UNROLL(D)
+                  for (int dz = 0; dz < nz; ++dz)
+                  {
+                     u[dz] += DDQ(dx,dy,qz,vd) * Btz(dz,qz);
+                  }
+               }
+               MFEM_UNROLL(D)
+               for (int dz = 0; dz < nz; ++dz) { Yxyz(dx,dy,dz,vd,e) += u[dz]; }
+            }
+         }
+      }
+      MFEM_SYNC_THREAD;
+   });
+}
+
+static void HdivDLFAssemble(const FiniteElementSpace &fes,
+                            const IntegrationRule *ir,
+                            const Array<int> &markers,
+                            const Vector &coeff,
+                            Vector &y)
+{
+   Mesh &mesh = *fes.GetMesh();
+   const int dim = mesh.Dimension();
+   const FiniteElement *el = fes.GetTypicalFE();
+   const auto *vel = dynamic_cast<const VectorTensorFiniteElement *>(el);
+   MFEM_VERIFY(vel != nullptr, "Must be VectorTensorFiniteElement");
+   const MemoryType mt = Device::GetDeviceMemoryType();
+   const DofToQuad &maps_o = vel->GetDofToQuadOpen(*ir, DofToQuad::TENSOR);
+   const DofToQuad &maps_c = vel->GetDofToQuad(*ir, DofToQuad::TENSOR);
+   const int d = maps_c.ndof, q = maps_c.nqpt;
+   constexpr int flags = GeometricFactors::JACOBIANS;
+   const GeometricFactors *geom = mesh.GetGeometricFactors(*ir, flags, mt);
+   decltype(&HdivDLFAssemble2D<>) ker =
+      dim == 2 ? HdivDLFAssemble2D<> : HdivDLFAssemble3D<>;
+
+   if (dim==2)
+   {
+      if (d==1 && q==1) { ker=HdivDLFAssemble2D<1,1>; }
+      if (d==2 && q==2) { ker=HdivDLFAssemble2D<2,2>; }
+      if (d==3 && q==3) { ker=HdivDLFAssemble2D<3,3>; }
+      if (d==4 && q==4) { ker=HdivDLFAssemble2D<4,4>; }
+      if (d==5 && q==5) { ker=HdivDLFAssemble2D<5,5>; }
+      if (d==6 && q==6) { ker=HdivDLFAssemble2D<6,6>; }
+      if (d==7 && q==7) { ker=HdivDLFAssemble2D<7,7>; }
+      if (d==8 && q==8) { ker=HdivDLFAssemble2D<8,8>; }
+   }
+
+   if (dim==3)
+   {
+      if (d==2 && q==2) { ker=HdivDLFAssemble3D<2,2>; }
+      if (d==3 && q==3) { ker=HdivDLFAssemble3D<3,3>; }
+      if (d==4 && q==4) { ker=HdivDLFAssemble3D<4,4>; }
+      if (d==5 && q==5) { ker=HdivDLFAssemble3D<5,5>; }
+      if (d==6 && q==6) { ker=HdivDLFAssemble3D<6,6>; }
+      if (d==7 && q==7) { ker=HdivDLFAssemble3D<7,7>; }
+      if (d==8 && q==8) { ker=HdivDLFAssemble3D<8,8>; }
+   }
+
+   MFEM_VERIFY(ker, "No kernel ndof " << d << " nqpt " << q);
+
+   const int ne = mesh.GetNE();
+   const int *M = markers.Read();
+   const real_t *Bo = maps_o.B.Read();
+   const real_t *Bc = maps_c.B.Read();
+   const real_t *J = geom->J.Read();
+   const real_t *W = ir->GetWeights().Read();
+   real_t *Y = y.ReadWrite();
+   ker(ne, d, q, M, Bo, Bc, J, W, coeff, Y);
 }
-/// \endcond DO_NOT_DOCUMENT
 
 void VectorFEDomainLFIntegrator::AssembleDevice(const FiniteElementSpace &fes,
                                                 const Array<int> &markers,
@@ -96,23 +337,15 @@ void VectorFEDomainLFIntegrator::AssembleDevice(const FiniteElementSpace &fes,
    QuadratureSpace qs(*fes.GetMesh(), *ir);
    CoefficientVector coeff(QF, qs, CoefficientStorage::COMPRESSED);
 
-   const FiniteElement::DerivType fe_type =
-      static_cast<FiniteElement::DerivType>(fe.GetDerivType());
-
-   Mesh &mesh = *fes.GetMesh();
-   const int dim = mesh.Dimension();
-   const FiniteElement *el = fes.GetTypicalFE();
-   const auto *vel = dynamic_cast<const VectorTensorFiniteElement *>(el);
-   MFEM_VERIFY(vel != nullptr, "Must be VectorTensorFiniteElement");
-   const MemoryType mt = Device::GetDeviceMemoryType();
-   const DofToQuad &maps_o = vel->GetDofToQuadOpen(*ir, DofToQuad::TENSOR);
-   const DofToQuad &maps_c = vel->GetDofToQuad(*ir, DofToQuad::TENSOR);
-   const int d = maps_c.ndof, q = maps_c.nqpt;
-   constexpr int flags = GeometricFactors::JACOBIANS;
-   const GeometricFactors *geom = mesh.GetGeometricFactors(*ir, flags, mt);
-
-   AssembleKernels::Run(fe_type, dim, d, q, mesh.GetNE(), markers, geom->J,
-                        ir->GetWeights(), maps_o.B, maps_c.B, coeff, b, d, q);
+   const int fe_type = fe.GetDerivType();
+   if (fe_type == FiniteElement::DIV)
+   {
+      HdivDLFAssemble(fes, ir, markers, coeff, b);
+   }
+   else
+   {
+      MFEM_ABORT("Not implemented.");
+   }
 }
 
 } // namespace mfem

fem/lininteg.cpp

@@ -471,13 +471,6 @@ void VectorBoundaryLFIntegrator::AssembleRHSElementVect(
    }
 }
 
-VectorFEDomainLFIntegrator::VectorFEDomainLFIntegrator(
-   VectorCoefficient &F, const IntegrationRule *ir)
-   : DeltaLFIntegrator(F, ir), QF(F)
-{
-   static Kernels kernels{};
-}
-
 void VectorFEDomainLFIntegrator::AssembleRHSElementVect(
    const FiniteElement &el, ElementTransformation &Tr, Vector &elvect)
 {

fem/lininteg.hpp

@@ -369,8 +369,8 @@ private:
    Vector vec;
 
 public:
-   VectorFEDomainLFIntegrator(VectorCoefficient &F,
-                              const IntegrationRule *ir = nullptr);
+   VectorFEDomainLFIntegrator(VectorCoefficient &F)
+      : DeltaLFIntegrator(F), QF(F) { }
 
    void AssembleRHSElementVect(const FiniteElement &el,
                                ElementTransformation &Tr,
@@ -387,40 +387,6 @@ public:
                        Vector &b) override;
 
    using LinearFormIntegrator::AssembleRHSElementVect;
-
-   /// @param ne number of elements
-   /// @param markers array where entry markers[e] == 0 to skip assembly over
-   /// element e element
-   /// @param jac Spatial Jacobians evaluated at all quadrature points
-   /// @param weights 1D quadrature weights
-   /// @param testBO 1D open basis test functions
-   /// @param testBC 1D closed basis test functions
-   /// @param coeff coefficient values evaluated at quadrature points, possibly
-   /// compressed.
-   /// @param d number of 1D closed dofs
-   /// @param q number of 1D quadrature points
-   using AssembleKernelType = void (*)(const int NE, const Array<int> &markers,
-                                       const Vector &jac,
-                                       const Array<real_t> &weights,
-                                       const Array<real_t> &testBO,
-                                       const Array<real_t> &testBC,
-                                       const Vector &coeff, Vector &y,
-                                       const int testd1d, const int q1d);
-
-   /// parameters: test_fetype, ndims, test_d1d, q1d
-   MFEM_REGISTER_KERNELS(AssembleKernels, AssembleKernelType,
-                         (FiniteElement::DerivType, int, int, int));
-
-   struct Kernels
-   {
-      Kernels();
-   };
-
-   template <FiniteElement::DerivType TestType, int DIM, int TEST_D1D, int Q1D>
-   static void AddSpecialization()
-   {
-      AssembleKernels::Specialization<TestType, DIM, TEST_D1D, Q1D>::Add();
-   }
 };
 
 /// $ (Q, \mathrm{curl}(v))_{\Omega} $ for Nedelec Elements

fem/particleset.cpp

@@ -10,7 +10,6 @@
 // CONTRIBUTING.md for details.
 
 #include "particleset.hpp"
-#include "../general/forall.hpp"
 
 #if defined(MFEM_USE_MPI) && defined(MFEM_USE_GSLIB)
 
@@ -226,7 +225,6 @@ void ParticleSet::AddParticles(const Array<IDType> &new_ids,
       }
    }
    // Add new ids
-   ids.HostReadWrite();
    ids.Append(new_ids);
 
    // Update data
@@ -246,102 +244,6 @@ void ParticleSet::AddParticles(const Array<IDType> &new_ids,
 #if defined(MFEM_USE_MPI) && defined(MFEM_USE_GSLIB)
 
 /// \cond DO_NOT_DOCUMENT
-// Static helper: gather selected particle-vector entries into a compact buffer.
-// nvcc does not allow extended host/device lambdas in non-public members.
-static void GatherParticleVectorDevice(const ParticleVector &pv,
-                                       const Array<int> &send_idxs,
-                                       Vector &send_data,
-                                       int nsend)
-{
-   const int vdim = pv.GetVDim();
-   const int ordering = pv.GetOrdering();
-   const int num_particles = pv.GetNumParticles();
-   const MemoryClass device_mc = Device::GetDeviceMemoryClass();
-   send_data.SetSize(nsend*vdim);
-   real_t *d_send_data =
-      send_data.GetMemory().Write(device_mc, send_data.Size());
-   const real_t *d_src = pv.GetMemory().Read(device_mc, pv.Size());
-   const int *d_send_idxs = send_idxs.GetMemory().Read(device_mc, nsend);
-
-   mfem::forall(nsend, [=] MFEM_HOST_DEVICE (int i)
-   {
-      const int p = d_send_idxs[i];
-      const int offset = (ordering == Ordering::byVDIM) ? p * vdim : p;
-      const int stride = (ordering == Ordering::byVDIM) ? 1 : num_particles;
-
-      for (int c = 0; c < vdim; c++)
-      {
-         d_send_data[i*vdim + c] = d_src[offset + c*stride];
-      }
-   });
-}
-
-// Static helper: gather selected tag values into a compact buffer.
-// nvcc does not allow extended host/device lambdas in non-public members.
-static void GatherParticleTagsDevice(const Array<int> &tag,
-                                     const Array<int> &send_idxs,
-                                     Array<int> &send_tag,
-                                     int nsend)
-{
-   const MemoryClass device_mc = Device::GetDeviceMemoryClass();
-   send_tag.SetSize(nsend);
-   int *d_send_tag = send_tag.GetMemory().Write(device_mc, nsend);
-   const int *d_tag = tag.GetMemory().Read(device_mc, tag.Size());
-   const int *d_send_idxs = send_idxs.GetMemory().Read(device_mc, nsend);
-
-   mfem::forall(nsend, [=] MFEM_HOST_DEVICE (int i)
-   {
-      d_send_tag[i] = d_tag[d_send_idxs[i]];
-   });
-}
-
-// Static helper: scatter compact particle-vector entries to particle storage.
-// nvcc does not allow extended host/device lambdas in non-public members.
-static void ScatterParticleVectorDevice(ParticleVector &pv,
-                                        const Vector &recv_data,
-                                        const Array<int> &recv_locs,
-                                        int nrecv)
-{
-   const int vdim = pv.GetVDim();
-   const int ordering = pv.GetOrdering();
-   const int num_particles = pv.GetNumParticles();
-   const MemoryClass device_mc = Device::GetDeviceMemoryClass();
-   const real_t *d_recv_data =
-      recv_data.GetMemory().Read(device_mc, recv_data.Size());
-   const int *d_recv_locs = recv_locs.GetMemory().Read(device_mc, nrecv);
-   real_t *d_dst = pv.GetMemory().ReadWrite(device_mc, pv.Size());
-
-   mfem::forall(nrecv, [=] MFEM_HOST_DEVICE (int i)
-   {
-      const int p = d_recv_locs[i];
-      const int offset = (ordering == Ordering::byVDIM) ? p * vdim : p;
-      const int stride = (ordering == Ordering::byVDIM) ? 1 : num_particles;
-
-      for (int c = 0; c < vdim; c++)
-      {
-         d_dst[offset + c*stride] = d_recv_data[i*vdim + c];
-      }
-   });
-}
-
-// Static helper: scatter compact tag values to particle storage.
-// nvcc does not allow extended host/device lambdas in non-public members.
-static void ScatterParticleTagsDevice(Array<int> &tag,
-                                      const Array<int> &recv_tag,
-                                      const Array<int> &recv_locs,
-                                      int nrecv)
-{
-   const MemoryClass device_mc = Device::GetDeviceMemoryClass();
-   const int *d_recv_tag = recv_tag.GetMemory().Read(device_mc, nrecv);
-   const int *d_recv_locs = recv_locs.GetMemory().Read(device_mc, nrecv);
-   int *d_tag = tag.GetMemory().ReadWrite(device_mc, tag.Size());
-
-   mfem::forall(nrecv, [=] MFEM_HOST_DEVICE (int i)
-   {
-      d_tag[d_recv_locs[i]] = d_recv_tag[i];
-   });
-}
-
 template<size_t NBytes>
 void ParticleSet::TransferParticlesImpl(ParticleSet &pset,
                                         const Array<int> &send_idxs,
@@ -364,129 +266,49 @@ void ParticleSet::TransferParticlesImpl(ParticleSet &pset,
    array_init(parr_t, &gsl_arr, send_idxs.Size());
    pdata_arr = (parr_t*) gsl_arr.ptr;
 
-   int nparticles = pset.GetNParticles();
-   int nsend      = send_idxs.Size();
    gsl_arr.n = send_idxs.Size();
-
-   const int *h_send_idxs_initial = send_idxs.HostRead();
-   const IDType *h_ids = pset.GetIDs().HostRead();
    for (int i = 0; i < send_idxs.Size(); i++)
    {
       parr_t &pdata = pdata_arr[i];
-      pdata.id = h_ids[h_send_idxs_initial[i]];
-   }
+      pdata.id = pset.GetIDs()[send_idxs[i]];
 
-   // Pack coords and fields into the GSLIB send buffer. Device-resident data
-   // is first gathered into a compact device buffer so that only selected
-   // particles are copied back to host. Host-resident data is packed directly.
-   int max_vdim = pset.Coords().GetVDim();
-   for (int f = 0; f < pset.GetNFields(); f++)
-   {
-      int f_vdim = pset.Field(f).GetVDim();
-      if (f_vdim > max_vdim) { max_vdim = f_vdim; }
-   }
-   Vector send_data;
-   Array<int> send_tag;
-   if (Device::IsEnabled())
-   {
-      send_data.SetSize(nsend * max_vdim); // allocate max size over all fields
-      send_tag.SetSize(nsend);
-   }
-
-   size_t counter = 0;
-   for (int f = -1; f < pset.GetNFields(); f++)
-   {
-      const ParticleVector &pv = f == -1 ? pset.Coords() : pset.Field(f);
-      const int vdim = pv.GetVDim();
-      const int ordering = pv.GetOrdering();
-      const int num_particles = pv.GetNumParticles();
-      const bool use_dev = Device::IsEnabled() && pv.UseDevice();
-
-      if (use_dev)
+      // Copy particle data directly into pdata
+      size_t counter = 0;
+      for (int f = -1; f < pset.GetNFields(); f++)
       {
-         GatherParticleVectorDevice(pv, send_idxs, send_data, nsend);
-
-         const real_t *h_send_data = send_data.HostRead();
-         for (int i = 0; i < nsend; i++)
+         ParticleVector &pv = (f == -1 ? pset.Coords() : pset.Field(f));
+         for (int c = 0; c < pv.GetVDim(); c++)
          {
-            std::memcpy(pdata_arr[i].data.data() + counter,
-                        h_send_data + i*vdim, vdim * sizeof(real_t));
-         }
-      }
-      else
-      {
-         const real_t *h_src = pv.HostRead();
-         const int *h_send_idxs = send_idxs.HostRead();
-         for (int i = 0; i < nsend; i++)
-         {
-            parr_t &pdata = pdata_arr[i];
-            const int p = h_send_idxs[i];
-            const int offset = (ordering == Ordering::byVDIM) ? p * vdim : p;
-            const int stride = (ordering == Ordering::byVDIM) ? 1 :
-                               num_particles;
-
-            for (int c = 0; c < vdim; c++)
-            {
-               std::memcpy(pdata.data.data() + counter + c*sizeof(real_t),
-                           h_src + offset + c*stride, sizeof(real_t));
-            }
+            std::memcpy(pdata.data.data() + counter, &pv(send_idxs[i], c),
+                        sizeof(real_t));
+            counter += sizeof(real_t);
          }
       }
 
-      counter += vdim*sizeof(real_t);
-   }
-
-   // Pack tags after all real_t data. Each tag uses the same selective
-   // device gather path when its Array is device-resident.
-   for (int t = 0; t < pset.GetNTags(); t++)
-   {
-      const Array<int> &tag = pset.Tag(t);
-      const size_t tag_counter = counter + t*sizeof(int);
-      const bool use_dev = Device::IsEnabled() && tag.UseDevice();
-
-      if (use_dev)
+      // Copy tags
+      for (int t = 0; t < pset.GetNTags(); t++)
       {
-         GatherParticleTagsDevice(tag, send_idxs, send_tag, nsend);
-
-         const int *h_send_tag = send_tag.HostRead();
-         for (int i = 0; i < nsend; i++)
-         {
-            std::memcpy(pdata_arr[i].data.data() + tag_counter,
-                        h_send_tag + i, sizeof(int));
-         }
-      }
-      else
-      {
-         const int *h_tag = tag.HostRead();
-         const int *h_send_idxs = send_idxs.HostRead();
-         for (int i = 0; i < nsend; i++)
-         {
-            std::memcpy(pdata_arr[i].data.data() + tag_counter,
-                        h_tag + h_send_idxs[i], sizeof(int));
-         }
+         Array<int> &tag_arr = pset.Tag(t);
+         std::memcpy(pdata.data.data() + counter, &tag_arr[send_idxs[i]],
+                     sizeof(int));
+         counter += sizeof(int);
       }
    }
 
+   int nparticles = pset.GetNParticles();
+   int nsend      = send_idxs.Size();
+
    // Transfer particles
    sarray_transfer_ext(parr_t, &gsl_arr, send_ranks.GetData(),
                        sizeof(unsigned int), pset.cr);
 
    // Make sure we have enough space for received particles
    int nrecv = (int) gsl_arr.n;
-
-   Vector recv_data;
-   Array<int> recv_tag;
-   if (Device::IsEnabled())
-   {
-      recv_data.SetSize(nrecv * max_vdim);
-      recv_tag.SetSize(nrecv);
-   }
-
    int ndelete = nsend - nrecv;
    if (ndelete > 0)
    {
       // Remove unneeded particles
-      auto datap = const_cast<int*>(send_idxs.HostRead());
+      auto datap = const_cast<int*>(send_idxs.GetData());
       Array<int> delete_idxs(datap + nrecv, ndelete);
       pset.RemoveParticles(delete_idxs);
    }
@@ -497,133 +319,47 @@ void ParticleSet::TransferParticlesImpl(ParticleSet &pset,
 
    pdata_arr = (parr_t*) gsl_arr.ptr;
 
-   // Make a list of new IDs to add
-   int num_new = nrecv > nsend ? nrecv - nsend : 0;
-   Array<IDType> new_ids(num_new);
-   for (int i = 0; i < num_new; i++)
-   {
-      new_ids[i] = pdata_arr[nsend + i].id;
-   }
-
-   // Add particles in batch
-   Array<int> new_indices;
-   if (num_new > 0)
-   {
-      pset.AddParticles(new_ids, &new_indices);
-   }
-
-   // Map each received packet to the local particle slot it updates.
-   Array<int> recv_locs(nrecv);
-   int *h_recv_locs = recv_locs.HostWrite();
-   const int *h_send_idxs_recv = send_idxs.HostRead();
+   // Add newly-recvd data directly to active state
    for (int i = 0; i < nrecv; i++)
    {
       parr_t &pdata = pdata_arr[i];
+      IDType id = pdata.id;
+
+      int new_loc_idx;
       if (i < nsend) // update existing particle
       {
-         h_recv_locs[i] = h_send_idxs_recv[i];
-         pset.UpdateID(h_recv_locs[i], pdata.id);
+         new_loc_idx = send_idxs[i];
+         pset.UpdateID(new_loc_idx, id);
       }
       else
       {
-         h_recv_locs[i] = new_indices[i - nsend];
+         // add new particle
+         Array<int> idx_temp;
+         pset.AddParticles(Array<IDType>({id}), &idx_temp);
+         new_loc_idx = idx_temp[0]; // Get index of newly-added particle
       }
-   }
 
-   // Unpack coords and fields from GSLIB host packets. Device-resident
-   // destinations use a compact host buffer followed by a device scatter.
-   size_t recv_counter = 0;
-   for (int f = -1; f < pset.GetNFields(); f++)
-   {
-      ParticleVector &pv = (f == -1 ? pset.Coords() : pset.Field(f));
-      const int vdim = pv.GetVDim();
-      const int ordering = pv.GetOrdering();
-      const int num_particles = pv.GetNumParticles();
-      const bool use_dev = Device::IsEnabled() && pv.UseDevice();
-
-      if (use_dev)
+      size_t counter = 0;
+      for (int f = -1; f < pset.GetNFields(); f++)
       {
-         recv_data.SetSize(nrecv*vdim);
-         real_t *h_recv_data = recv_data.HostWrite();
-
-         for (int i = 0; i < nrecv; i++)
+         ParticleVector &pv = (f == -1 ? pset.Coords() : pset.Field(f));
+         for (int c = 0; c < pv.GetVDim(); c++)
          {
-            std::memcpy(h_recv_data + i*vdim,
-                        pdata_arr[i].data.data() + recv_counter,
-                        vdim*sizeof(real_t));
-         }
-
-         ScatterParticleVectorDevice(pv, recv_data, recv_locs, nrecv);
-      }
-      else
-      {
-         real_t *h_dst = pv.HostReadWrite();
-         const int *h_recv_locs_read = recv_locs.HostRead();
-         for (int i = 0; i < nrecv; i++)
-         {
-            parr_t &pdata = pdata_arr[i];
-            const int p = h_recv_locs_read[i];
-            const int offset = (ordering == Ordering::byVDIM) ? p * vdim : p;
-            const int stride = (ordering == Ordering::byVDIM) ? 1 :
-                               num_particles;
-
-            for (int c = 0; c < vdim; c++)
-            {
-               std::memcpy(h_dst + offset + c*stride,
-                           pdata.data.data() + recv_counter + c*sizeof(real_t),
-                           sizeof(real_t));
-            }
+            real_t& val = pv(new_loc_idx, c);
+            std::memcpy(&val, pdata.data.data() + counter, sizeof(real_t));
+            counter += sizeof(real_t);
          }
       }
 
-      recv_counter += vdim*sizeof(real_t);
-   }
-
-   // Unpack tags after all real_t data, using the same compact scatter path
-   // for device-resident tag arrays.
-   for (int t = 0; t < pset.GetNTags(); t++)
-   {
-      Array<int> &tag = pset.Tag(t);
-      const size_t tag_counter = recv_counter + t*sizeof(int);
-      const bool use_dev = Device::IsEnabled() && tag.UseDevice();
-
-      if (use_dev)
+      for (int t = 0; t < pset.GetNTags(); t++)
       {
-         recv_tag.SetSize(nrecv);
-         int *h_recv_tag = recv_tag.HostWrite();
-
-         for (int i = 0; i < nrecv; i++)
-         {
-            std::memcpy(h_recv_tag + i,
-                        pdata_arr[i].data.data() + tag_counter, sizeof(int));
-         }
-
-         ScatterParticleTagsDevice(tag, recv_tag, recv_locs, nrecv);
-      }
-      else
-      {
-         int *h_tag = tag.HostReadWrite();
-         const int *h_recv_locs_read = recv_locs.HostRead();
-         for (int i = 0; i < nrecv; i++)
-         {
-            std::memcpy(h_tag + h_recv_locs_read[i],
-                        pdata_arr[i].data.data() + tag_counter, sizeof(int));
-         }
+         Array<int> &tag_arr = pset.Tag(t);
+         std::memcpy(&tag_arr[new_loc_idx],
+                     pdata.data.data() + counter, sizeof(int));
+         counter += sizeof(int);
       }
    }
    array_free(&gsl_arr);
-
-   // Restore Device validity if needed
-   for (int f = -1; f < pset.GetNFields(); f++)
-   {
-      ParticleVector &pv = (f == -1 ? pset.Coords() : pset.Field(f));
-      pv.ReadWrite(pv.UseDevice());
-   }
-   for (int t = 0; t < pset.GetNTags(); t++)
-   {
-      Array<int> &tag_arr = pset.Tag(t);
-      if (tag_arr.UseDevice()) { tag_arr.ReadWrite(true); }
-   }
 }
 
 template<size_t NBytes>
@@ -790,14 +526,11 @@ ParticleSet::ParticleSet(int id_stride_, IDType id_counter_, int num_particles,
                          int dim, Ordering::Type coords_ordering, const Array<int> &field_vdims,
                          const Array<Ordering::Type> &field_orderings,
                          const Array<const char*> &field_names_, int num_tags,
-                         const Array<const char*> &tag_names_,
-                         bool use_device)
+                         const Array<const char*> &tag_names_)
    : id_stride(id_stride_),
      id_counter(id_counter_),
      coords(dim, coords_ordering)
 {
-   if (use_device) { coords.UseDevice(true); }
-
    // Initialize fields
    for (int f = 0; f < field_vdims.Size(); f++)
    {
@@ -847,22 +580,21 @@ bool ParticleSet::IsValidParticle(const Particle &p) const
 }
 
 ParticleSet::ParticleSet(int num_particles, int dim,
-                         Ordering::Type coords_ordering,
-                         bool use_device)
+                         Ordering::Type coords_ordering)
    : ParticleSet(1, 0, num_particles, dim, coords_ordering, Array<int>(),
                  Array<Ordering::Type>(), Array<const char*>(), 0,
-                 Array<const char*>(), use_device)
+                 Array<const char*>())
 {
 
 }
 
 ParticleSet::ParticleSet(int num_particles, int dim,
                          const Array<int> &field_vdims, int num_tags,
-                         Ordering::Type all_ordering, bool use_device)
+                         Ordering::Type all_ordering)
    : ParticleSet(1, 0, num_particles, dim, all_ordering, field_vdims,
                  GetOrderingArray(all_ordering, field_vdims.Size()),
                  GetEmptyNameArray(field_vdims.Size()), num_tags,
-                 GetEmptyNameArray(num_tags), use_device)
+                 GetEmptyNameArray(num_tags))
 {
 }
 
@@ -870,11 +602,11 @@ ParticleSet::ParticleSet(int num_particles, int dim,
                          const Array<int> &field_vdims, const Array<const
                          char*> &field_names_, int num_tags,
                          const Array<const char*> &tag_names_,
-                         Ordering::Type all_ordering, bool use_device)
+                         Ordering::Type all_ordering)
    : ParticleSet(1, 0, num_particles, dim, all_ordering, field_vdims,
                  GetOrderingArray(all_ordering, field_vdims.Size()),
                  field_names_, num_tags,
-                 tag_names_, use_device)
+                 tag_names_)
 {
 
 }
@@ -884,9 +616,9 @@ ParticleSet::ParticleSet(int num_particles, int dim,
                          const Array<int> &field_vdims,
                          const Array<Ordering::Type> &field_orderings,
                          const Array<const char*> &field_names_, int num_tags,
-                         const Array<const char*> &tag_names_, bool use_device)
+                         const Array<const char*> &tag_names_)
    : ParticleSet(1, 0, num_particles, dim, coords_ordering, field_vdims,
-                 field_orderings, field_names_, num_tags, tag_names_, use_device)
+                 field_orderings, field_names_, num_tags, tag_names_)
 {
 
 }
@@ -895,21 +627,21 @@ ParticleSet::ParticleSet(int num_particles, int dim,
 
 #ifdef MFEM_USE_MPI
 ParticleSet::ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
-                         Ordering::Type coords_ordering, bool use_device)
+                         Ordering::Type coords_ordering)
    : ParticleSet(comm_, rank_num_particles, dim, coords_ordering, Array<int>(),
                  Array<Ordering::Type>(), Array<const char*>(), 0,
-                 Array<const char*>(), use_device)
+                 Array<const char*>())
 {
 
 };
 
 ParticleSet::ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
                          const Array<int> &field_vdims, int num_tags,
-                         Ordering::Type all_ordering, bool use_device)
+                         Ordering::Type all_ordering)
    : ParticleSet(comm_, rank_num_particles, dim, all_ordering, field_vdims,
                  GetOrderingArray(all_ordering, field_vdims.Size()),
                  GetEmptyNameArray(field_vdims.Size()), num_tags,
-                 GetEmptyNameArray(num_tags), use_device)
+                 GetEmptyNameArray(num_tags))
 {
 
 }
@@ -918,11 +650,11 @@ ParticleSet::ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
                          const Array<int> &field_vdims, const Array<const
                          char*> &field_names_,
                          int num_tags, const Array<const char*> &tag_names_,
-                         Ordering::Type all_ordering, bool use_device)
+                         Ordering::Type all_ordering)
    : ParticleSet(comm_, rank_num_particles, dim, all_ordering, field_vdims,
                  GetOrderingArray(all_ordering, field_vdims.Size()),
                  field_names_, num_tags,
-                 tag_names_, use_device)
+                 tag_names_)
 {
 
 }
@@ -932,7 +664,7 @@ ParticleSet::ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
                          const Array<int> &field_vdims,
                          const Array<Ordering::Type> &field_orderings,
                          const Array<const char*> &field_names_, int num_tags,
-                         const Array<const char*> &tag_names_, bool use_device)
+                         const Array<const char*> &tag_names_)
    : ParticleSet(GetSize(comm_), (IDType)GetRank(comm_),
                  rank_num_particles,
                  dim,
@@ -941,7 +673,7 @@ ParticleSet::ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
                  field_orderings,
                  field_names_,
                  num_tags,
-                 tag_names_, use_device)
+                 tag_names_)
 {
    comm = comm_;
 #ifdef MFEM_USE_GSLIB
@@ -973,7 +705,6 @@ int ParticleSet::AddField(int vdim, Ordering::Type field_ordering,
    }
    fields.emplace_back(std::make_unique<ParticleVector>(vdim, field_ordering,
                                                         GetNParticles()));
-   if (coords.UseDevice()) { fields.back()->UseDevice(true); }
    field_names.emplace_back(field_name_str);
 
    return GetNFields() - 1;
@@ -987,7 +718,6 @@ int ParticleSet::AddTag(const char* tag_name)
       tag_name_str = GetDefaultTagName(tag_names.size());
    }
    tags.emplace_back(std::make_unique<Array<int>>(GetNParticles()));
-   if (coords.UseDevice()) { tags.back()->GetMemory().UseDevice(true); }
    tag_names.emplace_back(tag_name_str);
 
    return GetNTags() - 1;
@@ -1052,7 +782,7 @@ Particle ParticleSet::GetParticle(int i) const
 
    for (int t = 0; t < GetNTags(); t++)
    {
-      p.Tag(t) = Tag(t).HostRead()[i];
+      p.Tag(t) = Tag(t)[i];
    }
 
    return p;
@@ -1060,21 +790,13 @@ Particle ParticleSet::GetParticle(int i) const
 
 bool ParticleSet::IsParticleRefValid() const
 {
-   if (coords.GetOrdering() == Ordering::byNODES || coords.UseDevice())
+   if (coords.GetOrdering() == Ordering::byNODES)
    {
       return false;
    }
    for (int f = 0; f < GetNFields(); f++)
    {
-      if (fields[f]->GetOrdering() == Ordering::byNODES ||
-          fields[f]->UseDevice())
-      {
-         return false;
-      }
-   }
-   for (int t = 0; t < GetNTags(); t++)
-   {
-      if (tags[t]->UseDevice())
+      if (fields[f]->GetOrdering() == Ordering::byNODES)
       {
          return false;
       }
@@ -1084,10 +806,6 @@ bool ParticleSet::IsParticleRefValid() const
 
 Particle ParticleSet::GetParticleRef(int i)
 {
-   MFEM_ASSERT(IsParticleRefValid(),
-               "GetParticleRef is only valid when coordinates and fields are "
-               "ordered byVDIM and particle data is host-resident.");
-
    Particle p = CreateParticle();
 
    Coords().GetValuesRef(i, p.Coords());
@@ -1121,7 +839,7 @@ void ParticleSet::SetParticle(int i, const Particle &p)
 
    for (int t = 0; t < GetNTags(); t++)
    {
-      Tag(t).HostReadWrite()[i] = p.Tag(t);
+      Tag(t)[i] = p.Tag(t);
    }
 }
 
@@ -1182,15 +900,6 @@ void ParticleSet::PrintCSV(const char *fname, const Array<int> &field_idxs,
 #ifdef MFEM_USE_MPI
    int rank = GetRank(comm);
 #endif // MFEM_USE_MPI
-   // make sure we can read tag data on host. fields and coords will be read as
-   // needed in the loop below, so we don't need to pre-read them here.
-   for (int i = 0; i < GetNTags(); i++)
-   {
-      tags[i]->HostRead();
-   }
-   ids.HostRead();
-
-   // Write particle data
    for (int i = 0; i < GetNParticles(); i++)
    {
       ss_data << ids[i];

fem/particleset.hpp

@@ -211,12 +211,6 @@ public:
  *  byVDIM). The unique_ptrs to all the ParticleVectors are stored in the
  *  std::vector \ref fields.
  *
- *  @par Device Behavior:
- *  When a ParticleSet is constructed with \p use_device=true, \ref coords and
- *  all ParticleVector fields are marked to use device memory. Fields added
- *  later through \ref AddField inherit the current device mode (through
- *  \ref coords).
- *
  *  @par Tags:
  *  Tags represent integers associated with each particle. For a given tag,
  *  all particle data are stored in a single Array<int>. The unique_ptrs to all
@@ -375,10 +369,7 @@ protected:
     *  ID of a particle.
     */
    void UpdateID(int local_idx, IDType new_global_id)
-   {
-      ids.HostReadWrite();
-      ids[local_idx] = new_global_id;
-   }
+   { ids[local_idx] = new_global_id; }
 
    /** @brief Create a Particle object with the same spatial dimension,
     *  number of fields and field vdims, and number of tags as this ParticleSet.
@@ -408,14 +399,12 @@ protected:
     *  @param[in] field_names_        Array of field names.
     *  @param[in] num_tags            Number of tags to register.
     *  @param[in] tag_names_          Array of tag names.
-    *  @param[in] use_device          Use device memory for particle fields.
     */
    ParticleSet(int id_stride_, IDType id_counter_, int num_particles, int dim,
                Ordering::Type coords_ordering, const Array<int> &field_vdims,
                const Array<Ordering::Type> &field_orderings,
                const Array<const char*> &field_names_, int num_tags,
-               const Array<const char*> &tag_names_,
-               bool use_device);
+               const Array<const char*> &tag_names_);
 
 public:
 
@@ -424,12 +413,9 @@ public:
     *  @param[in] num_particles       Number of particles to initialize.
     *  @param[in] dim                 Particle spatial dimension.
     *  @param[in] coords_ordering     Ordering of coordinates.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(int num_particles, int dim,
-               Ordering::Type coords_ordering=Ordering::byVDIM,
-               bool use_device=false);
+               Ordering::Type coords_ordering=Ordering::byVDIM);
 
    /** @brief Construct a serial ParticleSet with specified fields and tags at
     *  construction.
@@ -440,12 +426,9 @@ public:
     *  @param[in] num_tags            Number of tags to register.
     *  @param[in] all_ordering        (Optional) Ordering of coordinates and
     *                                 field ParticleVector.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(int num_particles, int dim, const Array<int> &field_vdims,
-               int num_tags, Ordering::Type all_ordering=Ordering::byVDIM,
-               bool use_device=false);
+               int num_tags, Ordering::Type all_ordering=Ordering::byVDIM);
 
    /** @brief Construct a serial ParticleSet with specified fields and tags at
     *  construction, with names.
@@ -458,14 +441,11 @@ public:
     *  @param[in] tag_names_          Array of tag names.
     *  @param[in] all_ordering        (Optional) Ordering of coordinates and
     *                                 field ParticleVector.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(int num_particles, int dim, const Array<int> &field_vdims,
                const Array<const char*> &field_names_, int num_tags,
                const Array<const char*> &tag_names_,
-               Ordering::Type all_ordering=Ordering::byVDIM,
-               bool use_device=false);
+               Ordering::Type all_ordering=Ordering::byVDIM);
 
    /** @brief Comprehensive serial constructor of ParticleSet.
     *
@@ -477,15 +457,12 @@ public:
     *  @param[in] field_names_        Array of field names.
     *  @param[in] num_tags            Number of tags to register.
     *  @param[in] tag_names_          Array of tag names.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(int num_particles, int dim, Ordering::Type coords_ordering,
                const Array<int> &field_vdims,
                const Array<Ordering::Type> &field_orderings,
                const Array<const char*> &field_names_, int num_tags,
-               const Array<const char*> &tag_names_,
-               bool use_device=false);
+               const Array<const char*> &tag_names_);
 
 #ifdef MFEM_USE_MPI
    /** @brief Construct a parallel ParticleSet.
@@ -494,12 +471,9 @@ public:
     *  @param[in] rank_num_particles  Number of particles to initialize.
     *  @param[in] dim                 Particle spatial dimension.
     *  @param[in] coords_ordering     (Optional) Ordering of coordinates.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
-               Ordering::Type coords_ordering=Ordering::byVDIM,
-               bool use_device=false);
+               Ordering::Type coords_ordering=Ordering::byVDIM);
 
    /** @brief Construct a parallel ParticleSet with specified fields and tags
     *  at construction.
@@ -511,13 +485,10 @@ public:
     *  @param[in] num_tags            Number of tags to register.
     *  @param[in] all_ordering        (Optional) Ordering of coordinates and
     *                                 field ParticleVector.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
                const Array<int> &field_vdims, int num_tags,
-               Ordering::Type all_ordering=Ordering::byVDIM,
-               bool use_device=false);
+               Ordering::Type all_ordering=Ordering::byVDIM);
 
    /** @brief Construct a parallel ParticleSet with specified fields and tags
     *  at construction, with names (for PrintCSV()).
@@ -531,15 +502,12 @@ public:
     *  @param[in] tag_names_          Array of tag names.
     *  @param[in] all_ordering        (Optional) Ordering of coordinates and
     *                                 field ParticleVector.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
                const Array<int> &field_vdims,
                const Array<const char*> &field_names_,
                int num_tags, const Array<const char*> &tag_names_,
-               Ordering::Type all_ordering=Ordering::byVDIM,
-               bool use_device=false);
+               Ordering::Type all_ordering=Ordering::byVDIM);
 
    /** @brief Comprehensive parallel constructor of ParticleSet.
     *
@@ -552,15 +520,12 @@ public:
     *  @param[in] field_names_        Array of field names.
     *  @param[in] num_tags            Number of tags to register.
     *  @param[in] tag_names_          Array of tag names.
-    *  @param[in] use_device          (Optional) Use device memory for particle
-    *                                 fields.
     */
    ParticleSet(MPI_Comm comm_, int rank_num_particles, int dim,
                Ordering::Type coords_ordering, const Array<int> &field_vdims,
                const Array<Ordering::Type> &field_orderings,
                const Array<const char*> &field_names_, int num_tags,
-               const Array<const char*> &tag_names_,
-               bool use_device=false);
+               const Array<const char*> &tag_names_);
 
    /// Get the MPI communicator for this ParticleSet.
    MPI_Comm GetComm() const { return comm; };
@@ -580,8 +545,6 @@ public:
     *  @param[in] field_ordering   (Optional) Ordering::Type of the field.
     *  @param[in] field_name       (Optional) Name of the field.
     *
-    *  @note New fields inherit the current device mode of \ref coords.
-    *
     *  @return Index of the newly-added field.
     */
    int AddField(int vdim, Ordering::Type field_ordering=Ordering::byVDIM,
@@ -674,8 +637,8 @@ public:
 
    /** @brief Determine if GetParticleRef is valid.
     *
-    * Returns true when coordinates and all fields are ordered byVDIM and
-    * particle data is host-resident. Otherwise, false.
+    * If coordinates and all fields are ordered byVDIM, then returns true.
+    * Otherwise, false.
     */
    bool IsParticleRefValid() const;
 

fem/transfer.cpp

@@ -1030,12 +1030,42 @@ void L2ProjectionGridTransfer::L2ProjectionL2Space::EAProlongateTranspose(
    BatchedLinAlg::MultTranspose(P_dt, x, y);
 }
 
+L2ProjectionGridTransfer::L2ProjectionH1Space::H1ConsistentMassOperator::
+H1ConsistentMassOperator(const Operator &M_LH_, const Solver &M_L_solver_)
+   : Operator(M_LH_.Height(), M_LH_.Width()),
+     M_LH(M_LH_),
+     M_L_solver(M_L_solver_)
+{
+   MFEM_VERIFY(M_LH.Height() == M_L_solver.Height() &&
+               M_LH.Height() == M_L_solver.Width(),
+               "incompatible consistent mass operator dimensions");
+}
+
+void L2ProjectionGridTransfer::L2ProjectionH1Space::H1ConsistentMassOperator::
+Mult(const Vector &x, Vector &y) const
+{
+   Vector tmp(M_LH.Height());
+   M_LH.Mult(x, tmp);
+   M_L_solver.Mult(tmp, y);
+}
+
+void L2ProjectionGridTransfer::L2ProjectionH1Space::H1ConsistentMassOperator::
+MultTranspose(const Vector &x, Vector &y) const
+{
+   Vector tmp(M_LH.Height());
+   M_L_solver.Mult(x, tmp);
+   M_LH.MultTranspose(tmp, y);
+}
+
 L2ProjectionGridTransfer::L2ProjectionH1Space::L2ProjectionH1Space(
    const FiniteElementSpace& fes_ho_, const FiniteElementSpace& fes_lor_,
-   const bool use_ea_, MemoryType d_mt_)
+   const bool use_ea_, const bool use_consistent_mass_, MemoryType d_mt_)
    : L2Projection(fes_ho_, fes_lor_, d_mt_),
-     use_ea(use_ea_)
+     use_ea(use_ea_),
+     use_consistent_mass(use_consistent_mass_)
 {
+   MFEM_VERIFY(!(use_ea && use_consistent_mass),
+               "consistent mass is not supported with element assembly");
 
    // need scalar to keep dimensions matching (operators are built to apply
    // individually on each vdim)
@@ -1053,7 +1083,7 @@ L2ProjectionGridTransfer::L2ProjectionH1Space::L2ProjectionH1Space(
 
    std::unique_ptr<SparseMatrix> R_mat, M_LH_mat;
 
-   std::tie(R_mat, M_LH_mat) = ComputeSparseRAndM_LH();
+   std::tie(R_mat, M_LH_mat) = ComputeSparseRAndM_LH(!use_consistent_mass);
 
    const SparseMatrix *P_ho = fes_ho_scalar->GetConformingProlongation();
    const SparseMatrix *P_lor = fes_lor_scalar->GetConformingProlongation();
@@ -1062,40 +1092,71 @@ L2ProjectionGridTransfer::L2ProjectionH1Space::L2ProjectionH1Space(
    {
       if (P_ho && P_lor)
       {
-         R_mat.reset(RAP(*P_lor, *R_mat, *P_ho));
+         if (R_mat) { R_mat.reset(RAP(*P_lor, *R_mat, *P_ho)); }
          M_LH_mat.reset(RAP(*P_lor, *M_LH_mat, *P_ho));
       }
       else if (P_ho)
       {
-         R_mat.reset(mfem::Mult(*R_mat, *P_ho));
+         if (R_mat) { R_mat.reset(mfem::Mult(*R_mat, *P_ho)); }
          M_LH_mat.reset(mfem::Mult(*M_LH_mat, *P_ho));
       }
       else // P_lor != nullptr
       {
-         R_mat.reset(mfem::Mult(*P_lor, *R_mat));
+         if (R_mat) { R_mat.reset(mfem::Mult(*P_lor, *R_mat)); }
          M_LH_mat.reset(mfem::Mult(*P_lor, *M_LH_mat));
       }
    }
 
-   SparseMatrix *RTxM_LH_mat = TransposeMult(*R_mat, *M_LH_mat);
-   precon.reset(new DSmoother(*RTxM_LH_mat));
+   if (use_consistent_mass)
+   {
+      BilinearForm M_lor(fes_lor_scalar.get());
+      M_lor.AddDomainIntegrator(new MassIntegrator);
+      M_lor.Assemble();
+      M_lor.Finalize();
+      SparseMatrix *M_L_mat = M_lor.LoseMat();
 
-   // Set ownership
-   RTxM_LH.reset(RTxM_LH_mat);
-   R = std::move(R_mat);
-   M_LH = std::move(M_LH_mat);
+      ML_precon.reset(new DSmoother(*M_L_mat));
+      ML_pcg.SetPrintLevel(0);
+      ML_pcg.SetMaxIter(1000);
+      ML_pcg.SetRelTol(1e-13);
+      ML_pcg.SetAbsTol(1e-13);
+      ML_pcg.SetPreconditioner(*ML_precon);
+      ML_pcg.SetOperator(*M_L_mat);
+      // Start each solve from zero so repeated Operator::Mult() calls do not
+      // depend on the output vector contents supplied by the caller.
+      ML_pcg.iterative_mode = false;
 
-   SetupPCG();
+      M_L.reset(M_L_mat);
+      M_LH = std::move(M_LH_mat);
+      R.reset(new H1ConsistentMassOperator(*M_LH, ML_pcg));
+   }
+   else
+   {
+      SparseMatrix *RTxM_LH_mat = TransposeMult(*R_mat, *M_LH_mat);
+      precon.reset(new DSmoother(*RTxM_LH_mat));
+
+      // Set ownership
+      RTxM_LH.reset(RTxM_LH_mat);
+      R = std::move(R_mat);
+      M_LH = std::move(M_LH_mat);
+
+      SetupPCG();
+   }
 }
 
 #ifdef MFEM_USE_MPI
 
 L2ProjectionGridTransfer::L2ProjectionH1Space::L2ProjectionH1Space(
    const ParFiniteElementSpace& pfes_ho, const ParFiniteElementSpace& pfes_lor,
-   const bool use_ea_, MemoryType d_mt_)
+   const bool use_ea_, const bool use_consistent_mass_, MemoryType d_mt_)
    : L2Projection(pfes_ho, pfes_lor, d_mt_),
-     use_ea(use_ea_), pcg(pfes_ho.GetComm())
+     use_ea(use_ea_),
+     use_consistent_mass(use_consistent_mass_),
+     ML_pcg(pfes_ho.GetComm()),
+     pcg(pfes_ho.GetComm())
 {
+   MFEM_VERIFY(!(use_ea && use_consistent_mass),
+               "consistent mass is not supported with element assembly");
 
    // need scalar to keep dimensions matching (operators are built to apply
    // individually on each vdim)
@@ -1111,8 +1172,42 @@ L2ProjectionGridTransfer::L2ProjectionH1Space::L2ProjectionH1Space(
       return;
    }
 
-   std::tie(R, M_LH) = ComputeSparseRAndM_LH();
+   std::tie(R, M_LH) = ComputeSparseRAndM_LH(!use_consistent_mass);
 
+   HypreParMatrix M_LH_local = HypreParMatrix(pfes_ho.GetComm(),
+                                              pfes_lor_scalar->GlobalVSize(),
+                                              pfes_ho_scalar->GlobalVSize(),
+                                              pfes_lor_scalar->GetDofOffsets(),
+                                              pfes_ho_scalar->GetDofOffsets(),
+                                              static_cast<SparseMatrix*>(M_LH.get()));
+   HypreParMatrix *M_LH_mat = RAP(pfes_lor_scalar->Dof_TrueDof_Matrix(),
+                                  &M_LH_local, pfes_ho_scalar->Dof_TrueDof_Matrix());
+
+   if (use_consistent_mass)
+   {
+      ParBilinearForm M_lor(pfes_lor_scalar.get());
+      M_lor.AddDomainIntegrator(new MassIntegrator);
+      M_lor.Assemble();
+      M_lor.Finalize();
+      HypreParMatrix *M_L_mat = M_lor.ParallelAssemble();
+
+      M_L.reset(M_L_mat);
+      M_LH.reset(M_LH_mat);
+      HypreDiagScale *ML_hypre_precon = new HypreDiagScale(*M_L_mat);
+      HyprePCG *ML_hypre_pcg = new HyprePCG(*M_L_mat);
+      ML_hypre_pcg->SetPrintLevel(0);
+      ML_hypre_pcg->SetMaxIter(1000);
+      ML_hypre_pcg->SetTol(1e-13);
+      ML_hypre_pcg->SetAbsTol(1e-13);
+      ML_hypre_pcg->SetPreconditioner(*ML_hypre_precon);
+      // Start each solve from zero so repeated Operator::Mult() calls do not
+      // depend on the output vector contents supplied by the caller.
+      ML_hypre_pcg->SetZeroInitialIterate();
+      ML_precon.reset(ML_hypre_precon);
+      ML_solver.reset(ML_hypre_pcg);
+      R.reset(new H1ConsistentMassOperator(*M_LH, *ML_solver));
+      return;
+   }
 
    HypreParMatrix R_local = HypreParMatrix(pfes_ho.GetComm(),
                                            pfes_lor_scalar->GlobalVSize(),
@@ -1120,17 +1215,9 @@ L2ProjectionGridTransfer::L2ProjectionH1Space::L2ProjectionH1Space(
                                            pfes_lor_scalar->GetDofOffsets(),
                                            pfes_ho_scalar->GetDofOffsets(),
                                            static_cast<SparseMatrix*>(R.get()));
-   HypreParMatrix M_LH_local = HypreParMatrix(pfes_ho.GetComm(),
-                                              pfes_lor_scalar->GlobalVSize(),
-                                              pfes_ho_scalar->GlobalVSize(),
-                                              pfes_lor_scalar->GetDofOffsets(),
-                                              pfes_ho_scalar->GetDofOffsets(),
-                                              static_cast<SparseMatrix*>(M_LH.get()));
 
    HypreParMatrix *R_mat = RAP(pfes_lor_scalar->Dof_TrueDof_Matrix(),
                                &R_local, pfes_ho_scalar->Dof_TrueDof_Matrix());
-   HypreParMatrix *M_LH_mat = RAP(pfes_lor_scalar->Dof_TrueDof_Matrix(),
-                                  &M_LH_local, pfes_ho_scalar->Dof_TrueDof_Matrix());
 
    std::unique_ptr<HypreParMatrix> R_T(R_mat->Transpose());
    HypreParMatrix *RTxM_LH_mat = ParMult(R_T.get(), M_LH_mat, true);
@@ -1438,6 +1525,8 @@ void L2ProjectionGridTransfer::L2ProjectionH1Space::MultTranspose(
 void L2ProjectionGridTransfer::L2ProjectionH1Space::Prolongate(
    const Vector& x, Vector& y) const
 {
+   MFEM_VERIFY(!use_consistent_mass,
+               "BackwardOperator is not supported with consistent mass");
 
    Vector X(fes_lor.GetTrueVSize());
    Vector X_dim(M_LH->Height());
@@ -1469,6 +1558,9 @@ void L2ProjectionGridTransfer::L2ProjectionH1Space::Prolongate(
 void L2ProjectionGridTransfer::L2ProjectionH1Space::ProlongateTranspose(
    const Vector& x, Vector& y) const
 {
+   MFEM_VERIFY(!use_consistent_mass,
+               "BackwardOperator is not supported with consistent mass");
+
    Vector X(fes_ho.GetTrueVSize());
    Vector X_dim(pcg.Width());
    Vector Xbar(pcg.Height());
@@ -1499,17 +1591,34 @@ void L2ProjectionGridTransfer::L2ProjectionH1Space::ProlongateTranspose(
 void L2ProjectionGridTransfer::L2ProjectionH1Space::SetRelTol(real_t p_rtol_)
 {
    pcg.SetRelTol(p_rtol_);
+   ML_pcg.SetRelTol(p_rtol_);
+#ifdef MFEM_USE_MPI
+   if (ML_solver)
+   {
+      HyprePCG *hypre_pcg = dynamic_cast<HyprePCG*>(ML_solver.get());
+      if (hypre_pcg) { hypre_pcg->SetTol(p_rtol_); }
+   }
+#endif
 }
 
 void L2ProjectionGridTransfer::L2ProjectionH1Space::SetAbsTol(real_t p_atol_)
 {
    pcg.SetAbsTol(p_atol_);
+   ML_pcg.SetAbsTol(p_atol_);
+#ifdef MFEM_USE_MPI
+   if (ML_solver)
+   {
+      HyprePCG *hypre_pcg = dynamic_cast<HyprePCG*>(ML_solver.get());
+      if (hypre_pcg) { hypre_pcg->SetAbsTol(p_atol_); }
+   }
+#endif
 }
 
 std::pair<
 std::unique_ptr<SparseMatrix>,
 std::unique_ptr<SparseMatrix>>
-                            L2ProjectionGridTransfer::L2ProjectionH1Space::ComputeSparseRAndM_LH()
+                            L2ProjectionGridTransfer::L2ProjectionH1Space::ComputeSparseRAndM_LH(
+                               bool build_R)
 {
    std::pair<std::unique_ptr<SparseMatrix>,
        std::unique_ptr<SparseMatrix>> r_and_mlh;
@@ -1523,10 +1632,10 @@ std::unique_ptr<SparseMatrix>>
    // If the local mesh is empty, skip all computations
    if (nel_ho == 0)
    {
-      return std::make_pair(
-                std::unique_ptr<SparseMatrix>(new SparseMatrix),
-                std::unique_ptr<SparseMatrix>(new SparseMatrix)
-             );
+      std::unique_ptr<SparseMatrix> R_empty;
+      if (build_R) { R_empty.reset(new SparseMatrix); }
+      std::unique_ptr<SparseMatrix> M_LH_empty(new SparseMatrix);
+      return std::make_pair(std::move(R_empty), std::move(M_LH_empty));
    }
 
    const CoarseFineTransformations& cf_tr = mesh_lor->GetRefinementTransforms();
@@ -1542,69 +1651,76 @@ std::unique_ptr<SparseMatrix>>
 
    BuildHo2Lor(nel_ho, nel_lor, cf_tr);
 
-   // ML_inv contains the inverse lumped (row sum) mass matrix. Note that the
-   // method will also work with a full (consistent) mass matrix, though this is
-   // not implemented here. L refers to the low-order refined mesh
    Vector ML_inv(ndof_lor);
-   ML_inv = 0.0;
-
-   // Compute ML_inv
-   for (int iho = 0; iho < nel_ho; ++iho)
+   if (build_R)
    {
-      Array<int> lor_els;
-      ho2lor.GetRow(iho, lor_els);
-      int nref = ho2lor.RowSize(iho);
+      // ML_inv contains the inverse lumped (row sum) mass matrix. L refers to
+      // the low-order refined mesh.
+      ML_inv = 0.0;
 
-      Geometry::Type geom = mesh_ho->GetElementBaseGeometry(iho);
-      const FiniteElement& fe_lor = *fes_lor.GetFE(lor_els[0]);
-      int nedof_lor = fe_lor.GetDof();
-
-      // Instead of using a MassIntegrator, manually loop over integration
-      // points so we can row sum and store the diagonal as a Vector.
-      Vector ML_el(nedof_lor);
-      Vector shape_lor(nedof_lor);
-      Array<int> dofs_lor(nedof_lor);
-
-      for (int iref = 0; iref < nref; ++iref)
+      // Compute ML_inv
+      for (int iho = 0; iho < nel_ho; ++iho)
       {
-         int ilor = lor_els[iref];
-         ElementTransformation* el_tr = fes_lor.GetElementTransformation(ilor);
+         Array<int> lor_els;
+         ho2lor.GetRow(iho, lor_els);
+         int nref = ho2lor.RowSize(iho);
 
-         int order = 2 * fe_lor.GetOrder() + el_tr->OrderW();
-         const IntegrationRule* ir = &IntRules.Get(geom, order);
-         ML_el = 0.0;
-         for (int i = 0; i < ir->GetNPoints(); ++i)
+         Geometry::Type geom = mesh_ho->GetElementBaseGeometry(iho);
+         const FiniteElement& fe_lor = *fes_lor.GetFE(lor_els[0]);
+         int nedof_lor = fe_lor.GetDof();
+
+         // Instead of using a MassIntegrator, manually loop over integration
+         // points so we can row sum and store the diagonal as a Vector.
+         Vector ML_el(nedof_lor);
+         Vector shape_lor(nedof_lor);
+         Array<int> dofs_lor(nedof_lor);
+
+         for (int iref = 0; iref < nref; ++iref)
          {
-            const IntegrationPoint& ip_lor = ir->IntPoint(i);
-            fe_lor.CalcShape(ip_lor, shape_lor);
-            el_tr->SetIntPoint(&ip_lor);
-            ML_el += (shape_lor *= (el_tr->Weight() * ip_lor.weight));
+            int ilor = lor_els[iref];
+            ElementTransformation* el_tr = fes_lor.GetElementTransformation(ilor);
+
+            int order = 2 * fe_lor.GetOrder() + el_tr->OrderW();
+            const IntegrationRule* ir = &IntRules.Get(geom, order);
+            ML_el = 0.0;
+            for (int i = 0; i < ir->GetNPoints(); ++i)
+            {
+               const IntegrationPoint& ip_lor = ir->IntPoint(i);
+               fe_lor.CalcShape(ip_lor, shape_lor);
+               el_tr->SetIntPoint(&ip_lor);
+               ML_el += (shape_lor *= (el_tr->Weight() * ip_lor.weight));
+            }
+            fes_lor.GetElementDofs(ilor, dofs_lor);
+            ML_inv.AddElementVector(dofs_lor, ML_el);
          }
-         fes_lor.GetElementDofs(ilor, dofs_lor);
-         ML_inv.AddElementVector(dofs_lor, ML_el);
       }
+      // DOF by DOF inverse of non-zero entries
+      LumpedMassInverse(ML_inv);
    }
-   // DOF by DOF inverse of non-zero entries
-   LumpedMassInverse(ML_inv);
 
    // Compute sparsity pattern for R = M_L^(-1) M_LH and allocate
-   r_and_mlh.first = AllocR();
+   std::unique_ptr<SparseMatrix> pattern = AllocR();
+   if (build_R)
+   {
+      r_and_mlh.first = std::move(pattern);
+   }
    // Allocate M_LH (same sparsity pattern as R)
    // L refers to the low-order refined mesh (DOFs correspond to rows)
    // H refers to the higher-order mesh (DOFs correspond to columns)
-   Memory<int> I(r_and_mlh.first->Height() + 1);
-   for (int icol = 0; icol < r_and_mlh.first->Height() + 1; ++icol)
+   SparseMatrix &pattern_mat = build_R ? *r_and_mlh.first : *pattern;
+   Memory<int> I(pattern_mat.Height() + 1);
+   for (int icol = 0; icol < pattern_mat.Height() + 1; ++icol)
    {
-      I[icol] = r_and_mlh.first->GetI()[icol];
+      I[icol] = pattern_mat.GetI()[icol];
    }
-   Memory<int> J(r_and_mlh.first->NumNonZeroElems());
-   for (int jcol = 0; jcol < r_and_mlh.first->NumNonZeroElems(); ++jcol)
+   Memory<int> J(pattern_mat.NumNonZeroElems());
+   for (int jcol = 0; jcol < pattern_mat.NumNonZeroElems(); ++jcol)
    {
-      J[jcol] = r_and_mlh.first->GetJ()[jcol];
+      J[jcol] = pattern_mat.GetJ()[jcol];
    }
    r_and_mlh.second = std::unique_ptr<SparseMatrix>(
-                         new SparseMatrix(I, J, NULL, r_and_mlh.first->Height(),
-                                          r_and_mlh.first->Width(), true, true, true));
+                         new SparseMatrix(I, J, NULL, pattern_mat.Height(),
+                                          pattern_mat.Width(), true, true, true));
 
    IntegrationPointTransformation ip_tr;
    IsoparametricTransformation& emb_tr = ip_tr.Transf;
@@ -1647,15 +1763,21 @@ std::unique_ptr<SparseMatrix>>
          Array<int> dofs_lor(nedof_lor);
          fes_lor.GetElementDofs(ilor, dofs_lor);
          Vector R_row;
-         for (int i = 0; i < nedof_lor; ++i)
+         if (build_R)
          {
-            M_LH_el.GetRow(i, R_row);
-            R_el.SetRow(i, R_row.Set(ML_inv[dofs_lor[i]], R_row));
+            for (int i = 0; i < nedof_lor; ++i)
+            {
+               M_LH_el.GetRow(i, R_row);
+               R_el.SetRow(i, R_row.Set(ML_inv[dofs_lor[i]], R_row));
+            }
          }
          Array<int> dofs_ho(nedof_ho);
          fes_ho.GetElementDofs(iho, dofs_ho);
          r_and_mlh.second->AddSubMatrix(dofs_lor, dofs_ho, M_LH_el);
-         r_and_mlh.first->AddSubMatrix(dofs_lor, dofs_ho, R_el);
+         if (build_R)
+         {
+            r_and_mlh.first->AddSubMatrix(dofs_lor, dofs_ho, R_el);
+         }
 
       }
    }
@@ -2009,6 +2131,8 @@ const Operator &L2ProjectionGridTransfer::ForwardOperator()
 
 const Operator &L2ProjectionGridTransfer::BackwardOperator()
 {
+   MFEM_VERIFY(!UsesH1ConsistentMass(),
+               "BackwardOperator is not supported with consistent mass");
    if (!B)
    {
       if (!F) { BuildF(); }
@@ -2017,15 +2141,30 @@ const Operator &L2ProjectionGridTransfer::BackwardOperator()
    return *B;
 }
 
+void L2ProjectionGridTransfer::UseConsistentMass(bool use_consistent_mass_)
+{
+   MFEM_VERIFY(!F && !B,
+               "UseConsistentMass must be called before constructing operators");
+   use_consistent_mass = use_consistent_mass_;
+}
+
+bool L2ProjectionGridTransfer::UsesH1ConsistentMass() const
+{
+   return use_consistent_mass && !force_l2_space &&
+          dom_fes.FEColl()->GetContType() == FiniteElementCollection::CONTINUOUS;
+}
+
 void L2ProjectionGridTransfer::BuildF()
 {
    if (!force_l2_space &&
        dom_fes.FEColl()->GetContType() == FiniteElementCollection::CONTINUOUS)
    {
+      MFEM_VERIFY(!(use_ea && use_consistent_mass),
+                  "consistent mass is not supported with element assembly");
       if (!Parallel())
       {
          F = new L2ProjectionH1Space(dom_fes, ran_fes,
-                                     use_ea, d_mt);
+                                     use_ea, use_consistent_mass, d_mt);
       }
       else
       {
@@ -2035,7 +2174,7 @@ void L2ProjectionGridTransfer::BuildF()
          const mfem::ParFiniteElementSpace& ran_pfes =
             static_cast<mfem::ParFiniteElementSpace&>(ran_fes);
          F = new L2ProjectionH1Space(dom_pfes, ran_pfes,
-                                     use_ea, d_mt);
+                                     use_ea, use_consistent_mass, d_mt);
 #endif
       }
    }
@@ -2048,6 +2187,7 @@ void L2ProjectionGridTransfer::BuildF()
 
 bool L2ProjectionGridTransfer::SupportsBackwardsOperator() const
 {
+   if (UsesH1ConsistentMass()) { return false; }
    return ran_fes.GetTrueVSize() >= dom_fes.GetTrueVSize();
 }
 

fem/transfer.hpp

@@ -169,10 +169,12 @@ public:
     is the forward transfer matrix, and M_f is the mass matrix on the coarse
     element. For L2 spaces, M_f is the mass matrix on the union of all fine
     elements comprising the coarse element. For H1 spaces, M_f is a diagonal
-    (lumped) mass matrix computed through row-summation. Note that the backward
-    transfer operator, B, is a left inverse of the forward transfer operator, F,
-    i.e. B F = I. Both F and B are defined in physical space and, generally for
-    L2 spaces, vary between different mesh elements.
+    (lumped) mass matrix computed through row-summation, unless
+    UseConsistentMass() is enabled for the forward H1 operator. When the
+    backward transfer operator, B, is supported, it is a left inverse of the
+    forward transfer operator, F, i.e. B F = I. Both F and B are defined in
+    physical space and, generally for L2 spaces, vary between different mesh
+    elements.
 
     This class supports H1 and L2 finite element spaces. Fine meshes are a
     uniform refinement of the coarse mesh, usually created through
@@ -352,16 +354,21 @@ public:
    class L2ProjectionH1Space : public L2Projection
    {
       const bool use_ea;
+      /// Use the consistent low-order mass matrix in non-EA H1 Mult() and
+      /// MultTranspose().
+      const bool use_consistent_mass;
 
    public:
       L2ProjectionH1Space(const FiniteElementSpace &fes_ho_,
                           const FiniteElementSpace &fes_lor_,
                           const bool use_ea_,
+                          const bool use_consistent_mass_,
                           MemoryType d_mt_ = Device::GetHostMemoryType());
 #ifdef MFEM_USE_MPI
       L2ProjectionH1Space(const ParFiniteElementSpace &pfes_ho_,
                           const ParFiniteElementSpace &pfes_lor_,
                           const bool use_ea_,
+                          const bool use_consistent_mass_,
                           MemoryType d_mt_ = Device::GetHostMemoryType());
 #endif
       /// Same as above but assembles action of R through 4 parts:
@@ -417,13 +424,33 @@ public:
       void SetAbsTol(real_t p_atol_) override;
 
    protected:
+      /// Applies the H1 transfer R = M_L^{-1} M_LH and its transpose, where
+      /// M_L is the consistent low-order mass matrix.
+      class H1ConsistentMassOperator : public Operator
+      {
+      private:
+         const Operator &M_LH;
+         const Solver &M_L_solver;
+
+      public:
+         H1ConsistentMassOperator(const Operator &M_LH_,
+                                  const Solver &M_L_solver_);
+
+         void Mult(const Vector &x, Vector &y) const override;
+
+         void MultTranspose(const Vector &x, Vector &y) const override;
+      };
+
       /// Sets up the PCG solver (sets parameters, operator, and preconditioner)
       void SetupPCG();
 
-      /// @brief Computes on-rank R and M_LH matrices. If true, computes mixed mass and/or
-      /// inverse lumped mass matrix error when compared to device implementation.
+      /** @brief Computes on-rank R and M_LH matrices.
+
+          If build_R is true, the returned pair contains both R and M_LH. If
+          build_R is false, the first pointer is null and only M_LH is built. */
       std::pair<std::unique_ptr<SparseMatrix>,
-          std::unique_ptr<SparseMatrix>> ComputeSparseRAndM_LH();
+          std::unique_ptr<SparseMatrix>> ComputeSparseRAndM_LH(
+             bool build_R = true);
 
       /// @brief Recovers vector of tdofs given a vector of dofs and a finite
       /// element space
@@ -453,20 +480,30 @@ public:
       /// elements and refined LOR elements.
       std::unique_ptr<SparseMatrix> AllocR();
 
-      CGSolver pcg;
-      std::unique_ptr<Solver> precon;
+      /// Consistent low-order mass matrix used when use_consistent_mass is true.
+      std::unique_ptr<Operator> M_L;
+      // Used to compute P = (RT*M_LH)^(-1) M_LH^T
+      std::unique_ptr<Operator> M_LH;
+      // Lumped M_L inverse operator built via EA. Wrapped with restriction maps
+      // to multiply with scalar TDof LOR vectors.
+      std::unique_ptr<Operator> ML_inv_vea;
+      /// Preconditioner for applying the inverse consistent low-order mass
+      /// matrix.
+      std::unique_ptr<Solver> ML_precon;
+      /// Serial PCG solver for applying the inverse consistent low-order mass
+      /// matrix in H1 Mult() and MultTranspose().
+      CGSolver ML_pcg;
+      /// Solver used by H1ConsistentMassOperator to apply M_L^{-1}.
+      std::unique_ptr<Solver> ML_solver;
       // The restriction operator is represented as an Operator R. The
       // prolongation operator is a dense matrix computed as the inverse of (R^T
       // M_L R), and hence, is not stored.
       // If element assembly is enabled
       std::unique_ptr<Operator> R;
-      // Used to compute P = (RT*M_LH)^(-1) M_LH^T
-      std::unique_ptr<Operator> M_LH;
       // Inverted operator in P = (RT*M_LH)^(-1) M_LH^T. Used to compute P via PCG.
       std::unique_ptr<Operator> RTxM_LH;
-      // Lumped M_L inverse operator built via EA. Wrapped with restriction maps
-      // to multiply with scalar TDof LOR vectors.
-      std::unique_ptr<Operator> ML_inv_vea;
+      std::unique_ptr<Solver> precon;
+      CGSolver pcg;
       // LDof Mixed mass operator built via EA. Wrapped with restriction maps to send
       // scalar LDof HO vectors to LDof LOR vectors.
       Operator *M_LH_local_op;
@@ -478,7 +515,6 @@ public:
       Vector M_LH_ea;
       // Element Assembled lumped M_L inverse built via EA. Stores diagonal as a Ldof vector.
       Vector ML_inv_ea;
-
 #ifdef MFEM_USE_MPI
       std::unique_ptr<ParFiniteElementSpace> pfes_ho_scalar;
       std::unique_ptr<ParFiniteElementSpace> pfes_lor_scalar;
@@ -511,6 +547,9 @@ public:
    L2Projection   *F; ///< Forward, coarse-to-fine, operator
    L2Prolongation *B; ///< Backward, fine-to-coarse, operator
    bool force_l2_space;
+   /// Use the consistent low-order mass matrix for non-EA H1 Mult() and
+   /// MultTranspose().
+   bool use_consistent_mass;
 
 public:
    L2ProjectionGridTransfer(FiniteElementSpace &coarse_fes_,
@@ -518,16 +557,26 @@ public:
                             bool force_l2_space_ = false,
                             MemoryType d_mt_ = Device::GetHostMemoryType()) // move to method
       : GridTransfer(coarse_fes_, fine_fes_),
-        F(NULL), B(NULL), force_l2_space(force_l2_space_)
+        F(NULL), B(NULL), force_l2_space(force_l2_space_),
+        use_consistent_mass(false)
    { }
    virtual ~L2ProjectionGridTransfer();
 
+   /** @brief Use the consistent low-order mass matrix in H1 non-EA Mult() and
+       MultTranspose().
+
+       This option must be set before constructing the transfer operators. It
+       only affects H1 transfer, is not supported with element assembly, and
+       disables BackwardOperator(). */
+   void UseConsistentMass(bool use_consistent_mass_ = true);
+
    const Operator &ForwardOperator() override;
 
    const Operator &BackwardOperator() override;
 
    bool SupportsBackwardsOperator() const override;
 private:
+   bool UsesH1ConsistentMass() const;
    void BuildF();
 };
 

general/backends.hpp

@@ -38,6 +38,15 @@
 #define CUB_IGNORE_DEPRECATED_CPP_DIALECT
 #define THRUST_IGNORE_DEPRECATED_CPP_DIALECT
 
+// MFEM only supports using RAJA/CAMP backends in default stream mode because
+// memory calls are performed outside of the RAJA ecosystem
+#ifndef CAMP_USE_PLATFORM_DEFAULT_STREAM
+#define CAMP_USE_PLATFORM_DEFAULT_STREAM 1
+#else
+#if !CAMP_USE_PLATFORM_DEFAULT_STREAM
+#error "MFEM only supports RAJA/CAMP with the default platform stream."
+#endif
+#endif
 #include "RAJA/RAJA.hpp"
 #if defined(RAJA_ENABLE_CUDA) && !defined(MFEM_USE_CUDA)
 #error When RAJA is built with CUDA, MFEM_USE_CUDA=YES is required

general/device.cpp

@@ -581,9 +581,7 @@ void Device::Setup(const std::string &device_option, const int device_id)
    if (Allows(Backend::CUDA)) { CudaDeviceSetup(dev, ngpu); }
    if (Allows(Backend::HIP)) { HipDeviceSetup(dev, ngpu); }
    if (Allows(Backend::RAJA_CUDA) || Allows(Backend::RAJA_HIP))
-   {
-      RajaDeviceSetup(dev, ngpu);
-   }
+   { RajaDeviceSetup(dev, ngpu); }
    // The check for MFEM_USE_OCCA is in the function OccaDeviceSetup().
    if (Allows(Backend::OCCA_MASK)) { OccaDeviceSetup(dev); }
    if (Allows(Backend::CEED_MASK))

general/device.hpp

@@ -16,11 +16,6 @@
 #include "globals.hpp"
 #include "mem_manager.hpp"
 
-#ifdef MFEM_USE_RAJA
-#include "RAJA/RAJA.hpp"
-#endif
-
-#include <memory>
 #include <string>
 
 namespace mfem
@@ -271,18 +266,6 @@ public:
    static inline bool Allows(unsigned long b_mask)
    { return Get().backends & b_mask; }
 
-#if defined(MFEM_USE_RAJA) &&                                                  \
-   (defined(RAJA_ENABLE_CUDA) || defined(RAJA_ENABLE_HIP))
-   static inline auto GetRajaResource()
-   {
-#if defined(RAJA_ENABLE_CUDA)
-      return RAJA::resources::Cuda::CudaFromStream(0, Get().GetId());
-#elif defined(RAJA_ENABLE_HIP)
-      return RAJA::resources::Hip::HipFromStream(0, Get().GetId());
-#endif
-   }
-#endif
-
    /** @brief Get the current Host MemoryType. This is the MemoryType used by
        most MFEM classes when allocating memory used on the host.
    */

general/forall.hpp

@@ -317,8 +317,8 @@ template <typename DBODY>
 void RajaCuWrap1D(const int N, DBODY &&d_body)
 {
    //true denotes asynchronous kernel
-   RAJA::forall<RAJA::cuda_exec<MFEM_CUDA_BLOCKS, true> >(
-      Device::GetRajaResource(), RAJA::RangeSegment(0, N), d_body);
+   RAJA::forall<RAJA::cuda_exec<MFEM_CUDA_BLOCKS,true>>(RAJA::RangeSegment(0,N),
+                                                        d_body);
 }
 
 template <typename DBODY>
@@ -331,9 +331,9 @@ void RajaCuWrap2D(const int N, DBODY &&d_body,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<cuda_launch_policy>(Device::GetRajaResource(),
-                              LaunchParams(Teams(G), Threads(X, Y, BZ)),
-                              [=] RAJA_DEVICE(LaunchContext ctx)
+   launch<cuda_launch_policy>
+   (LaunchParams(Teams(G), Threads(X, Y, BZ)),
+    [=] RAJA_DEVICE (LaunchContext ctx)
    {
 
       loop<cuda_teams_x>(ctx, RangeSegment(0, G), [&] (const int n)
@@ -349,6 +349,7 @@ void RajaCuWrap2D(const int N, DBODY &&d_body,
          });
 
       });
+
    });
 
    MFEM_GPU_CHECK(cudaGetLastError());
@@ -364,9 +365,9 @@ void RajaCuWrap2DLaunchBounds(const int N, DBODY &&d_body, const int X,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<cuda_launch_bounds_policy<LB> >(
-      Device::GetRajaResource(), LaunchParams(Teams(G), Threads(X, Y, BZ)),
-      [=] RAJA_DEVICE(LaunchContext ctx)
+   launch<cuda_launch_bounds_policy<LB> >
+   (LaunchParams(Teams(G), Threads(X, Y, BZ)),
+    [=] RAJA_DEVICE(LaunchContext ctx)
    {
       loop<cuda_teams_x>(ctx, RangeSegment(0, G), [&] (const int n)
       {
@@ -389,12 +390,13 @@ void RajaCuWrap3D(const int N, DBODY &&d_body,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<cuda_launch_policy>(Device::GetRajaResource(),
-                              LaunchParams(Teams(GRID), Threads(X, Y, Z)),
-                              [=] RAJA_DEVICE(LaunchContext ctx)
+   launch<cuda_launch_policy>
+   (LaunchParams(Teams(GRID), Threads(X, Y, Z)),
+    [=] RAJA_DEVICE (LaunchContext ctx)
    {
 
       loop<cuda_teams_x>(ctx, RangeSegment(0, N), d_body);
+
    });
 
    MFEM_GPU_CHECK(cudaGetLastError());
@@ -408,10 +410,12 @@ void RajaCuWrap3DLaunchBounds(const int N, DBODY &&d_body,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<cuda_launch_bounds_policy<LB> >(
-      Device::GetRajaResource(), LaunchParams(Teams(GRID), Threads(X, Y, Z)),
-      [=] RAJA_DEVICE(LaunchContext ctx)
-   { loop<cuda_teams_x>(ctx, RangeSegment(0, N), d_body); });
+   launch<cuda_launch_bounds_policy<LB> >
+   (LaunchParams(Teams(GRID), Threads(X, Y, Z)),
+    [=] RAJA_DEVICE(LaunchContext ctx)
+   {
+      loop<cuda_teams_x>(ctx, RangeSegment(0, N), d_body);
+   });
    MFEM_GPU_CHECK(cudaGetLastError());
 }
 
@@ -480,8 +484,8 @@ template <typename DBODY>
 void RajaHipWrap1D(const int N, DBODY &&d_body)
 {
    //true denotes asynchronous kernel
-   RAJA::forall<RAJA::hip_exec<MFEM_HIP_BLOCKS,true> >(RAJA::RangeSegment(0,N),
-                                                       d_body);
+   RAJA::forall<RAJA::hip_exec<MFEM_HIP_BLOCKS,true>>(RAJA::RangeSegment(0,N),
+                                                      d_body);
 }
 
 template <typename DBODY>
@@ -494,9 +498,9 @@ void RajaHipWrap2D(const int N, DBODY &&d_body,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<hip_launch_policy>(Device::GetRajaResource(),
-                             LaunchParams(Teams(G), Threads(X, Y, BZ)),
-                             [=] RAJA_DEVICE(LaunchContext ctx)
+   launch<hip_launch_policy>
+   (LaunchParams(Teams(G), Threads(X, Y, BZ)),
+    [=] RAJA_DEVICE (LaunchContext ctx)
    {
 
       loop<hip_teams_x>(ctx, RangeSegment(0, G), [&] (const int n)
@@ -512,6 +516,7 @@ void RajaHipWrap2D(const int N, DBODY &&d_body,
          });
 
       });
+
    });
 
    MFEM_GPU_CHECK(hipGetLastError());
@@ -527,9 +532,9 @@ void RajaHipWrap2DLaunchBounds(const int N, DBODY &&d_body, const int X,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<hip_launch_bounds_policy<LB> >(
-      Device::GetRajaResource(), LaunchParams(Teams(G), Threads(X, Y, BZ)),
-      [=] RAJA_DEVICE(LaunchContext ctx)
+   launch<hip_launch_bounds_policy<LB> >
+   (LaunchParams(Teams(G), Threads(X, Y, BZ)),
+    [=] RAJA_DEVICE(LaunchContext ctx)
    {
       loop<hip_teams_x>(ctx, RangeSegment(0, G), [&] (const int n)
       {
@@ -552,12 +557,13 @@ void RajaHipWrap3D(const int N, DBODY &&d_body,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<hip_launch_policy>(Device::GetRajaResource(),
-                             LaunchParams(Teams(GRID), Threads(X, Y, Z)),
-                             [=] RAJA_DEVICE(LaunchContext ctx)
+   launch<hip_launch_policy>
+   (LaunchParams(Teams(GRID), Threads(X, Y, Z)),
+    [=] RAJA_DEVICE (LaunchContext ctx)
    {
 
       loop<hip_teams_x>(ctx, RangeSegment(0, N), d_body);
+
    });
 
    MFEM_GPU_CHECK(hipGetLastError());
@@ -571,10 +577,12 @@ void RajaHipWrap3DLaunchBounds(const int N, DBODY &&d_body, const int X,
    using namespace RAJA;
    using RAJA::RangeSegment;
 
-   launch<hip_launch_bounds_policy<LB> >(
-      Device::GetRajaResource(), LaunchParams(Teams(GRID), Threads(X, Y, Z)),
-      [=] RAJA_DEVICE(LaunchContext ctx)
-   { loop<hip_teams_x>(ctx, RangeSegment(0, N), d_body); });
+   launch<hip_launch_bounds_policy<LB> >
+   (LaunchParams(Teams(GRID), Threads(X, Y, Z)),
+    [=] RAJA_DEVICE(LaunchContext ctx)
+   {
+      loop<hip_teams_x>(ctx, RangeSegment(0, N), d_body);
+   });
    MFEM_GPU_CHECK(hipGetLastError());
 }
 

linalg/cudss.cpp

@@ -15,20 +15,10 @@
 
 #ifdef MFEM_USE_CUDSS
 
-#if CUDSS_VERSION >= 800
 #ifdef MFEM_USE_SINGLE
-#define CUDSS_REAL_T CUDSS_R_32F
+#define CUDA_REAL_T CUDA_R_32F
 #else
-#define CUDSS_REAL_T CUDSS_R_64F
-#endif
-#define CUDSS_INT_T CUDSS_R_32I
-#else
-#ifdef MFEM_USE_SINGLE
-#define CUDSS_REAL_T CUDA_R_32F
-#else
-#define CUDSS_REAL_T CUDA_R_64F
-#endif
-#define CUDSS_INT_T CUDA_R_32I
+#define CUDA_REAL_T CUDA_R_64F
 #endif
 
 // Define a cuDSS error check macro, MFEM_CUDSS_CHECK(x), where x returns/is of
@@ -75,13 +65,8 @@ CuDSSSolver::CuDSSSolver(MPI_Comm comm_) : mpi_comm(comm_)
 #endif
    MFEM_CUDSS_CHECK(cudssSetCommLayer(handle, comm_lib));
 
-#if CUDSS_VERSION >= 800
-   MFEM_CUDSS_CHECK(cudssDataSet(handle, solverData, CUDSS_DATA_COMM_HOST,
-                                 &mpi_comm, sizeof(MPI_Comm *)));
-#else
    MFEM_CUDSS_CHECK(cudssDataSet(handle, solverData, CUDSS_DATA_COMM,
                                  &mpi_comm, sizeof(MPI_Comm *)));
-#endif
 }
 #endif // MFEM_USE_MPI
 
@@ -272,19 +257,11 @@ void CuDSSSolver::SetMatrixCuDSS(int *csr_offsets, int *csr_columns,
          CuMemcpyDtoD(csr_offsets_d, csr_offsets, (n_loc + 1) * sizeof(int));
          CuMemcpyDtoD(csr_columns_d, csr_columns, nnz * sizeof(int));
 
-#if CUDSS_VERSION >= 800
          MFEM_CUDSS_CHECK(
             cudssMatrixCreateCsr(
                Ac.get(), n_global, n_global, nnz, csr_offsets_d, NULL,
-               csr_columns_d, csr_values_d, CUDSS_INT_T, CUDSS_INT_T, CUDSS_REAL_T,
-               mat_type, mview, CUDSS_BASE_ZERO));
-#else
-         MFEM_CUDSS_CHECK(
-            cudssMatrixCreateCsr(
-               Ac.get(), n_global, n_global, nnz, csr_offsets_d, NULL,
-               csr_columns_d, csr_values_d, CUDSS_INT_T, CUDSS_REAL_T,
-               mat_type, mview, CUDSS_BASE_ZERO));
-#endif
+               csr_columns_d, csr_values_d, CUDA_R_32I, CUDA_REAL_T, mat_type, mview,
+               CUDSS_BASE_ZERO));
       }
       else    // !reorder_reuse
       {
@@ -292,19 +269,11 @@ void CuDSSSolver::SetMatrixCuDSS(int *csr_offsets, int *csr_columns,
          {
             MFEM_CUDSS_CHECK(cudssMatrixDestroy(*Ac));
          }
-#if CUDSS_VERSION >= 800
          MFEM_CUDSS_CHECK(
             cudssMatrixCreateCsr(
-               Ac.get(), n_global, n_global, nnz, csr_offsets, NULL,
-               csr_columns, csr_values_d, CUDSS_INT_T, CUDSS_INT_T, CUDSS_REAL_T,
-               mat_type, mview, CUDSS_BASE_ZERO));
-#else
-         MFEM_CUDSS_CHECK(
-            cudssMatrixCreateCsr(
-               Ac.get(), n_global, n_global, nnz, csr_offsets, NULL,
-               csr_columns, csr_values_d, CUDSS_INT_T, CUDSS_REAL_T,
-               mat_type, mview, CUDSS_BASE_ZERO));
-#endif
+               Ac.get(), n_global, n_global, nnz, csr_offsets, NULL, csr_columns,
+               csr_values_d, CUDA_R_32I, CUDA_REAL_T, mat_type, mview,
+               CUDSS_BASE_ZERO));
       }
 #ifdef MFEM_USE_MPI
       if (Mpi::IsInitialized())
@@ -365,10 +334,10 @@ void CuDSSSolver::SetNumRHS(int nrhs_) const
       }
       // Create empty RHS and solution vectors
       MFEM_CUDSS_CHECK(cudssMatrixCreateDn(&xc, n_global, nrhs_, n_global, NULL,
-                                           CUDSS_REAL_T, CUDSS_LAYOUT_COL_MAJOR));
+                                           CUDA_REAL_T, CUDSS_LAYOUT_COL_MAJOR));
 
       MFEM_CUDSS_CHECK(cudssMatrixCreateDn(&yc, n_global, nrhs_, n_global, NULL,
-                                           CUDSS_REAL_T, CUDSS_LAYOUT_COL_MAJOR));
+                                           CUDA_REAL_T, CUDSS_LAYOUT_COL_MAJOR));
 
 #ifdef MFEM_USE_MPI
       MFEM_CUDSS_CHECK(cudssMatrixSetDistributionRow1d(xc, row_start, row_end));

linalg/ginkgo.hpp

@@ -39,7 +39,6 @@ namespace Ginkgo
 {
 
 template <typename T> using gko_array = gko::array<T>;
-#if defined(MFEM_USE_MPI) && GINKGO_BUILD_MPI
 // for inter-operability with hypre integer types
 using gko_hypre_int =
    std::conditional_t<sizeof(HYPRE_Int) == sizeof(std::int32_t), std::int32_t,
@@ -51,7 +50,6 @@ static_assert(!std::is_void_v<gko_hypre_int>,
               "HYPRE_Int type is incompatible with Ginkgo");
 static_assert(!std::is_void_v<gko_hypre_bigint>,
               "HYPRE_BigInt type is incompatible with Ginkgo");
-#endif
 
 /**
 * Helper class for a case where a wrapped MFEM Vector

linalg/hypre.cpp

@@ -2872,8 +2872,8 @@ void HypreParMatrix::Destroy()
    if (HypreUsingGPU() && ParCSROwner && (diagOwner < 0 || offdOwner < 0))
    {
       // Put the "host" or "hypre" pointers in {i,j,data} of A->{diag,offd}, so
-      // that they can be destroyed by mfem_hypre_TFree_host() or hypre when
-      // hypre_ParCSRMatrixDestroy(A) is called below, respectively.
+      // that they can be destroyed by hypre when hypre_ParCSRMatrixDestroy(A)
+      // is called below.
 
       // Check that if both diagOwner and offdOwner are negative then they have
       // the same value.
@@ -2882,33 +2882,7 @@ void HypreParMatrix::Destroy()
 
       MemoryClass mc = (diagOwner == -1 || offdOwner == -1) ?
                        Device::GetHostMemoryClass() : GetHypreMemoryClass();
-      Write(mc, diagOwner < 0, offdOwner < 0);
-      if (diagOwner == -1)
-      {
-         // Note: mfem_hypre_TFree_host() sets the pointer to NULL.
-         mfem_hypre_TFree_host(hypre_CSRMatrixI(A->diag));
-         if (hypre_CSRMatrixOwnsData(A->diag))
-         {
-            mfem_hypre_TFree_host(hypre_CSRMatrixJ(A->diag));
-            mfem_hypre_TFree_host(hypre_CSRMatrixData(A->diag));
-         }
-#if MFEM_HYPRE_VERSION >= 21800
-         hypre_CSRMatrixMemoryLocation(A->diag) = GetHypreMemoryLocation();
-#endif
-      }
-      if (offdOwner == -1)
-      {
-         // Note: mfem_hypre_TFree_host() sets the pointer to NULL.
-         mfem_hypre_TFree_host(hypre_CSRMatrixI(A->offd));
-         if (hypre_CSRMatrixOwnsData(A->offd))
-         {
-            mfem_hypre_TFree_host(hypre_CSRMatrixJ(A->offd));
-            mfem_hypre_TFree_host(hypre_CSRMatrixData(A->offd));
-         }
-#if MFEM_HYPRE_VERSION >= 21800
-         hypre_CSRMatrixMemoryLocation(A->offd) = GetHypreMemoryLocation();
-#endif
-      }
+      Write(mc, diagOwner < 0, offdOwner <0);
    }
 #endif
 

linalg/hypre.hpp

@@ -432,11 +432,10 @@ private:
    // and A->col_map_offd.
    // The possible values for diagOwner are:
    //  -1: no special treatment of A->diag (default)
-   //      when hypre is using GPU, A->diag owns the "host" pointers (according
-   //      to A->diag->owns_data); these host pointers are freed by MFEM using
-   //      hypre's host deallocation macros
-   //  -2: used when hypre is using GPU, A->diag owns the "hypre" pointers
-   //      (according to A->diag->owns_data)
+   //      when hypre is built with CUDA support, A->diag owns the "host"
+   //      pointers (according to A->diag->owns_data)
+   //  -2: used when hypre is built with CUDA support, A->diag owns the "hypre"
+   //      pointers (according to A->diag->owns_data)
    //   0: prevent hypre from destroying A->diag->{i,j,data}
    //   1: same as 0, plus own the "host" A->diag->{i,j}
    //   2: same as 0, plus own the "host" A->diag->data

linalg/linalg.hpp

@@ -65,7 +65,7 @@
 #include "hypre_parcsr.hpp"
 #include "hypre.hpp"
 
-#if defined(MFEM_USE_MUMPS) || defined(MFEM_USE_COMPLEX_MUMPS)
+#ifdef MFEM_USE_MUMPS
 #include "mumps.hpp"
 #endif
 

linalg/mumps.cpp

@@ -12,9 +12,11 @@
 #include "../config/config.hpp"
 #include "../general/communication.hpp"
 
-#if defined(MFEM_USE_MUMPS) || defined(MFEM_USE_COMPLEX_MUMPS)
+#ifdef MFEM_USE_MUMPS
+#ifdef MFEM_USE_MPI
+
 #include "mumps.hpp"
-#include <unordered_map>
+
 #include <algorithm>
 
 #if MFEM_MUMPS_VERSION >= 530
@@ -33,14 +35,9 @@
 #define MUMPS_INFO(I) info[(I) -1]
 #define MUMPS_INFOG(I) infog[(I) -1]
 
-#endif // MFEM_USE_MUMPS || MFEM_USE_COMPLEX_MUMPS
-
-
 namespace mfem
 {
 
-#ifdef MFEM_USE_MUMPS
-
 MUMPSSolver::MUMPSSolver(MPI_Comm comm_)
 {
    Init(comm_);
@@ -670,760 +667,7 @@ void MUMPSSolver::RedistributeSol(const int *rmap, const real_t *x,
 }
 #endif
 
-#endif // MFEM_USE_MUMPS
-
-
-#ifdef MFEM_USE_COMPLEX_MUMPS
-
-ComplexMUMPSSolver::ComplexMUMPSSolver(MPI_Comm comm_)
-{
-   Init(comm_);
-}
-
-ComplexMUMPSSolver::ComplexMUMPSSolver(const Operator &op)
-{
-   auto APtr = dynamic_cast<const ComplexHypreParMatrix *>(&op);
-   MFEM_VERIFY(APtr,
-               "ComplexMUMPSSolver requires a ComplexHypreParMatrix operator");
-   SetOperator(op);
-}
-
-void ComplexMUMPSSolver::Init(MPI_Comm comm_)
-{
-   comm = comm_;
-   MPI_Comm_size(comm, &numProcs);
-   MPI_Comm_rank(comm, &myid);
-
-   print_level = 2;
-   row_start = 0;
-
-   id = nullptr;
-
-#if MFEM_MUMPS_VERSION >= 530
-   irhs_loc = nullptr;
-   isol_loc = nullptr;
-   rhs_loc  = nullptr;
-   sol_loc  = nullptr;
-#else
-   global_num_rows = 0;
-   recv_counts = nullptr;
-   displs = nullptr;
-   rhs_glob = nullptr;
-   rhs_glob_r = nullptr;
-   rhs_glob_i = nullptr;
-#endif
-}
-
-ComplexMUMPSSolver::~ComplexMUMPSSolver()
-{
-#if MFEM_MUMPS_VERSION >= 530
-   delete [] irhs_loc;
-   delete [] isol_loc;
-   delete [] rhs_loc;
-   delete [] sol_loc;
-#else
-   delete [] recv_counts;
-   delete [] displs;
-   delete [] rhs_glob;
-   delete [] rhs_glob_r;
-   delete [] rhs_glob_i;
-#endif
-
-   if (id)
-   {
-      id->job = -2;
-      mumps_call();
-      delete id;
-      id = nullptr;
-   }
-}
-
-void ComplexMUMPSSolver::SetOperator(const Operator &op)
-{
-   auto APtr = dynamic_cast<const ComplexHypreParMatrix *>(&op);
-   MFEM_VERIFY(APtr,
-               "ComplexMUMPSSolver requires a ComplexHypreParMatrix operator");
-
-   height = op.Height();
-   width  = op.Width();
-
-   const HypreParMatrix *Ar = (APtr->hasRealPart()) ? &APtr->real() : nullptr;
-   const HypreParMatrix *Ai = (APtr->hasImagPart()) ? &APtr->imag() : nullptr;
-
-   MFEM_VERIFY(Ar || Ai, "ComplexMUMPSSolver: both real and imag parts are null.");
-
-   // Pick communicator from the non-null part
-   MPI_Comm op_comm = (Ar ? Ar->GetComm() : Ai->GetComm());
-
-   // Comm setup/check
-   if (comm == MPI_COMM_NULL) { Init(op_comm); }
-   else
-   {
-      int cmp = MPI_UNEQUAL;
-      MPI_Comm_compare(comm, op_comm, &cmp);
-      MFEM_VERIFY(cmp != MPI_UNEQUAL, "MPI Comm mismatch");
-   }
-
-   // HostRead only if non-null
-   if (Ar) { Ar->HostRead(); }
-   if (Ai) { Ai->HostRead(); }
-
-   // hypre parcsr pointers
-   hypre_ParCSRMatrix *parcsr_op_r = nullptr;
-   hypre_ParCSRMatrix *parcsr_op_i = nullptr;
-
-   if (Ar) { parcsr_op_r = (hypre_ParCSRMatrix*) const_cast<HypreParMatrix&>(*Ar); }
-   if (Ai) { parcsr_op_i = (hypre_ParCSRMatrix*) const_cast<HypreParMatrix&>(*Ai); }
-
-   // Merge diag+offd for whichever exists
-   hypre_CSRMatrix *csr_op_r = nullptr;
-   hypre_CSRMatrix *csr_op_i = nullptr;
-
-   if (parcsr_op_r) { csr_op_r = hypre_MergeDiagAndOffd(parcsr_op_r); }
-   if (parcsr_op_i) { csr_op_i = hypre_MergeDiagAndOffd(parcsr_op_i); }
-
-#if MFEM_HYPRE_VERSION >= 21600
-   if (csr_op_r) { hypre_CSRMatrixBigJtoJ(csr_op_r); }
-   if (csr_op_i) { hypre_CSRMatrixBigJtoJ(csr_op_i); }
-#endif
-
-   // Determine local/global sizes and row_start from an existing part
-   const int n_loc = internal::to_int((csr_op_r ? csr_op_r->num_rows :
-                                       csr_op_i->num_rows));
-   row_start = internal::to_int((parcsr_op_r ? parcsr_op_r->first_row_index
-                                 : parcsr_op_i->first_row_index));
-   const int global_n = internal::to_int((parcsr_op_r ?
-                                          parcsr_op_r->global_num_rows
-                                          : parcsr_op_i->global_num_rows));
-
-   // Use nullptr checks
-   const int *Ir = csr_op_r ? csr_op_r->i : nullptr;
-   const int *Jr = csr_op_r ? csr_op_r->j : nullptr;
-   const real_t *Vr = csr_op_r ? (const real_t*)csr_op_r->data : nullptr;
-
-   const int *Ii = csr_op_i ? csr_op_i->i : nullptr;
-   const int *Ji = csr_op_i ? csr_op_i->j : nullptr;
-   const real_t *Vi = csr_op_i ? (const real_t*)csr_op_i->data : nullptr;
-
-   // Build union COO
-   std::vector<int> Icoo, Jcoo;
-   std::vector<mumps_complex_t> Zcoo;
-
-   size_t nnz_r = csr_op_r ? (size_t)csr_op_r->num_nonzeros : 0;
-   size_t nnz_i = csr_op_i ? (size_t)csr_op_i->num_nonzeros : 0;
-   Icoo.reserve(nnz_r + nnz_i);
-   Jcoo.reserve(nnz_r + nnz_i);
-   Zcoo.reserve(nnz_r + nnz_i);
-
-   BuildUnionCOO(n_loc, row_start, Ir, Jr, Vr, Ii, Ji, Vi, Icoo, Jcoo, Zcoo);
-
-   const int nnz = (int)Icoo.size();
-   int *I = new int[nnz];
-   int *J = new int[nnz];
-   mumps_complex_t *A = new mumps_complex_t[nnz];
-
-   std::copy(Icoo.begin(), Icoo.end(), I);
-   std::copy(Jcoo.begin(), Jcoo.end(), J);
-   std::copy(Zcoo.begin(), Zcoo.end(), A);
-
-   // New ComplexMUMPS object or reuse an existing one
-   if (!id || !reorder_reuse)
-   {
-      if (id)
-      {
-         id->job = -2;
-         mumps_call();
-         delete id;
-         id = nullptr;
-      }
-
-#ifdef MFEM_USE_SINGLE
-      id = new CMUMPS_STRUC_C();
-#else
-      id = new ZMUMPS_STRUC_C();
-#endif
-
-      id->sym = 0; // general complex
-      id->par = 1;
-      id->comm_fortran = (MUMPS_INT)MPI_Comm_c2f(comm);
-
-      // Init
-      id->job = -1;
-      mumps_call();
-
-      // Set parameters
-      SetParameters();
-
-      // Attach matrix
-      id->n       = global_n;
-      id->nnz_loc = nnz;
-      id->irn_loc = I;
-      id->jcn_loc = J;
-      id->a_loc   = A;
-
-      // Analysis (ordering + symbolic)
-      id->job = 1;
-      mumps_call();
-   }
-   else
-   {
-      // Reuse symbolic factorization / ordering
-      MFEM_VERIFY(id->n == global_n,
-                  "ReorderingReuse requires same global size (id->n mismatch)");
-
-      // Update matrix pointers (pattern is assumed compatible)
-      id->nnz_loc = nnz;
-      id->irn_loc = I;
-      id->jcn_loc = J;
-      id->a_loc   = A;
-   }
-
-   // Factorization
-   id->job = 2;
-   {
-      const int mem_relax_lim = 200;
-      while (true)
-      {
-         mumps_call();
-         if (id->MUMPS_INFOG(1) < 0)
-         {
-            if (id->MUMPS_INFOG(1) == -8 || id->MUMPS_INFOG(1) == -9)
-            {
-               id->MUMPS_ICNTL(14) += 20;
-               MFEM_VERIFY(id->MUMPS_ICNTL(14) <= mem_relax_lim,
-                           "Memory relaxation limit reached for ComplexMUMPSSolver factorization");
-               if (myid == 0 && print_level > 0)
-               {
-                  out << "Re-running ComplexMUMPSSolver factorization with memory relaxation "
-                      << id->MUMPS_ICNTL(14) << '\n';
-               }
-            }
-            else
-            {
-               MFEM_ABORT("Error during ComplexMUMPSSolver numerical factorization");
-            }
-         }
-         else { break; }
-      }
-   }
-
-   // Done with input storage
-   if (csr_op_r) { hypre_CSRMatrixDestroy(csr_op_r);}
-   if (csr_op_i) { hypre_CSRMatrixDestroy(csr_op_i);}
-   delete [] I;
-   delete [] J;
-   delete [] A;
-
-   // Post-factorization RHS/SOL setup
-   id->nrhs = -1;
-
-#if MFEM_MUMPS_VERSION >= 530
-   // Distributed RHS/SOL sizes
-   id->nloc_rhs = n_loc;
-   id->lrhs_loc = n_loc;
-   id->lsol_loc = id->MUMPS_INFO(23);
-
-   delete [] irhs_loc;
-   irhs_loc = new int[id->lrhs_loc];
-   for (int i = 0; i < n_loc; i++)
-   {
-      irhs_loc[i] = row_start + i + 1;
-   }
-   id->irhs_loc = irhs_loc;
-
-   delete [] isol_loc;
-   isol_loc = new int[id->lsol_loc];
-   id->isol_loc = isol_loc;
-
-   row_starts.SetSize(numProcs);
-   MPI_Allgather(&row_start, 1, MPI_INT, row_starts, 1, MPI_INT, comm);
-
-   // Reset cached buffers
-   delete [] rhs_loc; rhs_loc = nullptr;
-   delete [] sol_loc; sol_loc = nullptr;
-   rhs1_buf.clear();
-
-#else
-   // Centralized RHS/SOL on root
-   id->lrhs = id->n;
-
-   global_num_rows = id->n;
-
-   if (myid == 0)
-   {
-      delete [] recv_counts;
-      delete [] displs;
-      recv_counts = new int[numProcs];
-      displs = new int[numProcs];
-
-      delete [] rhs_glob;   rhs_glob = nullptr;
-      delete [] rhs_glob_r; rhs_glob_r = nullptr;
-      delete [] rhs_glob_i; rhs_glob_i = nullptr;
-   }
-
-   MPI_Gather(&n_loc, 1, MPI_INT, recv_counts, 1, MPI_INT, 0, comm);
-
-   if (myid == 0)
-   {
-      displs[0] = 0;
-      int s = 0;
-      for (int k = 0; k < numProcs - 1; k++)
-      {
-         s += recv_counts[k];
-         displs[k+1] = s;
-      }
-   }
-#endif
-}
-
-void ComplexMUMPSSolver::InitRhsSol(int nrhs) const
-{
-#if MFEM_MUMPS_VERSION >= 530
-
-   MFEM_VERIFY(id, "InitRhsSol called before SetOperator");
-
-   if (id->nrhs != nrhs)
-   {
-      delete [] rhs_loc;
-      delete [] sol_loc;
-
-      rhs_loc = new mumps_complex_t[(size_t)nrhs * (size_t)id->lrhs_loc];
-      sol_loc = new mumps_complex_t[(size_t)nrhs * (size_t)id->lsol_loc];
-
-      id->rhs_loc = rhs_loc;
-      id->sol_loc = sol_loc;
-   }
-   id->nrhs = nrhs;
-
-#else
-   MFEM_VERIFY(id, "InitRhsSol called before SetOperator");
-
-   id->nrhs = nrhs;
-   id->lrhs = id->n;
-
-   if (myid == 0)
-   {
-      const size_t N = (size_t)nrhs * (size_t)global_num_rows;
-
-      delete [] rhs_glob;
-      delete [] rhs_glob_r;
-      delete [] rhs_glob_i;
-
-      rhs_glob   = new mumps_complex_t[N];
-      rhs_glob_r = new real_t[N];
-      rhs_glob_i = new real_t[N];
-
-      id->rhs = rhs_glob;
-   }
-#endif
-}
-
-void ComplexMUMPSSolver::Mult(const Vector &x, Vector &y) const
-{
-   Array<const Vector *> X(1);
-   Array<Vector *> Y(1);
-   X[0] = &x;
-   Y[0] = &y;
-   ArrayMult(X, Y);
-}
-
-void ComplexMUMPSSolver::ArrayMult(const Array<const Vector *> &X,
-                                   Array<Vector *> &Y) const
-{
-   MFEM_ASSERT(X.Size() == Y.Size(),
-               "Number of columns mismatch in ComplexMUMPSSolver::Mult!");
-   MFEM_VERIFY(id, "ComplexMUMPSSolver::ArrayMult called before SetOperator");
-
-   InitRhsSol(X.Size());
-
-#if MFEM_MUMPS_VERSION >= 530
-   MFEM_VERIFY(irhs_loc && isol_loc, "RHS/SOL maps not initialized");
-   MFEM_VERIFY(rhs_loc && sol_loc, "RHS/SOL buffers not initialized");
-   const int n_loc = id->lrhs_loc;
-   const int nrhs  = id->nrhs;
-
-   // Pack all RHS
-   int xisign = (conv == ComplexOperator::BLOCK_SYMMETRIC) ? -1 : 1;
-   for (int i = 0; i < nrhs; i++)
-   {
-      MFEM_ASSERT(X[i], "Missing Vector in Mult!");
-      X[i]->HostRead();
-      MFEM_VERIFY(X[i]->Size() == 2*n_loc, "RHS size mismatch");
-
-      const real_t *xdata = X[i]->GetData();
-      const real_t *xr = xdata;
-      const real_t *xi = xdata + n_loc;
-
-      mumps_complex_t *dst = rhs_loc + i * n_loc;
-      for (int j = 0; j < n_loc; j++)
-      {
-         dst[j].r = xr[j];
-         dst[j].i = xisign * xi[j];
-      }
-   }
-
-   id->rhs_loc  = rhs_loc;
-   id->sol_loc  = sol_loc;
-   id->irhs_loc = irhs_loc;
-   id->isol_loc = isol_loc;
-
-   // MUMPS solve
-   id->job = 3;
-   mumps_call();
-
-   const int lsol = id->lsol_loc;
-
-   // Redistribute each solution column into Y
-   for (int i = 0; i < nrhs; i++)
-   {
-      MFEM_ASSERT(Y[i], "Missing output Vector in Mult!");
-      Y[i]->HostWrite();
-      MFEM_VERIFY(Y[i]->Size() == 2*n_loc, "Output size mismatch");
-
-      const mumps_complex_t *xcol = sol_loc + i * lsol;
-      RedistributeSol(isol_loc, xcol, Y[i]->GetData(), n_loc, lsol);
-   }
-
-#else // MFEM_MUMPS_VERSION < 530
-
-   const int nrhs = id->nrhs;
-
-   MFEM_VERIFY(X.Size() > 0 && X[0], "Missing RHS");
-   const int n_loc = X[0]->Size()/2;
-
-   for (int i = 0; i < nrhs; i++)
-   {
-      MFEM_ASSERT(X[i], "Missing Vector in Mult!");
-      X[i]->HostRead();
-      MFEM_VERIFY(X[i]->Size() == 2*n_loc, "RHS size mismatch");
-   }
-
-   // Gather each RHS column (real+imag separately) into root staging
-   for (int i = 0; i < nrhs; i++)
-   {
-      const real_t *xdata = X[i]->GetData();
-
-      MPI_Gatherv(xdata, n_loc, MPITypeMap<real_t>::mpi_type,
-                  rhs_glob_r + i * global_num_rows,
-                  recv_counts, displs, MPITypeMap<real_t>::mpi_type,
-                  0, comm);
-
-      MPI_Gatherv(xdata + n_loc, n_loc, MPITypeMap<real_t>::mpi_type,
-                  rhs_glob_i + i * global_num_rows,
-                  recv_counts, displs, MPITypeMap<real_t>::mpi_type,
-                  0, comm);
-   }
-
-   // Pack into MUMPS complex RHS on root: id->rhs is in-place
-   if (myid == 0)
-   {
-      for (int i = 0; i < nrhs; i++)
-      {
-         mumps_complex_t *dst = rhs_glob + i * global_num_rows;
-         const real_t *rr = rhs_glob_r + i * global_num_rows;
-         const real_t *ri = rhs_glob_i + i * global_num_rows;
-
-         for (int j = 0; j < global_num_rows; j++)
-         {
-            dst[j].r = rr[j];
-            dst[j].i = ri[j];
-         }
-      }
-      id->rhs = rhs_glob;
-   }
-
-   // Solve
-   id->job = 3;
-   mumps_call();
-
-   // Unpack to real/imag
-   if (myid == 0)
-   {
-      for (int i = 0; i < nrhs; i++)
-      {
-         const mumps_complex_t *src = rhs_glob + i * global_num_rows;
-         real_t *rr = rhs_glob_r + i * global_num_rows;
-         real_t *ri = rhs_glob_i + i * global_num_rows;
-
-         for (int j = 0; j < global_num_rows; j++)
-         {
-            rr[j] = src[j].r;
-            ri[j] = src[j].i;
-         }
-      }
-   }
-
-   // Scatter each RHS solution
-   for (int i = 0; i < nrhs; i++)
-   {
-      MFEM_ASSERT(Y[i], "Missing Vector in Mult!");
-      Y[i]->HostWrite();
-      MFEM_VERIFY(Y[i]->Size() == 2*n_loc, "Output size mismatch");
-
-      real_t *ydata = Y[i]->GetData();
-
-      MPI_Scatterv(rhs_glob_r + i * global_num_rows,
-                   recv_counts, displs, MPITypeMap<real_t>::mpi_type,
-                   ydata, n_loc, MPITypeMap<real_t>::mpi_type,
-                   0, comm);
-
-      MPI_Scatterv(rhs_glob_i + i * global_num_rows,
-                   recv_counts, displs, MPITypeMap<real_t>::mpi_type,
-                   ydata + n_loc, n_loc, MPITypeMap<real_t>::mpi_type,
-                   0, comm);
-   }
-
-#endif
-}
-
-void ComplexMUMPSSolver::MultTranspose(const Vector &x, Vector &y) const
-{
-   MFEM_VERIFY(id, "MultTranspose called before SetOperator");
-
-   // Transpose solve
-   id->MUMPS_ICNTL(9) = 0;
-   Mult(x, y);
-   id->MUMPS_ICNTL(9) = 1;
-}
-
-void ComplexMUMPSSolver::ArrayMultTranspose(const Array<const Vector *> &X,
-                                            Array<Vector *> &Y) const
-{
-   MFEM_VERIFY(id, "ArrayMultTranspose called before SetOperator");
-
-   // Transpose solve
-   id->MUMPS_ICNTL(9) = 0;
-   ArrayMult(X, Y);
-   id->MUMPS_ICNTL(9) = 1;
-}
-
-void ComplexMUMPSSolver::SetParameters()
-{
-   // Output stream for error messages
-   id->MUMPS_ICNTL(1) = 6;
-   // Output stream for diagnostic printing local to each proc
-   id->MUMPS_ICNTL(2) = 0;
-   // Output stream for global info
-   id->MUMPS_ICNTL(3) = 6;
-   // Level of error printing
-   id->MUMPS_ICNTL(4) = print_level;
-
-   // Input matrix format (assembled)
-   id->MUMPS_ICNTL(5) = 0;
-   // Use A or A^T
-   id->MUMPS_ICNTL(9) = 1;
-   // Iterative refinement (disabled)
-   id->MUMPS_ICNTL(10) = 0;
-   // Error analysis-statistics (disabled)
-   id->MUMPS_ICNTL(11) = 0;
-   // Use of ScaLAPACK (disabled)
-   id->MUMPS_ICNTL(13) = 0;
-   // Workspace relaxation (% increase)
-   id->MUMPS_ICNTL(14) = 20;
-   // OpenMP threads (default)
-   id->MUMPS_ICNTL(16) = 0;
-   // Matrix input format (distributed)
-   id->MUMPS_ICNTL(18) = 3;
-   // Schur complement (none)
-   id->MUMPS_ICNTL(19) = 0;
-
-#if MFEM_MUMPS_VERSION >= 530
-   // Distributed RHS
-   id->MUMPS_ICNTL(20) = 10;
-   // Distributed Sol
-   id->MUMPS_ICNTL(21) = 1;
-#else
-   // Centralized RHS
-   id->MUMPS_ICNTL(20) = 0;
-   // Centralized Sol
-   id->MUMPS_ICNTL(21) = 0;
-#endif
-
-   // Out-of-core (disabled)
-   id->MUMPS_ICNTL(22) = 0;
-   // Max size of working memory (default)
-   id->MUMPS_ICNTL(23) = 0;
-
-   switch (reorder_method)
-   {
-      case ReorderingStrategy::AUTOMATIC:
-         id->MUMPS_ICNTL(28) = 0;
-         id->MUMPS_ICNTL(7) = 7;
-         id->MUMPS_ICNTL(29) = 0;
-         break;
-      case ReorderingStrategy::AMD:
-         id->MUMPS_ICNTL(28) = 1;
-         id->MUMPS_ICNTL(7) = 0;
-         break;
-      case ReorderingStrategy::AMF:
-         id->MUMPS_ICNTL(28) = 1;
-         id->MUMPS_ICNTL(7) = 2;
-         break;
-      case ReorderingStrategy::PORD:
-         id->MUMPS_ICNTL(28) = 1;
-         id->MUMPS_ICNTL(7) = 4;
-         break;
-      case ReorderingStrategy::METIS:
-         id->MUMPS_ICNTL(28) = 1;
-         id->MUMPS_ICNTL(7) = 5;
-         break;
-      case ReorderingStrategy::PARMETIS:
-         id->MUMPS_ICNTL(28) = 2;
-         id->MUMPS_ICNTL(29) = 2;
-         break;
-      case ReorderingStrategy::SCOTCH:
-         id->MUMPS_ICNTL(28) = 1;
-         id->MUMPS_ICNTL(7) = 3;
-         break;
-      case ReorderingStrategy::PTSCOTCH:
-         id->MUMPS_ICNTL(28) = 2;
-         id->MUMPS_ICNTL(29) = 1;
-         break;
-      default:
-         break; // This should be unreachable
-   }
-
-}
-
-void ComplexMUMPSSolver::BuildUnionCOO(const int n_loc,
-                                       const int row_start_,
-                                       const int *Ir, const int *Jr, const real_t *Vr,
-                                       const int *Ii, const int *Ji, const real_t *Vi,
-                                       std::vector<int> &Icoo,
-                                       std::vector<int> &Jcoo,
-                                       std::vector<mumps_complex_t> &Zcoo) const
-{
-   for (int r = 0; r < n_loc; ++r)
-   {
-      std::unordered_map<int, std::pair<real_t, real_t>> row;
-
-      const int rr0 = Ir ? Ir[r]   : 0;
-      const int rr1 = Ir ? Ir[r+1] : 0;
-      const int ii0 = Ii ? Ii[r]   : 0;
-      const int ii1 = Ii ? Ii[r+1] : 0;
-
-      row.reserve((rr1 - rr0) + (ii1 - ii0));
-
-      if (Ir)
-      {
-         for (int p = rr0; p < rr1; ++p) { row[Jr[p]].first += Vr[p]; }
-      }
-      if (Ii)
-      {
-         for (int p = ii0; p < ii1; ++p) { row[Ji[p]].second += Vi[p]; }
-      }
-
-      for (const auto &kv : row)
-      {
-         Icoo.push_back(row_start_ + r + 1);
-         Jcoo.push_back(kv.first + 1);
-         Zcoo.push_back(mumps_complex_t{kv.second.first, kv.second.second});
-      }
-   }
-}
-
-#if MFEM_MUMPS_VERSION >= 530
-int ComplexMUMPSSolver::GetRowRank(int i, const Array<int> &row_starts_) const
-{
-   if (row_starts_.Size() == 1) { return 0; }
-   auto up = std::upper_bound(row_starts_.begin(), row_starts_.end(), i);
-   return (int)std::distance(row_starts_.begin(), up) - 1;
-}
-
-void ComplexMUMPSSolver::RedistributeSol(const int *row_map,
-                                         const mumps_complex_t *x,
-                                         real_t *y_ri,
-                                         int n_loc,
-                                         int lsol_loc) const
-{
-   int *send_count = new int[numProcs]();
-   for (int i = 0; i < lsol_loc; i++)
-   {
-      const int j = row_map[i] - 1;
-      const int row_rank = GetRowRank(j, row_starts);
-      if (myid == row_rank) { continue; }
-      send_count[row_rank]++;
-   }
-
-   int *recv_count = new int[numProcs];
-   MPI_Alltoall(send_count, 1, MPI_INT, recv_count, 1, MPI_INT, comm);
-
-   int *send_displ = new int[numProcs]; send_displ[0] = 0;
-   int *recv_displ = new int[numProcs]; recv_displ[0] = 0;
-
-   int sbuff_size = send_count[numProcs-1];
-   int rbuff_size = recv_count[numProcs-1];
-   for (int k = 0; k < numProcs - 1; k++)
-   {
-      send_displ[k+1] = send_displ[k] + send_count[k];
-      recv_displ[k+1] = recv_displ[k] + recv_count[k];
-      sbuff_size += send_count[k];
-      rbuff_size += recv_count[k];
-   }
-
-   int   *sendbuf_index = new int[sbuff_size];
-   real_t *sendbuf_r    = new real_t[sbuff_size];
-   real_t *sendbuf_i    = new real_t[sbuff_size];
-   int   *soffs         = new int[numProcs]();
-
-   for (int i = 0; i < lsol_loc; i++)
-   {
-      const int j = row_map[i] - 1;
-      const int row_rank = GetRowRank(j, row_starts);
-
-      const real_t xr = (real_t)x[i].r;
-      const real_t xi = (real_t)x[i].i;
-
-      if (myid == row_rank)
-      {
-         const int local_index = j - row_start;
-         y_ri[local_index]        = xr;
-         y_ri[local_index+n_loc]  = xi;
-      }
-      else
-      {
-         const int k = send_displ[row_rank] + soffs[row_rank];
-         sendbuf_index[k] = j;
-         sendbuf_r[k] = xr;
-         sendbuf_i[k] = xi;
-         soffs[row_rank]++;
-      }
-   }
-
-   int    *recvbuf_index = new int[rbuff_size];
-   real_t *recvbuf_r     = new real_t[rbuff_size];
-   real_t *recvbuf_i     = new real_t[rbuff_size];
-
-   MPI_Alltoallv(sendbuf_index, send_count, send_displ, MPI_INT,
-                 recvbuf_index, recv_count, recv_displ, MPI_INT, comm);
-
-   MPI_Alltoallv(sendbuf_r, send_count, send_displ, MPITypeMap<real_t>::mpi_type,
-                 recvbuf_r, recv_count, recv_displ, MPITypeMap<real_t>::mpi_type, comm);
-
-   MPI_Alltoallv(sendbuf_i, send_count, send_displ, MPITypeMap<real_t>::mpi_type,
-                 recvbuf_i, recv_count, recv_displ, MPITypeMap<real_t>::mpi_type, comm);
-
-   for (int i = 0; i < rbuff_size; i++)
-   {
-      const int local_index = recvbuf_index[i] - row_start;
-      y_ri[local_index]       = recvbuf_r[i];
-      y_ri[local_index+n_loc] = recvbuf_i[i];
-   }
-
-   delete [] recvbuf_i;
-   delete [] recvbuf_r;
-   delete [] recvbuf_index;
-   delete [] soffs;
-   delete [] sendbuf_i;
-   delete [] sendbuf_r;
-   delete [] sendbuf_index;
-   delete [] recv_displ;
-   delete [] send_displ;
-   delete [] recv_count;
-   delete [] send_count;
-}
-#endif // MFEM_MUMPS_VERSION >= 530
-
-#endif // MFEM_USE_COMPLEX_MUMPS
-
 } // namespace mfem
+
+#endif // MFEM_USE_MPI
+#endif // MFEM_USE_MUMPS

linalg/mumps.hpp

@@ -14,34 +14,22 @@
 
 #include "../config/config.hpp"
 
-#if defined(MFEM_USE_MUMPS) || defined(MFEM_USE_COMPLEX_MUMPS)
+#ifdef MFEM_USE_MUMPS
+#ifdef MFEM_USE_MPI
+
 #include "operator.hpp"
 #include "hypre.hpp"
 #include <mpi.h>
-#endif
 
-#ifdef MFEM_USE_MUMPS
 #ifdef MFEM_USE_SINGLE
 #include "smumps_c.h"
 #else
 #include "dmumps_c.h"
 #endif
-#endif
-
-#ifdef MFEM_USE_COMPLEX_MUMPS
-#include "complex_operator.hpp"
-#ifdef MFEM_USE_SINGLE
-#include "cmumps_c.h"
-#else
-#include "zmumps_c.h"
-#endif
-#include <vector>
-#endif
 
 namespace mfem
 {
 
-#ifdef MFEM_USE_MUMPS
 /**
  * @brief MUMPS: A Parallel Sparse Direct Solver
  *
@@ -64,7 +52,7 @@ public:
    /// Specify the reordering strategy for the MUMPS solver
    enum ReorderingStrategy
    {
-      /// Let MUMPS automatically decide the reordering strategy
+      /// Let MUMPS automatically decide the reording strategy
       AUTOMATIC = 0,
       /// Approximate Minimum Degree with auto quasi-dense row detection is used
       AMD,
@@ -110,7 +98,7 @@ public:
    void Mult(const Vector &x, Vector &y) const;
 
    /**
-    * @brief Solve $ Y_i = Op^{-1} X_i $
+    * @brief Solve $ Y_i = Op^{-T} X_i $
     *
     * @param X Array of RHS vectors
     * @param Y Array of Solution vectors
@@ -141,8 +129,8 @@ public:
     * - 0:  No output printed
     * - 1:  Only errors printed
     * - 2:  Errors, warnings, and main stats printed
-    * - 3:  Errors, warnings, main stats, and terse diagnostics printed
-    * - 4:  Errors, warnings, main stats, diagnostics, and input/output printed
+    * - 3:  Errors, warning, main stats, and terse diagnostics printed
+    * - 4:  Errors, warning, main stats, diagnostics, and input/output printed
     *
     * @param print_lvl Print level, default is 2
     *
@@ -270,247 +258,8 @@ private:
 #endif
 }; // mfem::MUMPSSolver class
 
-#endif // MFEM_USE_MUMPS
-
-#ifdef MFEM_USE_COMPLEX_MUMPS
-/**
- * @brief Complex MUMPS: Parallel sparse direct solver for ComplexHypreParMatrix
- *
- * Notes:
- *  - Expects Operator to be a ComplexHypreParMatrix.
- *  - Complex vectors are assumed packed as [Re; Im] in a real Vector.
- *  - SetOperator(): analysis + factorization
- *  - Mult()       : solve
- */
-class ComplexMUMPSSolver : public Solver
-{
-public:
-   /// Specify the reordering strategy
-   enum ReorderingStrategy
-   {
-      /// Let MUMPS automatically decide the reordering strategy
-      AUTOMATIC = 0,
-      /// Approximate Minimum Degree with auto quasi-dense row detection is used
-      AMD,
-      /// Approximate Minimum Fill method will be used
-      AMF,
-      /// The PORD library will be used
-      PORD,
-      /// The METIS library will be used
-      METIS,
-      /// The ParMETIS library will be used
-      PARMETIS,
-      /// The Scotch library will be used
-      SCOTCH,
-      /// The PTScotch library will be used
-      PTSCOTCH
-   };
-
-   /**
-    * @brief Constructor with MPI_Comm parameter.
-    */
-   ComplexMUMPSSolver(MPI_Comm comm_);
-   /**
-    * @brief Constructor with a ComplexHypreParMatrix Operator.
-    */
-   ComplexMUMPSSolver(const Operator &op);
-
-   /**
-    * @brief Set the Operator and perform factorization
-    *
-    * @a op needs to be of type ComplexHypreParMatrix.
-    *
-    * @param op Operator used in factorization and solve
-    */
-   void SetOperator(const Operator &op);
-
-   /**
-    * @brief Solve $ y = Op^{-1} x $
-    *
-    * @param x RHS vector
-    * @param y Solution vector
-    */
-   void Mult(const Vector &x, Vector &y) const;
-   /**
-    * @brief Solve $ Y_i = Op^{-1} X_i $
-    *
-    * @param X Array of RHS vectors
-    * @param Y Array of Solution vectors
-    */
-   void ArrayMult(const Array<const Vector *> &X, Array<Vector *> &Y) const;
-   /**
-    * @brief Transpose Solve $ y = Op^{-T} x $
-    * @note This is not a Hermitian/conjugate-transpose solve.
-    *
-    * @param x RHS vector
-    * @param y Solution vector
-    */
-   void MultTranspose(const Vector &x, Vector &y) const;
-
-   /**
-    * @brief Transpose Solve $ Y_i = Op^{-T} X_i $
-    * @note This is not a Hermitian/conjugate-transpose solve.
-    *
-    * @param X Array of RHS vectors
-    * @param Y Array of Solution vectors
-    */
-   void ArrayMultTranspose(const Array<const Vector *> &X,
-                           Array<Vector *> &Y) const;
-
-   /**
-    * @brief Set the error print level for MUMPS
-    *
-    * Supported values are:
-    * - 0:  No output printed
-    * - 1:  Only errors printed
-    * - 2:  Errors, warnings, and main stats printed
-    * - 3:  Errors, warnings, main stats, and terse diagnostics printed
-    * - 4:  Errors, warnings, main stats, diagnostics, and input/output printed
-    *
-    * @param print_lvl Print level, default is 2
-    *
-    * @note This method has to be called before SetOperator
-    */
-   void SetPrintLevel(int print_lvl) { print_level = print_lvl;}
-
-   /**
-    * @brief Set the reordering strategy
-    *
-    * Supported reorderings are: ComplexMUMPSSolver::AUTOMATIC,
-    * ComplexMUMPSSolver::AMD, ComplexMUMPSSolver::AMF,
-    * ComplexMUMPSSolver::PORD, ComplexMUMPSSolver::METIS,
-    * ComplexMUMPSSolver::PARMETIS, ComplexMUMPSSolver::SCOTCH,
-    * and ComplexMUMPSSolver::PTSCOTCH
-    *
-    * @param method Reordering method
-    *
-    * @note This method has to be called before SetOperator
-    */
-   void SetReorderingStrategy(ReorderingStrategy method) { reorder_method = method; }
-
-   /**
-    * @brief Set the flag controlling reuse of the symbolic factorization
-    * for multiple operators
-    *
-    * @param reuse Flag to reuse symbolic factorization
-    *
-    * @note This method has to be called before repeated calls to SetOperator
-    */
-   void SetReorderingReuse(bool reuse) { reorder_reuse = reuse; }
-
-   ~ComplexMUMPSSolver();
-
-private:
-   // MPI communicator
-   MPI_Comm comm = MPI_COMM_NULL;
-
-   // Number of procs
-   int numProcs;
-
-   // MPI rank
-   int myid;
-
-   // Parameter controlling the printing level
-   int print_level = 0;
-
-   // Parameter controlling the reordering strategy
-   ReorderingStrategy reorder_method = ReorderingStrategy::AUTOMATIC;
-
-   // Parameter controlling whether or not to reuse the symbolic factorization
-   // for multiple calls to SetOperator
-   bool reorder_reuse = false;
-
-   // Local row offsets
-   int row_start;
-
-   // ComplexMUMPS object
-#ifdef MFEM_USE_SINGLE
-   CMUMPS_STRUC_C *id = nullptr;
-   using mumps_complex_t = mumps_complex;
-#else
-   ZMUMPS_STRUC_C *id = nullptr;
-   using mumps_complex_t = mumps_double_complex;
-#endif
-
-   /// Method for initialization
-   void Init(MPI_Comm comm_);
-
-   /// Method for setting ComplexMUMPS internal parameters
-   void SetParameters();
-
-   /// Method for configuring storage for distributed/centralized
-   /// RHS and solution
-   void InitRhsSol(int nrhs) const;
-
-   /// Method for calling the single/double ComplexMUMPS solver
-   inline void mumps_call() const
-   {
-#ifdef MFEM_USE_SINGLE
-      cmumps_c(id);
-#else
-      zmumps_c(id);
-#endif
-   }
-
-   /// Method for building the COO format of the combined complex operator
-   /// from the real and imaginary parts. This is particularly useful when
-   /// real and imaginary parts have different sparsity patterns.
-   void BuildUnionCOO(const int n_loc,
-                      const int row_start,
-                      const int *Ir, const int *Jr, const real_t *Vr,
-                      const int *Ii, const int *Ji, const real_t *Vi,
-                      std::vector<int> &Icoo,
-                      std::vector<int> &Jcoo,
-                      std::vector<mumps_complex_t> &Zcoo) const;
-
-#if MFEM_MUMPS_VERSION >= 530
-   // Row offsets on all procs
-   Array<int> row_starts;
-
-   // Local RHS row indices
-   int *irhs_loc = nullptr;
-
-   // Local solution row map returned by MUMPS
-   int *isol_loc = nullptr;
-
-   // Cached buffers
-   mutable mumps_complex_t *rhs_loc = nullptr;
-   mutable mumps_complex_t *sol_loc = nullptr;
-
-   // RHS buffers
-   mutable std::vector<mumps_complex_t> rhs1_buf;
-
-   // These two methods are needed to distribute the local solution
-   // vectors returned by MUMPS to the original MFEM parallel partition
-   int GetRowRank(int i, const Array<int> &row_starts_) const;
-
-   void RedistributeSol(const int *row_map,
-                        const mumps_complex_t *x,
-                        real_t *y_ri,
-                        int n_loc,
-                        int lsol_loc) const;
-
-   ComplexOperator::Convention conv = ComplexOperator::Convention::HERMITIAN;
-
-#else
-   // Root-gather path
-   int global_num_rows;
-
-   // Arrays needed for MPI_Gatherv and MPI_Scatterv
-   int *recv_counts = nullptr;
-   int *displs = nullptr;
-
-   // Complex RHS/solution on root
-   mutable mumps_complex_t *rhs_glob = nullptr;
-
-   // Cached real/imag staging on root
-   mutable real_t *rhs_glob_r = nullptr;
-   mutable real_t *rhs_glob_i = nullptr;
-#endif
-};
-
-#endif // MFEM_USE_COMPLEX_MUMPS
-
 } // namespace mfem
 
+#endif // MFEM_USE_MPI
+#endif // MFEM_USE_MUMPS
 #endif // MFEM_MUMPS

linalg/particlevector.cpp

@@ -10,7 +10,6 @@
 // CONTRIBUTING.md for details.
 
 #include "particlevector.hpp"
-#include "../general/forall.hpp"
 
 namespace mfem
 {
@@ -47,38 +46,20 @@ void ParticleVector::GetValues(int i, Vector &nvals) const
 {
    nvals.SetSize(vdim);
 
-   const bool nvals_use_dev = nvals.UseDevice();
-   // Use ParticleVector's device flag to minimize movement from large source
-   const bool use_dev = UseDevice();
-   const auto d_src = Read(use_dev);
-   auto d_dest = nvals.Write(use_dev);
-
-   const int vdim_ = vdim;
-   const int ordering_ = (int)ordering;
-   const int nv = (ordering == Ordering::byNODES) ? size / vdim : 0;
-
-   mfem::forall_switch(use_dev, vdim_, [=] MFEM_HOST_DEVICE (int c)
+   if (ordering == Ordering::byNODES)
    {
-      if (ordering_ == Ordering::byNODES)
+      int nv = GetNumParticles();
+      for (int c = 0; c < vdim; c++)
       {
-         d_dest[c] = d_src[i + nv*c];
+         nvals[c] = Vector::operator[](i+nv*c);
       }
-      else
-      {
-         d_dest[c] = d_src[c + vdim_*i];
-      }
-   });
-
-   // If nvals was not using device but ParticleVector is, copy back to host
-   if (!nvals_use_dev && use_dev)
-   {
-      nvals.HostRead();
-      nvals.UseDevice(false);
    }
-   // If nvals was using device but ParticleVector is not, copy back to device
-   if (!use_dev && nvals_use_dev)
+   else
    {
-      nvals.Read();
+      for (int c = 0; c < vdim; c++)
+      {
+         nvals[c] = Vector::operator[](c+vdim*i);
+      }
    }
 }
 
@@ -118,27 +99,21 @@ void ParticleVector::GetComponentsRef(int vd, Vector &nref)
 
 void ParticleVector::SetValues(int i, const Vector &nvals)
 {
-   const bool use_dev = UseDevice(); // use ParticleVector's device flag
-   const auto mc = use_dev ? Device::GetDeviceMemoryClass()
-                   : Device::GetHostMemoryClass();
-   auto d_dest = ReadWrite(use_dev);
-   const auto d_src = nvals.GetMemory().Read(mc, nvals.Size());
-
-   const int vdim_ = vdim;
-   const int ordering_ = (int)ordering;
-   const int nv = (ordering == Ordering::byNODES) ? size / vdim : 0;
-
-   mfem::forall_switch(use_dev, vdim_, [=] MFEM_HOST_DEVICE (int c)
+   if (ordering == Ordering::byNODES)
    {
-      if (ordering_ == Ordering::byNODES)
+      int nv = GetNumParticles();
+      for (int c = 0; c < vdim; c++)
       {
-         d_dest[i + c*nv] = d_src[c];
+         Vector::operator[](i + c*nv) = nvals[c];
       }
-      else
+   }
+   else
+   {
+      for (int c = 0; c < vdim; c++)
       {
-         d_dest[c + i*vdim_] = d_src[c];
+         Vector::operator[](c + i*vdim) = nvals[c];
       }
-   });
+   }
 }
 
 void ParticleVector::SetComponents(int vd, const Vector &comp)
@@ -169,9 +144,6 @@ real_t& ParticleVector::operator()(int i, int comp)
                "Component index " << comp <<
                " is invalid for vector dimension " << vdim);
 
-   // non-const so we make host flag valid in case user modifies data
-   HostReadWrite();
-
    if (ordering == Ordering::byNODES)
    {
       return Vector::operator[](i + comp*GetNumParticles());
@@ -191,8 +163,6 @@ const real_t& ParticleVector::operator()(int i, int comp) const
                "Component index " << comp <<
                " is invalid for vector dimension " << vdim);
 
-   HostRead();
-
    if (ordering == Ordering::byNODES)
    {
       return Vector::operator[](i + comp*GetNumParticles());
@@ -270,37 +240,9 @@ void ParticleVector::SetVDim(int vdim_, bool keep_data)
 
 void ParticleVector::SetOrdering(Ordering::Type ordering_, bool keep_data)
 {
-   if (keep_data && ordering != ordering_)
+   if (keep_data)
    {
-      int num_particles = GetNumParticles();
-      // create deep copy of old data that will be copied
-      Vector old_data(*this);
-
-      const bool use_dev = UseDevice();
-      const auto d_src = old_data.Read(use_dev);
-      auto d_dest = Write(use_dev);
-
-      const int vdim_ = vdim;
-      const int size_ = size;
-
-      if (ordering_ == Ordering::byNODES) // byVDIM -> byNODES
-      {
-         mfem::forall_switch(use_dev, size_, [=] MFEM_HOST_DEVICE (int k)
-         {
-            int i = k / vdim_; // src particle index
-            int d = k % vdim_; // src component index
-            d_dest[i + d * num_particles] = d_src[k];
-         });
-      }
-      else // byNODES -> byVDIM
-      {
-         mfem::forall_switch(use_dev, size_, [=] MFEM_HOST_DEVICE (int k)
-         {
-            int d = k / num_particles; // src component index
-            int i = k % num_particles; // src particle index
-            d_dest[d + i * vdim_] = d_src[k];
-         });
-      }
+      Ordering::Reorder(*this, vdim, ordering, ordering_);
    }
    ordering = ordering_;
 }
@@ -328,47 +270,32 @@ void ParticleVector::SetNumParticles(int num_vectors, bool keep_data)
 
       if (!keep_data) { return; }
 
-      const bool use_dev = UseDevice();
-      auto d_dest = this->ReadWrite(use_dev);
-
       if (ordering == Ordering::byNODES)
       {
-         // create deep copy of old data that will be copied
-         Vector old_slice;
-         old_slice.MakeRef(*this, 0, old_nv * vdim);
-         Vector old_copy(old_slice);
-
-         const auto d_src = old_copy.Read(use_dev);
-         const int vdim_ = vdim;
-
          // Shift entries for byNODES
-         mfem::forall_switch(use_dev, old_nv * vdim_,
-                             [=] MFEM_HOST_DEVICE (int k)
+         for (int c = vdim-1; c > 0; c--)
          {
-            const int d = k / old_nv;
-            const int i = k % old_nv;
-            d_dest[i + d*num_vectors] = d_src[k];
-         });
+            for (int i = old_nv-1; i >= 0; i--)
+            {
+               Vector::operator[](i+c*num_vectors) = Vector::operator[](i+c*old_nv);
+            }
+         }
 
-         // Zero-out new data slots
-         const int diff = num_vectors - old_nv;
-         mfem::forall_switch(use_dev, diff * vdim,
-                             [=] MFEM_HOST_DEVICE (int k)
+         // Zero-out data now associated with new Vectors
+         for (int c = 0; c < vdim; c++)
          {
-            const int d = k / diff;
-            const int i = k % diff;
-            d_dest[d * num_vectors + old_nv + i] = 0.0;
-         });
+            for (int i = old_nv; i < num_vectors; i++)
+            {
+               Vector::operator[](i+c*num_vectors) = 0.0;
+            }
+         }
       }
       else // byVDIM
       {
-         const int start_idx = old_nv * vdim;
-         const int end_idx = num_vectors * vdim;
-         const int diff = end_idx - start_idx;
-         mfem::forall_switch(use_dev, diff, [=] MFEM_HOST_DEVICE (int i)
+         for (int i = old_nv*vdim; i < num_vectors*vdim; i++)
          {
-            d_dest[start_idx + i] = 0.0;
-         });
+            data[i] = 0.0;
+         }
       }
    }
    else // Else just remove the trailing vector data

makefile

@@ -229,7 +229,7 @@ CXXFLAGS ?= $(OPTIM_FLAGS)
 # MPI configuration
 ifneq ($(MFEM_USE_MPI),YES)
    HOST_CXX = $(CXX)
-   PKGS_NEED_MPI = SUPERLU MUMPS COMPLEX_MUMPS STRUMPACK PETSC PUMI SLEPC MKL_CPARDISO
+   PKGS_NEED_MPI = SUPERLU MUMPS STRUMPACK PETSC PUMI SLEPC MKL_CPARDISO
    $(foreach mpidep,$(PKGS_NEED_MPI),$(if $(MFEM_USE_$(mpidep):NO=),\
      $(warning *** [MPI is OFF] setting MFEM_USE_$(mpidep) = NO)\
      $(eval override MFEM_USE_$(mpidep)=NO),))
@@ -304,7 +304,7 @@ ifeq ($(MFEM_USE_LEGACY_OPENMP),YES)
 endif
 
 # List of MFEM dependencies, that require the *_LIB variable to be non-empty
-MFEM_REQ_LIB_DEPS = SUPERLU MUMPS COMPLEX_MUMPS METIS FMS CONDUIT SIDRE LAPACK SUNDIALS\
+MFEM_REQ_LIB_DEPS = SUPERLU MUMPS METIS FMS CONDUIT SIDRE LAPACK SUNDIALS\
  SUITESPARSE STRUMPACK GINKGO GNUTLS HDF5 NETCDF SLEPC PETSC MPFR PUMI HIOP\
  GSLIB OCCA CEED RAJA UMPIRE MKL_CPARDISO MKL_PARDISO AMGX MAGMA CALIPER PARELAG\
  TRIBOL BENCHMARK MOONOLITH ALGOIM CUDSS
@@ -374,7 +374,7 @@ MFEM_DEFINES = MFEM_VERSION MFEM_VERSION_STRING MFEM_GIT_STRING MFEM_USE_MPI\
  MFEM_USE_PUMI MFEM_USE_HIOP MFEM_USE_GSLIB MFEM_USE_CUDA MFEM_USE_HIP\
  MFEM_USE_OCCA MFEM_USE_MOONOLITH MFEM_USE_CEED MFEM_USE_RAJA MFEM_USE_UMPIRE\
  MFEM_USE_SIMD MFEM_USE_ADIOS2 MFEM_USE_MKL_CPARDISO MFEM_USE_MKL_PARDISO MFEM_USE_AMGX\
- MFEM_USE_MAGMA MFEM_USE_MUMPS MFEM_USE_COMPLEX_MUMPS MFEM_USE_ADFORWARD MFEM_USE_CODIPACK MFEM_USE_CALIPER\
+ MFEM_USE_MAGMA MFEM_USE_MUMPS MFEM_USE_ADFORWARD MFEM_USE_CODIPACK MFEM_USE_CALIPER\
  MFEM_USE_BENCHMARK MFEM_USE_PARELAG MFEM_USE_TRIBOL MFEM_USE_ALGOIM MFEM_USE_ENZYME\
  MFEM_SOURCE_DIR MFEM_INSTALL_DIR MFEM_SHARED_BUILD MFEM_USE_DOUBLE MFEM_USE_SINGLE\
  MFEM_USE_CUDSS MFEM_CUDSS_COMM_LIB MFEM_CUDSS_THREADING_LIB
@@ -412,7 +412,7 @@ MFEM_INSTALL_DIR = $(abspath $(MFEM_PREFIX))
 # If we have 'config' target, export variables used by config/makefile
 ifneq (,$(filter config,$(MAKECMDGOALS)))
    export $(MFEM_DEFINES) MFEM_DEFINES $(MFEM_CONFIG_VARS) MFEM_CONFIG_VARS
-   export VERBOSE HYPRE_OPT PUMI_DIR MUMPS_OPT COMPLEX_MUMPS_OPT GSLIB_OPT CUDSS_OPT
+   export VERBOSE HYPRE_OPT PUMI_DIR MUMPS_OPT GSLIB_OPT CUDSS_OPT
 endif
 
 # If we have 'install' target, export variables used by config/makefile
@@ -742,7 +742,6 @@ status info:
 	$(info MFEM_USE_SUPERLU       = $(MFEM_USE_SUPERLU))
 	$(info MFEM_USE_SUPERLU5      = $(MFEM_USE_SUPERLU5))
 	$(info MFEM_USE_MUMPS         = $(MFEM_USE_MUMPS))
-	$(info MFEM_USE_COMPLEX_MUMPS = $(MFEM_USE_COMPLEX_MUMPS))
 	$(info MFEM_USE_STRUMPACK     = $(MFEM_USE_STRUMPACK))
 	$(info MFEM_USE_CUDSS         = $(MFEM_USE_CUDSS))
 	$(info MFEM_USE_GINKGO        = $(MFEM_USE_GINKGO))

miniapps/common/particles_extras.cpp

@@ -126,7 +126,6 @@ void VisualizeParticles(socketstream &sock, const char* vishost, int visport,
    {
       Vector pcoords;
       pset.Coords().GetValues(i, pcoords);
-      pcoords.HostRead();
       if (dim == 2)
       {
          Add2DPoint(pcoords, particles_mesh, psize);
@@ -140,7 +139,6 @@ void VisualizeParticles(socketstream &sock, const char* vishost, int visport,
 
    FiniteElementSpace fes(&particles_mesh, &l2fec, 1);
    GridFunction gf(&fes);
-   gf.HostWrite();
 
    for (int i = 0; i < pset.GetNParticles(); i++)
    {
@@ -195,7 +193,6 @@ void ParticleTrajectories::AddSegmentStart()
    {
       Vector pcoords;
       pset.Coords().GetValues(i, pcoords);
-      pcoords.HostRead();
       segment_meshes.front().AddVertex(pcoords);
    }
 }
@@ -216,7 +213,6 @@ void ParticleTrajectories::SetSegmentEnd()
       {
          Vector pcoords;
          pset.Coords().GetValues(pidx, pcoords);
-         pcoords.HostRead();
          segment_meshes.front().AddVertex(pcoords);
       }
       else // Otherwise set its end vertex == start vertex

miniapps/electromagnetics/lorentz.cpp

@@ -91,7 +91,6 @@ struct LorentzContext
    int nt = 1000;                  // number of timesteps
    int redist_interval = 5;        // redistribution interval
    int redist_mesh = 0;            // redistribution mesh: 0: E mesh, 1: B mesh
-   std::string device_config = "cpu";
 } ctx;
 
 /// This class implements the Boris algorithm as described in the article
@@ -131,7 +130,7 @@ protected:
 public:
 
    Boris(MPI_Comm comm, GridFunction *E_gf_, GridFunction *B_gf_,
-         int nparticles, Ordering::Type pdata_ordering, bool use_device);
+         int nparticles, Ordering::Type pdata_ordering);
 
    /// Find Particles in mesh corresponding to E and B fields
    void FindParticles();
@@ -140,12 +139,9 @@ public:
    /// right after FindParticles has been called.
    void EvaluateFieldsAtParticles();
 
-   /// Advance particles one time step using Boris algorithm. Host version.
+   /// Advance particles one time step using Boris algorithm
    void Step(real_t &t, real_t &dt);
 
-   /// Advance particles one time step using Boris algorithm. Device version.
-   void StepDevice(real_t &t, real_t &dt);
-
    /// Remove lost particles and return their indices
    Array<int> RemoveLostParticles();
 
@@ -239,8 +235,6 @@ int main(int argc, char *argv[])
    args.AddOption(&vis_interval, "-vf", "--vis-interval",
                   "GLVis visualization update after this many timesteps. "
                   "0 means no visualization.");
-   args.AddOption(&ctx.device_config, "-d", "--device",
-                  "Device configuration definition string.");
 
    args.Parse();
    if (!args.Good())
@@ -257,10 +251,6 @@ int main(int argc, char *argv[])
       args.PrintOptions(cout);
    }
 
-   Device device(ctx.device_config);
-   if (Mpi::Root()) { device.Print(); }
-   bool use_device = (ctx.device_config != "cpu") && Device::IsEnabled();
-
    std::unique_ptr<VisItDataCollection> E_dc, B_dc;
    ParGridFunction *E_gf = nullptr, *B_gf = nullptr;
    Vector bb_xmin, bb_xmax;
@@ -276,7 +266,6 @@ int main(int argc, char *argv[])
          return 1;
       }
       E_gf->ParFESpace()->GetParMesh()->GetBoundingBox(bb_xmin, bb_xmax, 2);
-      E_gf->UseDevice(use_device);
    }
 
    // Read B field if provided
@@ -291,7 +280,6 @@ int main(int argc, char *argv[])
       }
       Vector bb_xmint, bb_xmaxt;
       B_gf->ParFESpace()->GetParMesh()->GetBoundingBox(bb_xmint, bb_xmaxt, 2);
-      B_gf->UseDevice(use_device);
       if (ctx.E.coll_name != "")
       {
          // compute intersection of bounding boxes
@@ -314,14 +302,10 @@ int main(int argc, char *argv[])
    // Initialize particles
    int num_particles = ctx.npt/num_ranks +
                        (rank < (ctx.npt % num_ranks) ? 1 : 0);
-   Boris boris(MPI_COMM_WORLD, E_gf, B_gf, num_particles, ordering_type,
-               use_device);
+   Boris boris(MPI_COMM_WORLD, E_gf, B_gf, num_particles, ordering_type);
    InitializeChargedParticles(boris.GetParticles(), ctx.x_min, ctx.x_max,
                               ctx.p_min, ctx.p_max, ctx.m, ctx.q);
-
-   Array<int> removed_idxs_dummy;
    boris.FindParticles();
-   boris.Redistribute(ctx.redist_mesh, removed_idxs_dummy);
    boris.EvaluateFieldsAtParticles();
 
    real_t t = 0.0;
@@ -345,14 +329,7 @@ int main(int argc, char *argv[])
    for (int step = 1; step <= ctx.nt; step++)
    {
       // Step the Boris algorithm
-      if (use_device)
-      {
-         boris.StepDevice(t, dt);
-      }
-      else
-      {
-         boris.Step(t, dt);
-      }
+      boris.Step(t, dt);
       if (Mpi::Root())
       {
          mfem::out << "Step: " << step << " | Time: " << t << endl;
@@ -420,7 +397,7 @@ void Boris::ParticleStep(Particle &part, real_t &dt)
 }
 
 Boris::Boris(MPI_Comm comm, GridFunction *E_gf_, GridFunction *B_gf_,
-             int nparticles, Ordering::Type pdata_ordering, bool use_device)
+             int nparticles, Ordering::Type pdata_ordering)
    : E_gf(E_gf_),
      B_gf(B_gf_),
      E_finder(comm),
@@ -449,7 +426,6 @@ Boris::Boris(MPI_Comm comm, GridFunction *E_gf_, GridFunction *B_gf_,
    }
 
    int dim = E_mesh ? E_mesh->SpaceDimension() : B_mesh->SpaceDimension();
-   MFEM_VERIFY(dim == 3, "Only 3D meshes are currently supported.");
 
    pxB_.SetSize(dim); pm_.SetSize(dim); pp_.SetSize(dim);
 
@@ -459,8 +435,7 @@ Boris::Boris(MPI_Comm comm, GridFunction *E_gf_, GridFunction *B_gf_,
    Array<int> field_vdims({1, 1, dim, dim, dim});
 
    charged_particles = std::make_unique<ParticleSet>
-                       (comm, nparticles, dim, field_vdims, 0, pdata_ordering,
-                        use_device);
+                       (comm, nparticles, dim, field_vdims, 0, pdata_ordering);
 }
 
 void Boris::FindParticles()
@@ -506,6 +481,7 @@ void Boris::Step(real_t &t, real_t &dt)
 {
    // Interpolate E and B fields onto particles
    EvaluateFieldsAtParticles();
+
    // Individually step each particle. If all ParticleSet fields are ordered
    // byVDIM, we can use GetParticleRef for better performance.
    if (charged_particles->IsParticleRefValid())
@@ -533,112 +509,6 @@ void Boris::Step(real_t &t, real_t &dt)
    t += dt;
 }
 
-void Boris::StepDevice(real_t &t, real_t &dt)
-{
-   // Interpolate E and B fields onto particles
-   EvaluateFieldsAtParticles();
-   const int N = charged_particles->GetNParticles();
-   auto &X = charged_particles->Coords();
-   auto &M = charged_particles->Field(MASS);
-   auto &Q = charged_particles->Field(CHARGE);
-   auto &P = charged_particles->Field(MOM);
-   auto &E = charged_particles->Field(EFIELD);
-   auto &B = charged_particles->Field(BFIELD);
-
-   const int dim = X.GetVDim();
-
-   // Capture orderings for each field to ensure correct access
-   const bool byVDIM_X = (X.GetOrdering() == Ordering::byVDIM);
-   const bool byVDIM_P = (P.GetOrdering() == Ordering::byVDIM);
-   const bool byVDIM_E = (E.GetOrdering() == Ordering::byVDIM);
-   const bool byVDIM_B = (B.GetOrdering() == Ordering::byVDIM);
-
-   auto d_x = X.ReadWrite();
-   auto d_m = M.Read();
-   auto d_q = Q.Read();
-   auto d_p = P.ReadWrite();
-   auto d_e = E.Read();
-   auto d_b = B.Read();
-
-   mfem::forall(N, [=] MFEM_HOST_DEVICE (int i)
-   {
-      const real_t m = d_m[i];
-      const real_t q = d_q[i];
-
-      real_t x[3], p[3], e[3], b[3];
-      // Load data
-      for (int d = 0; d < dim; d++)
-      {
-         x[d] = d_x[byVDIM_X ? i * dim + d : i + d * N];
-         p[d] = d_p[byVDIM_P ? i * dim + d : i + d * N];
-         e[d] = d_e[byVDIM_E ? i * dim + d : i + d * N];
-         b[d] = d_b[byVDIM_B ? i * dim + d : i + d * N];
-      }
-
-      // Boris algorithm implementation
-      real_t pm[3], pxB[3], pp[3];
-
-      // Compute half of the contribution from q E
-      // pm = p + 0.5 * dt * q * e
-      for (int d = 0; d < dim; d++)
-      {
-         pm[d] = p[d] + (0.5 * dt * q) * e[d];
-      }
-
-      // Compute the contribution from q p x B
-      real_t B2 = 0.0;
-      for (int d = 0; d < dim; d++) { B2 += b[d] * b[d]; }
-
-      // ... along pm x B
-      // pxB = pm x b
-      pxB[0] = pm[1] * b[2] - pm[2] * b[1];
-      pxB[1] = pm[2] * b[0] - pm[0] * b[2];
-      pxB[2] = pm[0] * b[1] - pm[1] * b[0];
-
-      // pp = a1 * pxB
-      const real_t a1 = 4.0 * dt * q * m;
-      for (int d = 0; d < dim; d++) { pp[d] = a1 * pxB[d]; }
-
-      // ... along pm
-      // pp += a2 * pm
-      const real_t a2 = 4.0 * m * m - dt * dt * q * q * B2;
-      for (int d = 0; d < dim; d++) { pp[d] += a2 * pm[d]; }
-
-      // ... along B
-      real_t b_dot_pm = 0.0;
-      for (int d = 0; d < dim; d++) { b_dot_pm += b[d] * pm[d]; }
-      const real_t a3 = 2.0 * dt * dt * q * q * b_dot_pm;
-      // pp += a3 * b
-      for (int d = 0; d < dim; d++) { pp[d] += a3 * b[d]; }
-
-      // scale by common denominator
-      const real_t a4 = 4.0 * m * m + dt * dt * q * q * B2;
-      for (int d = 0; d < dim; d++) { pp[d] /= a4; }
-
-      // Update the momentum
-      // p = pp + 0.5 * dt * q * e
-      for (int d = 0; d < dim; d++)
-      {
-         p[d] = pp[d] + (0.5 * dt * q) * e[d];
-      }
-
-      // Update the position
-      // x += (dt / m) * p
-      // Store back to global arrays
-      for (int d = 0; d < dim; d++)
-      {
-         d_p[byVDIM_P ? i * dim + d : i + d * N] = p[d];
-         d_x[byVDIM_X ? i * dim + d : i + d * N] = x[d] + (dt / m) * p[d];
-      }
-   });
-
-   // Find updated particle locations in E and B field meshes
-   FindParticles();
-
-   // Update time
-   t += dt;
-}
-
 Array<int> Boris::RemoveLostParticles()
 {
    Array<int> lost_idxs;
@@ -747,11 +617,6 @@ void InitializeChargedParticles(ParticleSet &charged_particles,
    ParticleVector &M = charged_particles.Field(Boris::MASS);
    ParticleVector &Q = charged_particles.Field(Boris::CHARGE);
 
-   X.HostWrite();
-   P.HostWrite();
-   M.HostWrite();
-   Q.HostWrite();
-
    for (int i = 0; i < charged_particles.GetNParticles(); i++)
    {
       for (int d = 0; d < dim; d++)
@@ -778,9 +643,4 @@ void InitializeChargedParticles(ParticleSet &charged_particles,
       M(i) = m;
       Q(i) = q;
    }
-
-   X.Read();
-   P.Read();
-   M.Read();
-   Q.Read();
 }

miniapps/gslib/findpts.cpp

@@ -49,9 +49,6 @@
 //    findpts -m ../../data/ref-square.mesh -o 2 -mo 1 -random 1 -surf
 //    findpts -m ../../data/ref-cube.mesh -o 2 -mo 1 -random 1 -surf
 //    findpts -m ../../data/square-disc-p2.mesh -o 4 -mo 2 -random 1 -surf
-// Surface meshes + bounding box size increase:
-//    findpts -m ../../data/square-disc-p2.mesh -o 4 -mo 2 -random 1 -surf -sabs 0.1
-//    findpts -m ../../data/tinyzoo-3d.mesh -o 4 -mo 2 -random 1 -surf -sabs 0.1
 
 #include "mfem.hpp"
 #include "../common/mfem-common.hpp"
@@ -112,7 +109,6 @@ int main (int argc, char *argv[])
    int randomization     = 0;
    int npt               = 100;
    bool surface          = false;
-   double surf_aabb_sz_inc = 0.0;
 
    // Parse command-line options.
    OptionsParser args(argc, argv);
@@ -154,9 +150,6 @@ int main (int argc, char *argv[])
    args.AddOption(&surface, "-surf", "--surface", "-no-surf",
                   "--no-surface",
                   "Extract surface mesh from volume mesh.");
-   args.AddOption(&surf_aabb_sz_inc, "-sabs", "--surface-aabb-size-inc",
-                  "Absolute AABB expansion applied to surface-search "
-                  "axis-aligned bounding boxes in FindPointsGSLIB surface meshes.");
 
    args.Parse();
    if (!args.Good())
@@ -391,17 +384,8 @@ int main (int argc, char *argv[])
 
    // Find and Interpolate FE function values on the desired points.
    Vector interp_vals(pts_cnt*vec_dim);
-   FindPointsGSLIB finder;
-   if (surface && surf_aabb_sz_inc > 0.0)
-   {
-      Vector bb_size({surf_aabb_sz_inc});
-      finder.SetupSurfWithAABBExpansion(*mesh, bb_size);
-   }
-   else
-   {
-      finder.Setup(*mesh);
-      // finder.SetDistanceToleranceForPointsFoundOnBoundary(10);
-   }
+   FindPointsGSLIB finder(*mesh);
+   finder.SetDistanceToleranceForPointsFoundOnBoundary(10);
    finder.SetL2AvgType(FindPointsGSLIB::NONE);
    finder.Interpolate(vxyz, field_vals, interp_vals, point_ordering);
    Array<unsigned int> code_out    = finder.GetCode();
@@ -440,7 +424,7 @@ int main (int argc, char *argv[])
         << "Searched points:     "   << pts_cnt
         << "\nFound points:        " << found
         << "\nMax interp error:    " << max_err
-        << "\nMax dist^2 (of found): " << max_dist
+        << "\nMax dist (of found): " << max_dist
         << "\nPoints not found:    " << not_found;
    if (randomization == 1)
    {

miniapps/gslib/pfindpts.cpp

@@ -48,14 +48,11 @@
 // Device runs:
 //    mpirun -np 2 pfindpts -m ../../data/inline-quad.mesh -o 3 -mo 2 -random 1 -d debug
 //    mpirun -np 2 pfindpts -m ../../data/amr-quad.mesh -rs 1 -o 4 -mo 2 -random 1 -npt 100 -d debug
-//    mpirun -np 2 pfindpts -m ../../data/inline-hex.mesh -o 3 -mo 2 -random 1 -d debug -ft 1
+//    mpirun -np 2 pfindpts -m ../../data/inline-hex.mesh -o 3 -mo 2 -random 1 -d debug
 // Surface meshes:
 //    mpirun -np 4 pfindpts -m ../../data/square-disc-p2.mesh -o 4 -mo 2 -vis -random 1 -surf
 //    mpirun -np 4 pfindpts -m ../../data/star-q3.mesh -o 6 -mo 3 -vis -random 1 -surf
 //    mpirun -np 4 pfindpts -m ../../data/fichera-q2.mesh -o 6 -mo 3 -vis -random 1 -surf
-// Surface meshes + bounding box size increase:
-//    mpirun -np 4 pfindpts -m ../../data/square-disc-p2.mesh -o 4 -mo 2 -vis -random 1 -surf -sabs 0.1
-//    mpirun -np 4 pfindpts -m ../../data/tinyzoo-3d.mesh -o 4 -mo 2 -vis -random 1 -surf -sabs 0.1
 
 #include "mfem.hpp"
 #include "../common/mfem-common.hpp"
@@ -105,7 +102,6 @@ int main (int argc, char *argv[])
    int randomization     = 0;
    int npt               = 100; //points per proc
    bool surface          = false;
-   double surf_aabb_sz_inc = 0.0;
 
    // Parse command-line options.
    OptionsParser args(argc, argv);
@@ -149,9 +145,7 @@ int main (int argc, char *argv[])
    args.AddOption(&surface, "-surf", "--surface", "-no-surf",
                   "--no-surface",
                   "Extract surface mesh from volume mesh.");
-   args.AddOption(&surf_aabb_sz_inc, "-sabs", "--surface-aabb-size-inc",
-                  "Absolute AABB expansion applied to surface-search "
-                  "axis-aligned bounding boxes in FindPointsGSLIB surface meshes.");
+
    args.Parse();
    if (!args.Good())
    {
@@ -349,7 +343,7 @@ int main (int argc, char *argv[])
             Geometry::GetRandomPoint(geom, ip);
             if (j < npt_face_per_elem)
             {
-               ip.x = 0.0; // force point to be on a face
+               ip.x = 0.0; // force point to be on the face
                npt_total_face++;
             }
             Vector pos_i(sdim);
@@ -379,17 +373,8 @@ int main (int argc, char *argv[])
 
    // Find and Interpolate FE function values on the desired points.
    Vector interp_vals(pts_cnt*vec_dim);
-   FindPointsGSLIB finder;
-   if (surface && surf_aabb_sz_inc > 0.0)
-   {
-      Vector bb_size({surf_aabb_sz_inc});
-      finder.SetupSurfWithAABBExpansion(pmesh, bb_size);
-   }
-   else
-   {
-      finder.Setup(pmesh);
-   }
-   // finder.SetDistanceToleranceForPointsFoundOnBoundary(1e-10);
+   FindPointsGSLIB finder(pmesh);
+   finder.SetDistanceToleranceForPointsFoundOnBoundary(10);
    // Enable GPU to CPU fallback for GPUData only if you are using an older
    // version of GSLIB.
    // finder.SetGPUtoCPUFallback(true);
@@ -471,11 +456,10 @@ int main (int argc, char *argv[])
            << "\nPoints on faces:      " << face_pts << " out of "
            << npt_total_face
            << "\nMax interp error:     " << max_error
-           << "\nMax dist^2 (of found): " << max_dist
+           << "\nMax dist (of found):  " << max_dist
            << endl;
    }
 
-
    delete fec;
 
    if (randomization != 0)

miniapps/spde/spde_solver.hpp

@@ -83,7 +83,7 @@ real_t IntegrateBC(const ParGridFunction &x, const Array<int> &bdr,
 /// where A is
 /// A = div ( Theta(x) grad + Id ) u(x)
 /// and alpha is given as
-/// alpha = (2 nu + dim) / 4.
+/// alpha = (2 nu + dim) / 2.
 /// Theta (anisotropy tensor) and nu (smoothness) can be specified in the
 /// constructor. Traditionally, the SPDE method requires the specification of
 /// a white noise right hands side. SPDESolver accepts arbitrary right hand

tests/unit/fem/test_gslib.cpp

@@ -12,8 +12,6 @@
 #include "unit_tests.hpp"
 #include "mfem.hpp"
 
-#include <random>
-
 using namespace mfem;
 #ifdef MFEM_USE_GSLIB
 namespace gslib_test
@@ -38,165 +36,6 @@ void F_exact(const Vector &p, Vector &F)
 
 enum class Space { H1, L2 };
 
-enum class SurfaceMeshType { Segment2D, Segment3D, Quad3D, Tri3D };
-
-const char *SurfaceMeshName(const SurfaceMeshType type)
-{
-   switch (type)
-   {
-      case SurfaceMeshType::Segment2D: return "segment-2d";
-      case SurfaceMeshType::Segment3D: return "segment-3d";
-      case SurfaceMeshType::Quad3D:    return "quad-3d";
-      case SurfaceMeshType::Tri3D:     return "tri-3d";
-   }
-   return "unknown";
-}
-
-int SurfaceSpaceDim(const SurfaceMeshType type)
-{
-   switch (type)
-   {
-      case SurfaceMeshType::Segment2D: return 2;
-      case SurfaceMeshType::Segment3D: return 3;
-      case SurfaceMeshType::Quad3D:    return 3;
-      case SurfaceMeshType::Tri3D:     return 3;
-   }
-   return -1;
-}
-
-Mesh MakeSurfaceMesh(const SurfaceMeshType type, const int ne)
-{
-   switch (type)
-   {
-      case SurfaceMeshType::Segment2D:
-         return Mesh::MakeCartesian1D(ne);
-      case SurfaceMeshType::Segment3D:
-         return Mesh::MakeCartesian1D(ne);
-      case SurfaceMeshType::Quad3D:
-         return Mesh::MakeCartesian2D(ne, ne, Element::QUADRILATERAL);
-      case SurfaceMeshType::Tri3D:
-         return Mesh::MakeCartesian2D(ne, ne, Element::TRIANGLE);
-   }
-   MFEM_ABORT("Unknown surface mesh type.");
-   return Mesh();
-}
-
-void GetSurfaceInteriorPoints(Mesh &mesh, const int npt_per_el,
-                              const int ordering, Vector &xyz,
-                              const int p0 = 0)
-{
-   MFEM_VERIFY(mesh.GetNodes() != nullptr, "Mesh nodes are required.");
-
-   const int sdim = mesh.SpaceDimension();
-   const int npt = xyz.Size()/sdim;
-   MFEM_VERIFY((p0 + mesh.GetNE()*npt_per_el)*sdim <= xyz.Size(),
-               "Output vector is too small.");
-   Vector point(sdim);
-   std::mt19937 gen(123);
-   std::uniform_real_distribution<double> uni(0.01, 0.99);
-   int p = p0;
-
-   for (int e = 0; e < mesh.GetNE(); e++)
-   {
-      ElementTransformation *T = mesh.GetElementTransformation(e);
-      const Geometry::Type geom = mesh.GetElementBaseGeometry(e);
-      for (int j = 0; j < npt_per_el; j++)
-      {
-         IntegrationPoint ip;
-         real_t xv = uni(gen);
-         if (geom == Geometry::SEGMENT)
-         {
-            ip.x = xv;
-         }
-         else if (geom == Geometry::SQUARE)
-         {
-            ip.Set2(xv, uni(gen));
-         }
-         else
-         {
-            MFEM_VERIFY(geom == Geometry::TRIANGLE,
-                        "Unsupported surface element geometry.");
-            ip.Set2(xv, uni(gen)*(1.0 - xv));
-         }
-         T->Transform(ip, point);
-         for (int d = 0; d < sdim; d++)
-         {
-            const int idx = (ordering == Ordering::byNODES) ?
-                            d*npt + p :
-                            p*sdim + d;
-            xyz(idx) = point(d);
-         }
-         p++;
-      }
-   }
-}
-
-void GetSurfaceBoundaryPoints(Mesh &mesh, const int npt_per_el,
-                              const int ordering, Vector &xyz,
-                              const int p0 = 0)
-{
-   MFEM_VERIFY(mesh.GetNodes() != nullptr, "Mesh nodes are required.");
-
-   const int sdim = mesh.SpaceDimension();
-   const int npt = xyz.Size()/sdim;
-   MFEM_VERIFY((p0 + mesh.GetNE()*npt_per_el)*sdim <= xyz.Size(),
-               "Output vector is too small.");
-   Vector point(sdim);
-   std::mt19937 gen(246);
-   std::uniform_real_distribution<double> uni(0.01, 0.99);
-   int p = p0;
-
-   for (int e = 0; e < mesh.GetNE(); e++)
-   {
-      ElementTransformation *T = mesh.GetElementTransformation(e);
-      const Geometry::Type geom = mesh.GetElementBaseGeometry(e);
-      for (int j = 0; j < npt_per_el; j++)
-      {
-         IntegrationPoint ip;
-         if (geom == Geometry::SEGMENT)
-         {
-            MFEM_VERIFY(npt_per_el == 2,
-                        "Segment boundary sampling requires npt_per_el = 2.");
-            ip.x = (j == 0) ? 0.0 : 1.0;
-         }
-         else
-         {
-            const double t = uni(gen);
-            if (geom == Geometry::SQUARE)
-            {
-               switch (j % 4)
-               {
-                  case 0: ip.Set2(t, 0.0);     break;
-                  case 1: ip.Set2(1.0, t);     break;
-                  case 2: ip.Set2(t, 1.0);     break;
-                  case 3: ip.Set2(0.0, t);     break;
-               }
-            }
-            else
-            {
-               MFEM_VERIFY(geom == Geometry::TRIANGLE,
-                           "Unsupported surface element geometry.");
-               switch (j % 3)
-               {
-                  case 0: ip.Set2(t, 0.0);     break;
-                  case 1: ip.Set2(t, 1.0 - t); break;
-                  case 2: ip.Set2(0.0, t);     break;
-               }
-            }
-         }
-         T->Transform(ip, point);
-         for (int d = 0; d < sdim; d++)
-         {
-            const int idx = (ordering == Ordering::byNODES) ?
-                            d*npt + p :
-                            p*sdim + d;
-            xyz(idx) = point(d);
-         }
-         p++;
-      }
-   }
-}
-
 TEST_CASE("GSLIBInterpolate", "[GSLIBInterpolate][GSLIB]")
 {
    auto space               = GENERATE(Space::H1, Space::L2);
@@ -351,92 +190,6 @@ TEST_CASE("GSLIBInterpolate", "[GSLIBInterpolate][GSLIB]")
    delete c_fec;
 }
 
-TEST_CASE("GSLIBSurfInterpolate", "[GSLIBSurfInterpolate][GSLIB]")
-{
-   auto surface_mesh_type   = GENERATE(SurfaceMeshType::Segment2D,
-                                       SurfaceMeshType::Segment3D,
-                                       SurfaceMeshType::Quad3D,
-                                       SurfaceMeshType::Tri3D);
-   func_order               = GENERATE(1, 2);
-   int mesh_order           = GENERATE(1, 2);
-   int mesh_node_ordering   = GENERATE(0, 1);
-   int point_ordering       = GENERATE(0, 1);
-   int ncomp                = GENERATE(1, 2);
-   int gf_ordering          = GENERATE(0, 1);
-   int func_out_ordering    = GENERATE(0, 1);
-
-   const char *mesh_name = SurfaceMeshName(surface_mesh_type);
-   CAPTURE(mesh_name, func_order, mesh_order, mesh_node_ordering,
-           point_ordering, ncomp, gf_ordering, func_out_ordering);
-
-   if (ncomp == 1 && gf_ordering == 1)
-   {
-      return;
-   }
-
-   Mesh mesh = MakeSurfaceMesh(surface_mesh_type, 4);
-   const int sdim = SurfaceSpaceDim(surface_mesh_type);
-   mesh.SetCurvature(mesh_order, false, sdim, mesh_node_ordering);
-
-   H1_FECollection c_fec(func_order, mesh.Dimension());
-   FiniteElementSpace c_fespace(&mesh, &c_fec, ncomp, gf_ordering);
-   GridFunction field_vals(&c_fespace);
-
-   VectorFunctionCoefficient F(ncomp, F_exact);
-   field_vals.ProjectCoefficient(F);
-
-   const int npt_per_el = 8;
-   const int pts_cnt = mesh.GetNE()*npt_per_el;
-   Vector vxyz(pts_cnt*sdim);
-   GetSurfaceInteriorPoints(mesh, npt_per_el, point_ordering, vxyz);
-
-   Vector interp_vals(pts_cnt*ncomp);
-   FindPointsGSLIB finder;
-   finder.SetupSurf(mesh);
-   finder.SetL2AvgType(FindPointsGSLIB::NONE);
-   finder.Interpolate(vxyz, field_vals, interp_vals, point_ordering,
-                      func_out_ordering);
-
-   Array<unsigned int> code_out = finder.GetCode();
-   Vector dist_p_out = finder.GetDist();
-
-   int not_found = 0;
-   double err = 0.0, max_err = 0.0, max_dist = 0.0;
-   Vector pos(sdim);
-   Vector exact_val(ncomp);
-
-   for (int i = 0; i < pts_cnt; i++)
-   {
-      max_dist = std::max(max_dist, dist_p_out(i));
-      for (int d = 0; d < sdim; d++)
-      {
-         const int idx = (point_ordering == Ordering::byNODES) ?
-                         d*pts_cnt + i :
-                         i*sdim + d;
-         pos(d) = vxyz(idx);
-      }
-      F_exact(pos, exact_val);
-      for (int j = 0; j < ncomp; j++)
-      {
-         if (code_out[i] < 2)
-         {
-            err = func_out_ordering == Ordering::byNODES ?
-                  fabs(exact_val(j) - interp_vals[i + j*pts_cnt]) :
-                  fabs(exact_val(j) - interp_vals[i*ncomp + j]);
-            max_err = std::max(max_err, err);
-         }
-         else if (j == 0)
-         {
-            not_found++;
-         }
-      }
-   }
-
-   REQUIRE(max_err < 1e-12);
-   REQUIRE(max_dist < 1e-10);
-   REQUIRE(not_found == 0);
-}
-
 // Generates meshes with different element types, followed by points at
 // element faces and interior, and finally checks to see if these points are
 // correctly detected at element boundary or not.
@@ -504,8 +257,9 @@ TEST_CASE("GSLIBFindAtElementBoundary",
       int nptface = xyz.Size()/dim;
 
       // Generate points inside each element
-      L2_FECollection l2_fec(l2_order, dim);
-      FiniteElementSpace l2_fespace(&mesh, &l2_fec, 1);
+      FiniteElementCollection *l2_fec = new L2_FECollection(l2_order, dim);
+      FiniteElementSpace l2_fespace =
+         FiniteElementSpace(&mesh, l2_fec, 1);
       DenseMatrix vals;
       DenseMatrix tr;
       for (int e = 0; e < mesh.GetNE(); e++)
@@ -541,92 +295,7 @@ TEST_CASE("GSLIBFindAtElementBoundary",
          cmax = std::max(code_out[i], cmax);
       }
       REQUIRE((cmin == 0 && cmax == 0)); // should be found inside element
-   }
-}
-
-TEST_CASE("GSLIBSurfFindAtElementBoundary",
-          "[GSLIBSurfFindAtElementBoundary][GSLIB]")
-{
-   auto surface_mesh_type = GENERATE(SurfaceMeshType::Segment2D,
-                                     SurfaceMeshType::Segment3D,
-                                     SurfaceMeshType::Quad3D,
-                                     SurfaceMeshType::Tri3D);
-   const char *mesh_name = SurfaceMeshName(surface_mesh_type);
-   CAPTURE(mesh_name);
-
-   Mesh mesh = MakeSurfaceMesh(surface_mesh_type, 4);
-   const int sdim = SurfaceSpaceDim(surface_mesh_type);
-   mesh.SetCurvature(2, false, sdim);
-
-   const int nptface_per_el = (mesh.Dimension() == 1) ? 2 : 8;
-   const int nptint_per_el = 8;
-   const int nptface = mesh.GetNE()*nptface_per_el;
-   const int nptint = mesh.GetNE()*nptint_per_el;
-   Vector xyz((nptface + nptint)*sdim);
-   GetSurfaceBoundaryPoints(mesh, nptface_per_el, Ordering::byVDIM, xyz, 0);
-   GetSurfaceInteriorPoints(mesh, nptint_per_el, Ordering::byVDIM, xyz,
-                            nptface);
-
-   FindPointsGSLIB finder;
-   finder.SetupSurf(mesh);
-   finder.FindPoints(xyz, Ordering::byVDIM);
-   Array<unsigned int> code_out = finder.GetCode();
-
-   for (int i = 0; i < nptface; i++)
-   {
-      REQUIRE(code_out[i] == 1);
-   }
-   for (int i = nptface; i < nptface + nptint; i++)
-   {
-      REQUIRE(code_out[i] == 0);
-   }
-}
-
-TEST_CASE("GSLIBSurfAABBExpansion", "[GSLIBSurfAABBExpansion][GSLIB]")
-{
-   auto surface_mesh_type = GENERATE(SurfaceMeshType::Segment2D,
-                                     SurfaceMeshType::Segment3D,
-                                     SurfaceMeshType::Quad3D,
-                                     SurfaceMeshType::Tri3D);
-   const char *mesh_name = SurfaceMeshName(surface_mesh_type);
-   CAPTURE(mesh_name);
-
-   constexpr double offset = 1.0e-3;
-   const int npt_per_el = 8;
-
-   Mesh mesh = MakeSurfaceMesh(surface_mesh_type, 4);
-   const int sdim = SurfaceSpaceDim(surface_mesh_type);
-   mesh.SetCurvature(2, false, sdim);
-
-   const int npt = mesh.GetNE()*npt_per_el;
-   Vector xyz(npt*sdim);
-   GetSurfaceInteriorPoints(mesh, npt_per_el, Ordering::byVDIM, xyz);
-   // offset them to move away from the surface
-   const int off_d = (surface_mesh_type == SurfaceMeshType::Segment2D) ? 1 : 2;
-   for (int i = 0; i < npt; i++)
-   {
-      xyz(i*sdim + off_d) += offset;
-   }
-
-   FindPointsGSLIB finder;
-   finder.SetupSurf(mesh, 0.0);
-   finder.FindPoints(xyz, Ordering::byVDIM);
-   Array<unsigned int> code_no_pad = finder.GetCode();
-
-   for (int i = 0; i < code_no_pad.Size(); i++)
-   {
-      REQUIRE(code_no_pad[i] == 2);
-   }
-
-   // make aabb at least big enough to include the offset points
-   Vector aabb_sz_inc({2.1*offset});
-   finder.SetupSurfWithAABBExpansion(mesh, aabb_sz_inc);
-   finder.FindPoints(xyz, Ordering::byVDIM);
-   Array<unsigned int> code_with_pad = finder.GetCode();
-
-   for (int i = 0; i < npt; i++)
-   {
-      REQUIRE(code_with_pad[i] == 1);
+      delete l2_fec;
    }
 }
 
@@ -653,8 +322,9 @@ TEST_CASE("GSLIBInterpolateL2ElementBoundary",
    mesh.SetCurvature(mesh_order);
 
    // Set GridFunction to be interpolated
-   L2_FECollection c_fec(3, dim);
-   FiniteElementSpace c_fespace(&mesh, &c_fec, 1);
+   FiniteElementCollection *c_fec = new L2_FECollection(3, dim);
+   FiniteElementSpace c_fespace =
+      FiniteElementSpace(&mesh, c_fec, 1);
    GridFunction field_vals(&c_fespace);
    Array<int> dofs;
    double leftval = 1.0;
@@ -696,6 +366,7 @@ TEST_CASE("GSLIBInterpolateL2ElementBoundary",
    REQUIRE(interp_vals(0) == MFEM_Approx(0.5*(leftval+rightval)));
 
    finder.FreeData();
+   delete c_fec;
 }
 
 #ifdef MFEM_USE_MPI

tests/unit/fem/test_linearform_ext.cpp

@@ -328,7 +328,7 @@ TEST_CASE("Linear Form Extension", "[LinearFormExtension], [GPU]")
    }
 }
 
-TEST_CASE("Vector FE Linear Form Extension", "[LinearFormExtension], [GPU]")
+TEST_CASE("H(div) Linear Form Extension", "[LinearFormExtension], [GPU]")
 {
    const bool all = launch_all_non_regression_tests;
 
@@ -341,44 +341,26 @@ TEST_CASE("Vector FE Linear Form Extension", "[LinearFormExtension], [GPU]")
    Mesh mesh(mesh_file);
    const int dim = mesh.Dimension();
 
-   {
-      const auto space_type =
-         dim == 3 ? GENERATE(FiniteElement::DIV, FiniteElement::CURL)
-         : FiniteElement::DIV;
+   CAPTURE(mesh_file, dim, p);
 
-      CAPTURE(mesh_file, dim, p, space_type);
+   RT_FECollection fec(p, dim);
+   FiniteElementSpace fes(&mesh, &fec);
 
-      std::unique_ptr<FiniteElementCollection> fec;
+   VectorFunctionCoefficient coeff(dim, fvec_dim);
 
-      switch (space_type)
-      {
-         case FiniteElement::DIV:
-            fec.reset(new RT_FECollection(p, dim));
-            break;
-         case FiniteElement::CURL:
-            fec.reset(new ND_FECollection(p, dim));
-            break;
-         default:
-            MFEM_ABORT("unsupported space type");
-      }
-      FiniteElementSpace fes(&mesh, fec.get());
+   LinearForm d1(&fes);
+   d1.AddDomainIntegrator(new VectorFEDomainLFIntegrator(coeff));
+   d1.UseFastAssembly(true);
+   d1.Assemble();
 
-      VectorFunctionCoefficient coeff(dim, fvec_dim);
+   LinearForm d2(&fes);
+   d2.AddDomainIntegrator(new VectorFEDomainLFIntegrator(coeff));
+   d2.UseFastAssembly(false);
+   d2.Assemble();
 
-      LinearForm d1(&fes);
-      d1.AddDomainIntegrator(new VectorFEDomainLFIntegrator(coeff));
-      d1.UseFastAssembly(true);
-      d1.Assemble();
-
-      LinearForm d2(&fes);
-      d2.AddDomainIntegrator(new VectorFEDomainLFIntegrator(coeff));
-      d2.UseFastAssembly(false);
-      d2.Assemble();
-
-      CAPTURE(d1.Norml2(), d2.Norml2());
-      d1 -= d2;
-      REQUIRE(d1.Norml2() == MFEM_Approx(0.0));
-   }
+   CAPTURE(d1.Norml2(), d2.Norml2());
+   d1 -= d2;
+   REQUIRE(d1.Norml2() == MFEM_Approx(0.0));
 }
 
 #ifdef MFEM_USE_MPI

tests/unit/fem/test_particleset.cpp

@@ -200,71 +200,10 @@ int CheckArrayEquality(const Array<T> &arr1, const Array<T> &arr2)
    return wrong_ct;
 }
 
-// Apply a deterministic perturbation to particle data on host.
-void PerturbParticleDataOnHost(std::vector<Particle> &particles)
-{
-   for (auto &p : particles)
-   {
-      for (int f = -1; f < p.GetNFields(); f++)
-      {
-         Vector &field = f == -1 ? p.Coords() : p.Field(f);
-         field.HostReadWrite();
-         const real_t scale = (f == -1) ? 0.001 : 1.0;
-         for (int c = 0; c < field.Size(); c++)
-         {
-            field(c) += scale * (f + c + 2);
-         }
-      }
-
-      for (int t = 0; t < p.GetNTags(); t++)
-      {
-         p.Tag(t) += t + 1;
-      }
-   }
-}
-
-// Apply a deterministic perturbation to particle data on device.
-void PerturbParticleDataOnDevice(ParticleSet &pset)
-{
-   const int np = pset.GetNParticles();
-
-   // Shift coordinates and fields using the same per-component formula while
-   // honoring the ParticleVector ordering selected by the test.
-   for (int f = -1; f < pset.GetNFields(); f++)
-   {
-      ParticleVector &field = f == -1 ? pset.Coords() : pset.Field(f);
-      const int vdim = field.GetVDim();
-      const bool by_vdim = (field.GetOrdering() == Ordering::byVDIM);
-      const real_t scale = (f == -1) ? 0.001 : 1.0;
-      auto d_field = field.ReadWrite();
-
-      mfem::forall(np, [=] MFEM_HOST_DEVICE (int i)
-      {
-         for (int c = 0; c < vdim; c++)
-         {
-            const int idx = by_vdim ? i * vdim + c : i + c * np;
-            d_field[idx] += scale * (f + c + 2);
-         }
-      });
-   }
-
-   for (int t = 0; t < pset.GetNTags(); t++)
-   {
-      Array<int> &tag = pset.Tag(t);
-      auto d_tag = tag.ReadWrite();
-
-      mfem::forall(np, [=] MFEM_HOST_DEVICE (int i)
-      {
-         d_tag[i] += t + 1;
-      });
-   }
-}
-
 void TestRedistribute(Ordering::Type ordering)
 {
    int size = Mpi::WorldSize();
    int rank = Mpi::WorldRank();
-   const bool use_device = Device::IsEnabled();
 
    // Create a 3D hex mesh
    Mesh m = Mesh::MakeCartesian3D(N_e, N_e, N_e, Element::Type::HEXAHEDRON);
@@ -313,22 +252,15 @@ void TestRedistribute(Ordering::Type ordering)
    SECTION(std::string("Ordering: ") +
            (ordering == Ordering::byNODES ? "byNODES" : "byVDIM"))
    {
+      // Add the particles uniquely to each rank particleset
       ParticleSet pset(MPI_COMM_WORLD, 0, SpaceDim, FieldVDims,
-                       NumTags, ordering, use_device);
-      CHECK(pset.IsParticleRefValid() ==
-            (!use_device && ordering == Ordering::byVDIM));
+                       NumTags, ordering);
 
       for (int i = 0; i < N_rank; i++)
       {
          pset.AddParticle(all_particles[i*size+rank]);
       }
 
-      if (use_device)
-      {
-         PerturbParticleDataOnDevice(pset);
-         PerturbParticleDataOnHost(all_particles);
-      }
-
       // Find points
       FindPointsGSLIB finder(MPI_COMM_WORLD);
       finder.Setup(pmesh);
@@ -338,7 +270,6 @@ void TestRedistribute(Ordering::Type ordering)
       int code_1_count = 0;
       int code_2_count = 0;
       const Array<unsigned int> &code = finder.GetCode();
-      code.HostRead();
       for (int i = 0; i < code.Size(); i++)
       {
          if (code[i] == 1)
@@ -361,7 +292,6 @@ void TestRedistribute(Ordering::Type ordering)
       finder.FindPoints(pset.Coords(), ordering);
 
       const Array<unsigned int> &procs = finder.GetProc();
-      procs.HostRead();
 
       int wrong_proc_count = 0;
       for (int i = 0; i < procs.Size(); i++)
@@ -377,11 +307,6 @@ void TestRedistribute(Ordering::Type ordering)
 
       // Check that coordinates + fields + tags are all still correct
       int wrong_particle_count = 0;
-      pset.GetIDs().HostRead();
-      for (int t = 0; t < pset.GetNTags(); t++)
-      {
-         pset.Tag(t).HostRead();
-      }
       for (int i = 0; i < pset.GetNParticles(); i++)
       {
          Particle &actual_p = all_particles[pset.GetIDs()[i]];
@@ -392,13 +317,13 @@ void TestRedistribute(Ordering::Type ordering)
             wrong_particle_count++;
          }
       }
-      MPI_Allreduce(MPI_IN_PLACE, &wrong_particle_count, 1, MPI_INT, MPI_SUM,
+      MPI_Allreduce(MPI_IN_PLACE, &wrong_proc_count, 1, MPI_INT, MPI_SUM,
                     MPI_COMM_WORLD);
       CHECK(wrong_particle_count == 0);
    }
 }
 
-TEST_CASE("Particle Redistribution", "[ParticleSet][Parallel][GPU]")
+TEST_CASE("Particle Redistribution", "[ParticleSet][Parallel]")
 {
    TestRedistribute(Ordering::byNODES);
    TestRedistribute(Ordering::byVDIM);

tests/unit/fem/test_project_bdr.cpp

@@ -124,8 +124,8 @@ TEST_CASE("3D ProjectBdrCoefficientNormal Scalar",
 
    const double tol = 1e-6;
 
-   const int bdrs_axis[] = {2, 1, 0, 1, 0, 2};
-   const int bdrs_sign[] = {-1, -1, +1, +1, -1, +1};
+   const char bdrs_axis[] = {2, 1, 0, 1, 0, 2};
+   const char bdrs_sign[] = {-1, -1, +1, +1, -1, +1};
 
    for (int type = (int)Element::TETRAHEDRON;
         type <= (int)Element::HEXAHEDRON; type++)

tests/unit/fem/test_transfer.cpp

@@ -440,6 +440,99 @@ TEST_CASE("Variable Order True Transfer", "[Transfer][VariableOrder]")
    delete c_fec;
 }
 
+TEST_CASE("H1 L2 transfer with consistent mass", "[Transfer]")
+{
+   auto vectorspace = GENERATE(VecSpace::H1, VecSpace::VectorH1nodes,
+                               VecSpace::VectorH1vdim);
+   dimension = GENERATE(2, 3);
+
+   const int order = 2;
+   const int ne = 2;
+   const int vdim = (vectorspace == VecSpace::VectorH1nodes
+                     || vectorspace == VecSpace::VectorH1vdim) ? dimension : 1;
+   Ordering::Type ordering = (vectorspace == VecSpace::VectorH1vdim)
+                             ? Ordering::byVDIM : Ordering::byNODES;
+
+   CAPTURE(VecSpaceName(vectorspace), dimension, order);
+
+   Mesh mesh;
+   if (dimension == 2)
+   {
+      mesh = Mesh::MakeCartesian2D(ne, ne, Element::QUADRILATERAL,
+                                   1, 1.0, 1.0);
+   }
+   else
+   {
+      mesh = Mesh::MakeCartesian3D(ne, ne, ne, Element::HEXAHEDRON,
+                                   1.0, 1.0, 1.0);
+   }
+
+   Mesh fineMesh(mesh);
+   fineMesh.UniformRefinement();
+
+   H1_FECollection fec(order, dimension);
+   FiniteElementSpace c_fespace(&mesh, &fec, vdim, ordering);
+   FiniteElementSpace f_fespace(&fineMesh, &fec, vdim, ordering);
+
+   L2ProjectionGridTransfer transfer(c_fespace, f_fespace);
+   transfer.UseConsistentMass();
+   const Operator &R = transfer.ForwardOperator();
+
+   GridFunction X(&c_fespace);
+   GridFunction Y(&f_fespace);
+   GridFunction Y_ref(&f_fespace);
+   coeff_order = 1;
+
+   LinearForm rhs(&f_fespace);
+   BilinearForm mass(&f_fespace);
+   FunctionCoefficient funcCoeff(&coeff);
+   VectorFunctionCoefficient vecCoeff(dimension, &vectorcoeff);
+   if (vectorspace == VecSpace::H1)
+   {
+      X.ProjectCoefficient(funcCoeff);
+      rhs.AddDomainIntegrator(new DomainLFIntegrator(funcCoeff));
+      mass.AddDomainIntegrator(new MassIntegrator);
+   }
+   else
+   {
+      X.ProjectCoefficient(vecCoeff);
+      rhs.AddDomainIntegrator(new VectorDomainLFIntegrator(vecCoeff));
+      mass.AddDomainIntegrator(new VectorMassIntegrator);
+   }
+
+   rhs.Assemble();
+   mass.Assemble();
+   SparseMatrix M;
+   Array<int> empty;
+   mass.FormSystemMatrix(empty, M);
+
+   GSSmoother M_prec(M);
+   Y_ref = 0.0;
+   PCG(M, M_prec, rhs, Y_ref, 0, 500, 1e-24, 0.0);
+
+   Y = 0.0;
+   R.Mult(X, Y);
+   Y -= Y_ref;
+   REQUIRE(Y.Norml2() < 1e-11 * Y_ref.Norml2());
+
+   Vector x(c_fespace.GetVSize());
+   Vector y(f_fespace.GetVSize());
+   Vector Ry(f_fespace.GetVSize());
+   Vector Rtx(c_fespace.GetVSize());
+   x.Randomize(1);
+   y.Randomize(2);
+
+   R.Mult(x, Ry);
+   R.MultTranspose(y, Rtx);
+
+   const real_t ip1 = InnerProduct(Ry, y);
+   const real_t ip2 = InnerProduct(x, Rtx);
+   REQUIRE(std::abs(ip1 - ip2) <
+           1e-10 * std::max(std::abs(ip1), std::abs(ip2)));
+
+   REQUIRE_FALSE(transfer.SupportsBackwardsOperator());
+}
+
 TEST_CASE("Restriction Transpose Operator")
 {
    int order = GENERATE(1, 2);
@@ -797,6 +890,59 @@ TEST_CASE("Parallel Transfer", "[Transfer][Parallel]")
    delete pmesh;
 }
 
+TEST_CASE("Parallel H1 L2 transfer with consistent mass",
+          "[Transfer][Parallel]")
+{
+   dimension = GENERATE(2, 3);
+
+   const int order = 2;
+   const int ne = 2;
+   const int vdim = 1;
+
+   CAPTURE(dimension, order);
+
+   Mesh mesh;
+   if (dimension == 2)
+   {
+      mesh = Mesh::MakeCartesian2D(ne, ne, Element::QUADRILATERAL,
+                                   1, 1.0, 1.0);
+   }
+   else
+   {
+      mesh = Mesh::MakeCartesian3D(ne, ne, ne, Element::HEXAHEDRON,
+                                   1.0, 1.0, 1.0);
+   }
+
+   ParMesh pmesh(MPI_COMM_WORLD, mesh);
+   ParMesh pfineMesh(MPI_COMM_WORLD, mesh);
+   pfineMesh.UniformRefinement();
+
+   H1_FECollection fec(order, dimension);
+   ParFiniteElementSpace c_fespace(&pmesh, &fec, vdim);
+   ParFiniteElementSpace f_fespace(&pfineMesh, &fec, vdim);
+
+   L2ProjectionGridTransfer transfer(c_fespace, f_fespace);
+   transfer.UseConsistentMass();
+   const Operator &R = transfer.TrueForwardOperator();
+
+   Vector x(c_fespace.GetTrueVSize());
+   Vector y(f_fespace.GetTrueVSize());
+   Vector Rx(f_fespace.GetTrueVSize());
+   Vector Rty(c_fespace.GetTrueVSize());
+   x.Randomize(1);
+   y.Randomize(2);
+
+   R.Mult(x, Rx);
+   R.MultTranspose(y, Rty);
+
+   const real_t ip1 = InnerProduct(MPI_COMM_WORLD, Rx, y);
+   const real_t ip2 = InnerProduct(MPI_COMM_WORLD, x, Rty);
+   REQUIRE(std::abs(ip1 - ip2) <
+           1e-10 * std::max(std::abs(ip1), std::abs(ip2)));
+
+   REQUIRE_FALSE(transfer.SupportsBackwardsOperator());
+}
+
 TEST_CASE("Trace PRefinement Parallel TrueTransfer", "[Transfer][Parallel]")
 {
    auto simplex = GENERATE(true, false);

tests/unit/linalg/test_complex_operator.cpp

@@ -113,65 +113,3 @@ TEST_CASE("ComplexOperator Quaternion Tests", "[ComplexOperator]")
       REQUIRE(qikx.Normlinf() < tol);
    }
 }
-
-#ifdef MFEM_USE_MPI
-
-TEST_CASE("ComplexHypreParMatrix GetSystemMatrix",
-          "[ComplexOperator][Parallel][GPU]")
-{
-   // This test reproduces the issue described in PR #5200 on GitHub. See also
-   // the follow up PR #5346.
-
-   // 1. Construct ComplexHypreParMatrix similar to ex25p.
-   const char mesh_file[] = "../../data/inline-quad.mesh";
-   Mesh *mesh = new Mesh(mesh_file, 1, 1);
-   int dim = mesh->Dimension();
-   int ref_levels = 1;
-   for (int l = 0; l < ref_levels; l++)
-   {
-      mesh->UniformRefinement();
-   }
-   ParMesh pmesh(MPI_COMM_WORLD, *mesh);
-   delete mesh;
-   int par_ref_levels = 1;
-   for (int l = 0; l < par_ref_levels; l++)
-   {
-      pmesh.UniformRefinement();
-   }
-   int order = 1;
-   ND_FECollection fec(order, dim);
-   ParFiniteElementSpace fespace(&pmesh, &fec);
-   Array<int> ess_tdof_list;
-   Array<int> ess_bdr;
-   if (pmesh.bdr_attributes.Size())
-   {
-      ess_bdr.SetSize(pmesh.bdr_attributes.Max());
-      ess_bdr = 1;
-   }
-   fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
-   ComplexOperator::Convention conv = ComplexOperator::HERMITIAN;
-   VectorConstantCoefficient f(Vector{1_r, 2_r});
-   ParComplexLinearForm b(&fespace, conv);
-   b.AddDomainIntegrator(NULL, new VectorFEDomainLFIntegrator(f));
-   b = 0.0;
-   b.Assemble();
-   ParComplexGridFunction x(&fespace);
-   x = 0.0;
-   ConstantCoefficient one(1_r);
-   ParSesquilinearForm a(&fespace, conv);
-   a.AddDomainIntegrator(new CurlCurlIntegrator(one),
-                         new CurlCurlIntegrator(one));
-   a.AddDomainIntegrator(new VectorFEMassIntegrator(one),
-                         new VectorFEMassIntegrator(one));
-   a.Assemble();
-   OperatorPtr Ah;
-   Vector B, X;
-   a.FormLinearSystem(ess_tdof_list, x, b, Ah, X, B);
-
-   // 2. Test the call to ComplexHypreParMatrix::GetSystemMatrix and destroying
-   //    the returned matrix.
-   HypreParMatrix *A = Ah.As<ComplexHypreParMatrix>()->GetSystemMatrix();
-   delete A;
-}
-
-#endif // MFEM_USE_MPI

tests/unit/linalg/test_direct_solvers.cpp

@@ -188,6 +188,8 @@ TEST_CASE("Serial Direct Solvers", "[GPU]")
 
 TEST_CASE("Parallel Direct Solvers", "[Parallel], [GPU]")
 {
+   int rank;
+   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    const int ne = 4;
    for (int dim = 1; dim < 4; ++dim)
    {
@@ -355,113 +357,3 @@ TEST_CASE("Parallel Direct Solvers", "[Parallel], [GPU]")
 }
 
 #endif
-
-
-#ifdef MFEM_USE_COMPLEX_MUMPS
-
-TEST_CASE("ComplexMUMPS Solver", "[Parallel], [GPU]")
-{
-   const int ne = 4;
-   const int order = 3;
-   auto dim = GENERATE(1, 2, 3);
-   auto conv = GENERATE(ComplexOperator::HERMITIAN,
-                        ComplexOperator::BLOCK_SYMMETRIC);
-   CAPTURE(dim, conv);
-
-   Mesh mesh;
-   if (dim == 1)
-   {
-      mesh = Mesh::MakeCartesian1D(ne, 1.0);
-   }
-   else if (dim == 2)
-   {
-      mesh = Mesh::MakeCartesian2D(
-                ne, ne, Element::QUADRILATERAL, 1, 1.0, 1.0);
-   }
-   else
-   {
-      mesh = Mesh::MakeCartesian3D(
-                ne, ne, ne, Element::HEXAHEDRON, 1.0, 1.0, 1.0);
-   }
-
-   ParMesh pmesh(MPI_COMM_WORLD, mesh);
-   mesh.Clear();
-   H1_FECollection fec(order, dim);
-   ParFiniteElementSpace fespace(&pmesh, &fec);
-   Array<int> ess_tdof_list, ess_bdr;
-   if (pmesh.bdr_attributes.Size())
-   {
-      ess_bdr.SetSize(pmesh.bdr_attributes.Max());
-      ess_bdr = 1;
-      fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
-   }
-
-   ConstantCoefficient one(1.0);
-   ConstantCoefficient negone(-1.0);
-   ConstantCoefficient two(2.0);
-
-   ComplexLinearForm b(&fespace, conv);
-   b.AddDomainIntegrator(new DomainLFIntegrator(one), new DomainLFIntegrator(two));
-   b.Assemble();
-
-   ParSesquilinearForm a_r(&fespace, conv);
-   a_r.AddDomainIntegrator(new DiffusionIntegrator(one), nullptr);
-   a_r.AddDomainIntegrator(new MassIntegrator(one), nullptr);
-   a_r.Assemble();
-
-   ParSesquilinearForm a_i(&fespace, conv);
-   a_i.AddDomainIntegrator(nullptr, new DiffusionIntegrator(one));
-   a_i.AddDomainIntegrator(nullptr, new MassIntegrator(one));
-   a_i.Assemble();
-
-   ParSesquilinearForm a_c(&fespace, conv);
-   a_c.AddDomainIntegrator(new DiffusionIntegrator(one), new MassIntegrator(two));
-   a_c.AddDomainIntegrator(new MassIntegrator(negone),nullptr);
-   a_c.Assemble();
-
-   ParComplexGridFunction x_c(&fespace);
-   ParComplexGridFunction x_r(&fespace);
-   ParComplexGridFunction x_i(&fespace);
-   x_c = 0.0; x_r = 0.0; x_i = 0.0;
-
-   OperatorPtr Ac, Ar, Ai;
-   Vector Bc, Br, Bi, Xr, Xc, Xi;
-   a_c.FormLinearSystem(ess_tdof_list, x_c, b, Ac, Xc, Bc);
-   a_r.FormLinearSystem(ess_tdof_list, x_r, b, Ar, Xr, Br);
-   a_i.FormLinearSystem(ess_tdof_list, x_i, b, Ai, Xi, Bi);
-
-   ComplexHypreParMatrix *Ahc = Ac.As<ComplexHypreParMatrix>();
-   ComplexHypreParMatrix *Ahr = Ar.As<ComplexHypreParMatrix>();
-   ComplexHypreParMatrix *Ahi = Ai.As<ComplexHypreParMatrix>();
-
-   ComplexMUMPSSolver cmumps(MPI_COMM_WORLD);
-   cmumps.SetPrintLevel(0);
-
-   cmumps.SetOperator(*Ahc);
-   cmumps.Mult(Bc, Xc);
-
-   cmumps.SetOperator(*Ahr);
-   cmumps.Mult(Br, Xr);
-
-   cmumps.SetOperator(*Ahi);
-   cmumps.Mult(Bi, Xi);
-
-   Vector Yc(Xc.Size()), Yr(Xr.Size()), Yi(Xi.Size());
-   Ahc->Mult(Xc, Yc); Ahr->Mult(Xr, Yr); Ahi->Mult(Xi, Yi);
-
-   if (conv == ComplexOperator::BLOCK_SYMMETRIC)
-   {
-      int n = Bc.Size()/2;
-      real_t * dataBc = Bc.GetData(); Vector Bcimag(&dataBc[n],n);
-      real_t * dataBr = Br.GetData(); Vector Brimag(&dataBr[n],n);
-      real_t * dataBi = Bi.GetData(); Vector Biimag(&dataBi[n],n);
-      Bcimag *= -1; Brimag *= -1; Biimag *= -1;
-   }
-
-   Yc -= Bc; REQUIRE(Yc.Norml2() < 1.e-12);
-   Yr -= Br; REQUIRE(Yr.Norml2() < 1.e-12);
-   Yi -= Bi; REQUIRE(Yi.Norml2() < 1.e-12);
-
-} // Test case "ComplexMUMPS Solver"
-
-#endif // MFEM_USE_COMPLEX_MUMPS