empty part fix

style
minor edits
2024-05-28 14:36:24 -07:00 · 2024-05-27 20:16:17 -07:00 · 2024-05-27 20:08:07 -07:00 · 2024-05-20 17:41:27 -07:00 · 2024-05-20 14:06:16 -07:00 · 2024-05-20 12:56:04 -07:00
111 changed files with 1306 additions and 17507 deletions
@@ -57,8 +57,6 @@ examples/ex2[0-9]
 examples/ex2[0-9]p
 examples/ex3[0-9]
 examples/ex3[0-9]p
-examples/ex4[0-9]
-examples/ex4[0-9]p

 examples/refined.mesh
 examples/displaced.mesh
@@ -13,9 +13,6 @@
 # at Lawrence Livermore National Laboratory (LLNL). This entire pipeline is
 # LLNL-specific!

-include:
-  - project: 'lc-templates/id_tokens'
-    file: 'id_tokens.yml'

 # The pipeline is divided into stages. Usually, jobs in a given stage wait for
 # the preceding stages to complete before to start. However, we sometimes use
@@ -9,10 +9,6 @@
 # terms of the BSD-3 license. We welcome feedback and contributions, see file
 # CONTRIBUTING.md for details.

-include:
-  - project: 'lc-templates/id_tokens'
-    file: 'id_tokens.yml'
-
 # We define the following GitLab pipeline variables:
 variables:

@@ -35,8 +35,9 @@ variables:
    - when: on_success

 # Lassen uses a different job scheduler (spectrum lsf) that does not allow
-# pre-allocation the same way slurm does.  We use the pci queue on lassen
-# to speed-up the allocation.
+# pre-allocation the same way slurm does.  We use pdebug queue on lassen
+# to speed-up the allocation.  However this would not be scalable to
+# multiple builds.
 .build_and_test_on_lassen:
  extends: [.on_lassen]
  stage: build_and_test
@@ -44,5 +45,5 @@ variables:
    - echo ${MFEM_DATA_DIR}
    - echo ${SPEC}
    # Next script uses 'THREADS': leaving it empty --> it uses 'make all -j'
-    - lalloc 1 -W 45 -q pci --atsdisable tests/gitlab/build_and_test --spec "${SPEC}" --data-dir "${MFEM_DATA_DIR}" --data
+    - lalloc 1 -W 45 -q pdebug --atsdisable tests/gitlab/build_and_test --spec "${SPEC}" --data-dir "${MFEM_DATA_DIR}" --data
  needs: [setup]
@@ -52,4 +52,4 @@ variables:
    - echo ${JOBID}
    - echo ${MFEM_DATA_DIR}
    - echo ${SPEC}
-    - srun $( [[ -n "${JOBID}" ]] && echo "--jobid=${JOBID}" ) --reservation=ci -t 45 -N 1 tests/gitlab/build_and_test --spec "${SPEC}" --data-dir "${MFEM_DATA_DIR}" --data
+    - srun $( [[ -n "${JOBID}" ]] && echo "--jobid=${JOBID}" ) -t 45 -N 1 tests/gitlab/build_and_test --spec "${SPEC}" --data-dir "${MFEM_DATA_DIR}" --data
@@ -14,14 +14,14 @@ stages:
  - build_and_test
  - report

-opt_mpi_cuda_gcc:
+opt_mpi_cuda_xl_16_1_1_12:
  variables:
-    SPEC: "%gcc@8.3.1 +mpi +cuda cuda_arch=70"
+    SPEC: "%xl@16.1.1.12 +mpi +cuda cuda_arch=70"
  extends: .build_and_test_on_lassen

-opt_mpi_cuda_hypre_cuda_gcc:
+opt_mpi_cuda_hypre_cuda_xl:
  variables:
-    SPEC: "%gcc@8.3.1 +mpi +cuda cuda_arch=70 ^hypre+cuda~shared cuda_arch=70"
+    SPEC: "%xl@16.1.1.12 +mpi +cuda cuda_arch=70 ^hypre+cuda~shared cuda_arch=70"
  extends: .build_and_test_on_lassen

 # Jobs report
@@ -32,11 +32,11 @@ mkdir _${BASELINE_TEST} && cd _${BASELINE_TEST}

 # run
 if [[ "${MACHINE_NAME}" == "quartz" || "${MACHINE_NAME}" == "ruby" ]]; then
-  salloc --nodes=1 --reservation=ci ../runtest ../../mfem "${BASELINE_TEST} ${TPLS_DIR}"
+  salloc --nodes=1 -p pdebug ../runtest ../../mfem "${BASELINE_TEST} ${TPLS_DIR}"
 elif [[ ${MACHINE_NAME} == "corona" ]]; then
  salloc --nodes=1 -t 60 -p pbatch ../runtest ../../mfem "${BASELINE_TEST} ${TPLS_DIR}"
 elif [[ ${MACHINE_NAME} == "lassen" ]]; then
-  lalloc 1 -q pci ../runtest ../../mfem "${BASELINE_TEST} ${TPLS_DIR}"
+  lalloc 1 -q pdebug ../runtest ../../mfem "${BASELINE_TEST} ${TPLS_DIR}"
 else
  echo "Unknown machine: MACHINE_NAME=$MACHINE_NAME"
  exit 1
@@ -11,11 +11,6 @@
 Version 4.7.1 (development)
 ===========================

- Added an MFEM example for the eikonal equation. This new solver is based on
-  the proximal Galerkin method introduced by Keith and Surowiec.
-
- API change: in class GridFunction, 'fec' was renamed to 'fec_owned'.
-

 Version 4.7, released on May 7, 2024
 ====================================
@@ -1,102 +0,0 @@
-MFEM mesh v1.0
-
-dimension
-4
-
-elements
-24
-1 7 4 5 8 11 13
-1 7 1 4 5 7 8
-1 7 1 4 5 8 11
-1 7 1 5 8 11 13
-1 7 1 5 7 8 13
-1 7 4 5 7 8 13
-1 7 1 3 4 8 11
-1 7 1 3 4 5 11
-1 7 1 5 10 11 13
-1 7 1 8 10 11 13
-1 7 1 3 5 10 11
-1 7 1 2 3 5 10
-1 7 0 1 3 4 8
-1 7 0 1 4 7 8
-1 7 1 5 6 7 13
-1 7 1 6 7 8 13
-1 7 6 7 8 13 15
-1 7 4 7 8 13 15
-1 7 4 8 12 13 15
-1 7 4 8 11 12 13
-1 7 6 8 13 14 15
-1 7 1 6 8 13 14
-1 7 1 8 9 10 13
-1 7 1 8 9 13 14
-
-boundary
-48
-1 4 0 1 3 4
-1 4 0 1 3 8
-1 4 0 3 4 8
-1 4 0 1 4 7
-1 4 0 1 7 8
-1 4 0 4 7 8
-1 4 1 4 5 7
-1 4 1 3 8 11
-1 4 1 3 4 5
-1 4 1 5 10 13
-1 4 1 8 10 11
-1 4 1 3 10 11
-1 4 1 2 3 5
-1 4 1 2 3 10
-1 4 1 2 5 10
-1 4 1 5 6 7
-1 4 1 5 6 13
-1 4 1 6 7 8
-1 4 1 6 8 14
-1 4 1 6 13 14
-1 4 1 8 9 10
-1 4 1 9 10 13
-1 4 1 8 9 14
-1 4 1 9 13 14
-1 4 2 3 5 10
-1 4 3 4 8 11
-1 4 3 4 5 11
-1 4 3 5 10 11
-1 4 4 5 11 13
-1 4 4 5 7 13
-1 4 4 7 8 15
-1 4 4 7 13 15
-1 4 4 8 12 15
-1 4 4 12 13 15
-1 4 4 8 11 12
-1 4 4 11 12 13
-1 4 5 10 11 13
-1 4 5 6 7 13
-1 4 6 7 8 15
-1 4 6 7 13 15
-1 4 6 8 14 15
-1 4 6 13 14 15
-2 4 8 10 11 13
-2 4 8 12 13 15
-2 4 8 11 12 13
-2 4 8 13 14 15
-2 4 8 9 10 13
-2 4 8 9 13 14
-
-vertices
-16
-4
-0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000
-1.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000
-1.0000000000000000 1.0000000000000000 0.0000000000000000 0.0000000000000000
-0.0000000000000000 1.0000000000000000 0.0000000000000000 0.0000000000000000
-0.0000000000000000 1.0000000000000000 1.0000000000000000 0.0000000000000000
-1.0000000000000000 1.0000000000000000 1.0000000000000000 0.0000000000000000
-1.0000000000000000 0.0000000000000000 1.0000000000000000 0.0000000000000000
-0.0000000000000000 0.0000000000000000 1.0000000000000000 0.0000000000000000
-0.0000000000000000 0.0000000000000000 0.0000000000000000 1.0000000000000000
-1.0000000000000000 0.0000000000000000 0.0000000000000000 1.0000000000000000
-1.0000000000000000 1.0000000000000000 0.0000000000000000 1.0000000000000000
-0.0000000000000000 1.0000000000000000 0.0000000000000000 1.0000000000000000
-0.0000000000000000 1.0000000000000000 1.0000000000000000 1.0000000000000000
-1.0000000000000000 1.0000000000000000 1.0000000000000000 1.0000000000000000
-1.0000000000000000 0.0000000000000000 1.0000000000000000 1.0000000000000000
-0.0000000000000000 0.0000000000000000 1.0000000000000000 1.0000000000000000
@@ -1,102 +0,0 @@
-MFEM mesh v1.0
-
-dimension
-4
-
-elements
-24
-17 8 4 5 8 11 13
-11 8 1 4 5 7 8
-15 8 1 4 5 8 11
-16 8 1 5 8 11 13
-12 8 1 5 7 8 13
-13 8 4 5 7 8 13
-7  8 1 3 4 8 11
-2  8 1 3 4 5 11
-4  8 1 5 10 11 13
-10 8 1 8 10 11 13
-3  8 1 3 5 10 11
-1  8 1 2 3 5 10
-6  8 0 1 3 4 8
-8  8 0 1 4 7 8
-5  8 1 5 6 7 13
-20 8 1 6 7 8 13
-19 8 6 7 8 13 15
-14 8 4 7 8 13 15
-21 8 4 8 12 13 15
-22 8 4 8 11 12 13
-23 8 6 8 13 14 15
-24 8 1 6 8 13 14
-9  8 1 8 9 10 13
-18 8 1 8 9 13 14
-
-boundary
-48
-1 4 0 1 3 4
-3 4 0 1 3 8
-3 4 0 3 4 8
-1 4 0 1 4 7
-3 4 0 1 7 8
-3 4 0 4 7 8
-1 4 1 4 5 7
-3 4 1 3 8 11
-1 4 1 3 4 5
-3 4 1 5 10 13
-3 4 1 8 10 11
-3 4 1 3 10 11
-1 4 1 2 3 5
-3 4 1 2 3 10
-3 4 1 2 5 10
-1 4 1 5 6 7
-3 4 1 5 6 13
-3 4 1 6 7 8
-3 4 1 6 8 14
-3 4 1 6 13 14
-3 4 1 8 9 10
-3 4 1 9 10 13
-3 4 1 8 9 14
-3 4 1 9 13 14
-3 4 2 3 5 10
-3 4 3 4 8 11
-3 4 3 4 5 11
-3 4 3 5 10 11
-3 4 4 5 11 13
-3 4 4 5 7 13
-3 4 4 7 8 15
-3 4 4 7 13 15
-3 4 4 8 12 15
-3 4 4 12 13 15
-3 4 4 8 11 12
-3 4 4 11 12 13
-3 4 5 10 11 13
-3 4 5 6 7 13
-3 4 6 7 8 15
-3 4 6 7 13 15
-3 4 6 8 14 15
-3 4 6 13 14 15
-5 4 8 10 11 13
-5 4 8 12 13 15
-5 4 8 11 12 13
-5 4 8 13 14 15
-5 4 8 9 10 13
-5 4 8 9 13 14
-
-vertices
-16
-4
-0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000
-1.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000
-1.0000000000000000 1.0000000000000000 0.0000000000000000 0.0000000000000000
-0.0000000000000000 1.0000000000000000 0.0000000000000000 0.0000000000000000
-0.0000000000000000 1.0000000000000000 1.0000000000000000 0.0000000000000000
-1.0000000000000000 1.0000000000000000 1.0000000000000000 0.0000000000000000
-1.0000000000000000 0.0000000000000000 1.0000000000000000 0.0000000000000000
-0.0000000000000000 0.0000000000000000 1.0000000000000000 0.0000000000000000
-0.0000000000000000 0.0000000000000000 0.0000000000000000 1.0000000000000000
-1.0000000000000000 0.0000000000000000 0.0000000000000000 1.0000000000000000
-1.0000000000000000 1.0000000000000000 0.0000000000000000 1.0000000000000000
-0.0000000000000000 1.0000000000000000 0.0000000000000000 1.0000000000000000
-0.0000000000000000 1.0000000000000000 1.0000000000000000 1.0000000000000000
-1.0000000000000000 1.0000000000000000 1.0000000000000000 1.0000000000000000
-1.0000000000000000 0.0000000000000000 1.0000000000000000 1.0000000000000000
-0.0000000000000000 0.0000000000000000 1.0000000000000000 1.0000000000000000
@@ -1,231 +0,0 @@
-MFEM mesh v1.0
-
-dimension
-4
-
-elements
-96
-1 8 0 1 7 8 9
-1 8 1 6 7 8 9
-1 8 4 5 6 8 9
-1 8 4 6 7 8 9
-1 8 0 1 3 8 9
-1 8 1 2 3 8 9
-1 8 0 4 7 8 9
-1 8 0 3 4 8 9
-1 8 1 2 6 8 9
-1 8 2 5 6 8 9
-1 8 3 4 5 8 9
-1 8 2 3 5 8 9
-1 8 9 10 11 17 18
-1 8 9 11 16 17 18
-1 8 9 14 15 16 18
-1 8 9 14 16 17 18
-1 8 9 10 11 13 18
-1 8 9 11 12 13 18
-1 8 9 10 14 17 18
-1 8 9 10 13 14 18
-1 8 9 11 12 16 18
-1 8 9 12 15 16 18
-1 8 9 13 14 15 18
-1 8 9 12 13 15 18
-1 8 9 12 15 16 19
-1 8 9 11 12 16 19
-1 8 1 6 9 11 19
-1 8 6 9 11 16 19
-1 8 1 2 6 9 19
-1 8 2 5 6 9 19
-1 8 2 5 9 15 19
-1 8 2 9 12 15 19
-1 8 5 6 9 16 19
-1 8 5 9 15 16 19
-1 8 1 9 11 12 19
-1 8 1 2 9 12 19
-1 8 9 10 13 14 20
-1 8 9 10 14 17 20
-1 8 0 9 10 17 20
-1 8 0 7 9 17 20
-1 8 0 3 4 9 20
-1 8 0 4 7 9 20
-1 8 3 4 9 13 20
-1 8 4 9 13 14 20
-1 8 4 7 9 14 20
-1 8 7 9 14 17 20
-1 8 0 3 9 10 20
-1 8 3 9 10 13 20
-1 8 2 5 9 15 21
-1 8 2 9 12 15 21
-1 8 2 3 5 9 21
-1 8 3 4 5 9 21
-1 8 9 13 14 15 21
-1 8 9 12 13 15 21
-1 8 4 5 9 14 21
-1 8 5 9 14 15 21
-1 8 2 3 9 12 21
-1 8 3 9 12 13 21
-1 8 3 4 9 13 21
-1 8 4 9 13 14 21
-1 8 1 6 9 11 22
-1 8 6 9 11 16 22
-1 8 6 7 9 16 22
-1 8 7 9 16 17 22
-1 8 0 7 9 17 22
-1 8 0 9 10 17 22
-1 8 0 1 9 10 22
-1 8 1 9 10 11 22
-1 8 0 1 7 9 22
-1 8 1 6 7 9 22
-1 8 9 10 11 17 22
-1 8 9 11 16 17 22
-1 8 5 9 15 16 23
-1 8 5 6 9 16 23
-1 8 6 7 9 16 23
-1 8 7 9 16 17 23
-1 8 7 9 14 17 23
-1 8 4 7 9 14 23
-1 8 4 5 9 14 23
-1 8 5 9 14 15 23
-1 8 4 6 7 9 23
-1 8 4 5 6 9 23
-1 8 9 14 15 16 23
-1 8 9 14 16 17 23
-1 8 1 2 9 12 24
-1 8 1 9 11 12 24
-1 8 0 1 9 10 24
-1 8 1 9 10 11 24
-1 8 0 3 9 10 24
-1 8 3 9 10 13 24
-1 8 2 3 9 12 24
-1 8 3 9 12 13 24
-1 8 1 2 3 9 24
-1 8 0 1 3 9 24
-1 8 9 10 11 13 24
-1 8 9 11 12 13 24
-
-boundary
-96
-1 4 0 1 7 8
-1 4 0 1 3 8
-1 4 0 4 7 8
-1 4 0 3 4 8
-2 4 0 10 17 20
-2 4 0 7 17 20
-2 4 0 3 4 20
-2 4 0 4 7 20
-2 4 0 3 10 20
-2 4 0 7 17 22
-2 4 0 10 17 22
-2 4 0 1 10 22
-2 4 0 1 7 22
-2 4 0 1 10 24
-2 4 0 3 10 24
-2 4 0 1 3 24
-1 4 1 6 7 8
-1 4 1 2 3 8
-1 4 1 2 6 8
-2 4 1 6 11 19
-2 4 1 2 6 19
-2 4 1 11 12 19
-2 4 1 2 12 19
-2 4 1 6 11 22
-2 4 1 10 11 22
-2 4 1 6 7 22
-2 4 1 2 12 24
-2 4 1 11 12 24
-2 4 1 10 11 24
-2 4 1 2 3 24
-1 4 2 5 6 8
-1 4 2 3 5 8
-2 4 2 5 6 19
-2 4 2 5 15 19
-2 4 2 12 15 19
-2 4 2 5 15 21
-2 4 2 12 15 21
-2 4 2 3 5 21
-2 4 2 3 12 21
-2 4 2 3 12 24
-1 4 3 4 5 8
-2 4 3 4 13 20
-2 4 3 10 13 20
-2 4 3 4 5 21
-2 4 3 12 13 21
-2 4 3 4 13 21
-2 4 3 10 13 24
-2 4 3 12 13 24
-1 4 4 5 6 8
-1 4 4 6 7 8
-2 4 4 13 14 20
-2 4 4 7 14 20
-2 4 4 5 14 21
-2 4 4 13 14 21
-2 4 4 7 14 23
-2 4 4 5 14 23
-2 4 4 6 7 23
-2 4 4 5 6 23
-2 4 5 6 16 19
-2 4 5 15 16 19
-2 4 5 14 15 21
-2 4 5 15 16 23
-2 4 5 6 16 23
-2 4 5 14 15 23
-2 4 6 11 16 19
-2 4 6 11 16 22
-2 4 6 7 16 22
-2 4 6 7 16 23
-2 4 7 14 17 20
-2 4 7 16 17 22
-2 4 7 16 17 23
-2 4 7 14 17 23
-3 4 10 11 17 18
-3 4 10 11 13 18
-3 4 10 14 17 18
-3 4 10 13 14 18
-2 4 10 13 14 20
-2 4 10 14 17 20
-2 4 10 11 17 22
-2 4 10 11 13 24
-3 4 11 16 17 18
-3 4 11 12 13 18
-3 4 11 12 16 18
-2 4 11 12 16 19
-2 4 11 16 17 22
-2 4 11 12 13 24
-3 4 12 15 16 18
-3 4 12 13 15 18
-2 4 12 15 16 19
-2 4 12 13 15 21
-3 4 13 14 15 18
-2 4 13 14 15 21
-3 4 14 15 16 18
-3 4 14 16 17 18
-2 4 14 15 16 23
-2 4 14 16 17 23
-
-vertices
-25
-4
-0.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000
-1.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000
-1.0000000000000000 1.0000000000000000 0.0000000000000000 0.0000000000000000
-0.0000000000000000 1.0000000000000000 0.0000000000000000 0.0000000000000000
-0.0000000000000000 1.0000000000000000 1.0000000000000000 0.0000000000000000
-1.0000000000000000 1.0000000000000000 1.0000000000000000 0.0000000000000000
-1.0000000000000000 0.0000000000000000 1.0000000000000000 0.0000000000000000
-0.0000000000000000 0.0000000000000000 1.0000000000000000 0.0000000000000000
-0.5000000000000000 0.5000000000000000 0.5000000000000000 0.0000000000000000
-0.5000000000000000 0.5000000000000000 0.5000000000000000 0.5000000000000000
-0.0000000000000000 0.0000000000000000 0.0000000000000000 1.0000000000000000
-1.0000000000000000 0.0000000000000000 0.0000000000000000 1.0000000000000000
-1.0000000000000000 1.0000000000000000 0.0000000000000000 1.0000000000000000
-0.0000000000000000 1.0000000000000000 0.0000000000000000 1.0000000000000000
-0.0000000000000000 1.0000000000000000 1.0000000000000000 1.0000000000000000
-1.0000000000000000 1.0000000000000000 1.0000000000000000 1.0000000000000000
-1.0000000000000000 0.0000000000000000 1.0000000000000000 1.0000000000000000
-0.0000000000000000 0.0000000000000000 1.0000000000000000 1.0000000000000000
-0.5000000000000000 0.5000000000000000 0.5000000000000000 1.0000000000000000
-1.0000000000000000 0.5000000000000000 0.5000000000000000 0.5000000000000000
-0.0000000000000000 0.5000000000000000 0.5000000000000000 0.5000000000000000
-0.5000000000000000 1.0000000000000000 0.5000000000000000 0.5000000000000000
-0.5000000000000000 0.0000000000000000 0.5000000000000000 0.5000000000000000
-0.5000000000000000 0.5000000000000000 1.0000000000000000 0.5000000000000000
-0.5000000000000000 0.5000000000000000 0.0000000000000000 0.5000000000000000
@@ -1,36 +0,0 @@
-MFEM mesh v1.0
-
-#
-# MFEM Geometry Types (see mesh/geom.hpp):
-#
-# POINT       = 0
-# SEGMENT     = 1
-# TRIANGLE    = 2
-# SQUARE      = 3
-# TETRAHEDRON = 4
-# CUBE        = 5
-# PRISM       = 6
-#
-
-dimension
-2
-
-elements
-2
-1 2 2 0 1
-1 2 0 2 3
-
-boundary
-4
-1 1 0 1
-1 1 1 2
-2 1 2 3
-1 1 3 0
-
-vertices
-4
-2
-0 0
-1 0
-1 1
-0 1
@@ -1,52 +0,0 @@
-MFEM mesh v1.0
-
-#
-# MFEM Geometry Types (see mesh/geom.hpp):
-#
-# POINT       = 0
-# SEGMENT     = 1
-# TRIANGLE    = 2
-# SQUARE      = 3
-# TETRAHEDRON = 4
-# CUBE        = 5
-# PRISM       = 6
-#
-
-dimension
-3
-
-elements
-6
-1 4 3 1 7 5
-1 4 1 6 7 4
-1 4 6 1 0 2
-1 4 1 6 4 2
-1 4 6 1 3 0
-1 4 1 6 3 7
-
-boundary
-12
-1 2 6 0 3
-1 2 0 6 2
-1 2 1 3 0
-1 2 3 1 5
-1 2 3 7 6
-1 2 7 3 5
-1 2 4 6 7
-1 2 6 4 2
-2 2 1 7 5
-2 2 7 1 4
-1 2 1 2 4
-1 2 2 1 0
-
-vertices
-8
-3
-0 0 0
-0 0 1
-1 0 0
-0 1 0
-1 0 1
-0 1 1
-1 1 0
-1 1 1
@@ -1208,13 +1208,13 @@ STRIP_CODE_COMMENTS    = NO
 # entity all documented functions referencing it will be listed.
 # The default value is: NO.

-REFERENCED_BY_RELATION = YES
+REFERENCED_BY_RELATION = NO

 # If the REFERENCES_RELATION tag is set to YES then for each documented function
 # all documented entities called/used by that function will be listed.
 # The default value is: NO.

-REFERENCES_RELATION    = YES
+REFERENCES_RELATION    = NO

 # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
 # to YES then the hyperlinks from functions in REFERENCES_RELATION and
@@ -114,9 +114,7 @@ namespace mfem {
 * - <a class="el" href="ex37p_8cpp_source.html">Example 37p</a>: parallel topology optimization
 * - <a class="el" href="ex38_8cpp_source.html">Example 38</a>: cut-surface and cut-volume integration
 * - <a class="el" href="ex39_8cpp_source.html">Example 39</a>: named mesh attributes
- * - <a class="el" href="ex39p_8cpp_source.html">Example 39p</a>: parallel named mesh attributes
- * - <a class="el" href="ex40_8cpp_source.html">Example 40</a>: eikonal equation
- * - <a class="el" href="ex40p_8cpp_source.html">Example 40p</a>: parallel eikonal equation
+ * - <a class="el" href="ex39p_8cpp_source.html">Example 39</a>: parallel named mesh attributes
 *
 * <H4>AmgX Examples</H4>
 * - Variants of Examples
@@ -45,7 +45,6 @@ list(APPEND ALL_EXE_SRCS
  ex37.cpp
  ex38.cpp
  ex39.cpp
-  ex40.cpp
  )

 if (MFEM_USE_MPI)
@@ -73,9 +72,6 @@ if (MFEM_USE_MPI)
    ex20p.cpp
    ex21p.cpp
    ex22p.cpp
-    ex1p_4d.cpp
-    ex3p_4d.cpp
-    ex4D_DivSkew.cpp
    ex24p.cpp
    ex25p.cpp
    ex26p.cpp
@@ -91,7 +87,6 @@ if (MFEM_USE_MPI)
    ex36p.cpp
    ex37p.cpp
    ex39p.cpp
-    ex40p.cpp
  )
 endif()

@@ -151,10 +146,10 @@ if (MFEM_ENABLE_TESTING)
  # Add CUDA/HIP tests.
  set(DEVICE_EXAMPLES
      # serial examples with device support:
-      ex1 ex3 ex4 ex5 ex6 ex9 ex14 ex22 ex24 ex25 ex26 ex34
+      ex1 ex3 ex4 ex5 ex6 ex9 ex22 ex24 ex25 ex26 ex34
      # parallel examples with device support:
-      ex1p ex2p ex3p ex4p ex5p ex6p ex7p ex9p ex13p ex14p ex22p ex24p ex25p
-      ex26p ex34p ex35p)
+      ex1p ex2p ex3p ex4p ex5p ex6p ex7p ex9p ex13p ex22p ex24p ex25p ex26p
+      ex34p ex35p)
  set(MFEM_TEST_DEVICE)
  if (MFEM_USE_CUDA)
    set(MFEM_TEST_DEVICE "cuda")
@@ -164,11 +159,6 @@ if (MFEM_ENABLE_TESTING)
  if (MFEM_TEST_DEVICE)
    foreach(TEST_NAME ${DEVICE_EXAMPLES})
      set(THIS_TEST_OPTIONS "-no-vis" "-d" "${MFEM_TEST_DEVICE}")
-      if (${TEST_NAME} MATCHES "ex14p")
-        list(APPEND THIS_TEST_OPTIONS "-rs" "2" "-rp" "0" "-pa")
-      elseif (${TEST_NAME} MATCHES "ex14")
-        list(APPEND THIS_TEST_OPTIONS "-r" "2" "-pa")
-      endif()
      if (NOT (${TEST_NAME} MATCHES ".*p$"))
        add_test(NAME ${TEST_NAME}_${MFEM_TEST_DEVICE}_ser
          COMMAND ${TEST_NAME} ${THIS_TEST_OPTIONS})
@@ -20,7 +20,6 @@
 //               ex14 -m ../data/fichera-amr.mesh
 //               ex14 -pa -r 1 -o 3
 //               ex14 -pa -r 1 -o 3 -m ../data/fichera.mesh
-//               ex14 -m ../data/inline-tet.mesh -o 0 -nt 4 -s 1
 //
 // Device sample runs:
 //               ex14 -pa -r 2 -d cuda -o 3
@@ -56,16 +55,10 @@ int main(int argc, char *argv[])
   bool pa = false;
   bool visualization = 1;
   const char *device_config = "cpu";
-   int nt = 0;
-   double st = 1.0;

   OptionsParser args(argc, argv);
   args.AddOption(&mesh_file, "-m", "--mesh",
                  "Mesh file to use.");
-   args.AddOption(&nt, "-nt", "--number-of-timeslices",
-                  "Number of slices through the hyper-prism in the 4th coordinate.");
-   args.AddOption(&st, "-st", "--size-time",
-                  "Length of hyper-prims in 4th coordinate (e.g. time).");
   args.AddOption(&ref_levels, "-r", "--refine",
                  "Number of times to refine the mesh uniformly, -1 for auto.");
   args.AddOption(&order, "-o", "--order",
@@ -104,17 +97,8 @@ int main(int argc, char *argv[])
   // 3. Read the mesh from the given mesh file. We can handle triangular,
   //    quadrilateral, tetrahedral and hexahedral meshes with the same code.
   //    NURBS meshes are projected to second order meshes.
-   Mesh *mesh = new Mesh(mesh_file, 1, 1);
-   int dim = mesh->Dimension();
-   if (dim == 3 && nt > 0)
-   {
-      Mesh* spat_mesh = mesh;
-      mesh = new Mesh(spat_mesh, nt, Element::PENTATOPE, true, st);
-      delete spat_mesh;
-
-      ref_levels = 0;
-      dim = 4;
-   }
+   Mesh mesh(mesh_file);
+   const int dim = mesh.Dimension();

   // 4. Refine the mesh to increase the resolution. In this example we do
   //    'ref_levels' of uniform refinement. By default, or if ref_levels < 0,
@@ -123,23 +107,23 @@ int main(int argc, char *argv[])
   {
      if (ref_levels < 0)
      {
-         ref_levels = (int)floor(log(50000./mesh->GetNE())/log(2.)/(dim < 4 ? dim : 1.));
+         ref_levels = (int)floor(log(50000./mesh.GetNE())/log(2.)/dim);
      }
      for (int l = 0; l < ref_levels; l++)
      {
-         mesh->UniformRefinement();
+         mesh.UniformRefinement();
      }
   }
-   if (mesh->NURBSext)
+   if (mesh.NURBSext)
   {
-      mesh->SetCurvature(max(order, 1));
+      mesh.SetCurvature(max(order, 1));
   }

   // 5. Define a finite element space on the mesh. Here we use discontinuous
   //    finite elements of the specified order >= 0.
   const auto bt = pa ? BasisType::GaussLobatto : BasisType::GaussLegendre;
   DG_FECollection fec(order, dim, bt);
-   FiniteElementSpace fespace(mesh, &fec);
+   FiniteElementSpace fespace(&mesh, &fec);
   cout << "Number of unknowns: " << fespace.GetVSize() << endl;

   // 6. Set up the linear form b(.) which corresponds to the right-hand side of
@@ -214,7 +198,7 @@ int main(int argc, char *argv[])
   //     later using GLVis: "glvis -m refined.mesh -g sol.gf".
   ofstream mesh_ofs("refined.mesh");
   mesh_ofs.precision(8);
-   mesh->Print(mesh_ofs);
+   mesh.Print(mesh_ofs);
   ofstream sol_ofs("sol.gf");
   sol_ofs.precision(8);
   x.Save(sol_ofs);
@@ -226,10 +210,8 @@ int main(int argc, char *argv[])
      int  visport   = 19916;
      socketstream sol_sock(vishost, visport);
      sol_sock.precision(8);
-      sol_sock << "solution\n" << *mesh << x << flush;
+      sol_sock << "solution\n" << mesh << x << flush;
   }

-   delete mesh;
-
   return 0;
 }
@@ -19,7 +19,6 @@
 //               mpirun -np 4 ex14p -m ../data/amr-hex.mesh
 //               mpirun -np 4 ex14p -pa -rs 1 -rp 0 -o 3
 //               mpirun -np 4 ex14p -pa -rs 1 -rp 0 -m ../data/fichera.mesh -o 3
-//               mpirun -np 4 ex14p -m ../data/inline-tet.mesh -o 0 -nt 4 -s 1
 //
 // Device sample runs:
 //               mpirun -np 4 ex14p -pa -rs 2 -rp 0 -d cuda -o 3
@@ -91,16 +90,10 @@ int main(int argc, char *argv[])
   bool pa = false;
   bool visualization = 1;
   const char *device_config = "cpu";
-   int nt = 0;
-   double st = 1.0;

   OptionsParser args(argc, argv);
   args.AddOption(&mesh_file, "-m", "--mesh",
                  "Mesh file to use.");
-   args.AddOption(&nt, "-nt", "--number-of-timeslices",
-                  "Number of slices through the hyper-prism in the 4th coordinate.");
-   args.AddOption(&st, "-st", "--size-time",
-                  "Length of hyper-prims in 4th coordinate (e.g. time).");
   args.AddOption(&ser_ref_levels, "-rs", "--refine-serial",
                  "Number of times to refine the mesh uniformly in serial,"
                  " -1 for auto.");
@@ -146,17 +139,8 @@ int main(int argc, char *argv[])
   // 3. Read the (serial) mesh from the given mesh file on all processors. We
   //    can handle triangular, quadrilateral, tetrahedral and hexahedral meshes
   //    with the same code. NURBS meshes are projected to second order meshes.
-   Mesh *mesh = new Mesh(mesh_file, 1, 1);
-   int dim = mesh->Dimension();
-   if (dim == 3 && nt > 0)
-   {
-      Mesh* spat_mesh = mesh;
-      mesh = new Mesh(spat_mesh, nt, Element::PENTATOPE, true, st);
-      delete spat_mesh;
-      dim = 4;
-   }
-   if (dim == 4)
-      ser_ref_levels = 0;
+   Mesh mesh(mesh_file);
+   int dim = mesh.Dimension();

   // 4. Refine the serial mesh on all processors to increase the resolution. In
   //    this example we do 'ser_ref_levels' of uniform refinement. By default,
@@ -165,23 +149,23 @@ int main(int argc, char *argv[])
   {
      if (ser_ref_levels < 0)
      {
-         ser_ref_levels = (int)floor(log(10000./mesh->GetNE())/log(2.)/dim);
+         ser_ref_levels = (int)floor(log(10000./mesh.GetNE())/log(2.)/dim);
      }
      for (int l = 0; l < ser_ref_levels; l++)
      {
-         mesh->UniformRefinement();
+         mesh.UniformRefinement();
      }
   }
-   if (mesh->NURBSext)
+   if (mesh.NURBSext)
   {
-      mesh->SetCurvature(max(order, 1));
+      mesh.SetCurvature(max(order, 1));
   }

   // 5. Define a parallel mesh by a partitioning of the serial mesh. Refine
   //    this mesh further in parallel to increase the resolution. Once the
   //    parallel mesh is defined, the serial mesh can be deleted.
-   ParMesh pmesh(MPI_COMM_WORLD, *mesh);
-   delete mesh;
+   ParMesh pmesh(MPI_COMM_WORLD, mesh);
+   mesh.Clear();
   {
      for (int l = 0; l < par_ref_levels; l++)
      {
@@ -1,412 +0,0 @@
-//                       MFEM Example 1 - Parallel Version
-//
-// Compile with: make ex1p
-//
-// Sample runs:  mpirun -np 4 ex1p -m ../data/square-disc.mesh
-//               mpirun -np 4 ex1p -m ../data/star.mesh
-//               mpirun -np 4 ex1p -m ../data/escher.mesh
-//               mpirun -np 4 ex1p -m ../data/fichera.mesh
-//               mpirun -np 4 ex1p -m ../data/square-disc-p2.vtk -o 2
-//               mpirun -np 4 ex1p -m ../data/square-disc-p3.mesh -o 3
-//               mpirun -np 4 ex1p -m ../data/square-disc-nurbs.mesh -o -1
-//               mpirun -np 4 ex1p -m ../data/disc-nurbs.mesh -o -1
-//               mpirun -np 4 ex1p -m ../data/pipe-nurbs.mesh -o -1
-//               mpirun -np 4 ex1p -m ../data/ball-nurbs.mesh -o 2
-//               mpirun -np 4 ex1p -m ../data/star-surf.mesh
-//               mpirun -np 4 ex1p -m ../data/square-disc-surf.mesh
-//               mpirun -np 4 ex1p -m ../data/inline-segment.mesh
-//               mpirun -np 4 ex1p -m ../data/amr-quad.mesh
-//               mpirun -np 4 ex1p -m ../data/amr-hex.mesh
-//               mpirun -np 4 ex1p -m ../data/mobius-strip.mesh
-//               mpirun -np 4 ex1p -m ../data/mobius-strip.mesh -o -1 -sc
-//
-// Description:  This example code demonstrates the use of MFEM to define a
-//               simple finite element discretization of the Laplace problem
-//               -Delta u = 1 with homogeneous Dirichlet boundary conditions.
-//               Specifically, we discretize using a FE space of the specified
-//               order, or if order < 1 using an isoparametric/isogeometric
-//               space (i.e. quadratic for quadratic curvilinear mesh, NURBS for
-//               NURBS mesh, etc.)
-//
-//               The example highlights the use of mesh refinement, finite
-//               element grid functions, as well as linear and bilinear forms
-//               corresponding to the left-hand side and right-hand side of the
-//               discrete linear system. We also cover the explicit elimination
-//               of essential boundary conditions, static condensation, and the
-//               optional connection to the GLVis tool for visualization.
-
-#include "mfem.hpp"
-#include <fstream>
-#include <iostream>
-
-#include "./spe10_coeff.cpp"
-
-
-int* LoadIterations(int NRows, int NCol)
-{
-   ifstream in("iter_grad.txt");
-
-   //initialize
-   int *iters = new int[NCol*NRows];
-   for (int col = 0; col < NCol; col++)
-   {
-      for (int row = 0; row < NRows; row++)
-      {
-         iters[row*NCol+col] = -1;
-      }
-   }
-
-   if (!in)
-   {
-      cout << "Cannot open file.\n";
-      return iters;
-   }
-
-   for (int row = 0; row < NRows; row++)
-      for (int col = 0; col < NCol; col++)
-      {
-         if (in.eof())
-         {
-            in.close();
-            return iters;
-         }
-         in >> iters[row*NCol+col];
-      }
-
-
-   in.close();
-
-   return iters;
-}
-
-void putIterationsInArray(int iter, int row, int col, int NCol, int* iters)
-{
-   iters[row*NCol+col] = iter;
-}
-
-void WriteIterations(int *iters, int NRows, int NCol)
-{
-   ofstream out;
-   out.open("iter_grad.txt",fstream::out);
-
-   if (!out)
-   {
-      cout << "Cannot open file.\n";
-      delete[] iters;
-
-      return;
-   }
-
-   for (int row = 0; row < NRows; row++)
-   {
-      for (int col = 0; col < NCol; col++)
-      {
-         out << iters[row*NCol+col] << "\t";
-      }
-      out << endl;
-   }
-   out.close();
-
-   delete[] iters;
-}
-
-
-using namespace std;
-using namespace mfem;
-
-double kappa = 1.0;
-
-double u_exact(const Vector &x)
-{
-   int dim = x.Size();
-
-   if (dim==4)
-   {
-      return cos(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*cos(M_PI*x(3));
-   }
-   else { return 0.0; }
-}
-
-double f_exact(const Vector &x)
-{
-   int dim = x.Size();
-
-   if (dim==4)
-   {
-      return (kappa + 4.0 * M_PI*M_PI) * cos(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(
-                                                                              2))*cos(M_PI*x(3));
-   }
-   else { return 0.0; }
-}
-
-
-int main(int argc, char *argv[])
-{
-   // 1. Initialize MPI.
-   int num_procs, myid;
-   MPI_Init(&argc, &argv);
-   MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
-   MPI_Comm_rank(MPI_COMM_WORLD, &myid);
-
-   bool verbose = (myid==0);
-
-   // 2. Parse command-line options.
-   const char *mesh_file = "../data/cube4d_96.MFEM";
-   int order = 1;
-   bool static_cond = false;
-   bool visualization = 1;
-   int sequ_ref_levels = 0;
-   int par_ref_levels = 0;
-   double tol = 1e-6;
-   bool set_bc = true;
-   bool standardCG = true;
-
-   OptionsParser args(argc, argv);
-   args.AddOption(&mesh_file, "-m", "--mesh",
-                  "Mesh file to use.");
-   args.AddOption(&sequ_ref_levels, "-sr", "--seqrefinement",
-                  "Number of sequential refinement steps.");
-   args.AddOption(&par_ref_levels, "-pr", "--parrefinement",
-                  "Number of parallel refinement steps.");
-   args.AddOption(&order, "-o", "--order",
-                  "Polynomial order of the finite element space.");
-   args.AddOption(&tol, "-tol", "--tol",
-                  "A parameter.");
-   args.AddOption(&set_bc, "-bc", "--impose-bc", "-no-bc", "--dont-impose-bc",
-                  "Impose or not essential boundary conditions.");
-   args.AddOption(&standardCG, "-sCG", "--stdCG", "-rCG", "--resCG",
-                  "Switch between standard PCG or recompute residuals in every step and use the residuals itself for the stopping criteria.");
-   args.Parse();
-   if (!args.Good())
-   {
-      args.PrintUsage(cout);
-      return 1;
-   }
-   if (verbose) { args.PrintOptions(cout); }
-
-   Mesh *mesh;
-   ifstream imesh(mesh_file);
-   if (!imesh)
-   {
-      cerr << "\nCan not open mesh file: " << mesh_file << '\n' << endl;
-      return 2;
-   }
-
-   mesh = new Mesh(imesh, 1, 1);
-   imesh.close();
-
-   int dim = mesh->Dimension();
-   int sdim = mesh->SpaceDimension();
-
-   //   if(dim !=4 || sdim != 4)
-   //   {
-   //    MPI_Finalize();
-   //    return 0;
-   //   }
-
-   for (int i=0; i<sequ_ref_levels; i++) { mesh->UniformRefinement(); }
-   if (verbose) { mesh->PrintCharacteristics(); }
-
-   if (verbose) { cout << "now we partition the mesh..." << endl << endl; }
-
-   ParMesh *pmesh = new ParMesh(MPI_COMM_WORLD, *mesh);
-   delete mesh;
-
-   for (int i=0; i<par_ref_levels; i++) { pmesh->UniformRefinement(); }
-
-   pmesh->PrintInfo(std::cout);
-   if (verbose) { cout << endl; }
-
-   // 6. Define a parallel finite element space on the parallel mesh. Here we
-   //    use continuous Lagrange finite elements of the specified order. If
-   //    order < 1, we instead use an isoparametric/isogeometric space.
-   FiniteElementCollection *fec;
-   if (order > 0)
-   {
-      if (dim==4)
-      {
-         if (order==1) { fec = new LinearFECollection; }
-         else { fec = new QuadraticFECollection; }
-      }
-      else { fec = new H1_FECollection(order, dim); }
-   }
-   else if (pmesh->GetNodes())
-   {
-      fec = pmesh->GetNodes()->OwnFEC();
-      if (myid == 0)
-      {
-         cout << "Using isoparametric FEs: " << fec->Name() << endl;
-      }
-   }
-   else
-   {
-      fec = new H1_FECollection(order = 1, dim);
-   }
-   ParFiniteElementSpace *fespace = new ParFiniteElementSpace(pmesh, fec);
-   HYPRE_Int size = fespace->GlobalTrueVSize();
-   if (myid == 0)
-   {
-      cout << "Number of finite element unknowns: " << size << endl;
-   }
-
-   // 7. Determine the list of true (i.e. parallel conforming) essential
-   //    boundary dofs. In this example, the boundary conditions are defined
-   //    by marking all the boundary attributes from the mesh as essential
-   //    (Dirichlet) and converting them to a list of true dofs.
-   Array<int> ess_tdof_list;
-   if (pmesh->bdr_attributes.Size())
-   {
-      Array<int> ess_bdr(pmesh->bdr_attributes.Max());
-      ess_bdr = set_bc ? 1 : 0;
-      fespace->GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
-   }
-
-
-   FunctionCoefficient uExact(u_exact);
-   ParGridFunction x(fespace);
-
-   int NExpo =8;
-   for (int expo=-NExpo; expo<=NExpo; expo++)
-   {
-      double weight = pow(10.0,expo);
-      kappa = weight;
-
-      x.ProjectCoefficient(uExact);
-
-      ParLinearForm *b = new ParLinearForm(fespace);
-      FunctionCoefficient ffunc(f_exact);
-      b->AddDomainIntegrator(new DomainLFIntegrator(ffunc));
-      b->Assemble();
-
-      x = 0.0;
-
-      // 10. Set up the parallel bilinear form a(.,.) on the finite element space
-      //     corresponding to the Laplacian operator -Delta, by adding the Diffusion
-      //     domain integrator.
-
-      //    std::string permFile = "spe_perm.dat";
-      //    InversePermeabilityFunction::ReadPermeabilityFile(permFile, MPI_COMM_WORLD);
-      //    FunctionCoefficient *cspe10 = new FunctionCoefficient(InversePermeabilityFunction::Norm2Permeability);
-      Coefficient *beta = new ConstantCoefficient(weight);
-
-      ParBilinearForm *a = new ParBilinearForm(fespace);
-      a->AddDomainIntegrator(new DiffusionIntegrator);
-      a->AddDomainIntegrator(new MassIntegrator(*beta));
-
-      // 11. Assemble the parallel bilinear form and the corresponding linear
-      //     system, applying any necessary transformations such as: parallel
-      //     assembly, eliminating boundary conditions, applying conforming
-      //     constraints for non-conforming AMR, static condensation, etc.
-      if (static_cond) { a->EnableStaticCondensation(); }
-      a->Assemble();
-
-      HypreParMatrix A;
-      Vector B, X;
-      a->FormLinearSystem(ess_tdof_list, x, *b, A, X, B);
-
-      if (myid == 0)
-      {
-         cout << "Size of linear system: " << A.GetGlobalNumRows() << endl;
-      }
-
-      // 12. Define and apply a parallel PCG solver for AX=B with the BoomerAMG
-      //     preconditioner from hypre.
-      HypreSolver *amg = new HypreBoomerAMG(A);
-
-      int iter = -1;
-      if (standardCG)
-      {
-         IterativeSolver *pcg = new CGSolver(MPI_COMM_WORLD);
-         pcg->SetOperator(A);
-         pcg->SetRelTol(tol);
-         pcg->SetMaxIter(5000);
-         pcg->SetPrintLevel(1);
-         pcg->SetPreconditioner(*amg);
-         pcg->Mult(B, X);
-
-         iter = pcg->GetNumIterations();
-
-         delete pcg;
-      }
-      else
-      {
-         HyprePCG *pcg = new HyprePCG(A);
-         pcg->SetTol(tol);
-         pcg->SetMaxIter(5000);
-         pcg->SetResidualConvergenceOptions(1,tol);
-         pcg->SetPrintLevel(2);
-         pcg->SetPreconditioner(*amg);
-         pcg->Mult(B, X);
-
-         pcg->GetNumIterations(iter);
-
-         delete pcg;
-      }
-
-
-      if (myid==0)
-      {
-         cout << "Weigth: " << weight << " " << iter << endl;
-
-         int *iters = LoadIterations(10, 2*NExpo+1);
-         putIterationsInArray(iter, sequ_ref_levels+par_ref_levels, expo+NExpo,
-                              2*NExpo+1, iters);
-         WriteIterations(iters, 10, 2*NExpo+1);
-      }
-
-
-      // 13. Recover the parallel grid function corresponding to X. This is the
-      //     local finite element solution on each processor.
-      a->RecoverFEMSolution(X, *b, x);
-
-      {
-         double err = x.ComputeL2Error(uExact);
-         if (myid == 0)
-         {
-            cout << "\n|| u - u_h ||_{L^2} = " << err << '\n' << endl;
-         }
-      }
-
-      // 14. Save the refined mesh and the solution in parallel. This output can
-      //     be viewed later using GLVis: "glvis -np <np> -m mesh -g sol".
-      //   {
-      //      ostringstream mesh_name, sol_name;
-      //      mesh_name << "mesh." << setfill('0') << setw(6) << myid;
-      //      sol_name << "sol." << setfill('0') << setw(6) << myid;
-      //
-      //      ofstream mesh_ofs(mesh_name.str().c_str());
-      //      mesh_ofs.precision(8);
-      //      pmesh->Print(mesh_ofs);
-      //
-      //      ofstream sol_ofs(sol_name.str().c_str());
-      //      sol_ofs.precision(8);
-      //      x.Save(sol_ofs);
-      //   }
-
-      // 15. Send the solution by socket to a GLVis server.
-      //   if (visualization)
-      //   {
-      //      char vishost[] = "localhost";
-      //      int  visport   = 19916;
-      //      socketstream sol_sock(vishost, visport);
-      //      sol_sock << "parallel " << num_procs << " " << myid << "\n";
-      //      sol_sock.precision(8);
-      //      sol_sock << "solution\n" << *pmesh << x << flush;
-      //   }
-
-      delete amg;
-      delete a;
-      delete beta;
-      delete b;
-   }
-
-   // 16. Free the used memory.
-
-   delete fespace;
-   if (order > 0) { delete fec; }
-   delete pmesh;
-
-   MPI_Finalize();
-
-   return 0;
-}
@@ -58,180 +58,6 @@ void f_exact(const Vector &, Vector &);
 real_t freq = 1.0, kappa;
 int dim;

-class Curl4dPrec : public Solver
-{
-
-private:
-   HypreParMatrix *A;
-   ParFiniteElementSpace *fespace;
-
-   HypreParMatrix *idMat;
-   HypreParMatrix *H1VecLaplaceMat;
-   HypreBoomerAMG *amgVecH1;
-
-
-   HypreParMatrix *gradMat;
-   HypreParMatrix *H1LaplaceMat;
-   HypreBoomerAMG *amgH1;
-
-   HypreSmoother * smoother;
-   CGSolver *pcgGrad;
-   CGSolver *pcgH1Vec;
-
-   Vector *f;
-   Vector *fGrad, *uGrad;
-   Vector *fH1Vec, *uH1Vec;
-
-   bool exactSolves;
-
-public:
-   Curl4dPrec(HypreParMatrix *AUser, ParFiniteElementSpace *fespaceUser,
-              const Array<int> &essBnd, int orderKernel=1, bool exactSolvesUser=false)
-   {
-      A = AUser;
-      fespace = fespaceUser;
-      ParMesh *pmesh = fespace->GetParMesh();
-      int dim = pmesh->Dimension();
-
-      exactSolves = exactSolvesUser;
-
-      int orderIm=1;  //vecH1  --> H(curl)
-      int orderKer=orderKernel; //grad V --> H(curl)
-
-      smoother = new HypreSmoother(*A, 16, 3);
-
-      //    //for the pure dirichlet case
-      //    Array<int> essBnd(pmesh->bdr_attributes.Max()); essBnd = 1;
-
-      Array<int> HCurl_essDof(fespace->GetVSize()); HCurl_essDof = 0;
-      fespace->GetEssentialVDofs(essBnd, HCurl_essDof);
-
-      //setup the H1 FESpace
-      FiniteElementCollection* fecH1;
-      if (orderKer==1) { fecH1 = new LinearFECollection; }
-      else { fecH1 = new QuadraticFECollection; }
-
-      ParFiniteElementSpace *H1FESpace = new ParFiniteElementSpace(pmesh, fecH1);
-      Array<int> H1_essDof(H1FESpace->GetVSize()); H1_essDof = 0;
-      H1FESpace->GetEssentialVDofs(essBnd, H1_essDof);
-
-      //setup the discrete gradient
-      ParDiscreteLinearOperator *disGrad = new ParDiscreteLinearOperator(H1FESpace,
-                                                                         fespace);
-      disGrad->AddDomainInterpolator(new GradientInterpolator);
-      disGrad->Assemble();
-      disGrad->Finalize();
-      SparseMatrix* smat = &(disGrad->SpMat());
-      smat->EliminateCols(H1_essDof);
-      for (int dof=0; dof<HCurl_essDof.Size(); dof++) if (HCurl_essDof[dof]<0) { smat->EliminateRow(dof); }
-      gradMat = disGrad->ParallelAssemble();
-      delete disGrad;
-
-      //setup the H1 preconditioner
-      ParBilinearForm* H1Varf = new ParBilinearForm(H1FESpace);
-      H1Varf->AddDomainIntegrator(new DiffusionIntegrator);
-      H1Varf->AddDomainIntegrator(new MassIntegrator);
-      H1Varf->Assemble();
-      H1Varf->Finalize();
-
-      SparseMatrix &matH1(H1Varf->SpMat());
-      for (int dof=0; dof<H1_essDof.Size(); dof++) if (H1_essDof[dof]<0) { matH1.EliminateRowCol(dof); }
-      H1LaplaceMat = H1Varf->ParallelAssemble();
-      delete H1Varf;
-      amgH1 = new HypreBoomerAMG(*H1LaplaceMat);
-
-
-      //setup the H1 injection
-      FiniteElementCollection* fecH1Vec;
-      if (orderIm==1) { fecH1Vec = new LinearFECollection; }
-      else { fecH1Vec = new QuadraticFECollection; }
-      ParFiniteElementSpace *H1VecFESpace = new ParFiniteElementSpace(pmesh, fecH1Vec,
-                                                                      dim, Ordering::byVDIM);
-      Array<int> H1Vec_essDof(H1VecFESpace->GetVSize()); H1Vec_essDof = 0;
-      H1VecFESpace->GetEssentialVDofs(essBnd, H1Vec_essDof);
-
-      //setup the discrete gradient
-      ParDiscreteLinearOperator *disInterpol = new ParDiscreteLinearOperator(
-         H1VecFESpace, fespace);
-      disInterpol->AddDomainInterpolator(new IdentityInterpolator);
-      disInterpol->Assemble();
-      disInterpol->Finalize();
-      SparseMatrix* smatID = &(disInterpol->SpMat());
-      smatID->EliminateCols(H1Vec_essDof);
-      for (int dof=0; dof<HCurl_essDof.Size(); dof++) if (HCurl_essDof[dof]<0) { smatID->EliminateRow(dof); }
-      idMat = disInterpol->ParallelAssemble();
-      delete disInterpol;
-
-      //setup the H1-vec preconditioner
-      ParBilinearForm* H1VecVarf = new ParBilinearForm(H1VecFESpace);
-      H1VecVarf->AddDomainIntegrator(new VectorDiffusionIntegrator);
-      H1VecVarf->AddDomainIntegrator(new VectorMassIntegrator);
-      H1VecVarf->Assemble();
-      H1VecVarf->Finalize();
-
-      SparseMatrix &matH1Vec(H1VecVarf->SpMat());
-      for (int dof=0; dof<H1Vec_essDof.Size(); dof++) if (H1Vec_essDof[dof]<0) { matH1Vec.EliminateRowCol(dof); }
-      H1VecLaplaceMat = H1VecVarf->ParallelAssemble();
-      delete H1VecVarf;
-      amgVecH1 = new HypreBoomerAMG(*H1VecLaplaceMat);
-      amgVecH1->SetSystemsOptions(dim);
-
-
-      f = new Vector(fespace->GetTrueVSize());
-
-      fGrad = new Vector(H1FESpace->GetTrueVSize());
-      uGrad = new Vector(H1FESpace->GetTrueVSize());
-
-      fH1Vec = new Vector(H1VecFESpace->GetTrueVSize());
-      uH1Vec = new Vector(H1VecFESpace->GetTrueVSize());;
-
-
-      amgH1->Mult(*fGrad, *uGrad);
-      amgVecH1->Mult(*fH1Vec, *uH1Vec);
-
-      pcgGrad = new CGSolver(MPI_COMM_WORLD);
-      pcgGrad->SetOperator(*H1LaplaceMat);
-      pcgGrad->SetPreconditioner(*amgH1);
-      pcgGrad->SetRelTol(1e-16);
-      pcgGrad->SetMaxIter(100000000);
-      pcgGrad->SetPrintLevel(-2);
-
-      pcgH1Vec = new CGSolver(MPI_COMM_WORLD);
-      pcgH1Vec->SetOperator(*H1VecLaplaceMat);
-      pcgH1Vec->SetPreconditioner(*amgVecH1);
-      pcgH1Vec->SetRelTol(1e-16);
-      pcgH1Vec->SetMaxIter(100000000);
-      pcgH1Vec->SetPrintLevel(-2);
-
-   }
-
-   void setExactSolve(bool exSol)
-   {
-      exactSolves = exSol;
-   }
-
-   virtual void Mult(const Vector &x, Vector &y) const
-   {
-      smoother->Mult(x,y);
-
-      idMat->MultTranspose(x,*fH1Vec);
-      *uH1Vec = 0.0;
-      if (exactSolves) { pcgH1Vec->Mult(*fH1Vec, *uH1Vec); }
-      else { amgVecH1->Mult(*fH1Vec, *uH1Vec); }
-      idMat->Mult(1.0, *uH1Vec, 1.0, y);
-
-      gradMat->MultTranspose(x,*fGrad);
-      *uGrad = 0.0;
-      if (exactSolves) { pcgGrad->Mult(*fGrad, *uGrad); }
-      else { amgH1->Mult(*fGrad, *uGrad); }
-      gradMat->Mult(1.0, *uGrad, 1.0, y);
-
-   }
-
-   virtual void SetOperator(const Operator &op) {};
-
-};
-
 int main(int argc, char *argv[])
 {
   // 1. Initialize MPI and HYPRE.
@@ -336,13 +162,7 @@ int main(int argc, char *argv[])

   // 7. Define a parallel finite element space on the parallel mesh. Here we
   //    use the Nedelec finite elements of the specified order.
-   FiniteElementCollection *fec;
-   if (dim==4)
-   {
-      if (order==1) { fec = new ND1_4DFECollection; }
-      else { fec = new ND2_4DFECollection; }
-   }
-   else { fec = new ND_FECollection(order, dim); }
+   FiniteElementCollection *fec = new ND_FECollection(order, dim);
   ParFiniteElementSpace *fespace = new ParFiniteElementSpace(pmesh, fec);
   HYPRE_BigInt size = fespace->GlobalTrueVSize();
   if (myid == 0)
@@ -428,29 +248,15 @@ int main(int argc, char *argv[])

      ParFiniteElementSpace *prec_fespace =
         (a->StaticCondensationIsEnabled() ? a->SCParFESpace() : fespace);
-      Solver *prec;
      HypreAMS ams(*A.As<HypreParMatrix>(), prec_fespace);
-      if (dim <= 3)
-      {
-         prec = new HypreAMS(*A.As<HypreParMatrix>(), prec_fespace);
-      }
-      else if (dim == 4)
-      {
-         prec = new Curl4dPrec(A.As<HypreParMatrix>(), fespace, ess_bdr, order, false);
-      }
-      IterativeSolver *pcg = new CGSolver(MPI_COMM_WORLD);
-      pcg->SetOperator(*A.As<HypreParMatrix>());
-      pcg->SetTol(1e-12);
-      pcg->SetMaxIter(500);
-      pcg->SetPrintLevel(2);
-      pcg->SetPreconditioner(*prec);
-      pcg->Mult(B, X);
-
-      delete pcg;
-      delete prec;
+      HyprePCG pcg(*A.As<HypreParMatrix>());
+      pcg.SetTol(1e-12);
+      pcg.SetMaxIter(500);
+      pcg.SetPrintLevel(2);
+      pcg.SetPreconditioner(ams);
+      pcg.Mult(B, X);
   }

-   // 13. Recover the parallel grid function corresponding to X. This is the
   // 14. Recover the parallel grid function corresponding to X. This is the
   //     local finite element solution on each processor.
   a->RecoverFEMSolution(X, *b, x);
@@ -506,14 +312,7 @@ int main(int argc, char *argv[])

 void E_exact(const Vector &x, Vector &E)
 {
-   if (dim==4)
-   {
-      E(0) =  sin(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*cos(M_PI*x(3));
-      E(1) = -cos(M_PI*x(0))*sin(M_PI*x(1))*cos(M_PI*x(2))*cos(M_PI*x(3));
-      E(2) =  cos(M_PI*x(0))*cos(M_PI*x(1))*sin(M_PI*x(2))*cos(M_PI*x(3));
-      E(3) = -cos(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*sin(M_PI*x(3));
-   }
-   else if (dim == 3)
+   if (dim == 3)
   {
      E(0) = sin(kappa * x(1));
      E(1) = sin(kappa * x(2));
@@ -529,19 +328,7 @@ void E_exact(const Vector &x, Vector &E)

 void f_exact(const Vector &x, Vector &f)
 {
-   //f_exact = E +  DivSkew P( curl E ), where P is the 4d permutation operator
-   if (dim==4)
-   {
-      f(0) =  (1.0+4.0*M_PI*M_PI)*sin(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*cos(
-                 M_PI*x(3));
-      f(1) = -(1.0+4.0*M_PI*M_PI)*cos(M_PI*x(0))*sin(M_PI*x(1))*cos(M_PI*x(2))*cos(
-                M_PI*x(3));
-      f(2) =  (1.0+4.0*M_PI*M_PI)*cos(M_PI*x(0))*cos(M_PI*x(1))*sin(M_PI*x(2))*cos(
-                 M_PI*x(3));
-      f(3) = -(1.0+4.0*M_PI*M_PI)*cos(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*sin(
-                M_PI*x(3));
-   }
-   else if (dim == 3)
+   if (dim == 3)
   {
      f(0) = (1. + kappa * kappa) * sin(kappa * x(1));
      f(1) = (1. + kappa * kappa) * sin(kappa * x(2));
@@ -1,650 +0,0 @@
-//                       MFEM Example 3 - Parallel Version
-//
-// Compile with: make ex3p
-//
-// Sample runs:  mpirun -np 4 ex3p -m ../data/star.mesh
-//               mpirun -np 4 ex3p -m ../data/square-disc.mesh -o 2
-//               mpirun -np 4 ex3p -m ../data/beam-tet.mesh
-//               mpirun -np 4 ex3p -m ../data/beam-hex.mesh
-//               mpirun -np 4 ex3p -m ../data/escher.mesh
-//               mpirun -np 4 ex3p -m ../data/fichera.mesh
-//               mpirun -np 4 ex3p -m ../data/fichera-q2.vtk
-//               mpirun -np 4 ex3p -m ../data/fichera-q3.mesh
-//               mpirun -np 4 ex3p -m ../data/square-disc-nurbs.mesh
-//               mpirun -np 4 ex3p -m ../data/beam-hex-nurbs.mesh
-//               mpirun -np 4 ex3p -m ../data/amr-quad.mesh -o 2
-//               mpirun -np 4 ex3p -m ../data/amr-hex.mesh
-//               mpirun -np 4 ex3p -m ../data/star-surf.mesh -o 2
-//               mpirun -np 4 ex3p -m ../data/mobius-strip.mesh -o 2 -f 0.1
-//               mpirun -np 4 ex3p -m ../data/klein-bottle.mesh -o 2 -f 0.1
-//
-// Description:  This example code solves a simple electromagnetic diffusion
-//               problem corresponding to the second order definite Maxwell
-//               equation curl curl E + E = f with boundary condition
-//               E x n = <given tangential field>. Here, we use a given exact
-//               solution E and compute the corresponding r.h.s. f.
-//               We discretize with Nedelec finite elements in 2D or 3D.
-//
-//               The example demonstrates the use of H(curl) finite element
-//               spaces with the curl-curl and the (vector finite element) mass
-//               bilinear form, as well as the computation of discretization
-//               error when the exact solution is known. Static condensation is
-//               also illustrated.
-//
-//               We recommend viewing examples 1-2 before viewing this example.
-
-#include "mfem.hpp"
-#include <fstream>
-#include <iostream>
-#include "./spe10_coeff.cpp"
-
-using namespace std;
-using namespace mfem;
-
-
-int* LoadIterations(int NRows, int NCol)
-{
-   ifstream in("iter_curl.txt");
-
-   //initialize
-   int *iters = new int[NCol*NRows];
-   for (int col = 0; col < NCol; col++)
-   {
-      for (int row = 0; row < NRows; row++)
-      {
-         iters[row*NCol+col] = -1;
-      }
-   }
-
-   if (!in)
-   {
-      cout << "Cannot open file.\n";
-      return iters;
-   }
-
-   for (int row = 0; row < NRows; row++)
-      for (int col = 0; col < NCol; col++)
-      {
-         if (in.eof())
-         {
-            in.close();
-            return iters;
-         }
-         in >> iters[row*NCol+col];
-      }
-
-
-   in.close();
-
-   return iters;
-}
-
-void putIterationsInArray(int iter, int row, int col, int NCol, int* iters)
-{
-   iters[row*NCol+col] = iter;
-}
-
-void WriteIterations(int *iters, int NRows, int NCol)
-{
-   ofstream out;
-   out.open("iter_curl.txt",fstream::out);
-
-   if (!out)
-   {
-      cout << "Cannot open file.\n";
-      delete[] iters;
-
-      return;
-   }
-
-   for (int row = 0; row < NRows; row++)
-   {
-      for (int col = 0; col < NCol; col++)
-      {
-         out << iters[row*NCol+col] << "\t";
-      }
-      out << endl;
-   }
-   out.close();
-
-   delete[] iters;
-}
-
-
-// Exact solution, E, and r.h.s., f. See below for implementation.
-void E_exact(const Vector &, Vector &);
-void f_exact(const Vector &, Vector &);
-double freq = 1.0, kappa = 1.0;
-int dim;
-
-double osziCoeff(const Vector &x)
-{
-   return 1.0001 + sin(100*x(0))*sin(200*x(1))*sin(300*x(2))*sin(400*x(3));
-}
-
-class Curl4dPrec : public Solver
-{
-
-private:
-   HypreParMatrix *A;
-   ParFiniteElementSpace *fespace;
-   Coefficient *alpha_, *beta_, *neg_beta_;
-
-   HypreParMatrix *idMat;
-   HypreParMatrix *H1VecLaplaceMat;
-   HypreBoomerAMG *amgVecH1;
-
-
-   HypreParMatrix *gradMat;
-   HypreParMatrix *H1LaplaceMat;
-   HypreBoomerAMG *amgH1;
-
-   HypreSmoother * smoother;
-   CGSolver *pcgGrad;
-   CGSolver *pcgH1Vec;
-
-   Vector *f;
-   Vector *fGrad, *uGrad;
-   Vector *fH1Vec, *uH1Vec;
-
-   bool exactSolves;
-
-public:
-   ~Curl4dPrec()
-   {
-      delete pcgH1Vec;
-      delete pcgGrad;
-
-      delete   f, fGrad, uGrad, fH1Vec, uH1Vec;
-
-      delete smoother;
-
-      delete amgVecH1, H1VecLaplaceMat;
-      delete idMat;
-      delete amgH1, H1LaplaceMat;
-      delete gradMat;
-   }
-
-   Curl4dPrec(HypreParMatrix *AUser, ParFiniteElementSpace *fespaceUser,
-              Coefficient *alpha, Coefficient *beta, Coefficient *neg_beta,
-              const Array<int> &essBnd, int orderKernel=1, bool exactSolvesUser=false)
-   {
-      A = AUser;
-      fespace = fespaceUser;
-      alpha_ = alpha;
-      beta_ = beta;
-      neg_beta_=neg_beta;
-
-      ParMesh *pmesh = fespace->GetParMesh();
-      int dim = pmesh->Dimension();
-
-      exactSolves = exactSolvesUser;
-
-      int orderIm=1;  //vecH1  --> H(curl)
-      int orderKer=orderKernel; //grad V --> H(curl)
-
-      smoother = new HypreSmoother(*A, 16, 3);
-
-      //    //for the pure dirichlet case
-      //    Array<int> essBnd(pmesh->bdr_attributes.Max()); essBnd = 1;
-
-      Array<int> HCurl_essDof(fespace->GetVSize()); HCurl_essDof = 0;
-      fespace->GetEssentialVDofs(essBnd, HCurl_essDof);
-
-      //setup the H1 FESpace
-      FiniteElementCollection* fecH1;
-      if (orderKer==1) { fecH1 = new LinearFECollection; }
-      else { fecH1 = new QuadraticFECollection; }
-
-      ParFiniteElementSpace *H1FESpace = new ParFiniteElementSpace(pmesh, fecH1);
-      Array<int> H1_essDof(H1FESpace->GetVSize()); H1_essDof = 0;
-      H1FESpace->GetEssentialVDofs(essBnd, H1_essDof);
-
-      //setup the discrete gradient
-      ParDiscreteLinearOperator *disGrad = new ParDiscreteLinearOperator(H1FESpace,
-                                                                         fespace);
-      disGrad->AddDomainInterpolator(new GradientInterpolator);
-      disGrad->Assemble();
-      disGrad->Finalize();
-      SparseMatrix* smat = &(disGrad->SpMat());
-      smat->EliminateCols(H1_essDof);
-      for (int dof=0; dof<HCurl_essDof.Size(); dof++) if (HCurl_essDof[dof]<0) { smat->EliminateRow(dof); }
-      gradMat = disGrad->ParallelAssemble();
-      delete disGrad;
-
-      //setup the H1 preconditioner
-      ParBilinearForm* H1Varf = new ParBilinearForm(H1FESpace);
-      H1Varf->AddDomainIntegrator(new DiffusionIntegrator(*beta_));
-      //    H1Varf->AddDomainIntegrator(new MassIntegrator);
-      H1Varf->Assemble();
-      H1Varf->Finalize();
-
-      SparseMatrix &matH1(H1Varf->SpMat());
-      for (int dof=0; dof<H1_essDof.Size(); dof++) if (H1_essDof[dof]<0) { matH1.EliminateRowCol(dof); }
-      H1LaplaceMat = H1Varf->ParallelAssemble();
-      delete H1Varf;
-      amgH1 = new HypreBoomerAMG(*H1LaplaceMat);
-
-
-      //setup the H1 injection
-      FiniteElementCollection* fecH1Vec;
-      if (orderIm==1) { fecH1Vec = new LinearFECollection; }
-      else { fecH1Vec = new QuadraticFECollection; }
-      ParFiniteElementSpace *H1VecFESpace = new ParFiniteElementSpace(pmesh, fecH1Vec,
-                                                                      dim, Ordering::byVDIM);
-      Array<int> H1Vec_essDof(H1VecFESpace->GetVSize()); H1Vec_essDof = 0;
-      H1VecFESpace->GetEssentialVDofs(essBnd, H1Vec_essDof);
-
-      //setup the discrete gradient
-      ParDiscreteLinearOperator *disInterpol = new ParDiscreteLinearOperator(
-         H1VecFESpace, fespace);
-      disInterpol->AddDomainInterpolator(new IdentityInterpolator);
-      disInterpol->Assemble();
-      disInterpol->Finalize();
-      SparseMatrix* smatID = &(disInterpol->SpMat());
-      smatID->EliminateCols(H1Vec_essDof);
-      for (int dof=0; dof<HCurl_essDof.Size(); dof++) if (HCurl_essDof[dof]<0) { smatID->EliminateRow(dof); }
-      idMat = disInterpol->ParallelAssemble();
-      delete disInterpol;
-
-      //setup the H1-vec preconditioner
-      ParBilinearForm* H1VecVarf = new ParBilinearForm(H1VecFESpace);
-      H1VecVarf->AddDomainIntegrator(new VectorDiffusionIntegrator(*alpha_));
-      H1VecVarf->AddDomainIntegrator(new VectorMassIntegrator(*neg_beta_));
-      H1VecVarf->Assemble();
-      H1VecVarf->Finalize();
-
-      SparseMatrix &matH1Vec(H1VecVarf->SpMat());
-      for (int dof=0; dof<H1Vec_essDof.Size(); dof++) if (H1Vec_essDof[dof]<0) { matH1Vec.EliminateRowCol(dof); }
-      H1VecLaplaceMat = H1VecVarf->ParallelAssemble();
-      delete H1VecVarf;
-      amgVecH1 = new HypreBoomerAMG(*H1VecLaplaceMat);
-      amgVecH1->SetSystemsOptions(dim);
-
-
-      f = new Vector(fespace->GetTrueVSize());
-
-      fGrad = new Vector(H1FESpace->GetTrueVSize());
-      uGrad = new Vector(H1FESpace->GetTrueVSize());
-
-      fH1Vec = new Vector(H1VecFESpace->GetTrueVSize());
-      uH1Vec = new Vector(H1VecFESpace->GetTrueVSize());
-
-
-      amgH1->Mult(*fGrad, *uGrad);
-      amgVecH1->Mult(*fH1Vec, *uH1Vec);
-
-      pcgGrad = new CGSolver(MPI_COMM_WORLD);
-      pcgGrad->SetOperator(*H1LaplaceMat);
-      pcgGrad->SetPreconditioner(*amgH1);
-      pcgGrad->SetRelTol(1e-16);
-      pcgGrad->SetMaxIter(100000000);
-      pcgGrad->SetPrintLevel(-2);
-
-      pcgH1Vec = new CGSolver(MPI_COMM_WORLD);
-      pcgH1Vec->SetOperator(*H1VecLaplaceMat);
-      pcgH1Vec->SetPreconditioner(*amgVecH1);
-      pcgH1Vec->SetRelTol(1e-16);
-      pcgH1Vec->SetMaxIter(100000000);
-      pcgH1Vec->SetPrintLevel(-2);
-
-      delete H1FESpace; delete fecH1;
-      delete H1VecFESpace; delete fecH1Vec;
-
-   }
-
-   void setExactSolve(bool exSol)
-   {
-      exactSolves = exSol;
-   }
-
-   virtual void Mult(const Vector &x, Vector &y) const
-   {
-      smoother->Mult(x,y);
-
-      idMat->MultTranspose(x,*fH1Vec);
-      *uH1Vec = 0.0;
-      if (exactSolves) { pcgH1Vec->Mult(*fH1Vec, *uH1Vec); }
-      else { amgVecH1->Mult(*fH1Vec, *uH1Vec); }
-      idMat->Mult(1.0, *uH1Vec, 1.0, y);
-
-      gradMat->MultTranspose(x,*fGrad);
-      *uGrad = 0.0;
-      if (exactSolves) { pcgGrad->Mult(*fGrad, *uGrad); }
-      else { amgH1->Mult(*fGrad, *uGrad); }
-      gradMat->Mult(1.0, *uGrad, 1.0, y);
-
-   }
-
-   virtual void SetOperator(const Operator &op) {};
-
-};
-
-int main(int argc, char *argv[])
-{
-   // 1. Initialize MPI.
-   int num_procs, myid;
-   MPI_Init(&argc, &argv);
-   MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
-   MPI_Comm_rank(MPI_COMM_WORLD, &myid);
-
-   bool verbose = (myid==0);
-
-   // 2. Parse command-line options.
-   const char *mesh_file = "../data/cube4d_96.MFEM";
-   int order = 1;
-   bool set_bc = true;
-   bool static_cond = false;
-   bool visualization = 1;
-   int sequ_ref_levels = 0;
-   int par_ref_levels = 0;
-   double tol = 1e-6;
-   double coeffWeight = 1.0;
-   bool exactH1Solver = false;
-   bool spe10Coeff = false;
-   bool standardCG = true;
-
-   int NExpo = 8;
-   int weightStart = -NExpo;
-   int weightEnd = NExpo;
-
-   OptionsParser args(argc, argv);
-   args.AddOption(&mesh_file, "-m", "--mesh",
-                  "Mesh file to use.");
-   args.AddOption(&sequ_ref_levels, "-sr", "--seqrefinement",
-                  "Number of sequential refinement steps.");
-   args.AddOption(&par_ref_levels, "-pr", "--parrefinement",
-                  "Number of parallel refinement steps.");
-   args.AddOption(&order, "-o", "--order",
-                  "Polynomial order of the finite element space.");
-   args.AddOption(&set_bc, "-bc", "--impose-bc", "-no-bc", "--dont-impose-bc",
-                  "Impose or not essential boundary conditions.");
-   args.AddOption(&tol, "-tol", "--tol",
-                  "A parameter.");
-   args.AddOption(&freq, "-f", "--frequency", "Set the frequency for the exact"
-                  " solution.");
-   args.AddOption(&coeffWeight, "-c", "--coeffMass",
-                  "the weight for the mass term.");
-   args.AddOption(&exactH1Solver, "-exH1Sol", "--exactH1Solver", "-H1prec",
-                  "--H1preconditioner",
-                  "Use exact H1 solvers for the preconditioner.");
-   args.AddOption(&spe10Coeff, "-spe10", "--useSPE10Coeff", "-constCoeff",
-                  "--constCoeff",
-                  "Switch between the coefficients for the mass bilinear form.");
-   args.AddOption(&standardCG, "-sCG", "--stdCG", "-rCG", "--resCG",
-                  "Switch between standard PCG or recompute residuals in every step and use the residuals itself for the stopping criteria.");
-   args.AddOption(&weightStart, "-ws", "--weightStart",
-                  "the exponent for the starting weight (for the mass term).");
-   args.AddOption(&weightEnd, "-we", "--weightEnd",
-                  "the exponent for the weight at the end (for the mass term).");
-
-   args.Parse();
-   if (!args.Good())
-   {
-      args.PrintUsage(cout);
-      return 1;
-   }
-   if (verbose) { args.PrintOptions(cout); }
-
-   kappa = freq * M_PI;
-
-   Mesh *mesh;
-   ifstream imesh(mesh_file);
-   if (!imesh)
-   {
-      cerr << "\nCan not open mesh file: " << mesh_file << '\n' << endl;
-      return 2;
-   }
-
-   mesh = new Mesh(imesh, 1, 1);
-   imesh.close();
-
-   dim = mesh->Dimension();
-   int sdim = mesh->SpaceDimension();
-
-
-   if (dim !=4 || sdim != 4)
-   {
-      MPI_Finalize();
-      return 0;
-   }
-
-   for (int i=0; i<sequ_ref_levels; i++) { mesh->UniformRefinement(); }
-   if (verbose) { mesh->PrintCharacteristics(); }
-
-   if (verbose) { cout << "now we partition the mesh..." << endl << endl; }
-
-   ParMesh *pmesh = new ParMesh(MPI_COMM_WORLD, *mesh);
-   delete mesh;
-
-   for (int i=0; i<par_ref_levels; i++) { pmesh->UniformRefinement(); }
-
-   pmesh->ReorientTetMesh();
-
-   pmesh->PrintInfo(std::cout);
-   if (verbose) { cout << endl; }
-
-   // 6. Define a parallel finite element space on the parallel mesh. Here we
-   //    use the Nedelec finite elements of the specified order.
-   FiniteElementCollection *fec;
-   if (dim==4)
-   {
-      if (order==1) { fec = new ND1_4DFECollection; }
-      else { fec = new ND2_4DFECollection; }
-   }
-   else { fec = new ND_FECollection(order, dim); }
-   ParFiniteElementSpace *fespace = new ParFiniteElementSpace(pmesh, fec);
-   HYPRE_Int size = fespace->GlobalTrueVSize();
-   if (myid == 0)
-   {
-      cout << "Number of finite element unknowns: " << size << endl;
-   }
-
-   // 7. Determine the list of true (i.e. parallel conforming) essential
-   //    boundary dofs. In this example, the boundary conditions are defined
-   //    by marking all the boundary attributes from the mesh as essential
-   //    (Dirichlet) and converting them to a list of true dofs.
-   Array<int> ess_tdof_list;
-   Array<int> ess_bdr(pmesh->bdr_attributes.Max());
-   ess_bdr = set_bc ? 1 : 0;
-   if (pmesh->bdr_attributes.Size())
-   {
-      fespace->GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
-   }
-
-   // 8. Set up the parallel linear form b(.) which corresponds to the
-   //    right-hand side of the FEM linear system, which in this case is
-   //    (f,phi_i) where f is given by the function f_exact and phi_i are the
-   //    basis functions in the finite element fespace.
-
-
-   // 9. Define the solution vector x as a parallel finite element grid function
-   //    corresponding to fespace. Initialize x by projecting the exact
-   //    solution. Note that only values from the boundary edges will be used
-   //    when eliminating the non-homogeneous boundary condition to modify the
-   //    r.h.s. vector b.
-   ParGridFunction x(fespace);
-   VectorFunctionCoefficient E(sdim, E_exact);
-
-   for (int expo=weightStart; expo<=weightEnd; expo++)
-   {
-      double weight = pow(10.0,expo);
-      kappa = weight;
-
-      VectorFunctionCoefficient f(sdim, f_exact);
-      ParLinearForm *b = new ParLinearForm(fespace);
-      b->AddDomainIntegrator(new VectorFEDomainLFIntegrator(f));
-      b->Assemble();
-
-      x.ProjectCoefficient(E);
-
-      // 10. Set up the parallel bilinear form corresponding to the EM diffusion
-      //     operator curl muinv curl + sigma I, by adding the curl-curl and the
-      //     mass domain integrators.
-      //    std::string permFile = "spe_perm.dat";
-      //    InversePermeabilityFunction::ReadPermeabilityFile(permFile, MPI_COMM_WORLD);
-
-      Coefficient *alpha = new ConstantCoefficient(1.0);
-      Coefficient *beta;
-      //    if(spe10Coeff) beta = new FunctionCoefficient(InversePermeabilityFunction::Norm2Permeability);
-      //    else
-      beta = new ConstantCoefficient(weight);
-      Coefficient *neg_beta = new ConstantCoefficient(-weight);
-
-      ParBilinearForm *a = new ParBilinearForm(fespace);
-      a->AddDomainIntegrator(new CurlCurlIntegrator(*alpha));
-      a->AddDomainIntegrator(new VectorFEMassIntegrator(*beta));
-
-      // 11. Assemble the parallel bilinear form and the corresponding linear
-      //     system, applying any necessary transformations such as: parallel
-      //     assembly, eliminating boundary conditions, applying conforming
-      //     constraints for non-conforming AMR, static condensation, etc.
-      if (static_cond) { a->EnableStaticCondensation(); }
-      a->Assemble();
-
-      HypreParMatrix A;
-      Vector B, X;
-      a->FormLinearSystem(ess_tdof_list, x, *b, A, X, B);
-
-      if (myid == 0)
-      {
-         cout << "Size of linear system: " << A.GetGlobalNumRows() << endl;
-      }
-
-      // 12. Define and apply a parallel PCG solver for AX=B with the AMS
-      //     preconditioner from hypre.
-      ParFiniteElementSpace *prec_fespace =
-         (a->StaticCondensationIsEnabled() ? a->SCParFESpace() : fespace);
-      Solver *prec;
-      if (dim<=3) { prec = new HypreAMS(A, prec_fespace); }
-      else if (dim==4) { prec = new Curl4dPrec(&A, fespace, alpha, beta, neg_beta, ess_bdr, order, false); }
-      IterativeSolver *pcg = new CGSolver(MPI_COMM_WORLD);
-      pcg->SetOperator(A);
-      pcg->SetRelTol(tol);
-      pcg->SetMaxIter(5000);
-      pcg->SetPrintLevel(1);
-      pcg->SetPreconditioner(*prec);
-      pcg->Mult(B, X);
-
-      int iter = pcg->GetNumIterations();
-      if (myid==0)
-      {
-         cout << "Weigth: " << weight << " " << iter << endl;
-
-         int *iters = LoadIterations(10, 2*NExpo+1);
-         putIterationsInArray(iter, sequ_ref_levels+par_ref_levels, expo+NExpo,
-                              2*NExpo+1, iters);
-         WriteIterations(iters, 10, 2*NExpo+1);
-      }
-
-      // 13. Recover the parallel grid function corresponding to X. This is the
-      //     local finite element solution on each processor.
-      a->RecoverFEMSolution(X, *b, x);
-
-      // 14. Compute and print the L^2 norm of the error.
-      {
-         double err = x.ComputeL2Error(E);
-         if (myid == 0)
-         {
-            cout << "\n|| E_h - E ||_{L^2} = " << err << '\n' << endl;
-         }
-      }
-
-      // 15. Save the refined mesh and the solution in parallel. This output can
-      //     be viewed later using GLVis: "glvis -np <np> -m mesh -g sol".
-      //   {
-      //      ostringstream mesh_name, sol_name;
-      //      mesh_name << "mesh." << setfill('0') << setw(6) << myid;
-      //      sol_name << "sol." << setfill('0') << setw(6) << myid;
-      //
-      //      ofstream mesh_ofs(mesh_name.str().c_str());
-      //      mesh_ofs.precision(8);
-      //      pmesh->Print(mesh_ofs);
-      //
-      //      ofstream sol_ofs(sol_name.str().c_str());
-      //      sol_ofs.precision(8);
-      //      x.Save(sol_ofs);
-      //   }
-
-      //   // 16. Send the solution by socket to a GLVis server.
-      //   if (visualization)
-      //   {
-      //      char vishost[] = "localhost";
-      //      int  visport   = 19916;
-      //      socketstream sol_sock(vishost, visport);
-      //      sol_sock << "parallel " << num_procs << " " << myid << "\n";
-      //      sol_sock.precision(8);
-      //      sol_sock << "solution\n" << *pmesh << x << flush;
-      //   }
-
-      delete pcg;
-      delete prec;
-      delete a;
-      delete alpha;
-      delete beta;
-      delete b;
-
-   }
-
-   // 17. Free the used memory.
-
-   delete fespace;
-   delete fec;
-   delete pmesh;
-
-   MPI_Finalize();
-
-   return 0;
-}
-
-
-void E_exact(const Vector &x, Vector &E)
-{
-   if (dim==4)
-   {
-      E(0) =  sin(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*cos(M_PI*x(3));
-      E(1) = -cos(M_PI*x(0))*sin(M_PI*x(1))*cos(M_PI*x(2))*cos(M_PI*x(3));
-      E(2) =  cos(M_PI*x(0))*cos(M_PI*x(1))*sin(M_PI*x(2))*cos(M_PI*x(3));
-      E(3) = -cos(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*sin(M_PI*x(3));
-   }
-   else if (dim == 3)
-   {
-      E(0) = sin(kappa * x(1));
-      E(1) = sin(kappa * x(2));
-      E(2) = sin(kappa * x(0));
-   }
-   else
-   {
-      E(0) = sin(kappa * x(1));
-      E(1) = sin(kappa * x(0));
-      if (x.Size() == 3) { E(2) = 0.0; }
-   }
-}
-
-void f_exact(const Vector &x, Vector &f)
-{
-   //f_exact = E +  DivSkew P( curl E ), where P is the 4d permutation operator
-   if (dim==4)
-   {
-      f(0) =  (kappa+4.0*M_PI*M_PI)*sin(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*cos(
-                 M_PI*x(3));
-      f(1) = -(kappa+4.0*M_PI*M_PI)*cos(M_PI*x(0))*sin(M_PI*x(1))*cos(M_PI*x(2))*cos(
-                M_PI*x(3));
-      f(2) =  (kappa+4.0*M_PI*M_PI)*cos(M_PI*x(0))*cos(M_PI*x(1))*sin(M_PI*x(2))*cos(
-                 M_PI*x(3));
-      f(3) = -(kappa+4.0*M_PI*M_PI)*cos(M_PI*x(0))*cos(M_PI*x(1))*cos(M_PI*x(2))*sin(
-                M_PI*x(3));
-   }
-   else if (dim == 3)
-   {
-      f(0) = (1. + kappa * kappa) * sin(kappa * x(1));
-      f(1) = (1. + kappa * kappa) * sin(kappa * x(2));
-      f(2) = (1. + kappa * kappa) * sin(kappa * x(0));
-   }
-   else
-   {
-      f(0) = (1. + kappa * kappa) * sin(kappa * x(1));
-      f(1) = (1. + kappa * kappa) * sin(kappa * x(0));
-      if (x.Size() == 3) { f(2) = 0.0; }
-   }
-}
@@ -1,374 +0,0 @@
-//                                MFEM Example 40
-//
-// Compile with: make ex40
-//
-// Sample runs: ex40 -step 10 -gr 2.0
-//              ex40 -step 10 -gr 2.0 -o 3 -r 1
-//              ex40 -step 10 -gr 2.0 -r 4 -m ../data/l-shape.mesh
-//              ex40 -step 10 -gr 2.0 -r 2 -m ../data/fichera.mesh
-//
-// Description: This example code demonstrates how to use MFEM to solve the
-//              eikonal equation,
-//
-//                      |∇𝑢| = 1 in Ω,  𝑢 = g on ∂Ω.
-//
-//              The solution of this problem coincides with the unique optimum of
-//              the nonlinear program
-//
-//                   maximize ∫_Ω 𝑢 d𝑥 subject to |∇𝑢| ≤ 1,   𝑢 = g on Ω,      (⋆)
-//
-//              which is the foundation for method implemented below.
-//
-//              Following the proximal Galerkin methodology [1] (see also Example
-//              36), we construct a Legendre function for the unit ball
-//              𝐵₁ := {𝑥 ∈ Rⁿ | |𝑥| < 1}. Our choice is the Hellinger entropy,
-//
-//                    h(𝑥) = −( 1 − |𝑥|² )^{1/2},
-//
-//              although other choices are possible, each leading to a slightly
-//              different algorithm. We then adaptively regularize the optimization
-//              problem (⋆) with the Bregman divergence of the Hellinger entropy,
-//
-//                 maximize  ∫_Ω 𝑢 d𝑥 - αₖ⁻¹ Dₕ(∇𝑢,∇𝑢ₖ₋₁)  subject to  𝑢 = g on Ω.
-//
-//              This results in a sequence of functions ( 𝜓ₖ , 𝑢ₖ ),
-//
-//                      𝑢ₖ → 𝑢,    𝜓ₖ/|𝜓ₖ| → ∇𝑢    as k → \infty,
-//
-//              defined by the nonlinear saddle-point problems
-//
-//               Find 𝜓ₖ ∈ H(div,Ω) and 𝑢ₖ ∈ L²(Ω) such that
-//               ( Zₖ(𝜓ₖ) , τ ) + ( 𝑢ₖ , ∇⋅τ ) = ⟨ g , τ⋅n ⟩         ∀ τ ∈ H(div,Ω)
-//               ( ∇⋅𝜓ₖ , v )                 = ( ∇⋅𝜓ₖ₋₁ - 1 , v )   ∀ v ∈ L²(Ω)
-//
-//              where Zₖ(𝜓) := ∇h⁻¹(αₖ 𝜓) = 𝜓 / ( αₖ⁻² + |𝜓|² )^{1/2} and step size
-//              αₖ > 0. These saddle-point problems are solved using a damped Newton's
-//              method. This example assumes that g = 0 and allows the step size to
-//              grow geometrically, αₖ = α₀rᵏ, where r ≥ 1 is the growth rate.
-//
-//              [1] Keith, B. and Surowiec, T. (2023) Proximal Galerkin: A structure-
-//                  preserving finite element method for pointwise bound constraints.
-//                  arXiv:2307.12444 [math.NA]
-
-#include "mfem.hpp"
-#include <fstream>
-#include <iostream>
-
-using namespace std;
-using namespace mfem;
-
-class ZCoefficient : public VectorCoefficient
-{
-protected:
-   GridFunction *psi;
-   real_t alpha;
-
-public:
-   ZCoefficient(int vdim, GridFunction &psi_, real_t alpha_ = 1.0)
-      : VectorCoefficient(vdim), psi(&psi_), alpha(alpha_) { }
-
-   virtual void Eval(Vector &V, ElementTransformation &T,
-                     const IntegrationPoint &ip);
-   void SetAlpha(real_t alpha_) { alpha = alpha_; }
-};
-
-class DZCoefficient : public MatrixCoefficient
-{
-protected:
-   GridFunction *psi;
-   real_t alpha;
-
-public:
-   DZCoefficient(int height, GridFunction &psi_, real_t alpha_ = 1.0)
-      : MatrixCoefficient(height),  psi(&psi_), alpha(alpha_) { }
-
-   virtual void Eval(DenseMatrix &K, ElementTransformation &T,
-                     const IntegrationPoint &ip);
-   void SetAlpha(real_t alpha_) { alpha = alpha_; }
-};
-
-int main(int argc, char *argv[])
-{
-   // 1. Parse command-line options.
-   const char *mesh_file = "../data/star.mesh";
-   int order = 1;
-   int max_it = 5;
-   int ref_levels = 3;
-   real_t alpha = 1.0;
-   real_t growth_rate = 1.0;
-   real_t newton_scaling = 0.9;
-   real_t tichonov = 1e-1;
-   real_t tol = 1e-4;
-   bool visualization = true;
-
-   OptionsParser args(argc, argv);
-   args.AddOption(&mesh_file, "-m", "--mesh",
-                  "Mesh file to use.");
-   args.AddOption(&order, "-o", "--order",
-                  "Finite element order (polynomial degree).");
-   args.AddOption(&ref_levels, "-r", "--refs",
-                  "Number of h-refinements.");
-   args.AddOption(&max_it, "-mi", "--max-it",
-                  "Maximum number of iterations");
-   args.AddOption(&tol, "-tol", "--tol",
-                  "Stopping criteria based on the difference between"
-                  "successive solution updates");
-   args.AddOption(&alpha, "-step", "--step",
-                  "Initial size alpha");
-   args.AddOption(&growth_rate, "-gr", "--growth-rate",
-                  "Growth rate of the step size alpha");
-   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
-                  "--no-visualization",
-                  "Enable or disable GLVis visualization.");
-   args.Parse();
-   if (!args.Good())
-   {
-      args.PrintUsage(cout);
-      return 1;
-   }
-   args.PrintOptions(cout);
-
-   // 2. Read the mesh from the mesh file.
-   Mesh mesh(mesh_file, 1, 1);
-   int dim = mesh.Dimension();
-   int sdim = mesh.SpaceDimension();
-
-   MFEM_ASSERT(mesh.bdr_attributes.Size(),
-               "This example does not currently support meshes"
-               " without boundary attributes."
-              )
-
-   // 3. Postprocess the mesh.
-   // 3A. Refine the mesh to increase the resolution.
-   for (int l = 0; l < ref_levels; l++)
-   {
-      mesh.UniformRefinement();
-   }
-
-   // 3B. Interpolate the geometry after refinement to control geometry error.
-   // NOTE: Minimum second-order interpolation is used to improve the accuracy.
-   int curvature_order = max(order,2);
-   mesh.SetCurvature(curvature_order);
-
-   // 4. Define the necessary finite element spaces on the mesh.
-   RT_FECollection RTfec(order, dim);
-   FiniteElementSpace RTfes(&mesh, &RTfec);
-
-   L2_FECollection L2fec(order, dim);
-   FiniteElementSpace L2fes(&mesh, &L2fec);
-
-   cout << "Number of H(div) dofs: "
-        << RTfes.GetTrueVSize() << endl;
-   cout << "Number of L² dofs: "
-        << L2fes.GetTrueVSize() << endl;
-
-   // 5. Define the offsets for the block matrices
-   Array<int> offsets(3);
-   offsets[0] = 0;
-   offsets[1] = RTfes.GetVSize();
-   offsets[2] = L2fes.GetVSize();
-   offsets.PartialSum();
-
-   BlockVector x(offsets), rhs(offsets);
-   x = 0.0; rhs = 0.0;
-
-   // 6. Define the solution vectors as a finite element grid functions
-   //    corresponding to the fespaces.
-   GridFunction u_gf, delta_psi_gf;
-   delta_psi_gf.MakeRef(&RTfes,x,offsets[0]);
-   u_gf.MakeRef(&L2fes,x,offsets[1]);
-
-   GridFunction psi_old_gf(&RTfes);
-   GridFunction psi_gf(&RTfes);
-   GridFunction u_old_gf(&L2fes);
-
-   // 7. Define initial guesses for the solution variables.
-   delta_psi_gf = 0.0;
-   psi_gf = 0.0;
-   u_gf = 0.0;
-   psi_old_gf = psi_gf;
-   u_old_gf = u_gf;
-
-   // 8. Prepare for glvis output.
-   char vishost[] = "localhost";
-   int  visport   = 19916;
-   socketstream sol_sock;
-   if (visualization)
-   {
-      sol_sock.open(vishost,visport);
-      sol_sock.precision(8);
-   }
-
-   // 9. Coefficients to be used later.
-   ConstantCoefficient neg_one(-1.0);
-   ConstantCoefficient zero(0.0);
-   ConstantCoefficient tichonov_cf(tichonov);
-   ConstantCoefficient neg_tichonov_cf(-1.0*tichonov);
-   ZCoefficient Z(sdim, psi_gf, alpha);
-   DZCoefficient DZ(sdim, psi_gf, alpha);
-   ScalarVectorProductCoefficient neg_Z(-1.0, Z);
-   DivergenceGridFunctionCoefficient div_psi_cf(&psi_gf);
-   DivergenceGridFunctionCoefficient div_psi_old_cf(&psi_old_gf);
-   SumCoefficient psi_old_minus_psi(div_psi_old_cf, div_psi_cf, 1.0, -1.0);
-
-   // 10. Assemble constant matrices/vectors to avoid reassembly in the loop.
-   LinearForm b0, b1;
-   b0.MakeRef(&RTfes,rhs.GetBlock(0),0);
-   b1.MakeRef(&L2fes,rhs.GetBlock(1),0);
-
-   b0.AddDomainIntegrator(new VectorFEDomainLFIntegrator(neg_Z));
-   b1.AddDomainIntegrator(new DomainLFIntegrator(neg_one));
-   b1.AddDomainIntegrator(new DomainLFIntegrator(psi_old_minus_psi));
-
-   BilinearForm a00(&RTfes);
-   a00.AddDomainIntegrator(new VectorFEMassIntegrator(DZ));
-   a00.AddDomainIntegrator(new VectorFEMassIntegrator(tichonov_cf));
-
-   MixedBilinearForm a10(&RTfes,&L2fes);
-   a10.AddDomainIntegrator(new VectorFEDivergenceIntegrator());
-   a10.Assemble();
-   a10.Finalize();
-   SparseMatrix &A10 = a10.SpMat();
-   SparseMatrix *A01 = Transpose(A10);
-
-   BilinearForm a11(&L2fes);
-   a11.AddDomainIntegrator(new MassIntegrator(neg_tichonov_cf));
-   a11.Assemble();
-   a11.Finalize();
-   SparseMatrix &A11 = a11.SpMat();
-
-   // 11. Iterate.
-   int k;
-   int total_iterations = 0;
-   real_t increment_u = 0.1;
-   GridFunction u_tmp(&L2fes);
-   for (k = 0; k < max_it; k++)
-   {
-      u_tmp = u_old_gf;
-      Z.SetAlpha(alpha);
-      DZ.SetAlpha(alpha);
-
-      mfem::out << "\nOUTER ITERATION " << k+1 << endl;
-
-      int j;
-      for ( j = 0; j < 5; j++)
-      {
-         total_iterations++;
-
-         b0.Assemble();
-         b1.Assemble();
-
-         a00.Assemble(false);
-         a00.Finalize(false);
-         SparseMatrix &A00 = a00.SpMat();
-
-         // Construct Schur-complement preconditioner
-         Vector A00_diag(a00.Height());
-         A00.GetDiag(A00_diag);
-         A00_diag.Reciprocal();
-         SparseMatrix *S = Mult_AtDA(*A01, A00_diag);
-
-         BlockDiagonalPreconditioner prec(offsets);
-         prec.SetDiagonalBlock(0,new DSmoother(A00));
-#ifndef MFEM_USE_SUITESPARSE
-         prec.SetDiagonalBlock(1,new GSSmoother(*S));
-#else
-         prec.SetDiagonalBlock(1,new UMFPackSolver(*S));
-#endif
-         prec.owns_blocks = 1;
-
-         BlockOperator A(offsets);
-         A.SetBlock(0,0,&A00);
-         A.SetBlock(1,0,&A10);
-         A.SetBlock(0,1,A01);
-         A.SetBlock(1,1,&A11);
-
-         GMRES(A,prec,rhs,x,0,2000,500,1e-12,0.0);
-         delete S;
-
-         u_tmp -= u_gf;
-         real_t Newton_update_size = u_tmp.ComputeL2Error(zero);
-         u_tmp = u_gf;
-
-         // Damped Newton update
-         psi_gf.Add(newton_scaling, delta_psi_gf);
-         a00.Update();
-
-         if (visualization)
-         {
-            sol_sock << "solution\n" << mesh << u_gf << "window_title 'Discrete solution'"
-                     << flush;
-         }
-
-         mfem::out << "Newton_update_size = " << Newton_update_size << endl;
-
-         if (Newton_update_size < increment_u)
-         {
-            break;
-         }
-      }
-
-      u_tmp = u_gf;
-      u_tmp -= u_old_gf;
-      increment_u = u_tmp.ComputeL2Error(zero);
-
-      mfem::out << "Number of Newton iterations = " << j+1 << endl;
-      mfem::out << "Increment (|| uₕ - uₕ_prvs||) = " << increment_u << endl;
-
-      u_old_gf = u_gf;
-      psi_old_gf = psi_gf;
-
-      if (increment_u < tol || k == max_it-1)
-      {
-         break;
-      }
-
-      alpha *= max(growth_rate, 1_r);
-
-   }
-
-   mfem::out << "\n Outer iterations: " << k+1
-             << "\n Total iterations: " << total_iterations
-             << "\n Total dofs:       " << RTfes.GetTrueVSize() + L2fes.GetTrueVSize()
-             << endl;
-
-   delete A01;
-   return 0;
-}
-
-void ZCoefficient::Eval(Vector &V, ElementTransformation &T,
-                        const IntegrationPoint &ip)
-{
-   MFEM_ASSERT(psi != NULL, "grid function is not set");
-   MFEM_ASSERT(alpha > 0, "alpha is not positive");
-
-   Vector psi_vals(vdim);
-   psi->GetVectorValue(T, ip, psi_vals);
-   real_t norm = psi_vals.Norml2();
-   real_t phi = 1.0 / sqrt(1.0/(alpha*alpha) + norm*norm);
-
-   V = psi_vals;
-   V *= phi;
-}
-
-void DZCoefficient::Eval(DenseMatrix &K, ElementTransformation &T,
-                         const IntegrationPoint &ip)
-{
-   MFEM_ASSERT(psi != NULL, "grid function is not set");
-   MFEM_ASSERT(alpha > 0, "alpha is not positive");
-
-   Vector psi_vals(height);
-   psi->GetVectorValue(T, ip, psi_vals);
-   real_t norm = psi_vals.Norml2();
-   real_t phi = 1.0 / sqrt(1.0/(alpha*alpha) + norm*norm);
-
-   K = 0.0;
-   for (int i = 0; i < height; i++)
-   {
-      K(i,i) = phi;
-      for (int j = 0; j < height; j++)
-      {
-         K(i,j) -= psi_vals(i) * psi_vals(j) * pow(phi, 3);
-      }
-   }
-}
@@ -1,436 +0,0 @@
-//                       MFEM Example 40 - Parallel Version
-//
-// Compile with: make ex40p
-//
-// Sample runs: mpirun -np 4 ex40p -step 10 -gr 2.0
-//              mpirun -np 4 ex40p -step 10 -gr 2.0 -o 3 -r 1
-//              mpirun -np 4 ex40p -step 10 -gr 2.0 -r 4 -m ../data/l-shape.mesh
-//              mpirun -np 4 ex40p -step 10 -gr 2.0 -r 2 -m ../data/fichera.mesh
-//
-// Description: This example code demonstrates how to use MFEM to solve the
-//              eikonal equation,
-//
-//                      |∇𝑢| = 1 in Ω,  𝑢 = g on ∂Ω.
-//
-//              The solution of this problem coincides with the unique optimum of
-//              the nonlinear program
-//
-//                   maximize ∫_Ω 𝑢 d𝑥 subject to |∇𝑢| ≤ 1,   𝑢 = g on Ω,      (⋆)
-//
-//              which is the foundation for method implemented below.
-//
-//              Following the proximal Galerkin methodology [1] (see also Example
-//              36), we construct a Legendre function for the unit ball
-//              𝐵₁ := {𝑥 ∈ Rⁿ | |𝑥| < 1}. Our choice is the Hellinger entropy,
-//
-//                    h(𝑥) = −( 1 − |𝑥|² )^{1/2},
-//
-//              although other choices are possible, each leading to a slightly
-//              different algorithm. We then adaptively regularize the optimization
-//              problem (⋆) with the Bregman divergence of the Hellinger entropy,
-//
-//                 maximize  ∫_Ω 𝑢 d𝑥 - αₖ⁻¹ Dₕ(∇𝑢,∇𝑢ₖ₋₁)  subject to  𝑢 = g on Ω.
-//
-//              This results in a sequence of functions ( 𝜓ₖ , 𝑢ₖ ),
-//
-//                      𝑢ₖ → 𝑢,    𝜓ₖ/|𝜓ₖ| → ∇𝑢    as k → \infty,
-//
-//              defined by the nonlinear saddle-point problems
-//
-//               Find 𝜓ₖ ∈ H(div,Ω) and 𝑢ₖ ∈ L²(Ω) such that
-//               ( Zₖ(𝜓ₖ) , τ ) + ( 𝑢ₖ , ∇⋅τ ) = ⟨ g , τ⋅n ⟩         ∀ τ ∈ H(div,Ω)
-//               ( ∇⋅𝜓ₖ , v )                 = ( ∇⋅𝜓ₖ₋₁ - 1 , v )   ∀ v ∈ L²(Ω)
-//
-//              where Zₖ(𝜓) := ∇h⁻¹(αₖ 𝜓) = 𝜓 / ( αₖ⁻² + |𝜓|² )^{1/2} and step size
-//              αₖ > 0. These saddle-point problems are solved using a damped Newton's
-//              method. This example assumes that g = 0 and allows the step size to
-//              grow geometrically, αₖ = α₀rᵏ, where r ≥ 1 is the growth rate.
-//
-//              [1] Keith, B. and Surowiec, T. (2023) Proximal Galerkin: A structure-
-//                  preserving finite element method for pointwise bound constraints.
-//                  arXiv:2307.12444 [math.NA]
-
-#include "mfem.hpp"
-#include <fstream>
-#include <iostream>
-
-using namespace std;
-using namespace mfem;
-
-class ZCoefficient : public VectorCoefficient
-{
-protected:
-   ParGridFunction *psi;
-   real_t alpha;
-
-public:
-   ZCoefficient(int vdim, ParGridFunction &psi_, real_t alpha_ = 1.0)
-      : VectorCoefficient(vdim), psi(&psi_), alpha(alpha_) { }
-
-   virtual void Eval(Vector &V, ElementTransformation &T,
-                     const IntegrationPoint &ip);
-   void SetAlpha(real_t alpha_) { alpha = alpha_; }
-};
-
-class DZCoefficient : public MatrixCoefficient
-{
-protected:
-   ParGridFunction *psi;
-   real_t alpha;
-
-public:
-   DZCoefficient(int height, ParGridFunction &psi_, real_t alpha_ = 1.0)
-      : MatrixCoefficient(height),  psi(&psi_), alpha(alpha_) { }
-
-   virtual void Eval(DenseMatrix &K, ElementTransformation &T,
-                     const IntegrationPoint &ip);
-   void SetAlpha(real_t alpha_) { alpha = alpha_; }
-};
-
-int main(int argc, char *argv[])
-{
-   // 0. Initialize MPI and HYPRE.
-   Mpi::Init();
-   int num_procs = Mpi::WorldSize();
-   int myid = Mpi::WorldRank();
-   Hypre::Init();
-
-   // 1. Parse command-line options.
-   const char *mesh_file = "../data/star.mesh";
-   int order = 1;
-   int max_it = 5;
-   int ref_levels = 3;
-   real_t alpha = 1.0;
-   real_t growth_rate = 1.0;
-   real_t newton_scaling = 0.9;
-   real_t tichonov = 1e-1;
-   real_t tol = 1e-4;
-   bool visualization = true;
-
-   OptionsParser args(argc, argv);
-   args.AddOption(&mesh_file, "-m", "--mesh",
-                  "Mesh file to use.");
-   args.AddOption(&order, "-o", "--order",
-                  "Finite element order (polynomial degree).");
-   args.AddOption(&ref_levels, "-r", "--refs",
-                  "Number of h-refinements.");
-   args.AddOption(&max_it, "-mi", "--max-it",
-                  "Maximum number of iterations");
-   args.AddOption(&tol, "-tol", "--tol",
-                  "Stopping criteria based on the difference between"
-                  "successive solution updates");
-   args.AddOption(&alpha, "-step", "--step",
-                  "Initial size alpha");
-   args.AddOption(&growth_rate, "-gr", "--growth-rate",
-                  "Growth rate of the step size alpha");
-   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
-                  "--no-visualization",
-                  "Enable or disable GLVis visualization.");
-   args.Parse();
-   if (!args.Good())
-   {
-      if (myid == 0)
-      {
-         args.PrintUsage(cout);
-      }
-      return 1;
-   }
-   if (myid == 0)
-   {
-      args.PrintOptions(cout);
-   }
-
-   // 2. Read the mesh from the mesh file.
-   Mesh mesh(mesh_file, 1, 1);
-   int dim = mesh.Dimension();
-   int sdim = mesh.SpaceDimension();
-
-   MFEM_ASSERT(mesh.bdr_attributes.Size(),
-               "This example does not currently support meshes"
-               " without boundary attributes."
-              )
-
-   // 3. Postprocess the mesh.
-   // 3A. Refine the mesh to increase the resolution.
-   for (int l = 0; l < ref_levels; l++)
-   {
-      mesh.UniformRefinement();
-   }
-
-   // 3B. Interpolate the geometry after refinement to control geometry error.
-   // NOTE: Minimum second-order interpolation is used to improve the accuracy.
-   int curvature_order = max(order,2);
-   mesh.SetCurvature(curvature_order);
-
-   ParMesh pmesh(MPI_COMM_WORLD, mesh);
-   mesh.Clear();
-
-   // 4. Define the necessary finite element spaces on the mesh.
-   RT_FECollection RTfec(order, dim);
-   ParFiniteElementSpace RTfes(&pmesh, &RTfec);
-
-   L2_FECollection L2fec(order, dim);
-   ParFiniteElementSpace L2fes(&pmesh, &L2fec);
-
-   int num_dofs_RT = RTfes.GlobalTrueVSize();
-   int num_dofs_L2 = L2fes.GlobalTrueVSize();
-   if (myid == 0)
-   {
-      cout << "Number of H(div) dofs: "
-           << num_dofs_RT << endl;
-      cout << "Number of L² dofs: "
-           << num_dofs_L2 << endl;
-   }
-
-   // 5. Define the offsets for the block matrices
-   Array<int> offsets(3);
-   offsets[0] = 0;
-   offsets[1] = RTfes.GetVSize();
-   offsets[2] = L2fes.GetVSize();
-   offsets.PartialSum();
-
-   Array<int> toffsets(3);
-   toffsets[0] = 0;
-   toffsets[1] = RTfes.GetTrueVSize();
-   toffsets[2] = L2fes.GetTrueVSize();
-   toffsets.PartialSum();
-
-   BlockVector x(offsets), rhs(offsets);
-   x = 0.0; rhs = 0.0;
-
-   BlockVector tx(toffsets), trhs(toffsets);
-   tx = 0.0; trhs = 0.0;
-
-   // 6. Define the solution vectors as a finite element grid functions
-   //    corresponding to the fespaces.
-   ParGridFunction u_gf, delta_psi_gf;
-   delta_psi_gf.MakeRef(&RTfes,x,offsets[0]);
-   u_gf.MakeRef(&L2fes,x,offsets[1]);
-
-   ParGridFunction psi_old_gf(&RTfes);
-   ParGridFunction psi_gf(&RTfes);
-   ParGridFunction u_old_gf(&L2fes);
-
-   // 7. Define initial guesses for the solution variables.
-   delta_psi_gf = 0.0;
-   psi_gf = 0.0;
-   u_gf = 0.0;
-   psi_old_gf = psi_gf;
-   u_old_gf = u_gf;
-
-   // 8. Prepare for glvis output.
-   char vishost[] = "localhost";
-   int  visport   = 19916;
-   socketstream sol_sock;
-   if (visualization)
-   {
-      sol_sock.open(vishost,visport);
-      sol_sock.precision(8);
-   }
-
-   // 9. Coefficients to be used later.
-   ConstantCoefficient neg_one(-1.0);
-   ConstantCoefficient zero(0.0);
-   ConstantCoefficient tichonov_cf(tichonov);
-   ConstantCoefficient neg_tichonov_cf(-1.0*tichonov);
-   ZCoefficient Z(sdim, psi_gf, alpha);
-   DZCoefficient DZ(sdim, psi_gf, alpha);
-   ScalarVectorProductCoefficient neg_Z(-1.0, Z);
-   DivergenceGridFunctionCoefficient div_psi_cf(&psi_gf);
-   DivergenceGridFunctionCoefficient div_psi_old_cf(&psi_old_gf);
-   SumCoefficient psi_old_minus_psi(div_psi_old_cf, div_psi_cf, 1.0, -1.0);
-
-   // 10. Assemble constant matrices/vectors to avoid reassembly in the loop.
-   ParLinearForm b0, b1;
-   b0.MakeRef(&RTfes,rhs.GetBlock(0),0);
-   b1.MakeRef(&L2fes,rhs.GetBlock(1),0);
-
-   b0.AddDomainIntegrator(new VectorFEDomainLFIntegrator(neg_Z));
-   b1.AddDomainIntegrator(new DomainLFIntegrator(neg_one));
-   b1.AddDomainIntegrator(new DomainLFIntegrator(psi_old_minus_psi));
-
-   ParBilinearForm a00(&RTfes);
-   a00.AddDomainIntegrator(new VectorFEMassIntegrator(DZ));
-   a00.AddDomainIntegrator(new VectorFEMassIntegrator(tichonov_cf));
-
-   ParMixedBilinearForm a10(&RTfes,&L2fes);
-   a10.AddDomainIntegrator(new VectorFEDivergenceIntegrator());
-   a10.Assemble();
-   a10.Finalize();
-   HypreParMatrix *A10 = a10.ParallelAssemble();
-
-   HypreParMatrix *A01 = A10->Transpose();
-
-   ParBilinearForm a11(&L2fes);
-   a11.AddDomainIntegrator(new MassIntegrator(neg_tichonov_cf));
-   a11.Assemble();
-   a11.Finalize();
-   HypreParMatrix *A11 = a11.ParallelAssemble();
-
-   // 11. Iterate.
-   int k;
-   int total_iterations = 0;
-   real_t increment_u = 0.1;
-   ParGridFunction u_tmp(&L2fes);
-   for (k = 0; k < max_it; k++)
-   {
-      u_tmp = u_old_gf;
-      Z.SetAlpha(alpha);
-      DZ.SetAlpha(alpha);
-
-      if (myid == 0)
-      {
-         mfem::out << "\nOUTER ITERATION " << k+1 << endl;
-      }
-
-      int j;
-      for ( j = 0; j < 5; j++)
-      {
-         total_iterations++;
-
-         b0.Assemble();
-         b0.ParallelAssemble(trhs.GetBlock(0));
-
-         b1.Assemble();
-         b1.ParallelAssemble(trhs.GetBlock(1));
-
-         a00.Assemble(false);
-         a00.Finalize(false);
-         HypreParMatrix *A00 = a00.ParallelAssemble();
-
-         // Construct Schur-complement preconditioner
-         HypreParVector A00_diag(MPI_COMM_WORLD, A00->GetGlobalNumRows(),
-                                 A00->GetRowStarts());
-         A00->GetDiag(A00_diag);
-         HypreParMatrix S_tmp(*A01);
-         S_tmp.InvScaleRows(A00_diag);
-         HypreParMatrix *S = ParMult(A10, &S_tmp, true);
-
-         BlockDiagonalPreconditioner prec(toffsets);
-         HypreBoomerAMG P00(*A00);
-         P00.SetPrintLevel(0);
-         HypreBoomerAMG P11(*S);
-         P11.SetPrintLevel(0);
-         prec.SetDiagonalBlock(0,&P00);
-         prec.SetDiagonalBlock(1,&P11);
-
-         BlockOperator A(toffsets);
-         A.SetBlock(0,0,A00);
-         A.SetBlock(1,0,A10);
-         A.SetBlock(0,1,A01);
-         A.SetBlock(1,1,A11);
-
-         GMRESSolver gmres(MPI_COMM_WORLD);
-         gmres.SetPrintLevel(-1);
-         gmres.SetRelTol(1e-8);
-         gmres.SetMaxIter(2000);
-         gmres.SetKDim(500);
-         gmres.SetOperator(A);
-         gmres.SetPreconditioner(prec);
-         gmres.Mult(trhs,tx);
-         delete S;
-         delete A00;
-
-         delta_psi_gf.SetFromTrueDofs(tx.GetBlock(0));
-         u_gf.SetFromTrueDofs(tx.GetBlock(1));
-
-         u_tmp -= u_gf;
-         real_t Newton_update_size = u_tmp.ComputeL2Error(zero);
-         u_tmp = u_gf;
-
-         // Damped Newton update
-         psi_gf.Add(newton_scaling, delta_psi_gf);
-         a00.Update();
-
-         if (visualization)
-         {
-            sol_sock << "parallel " << num_procs << " " << myid << "\n";
-            sol_sock << "solution\n" << pmesh << u_gf << "window_title 'Discrete solution'"
-                     << flush;
-         }
-
-         if (myid == 0)
-         {
-            mfem::out << "Newton_update_size = " << Newton_update_size << endl;
-         }
-
-         if (Newton_update_size < increment_u)
-         {
-            break;
-         }
-      }
-
-      u_tmp = u_gf;
-      u_tmp -= u_old_gf;
-      increment_u = u_tmp.ComputeL2Error(zero);
-
-      if (myid == 0)
-      {
-         mfem::out << "Number of Newton iterations = " << j+1 << endl;
-         mfem::out << "Increment (|| uₕ - uₕ_prvs||) = " << increment_u << endl;
-      }
-
-      u_old_gf = u_gf;
-      psi_old_gf = psi_gf;
-
-      if (increment_u < tol || k == max_it-1)
-      {
-         break;
-      }
-
-      alpha *= max(growth_rate, 1_r);
-
-   }
-
-   // 12. Print stats.
-   if (myid == 0)
-   {
-      mfem::out << "\n Outer iterations: " << k+1
-                << "\n Total iterations: " << total_iterations
-                << "\n Total dofs:       " << RTfes.GetTrueVSize() + L2fes.GetTrueVSize()
-                << endl;
-   }
-
-   // 13. Free the used memory.
-   delete A01;
-   delete A10;
-   delete A11;
-   return 0;
-}
-
-void ZCoefficient::Eval(Vector &V, ElementTransformation &T,
-                        const IntegrationPoint &ip)
-{
-   MFEM_ASSERT(psi != NULL, "grid function is not set");
-   MFEM_ASSERT(alpha > 0, "alpha is not positive");
-
-   Vector psi_vals(vdim);
-   psi->GetVectorValue(T, ip, psi_vals);
-   real_t norm = psi_vals.Norml2();
-   real_t phi = 1.0 / sqrt(1.0/(alpha*alpha) + norm*norm);
-
-   V = psi_vals;
-   V *= phi;
-}
-
-void DZCoefficient::Eval(DenseMatrix &K, ElementTransformation &T,
-                         const IntegrationPoint &ip)
-{
-   MFEM_ASSERT(psi != NULL, "grid function is not set");
-   MFEM_ASSERT(alpha > 0, "alpha is not positive");
-
-   Vector psi_vals(height);
-   psi->GetVectorValue(T, ip, psi_vals);
-   real_t norm = psi_vals.Norml2();
-   real_t phi = 1.0 / sqrt(1.0/(alpha*alpha) + norm*norm);
-
-   K = 0.0;
-   for (int i = 0; i < height; i++)
-   {
-      K(i,i) = phi;
-      for (int j = 0; j < height; j++)
-      {
-         K(i,j) -= psi_vals(i) * psi_vals(j) * pow(phi, 3);
-      }
-   }
-}
@@ -1,782 +0,0 @@
-//                       MFEM Example 3 - Parallel Version
-//
-// Compile with: make ex3p
-//
-// Sample runs:  mpirun -np 4 ex3p -m ../data/star.mesh
-//               mpirun -np 4 ex3p -m ../data/square-disc.mesh -o 2
-//               mpirun -np 4 ex3p -m ../data/beam-tet.mesh
-//               mpirun -np 4 ex3p -m ../data/beam-hex.mesh
-//               mpirun -np 4 ex3p -m ../data/escher.mesh
-//               mpirun -np 4 ex3p -m ../data/fichera.mesh
-//               mpirun -np 4 ex3p -m ../data/fichera-q2.vtk
-//               mpirun -np 4 ex3p -m ../data/fichera-q3.mesh
-//               mpirun -np 4 ex3p -m ../data/square-disc-nurbs.mesh
-//               mpirun -np 4 ex3p -m ../data/beam-hex-nurbs.mesh
-//               mpirun -np 4 ex3p -m ../data/amr-quad.mesh -o 2
-//               mpirun -np 4 ex3p -m ../data/amr-hex.mesh
-//               mpirun -np 4 ex3p -m ../data/star-surf.mesh -o 2
-//               mpirun -np 4 ex3p -m ../data/mobius-strip.mesh -o 2 -f 0.1
-//               mpirun -np 4 ex3p -m ../data/klein-bottle.mesh -o 2 -f 0.1
-//
-// Description:  This example code solves a simple electromagnetic diffusion
-//               problem corresponding to the second order definite Maxwell
-//               equation curl curl E + E = f with boundary condition
-//               E x n = <given tangential field>. Here, we use a given exact
-//               solution E and compute the corresponding r.h.s. f.
-//               We discretize with Nedelec finite elements in 2D or 3D.
-//
-//               The example demonstrates the use of H(curl) finite element
-//               spaces with the curl-curl and the (vector finite element) mass
-//               bilinear form, as well as the computation of discretization
-//               error when the exact solution is known. Static condensation is
-//               also illustrated.
-//
-//               We recommend viewing examples 1-2 before viewing this example.
-
-#include "mfem.hpp"
-#include <fstream>
-#include <iostream>
-#include "./spe10_coeff.cpp"
-
-using namespace std;
-using namespace mfem;
-
-
-int* LoadIterations(int NRows, int NCol)
-{
-   ifstream in("iter_DivSkew.txt");
-
-   //initialize
-   int *iters = new int[NCol*NRows];
-   for (int col = 0; col < NCol; col++)
-   {
-      for (int row = 0; row < NRows; row++)
-      {
-         iters[row*NCol+col] = -1;
-      }
-   }
-
-   if (!in)
-   {
-      cout << "Cannot open file.\n";
-      return iters;
-   }
-
-   for (int row = 0; row < NRows; row++)
-      for (int col = 0; col < NCol; col++)
-      {
-         if (in.eof())
-         {
-            in.close();
-            return iters;
-         }
-         in >> iters[row*NCol+col];
-      }
-
-   in.close();
-
-   return iters;
-}
-
-void putIterationsInArray(int iter, int row, int col, int NCol, int* iters)
-{
-   iters[row*NCol+col] = iter;
-}
-
-void WriteIterations(int *iters, int NRows, int NCol)
-{
-   ofstream out;
-   out.open("iter_DivSkew.txt",fstream::out);
-
-   if (!out)
-   {
-      cout << "Cannot open file.\n";
-      delete[] iters;
-
-      return;
-   }
-
-   for (int row = 0; row < NRows; row++)
-   {
-      for (int col = 0; col < NCol; col++)
-      {
-         out << iters[row*NCol+col] << "\t";
-      }
-      out << endl;
-   }
-   out.close();
-
-   delete[] iters;
-}
-
-
-// Exact solution, E, and r.h.s., f. See below for implementation.
-void E_exact_vec(const Vector &x, Vector &E);
-void E_exact(const Vector &, DenseMatrix &);
-void f_exact(const Vector &, DenseMatrix &);
-
-
-class DivSkew4dPrec : public Solver
-{
-
-private:
-   HypreParMatrix *A;
-   ParFiniteElementSpace *fespace;
-   Coefficient *alpha_, *beta_;
-
-   //kernel operators
-   HypreParMatrix *P_d_HCurl_HDivSkew;
-
-
-   HypreParMatrix *P_H1_HCurl;
-   HypreParMatrix *H1_KernelMat;
-   HypreBoomerAMG *amgH1_Kernel;
-
-   //"image" operators
-   HypreParMatrix *P_H1_HDivSkew;
-   HypreParMatrix *H1_ImageMat;
-   HypreBoomerAMG *amgH1_Image;
-
-
-   HypreParMatrix *HCurlMat;
-   HypreSmoother * smootherDivSkew;
-   HypreSmoother * smootherCurl;
-
-   CGSolver *pcgKernel;
-   CGSolver *pcgImage;
-
-   Vector *f;
-   Vector *fKernel, *uKernel;
-   Vector *fImage, *uImage;
-   Vector *fCurl, *uCurl;
-
-   bool exactSolves;
-
-   FiniteElementCollection* fecHCurlKernel;
-   ParFiniteElementSpace *HCurlKernelFESpace;
-
-
-public:
-   ~DivSkew4dPrec()
-   {
-      delete pcgImage, pcgKernel;
-
-      delete f, fKernel, uKernel, fImage, uImage, fCurl, uCurl;
-
-      delete smootherCurl, HCurlMat;
-
-      delete P_d_HCurl_HDivSkew, P_H1_HDivSkew, P_H1_HCurl;
-
-      delete amgH1_Image, H1_ImageMat;
-      delete amgH1_Kernel, H1_KernelMat;
-
-      delete smootherDivSkew;
-
-      delete HCurlKernelFESpace, fecHCurlKernel;
-   }
-   DivSkew4dPrec(HypreParMatrix *AUser, ParFiniteElementSpace *fespaceUser,
-                 Coefficient *alpha, Coefficient *beta,
-                 const Array<int> &essBnd, int orderKernel=1, bool exactSolvesUser=false)
-   {
-      A = AUser;
-      fespace = fespaceUser;
-      alpha_ = alpha;
-      beta_ = beta;
-
-      ParMesh *pmesh = fespace->GetParMesh();
-      int dim = pmesh->Dimension();
-
-      exactSolves = exactSolvesUser;
-
-      int orderIm=1;  //H1  --> H(divSkew)
-      int orderKer=orderKernel; //curl V --> H(divSkew)
-
-      smootherDivSkew = new HypreSmoother(*A, 16, 3);
-
-      Array<int> HDivSkew_essDof(fespace->GetVSize()); HDivSkew_essDof = 0;
-      fespace->GetEssentialVDofs(essBnd, HDivSkew_essDof);
-
-      //setup the H1 FESpace for the kernel
-      FiniteElementCollection* fecH1Kernel = new H1_FECollection(orderKer, 4);
-
-      ParFiniteElementSpace *H1KernelFESpace = new ParFiniteElementSpace(pmesh,
-                                                                         fecH1Kernel, dim, Ordering::byVDIM);
-      Array<int> H1Kernel_essDof(H1KernelFESpace->GetVSize()); H1Kernel_essDof = 0;
-      H1KernelFESpace->GetEssentialVDofs(essBnd, H1Kernel_essDof);
-
-
-      //setup the H(curl) FESpace for the kernel
-      if (orderKer==1) { fecHCurlKernel = new ND1_4DFECollection; }
-      else { fecHCurlKernel = new ND2_4DFECollection; }
-
-      HCurlKernelFESpace = new ParFiniteElementSpace(pmesh,
-                                                     fecHCurlKernel);
-      Array<int> HCurlKernel_essDof(HCurlKernelFESpace->GetVSize());
-      HCurlKernel_essDof = 0;
-      HCurlKernelFESpace->GetEssentialVDofs(essBnd, HCurlKernel_essDof);
-
-
-      //setup the FESpace for the H1 injection
-      FiniteElementCollection* fecH1Vec;
-      if (orderIm==1) { fecH1Vec = new LinearFECollection; }
-      else { fecH1Vec = new QuadraticFECollection; }
-      ParFiniteElementSpace *H1_ImageFESpace = new ParFiniteElementSpace(pmesh,
-                                                                         fecH1Vec, 6, Ordering::byVDIM);
-      Array<int> H1Image_essDof(H1_ImageFESpace->GetVSize()); H1Image_essDof = 0;
-      H1_ImageFESpace->GetEssentialVDofs(essBnd, H1Image_essDof);
-
-
-
-      //setup the H1 preconditioner for the kernel
-      ParBilinearForm* H1Varf = new ParBilinearForm(H1KernelFESpace);
-      H1Varf->AddDomainIntegrator(new VectorDiffusionIntegrator(*beta_));
-      //      H1Varf->AddDomainIntegrator(new VectorMassIntegrator);
-      H1Varf->Assemble();
-      H1Varf->Finalize();
-      SparseMatrix &matH1(H1Varf->SpMat());
-      for (int dof = 0; dof < H1Kernel_essDof.Size(); dof++)
-         if (H1Kernel_essDof[dof] < 0)
-         {
-            matH1.EliminateRowCol(dof);
-         }
-      H1_KernelMat = H1Varf->ParallelAssemble();
-      delete H1Varf;
-      amgH1_Kernel = new HypreBoomerAMG(*H1_KernelMat);
-      amgH1_Kernel->SetSystemsOptions(dim);
-      amgH1_Kernel->SetPrintLevel(0);
-
-      //setup the H1 preconditioner for the image
-      ParBilinearForm* H1VecVarf = new ParBilinearForm(H1_ImageFESpace);
-      VectorDiffusionIntegrator *alpha_integ = new VectorDiffusionIntegrator(*alpha_);
-      alpha_integ->SetVDim(6);
-      H1VecVarf->AddDomainIntegrator(alpha_integ);
-      VectorMassIntegrator *beta_integ = new VectorMassIntegrator(*beta);
-      beta_integ->SetVDim(6);
-      H1VecVarf->AddDomainIntegrator(beta_integ);
-      H1VecVarf->Assemble();
-      H1VecVarf->Finalize();
-      SparseMatrix &matH1Vec(H1VecVarf->SpMat());
-      for (int dof=0; dof<H1Image_essDof.Size(); dof++) if (H1Image_essDof[dof]<0) { matH1Vec.EliminateRowCol(dof); }
-      H1_ImageMat = H1VecVarf->ParallelAssemble();
-      delete H1VecVarf;
-      amgH1_Image = new HypreBoomerAMG(*H1_ImageMat);
-      amgH1_Image->SetSystemsOptions(6);
-      amgH1_Image->SetPrintLevel(0);
-
-
-      //setup the injection of H1 into H(curl)
-      ParDiscreteLinearOperator *disInterpol = new ParDiscreteLinearOperator(
-         H1KernelFESpace, HCurlKernelFESpace);
-      disInterpol->AddDomainInterpolator(new IdentityInterpolator);
-      disInterpol->Assemble();
-      disInterpol->Finalize();
-      SparseMatrix* smatID = &(disInterpol->SpMat());
-      smatID->EliminateCols(H1Kernel_essDof);
-      for (int dof=0; dof<HCurlKernel_essDof.Size();
-           dof++) if (HCurlKernel_essDof[dof]<0) { smatID->EliminateRow(dof); }
-      P_H1_HCurl = disInterpol->ParallelAssemble();
-      delete disInterpol;
-
-      //setup the injection of H1 into H(DivSkew)
-      ParDiscreteLinearOperator *disInterpolIm = new ParDiscreteLinearOperator(
-         H1_ImageFESpace, fespace);
-      disInterpolIm->AddDomainInterpolator(new IdentityInterpolator);
-      disInterpolIm->Assemble();
-      disInterpolIm->Finalize();
-      SparseMatrix* smatIDIm = &(disInterpolIm->SpMat());
-      smatIDIm->EliminateCols(H1Image_essDof);
-      for (int dof=0; dof<HDivSkew_essDof.Size(); dof++) if (HDivSkew_essDof[dof]<0) { smatIDIm->EliminateRow(dof); }
-      P_H1_HDivSkew = disInterpolIm->ParallelAssemble();
-      delete disInterpolIm;
-
-
-      //setup the injection of the curl(H(curl)) into H(DivSkew)
-      ParDiscreteLinearOperator *disCurl = new ParDiscreteLinearOperator(
-         HCurlKernelFESpace, fespace);
-      disCurl->AddDomainInterpolator(new CurlInterpolator);
-      disCurl->Assemble();
-      disCurl->Finalize();
-      SparseMatrix* smatCurl = &(disCurl->SpMat());
-      smatCurl->EliminateCols(HCurlKernel_essDof);
-      for (int dof=0; dof<HDivSkew_essDof.Size(); dof++) if (HDivSkew_essDof[dof]<0) { smatCurl->EliminateRow(dof); }
-      P_d_HCurl_HDivSkew = disCurl->ParallelAssemble();
-      delete disCurl;
-
-      //setup the smoother for H(curl)
-      //      Coefficient *massC = new ConstantCoefficient(1.0);
-      //      Coefficient *CurlCurlC = new ConstantCoefficient(1.0);
-      ParBilinearForm *a_HCurl = new ParBilinearForm(HCurlKernelFESpace);
-      a_HCurl->AddDomainIntegrator(new CurlCurlIntegrator(*beta_));
-      //      a_HCurl->AddDomainIntegrator(new CurlCurlIntegrator(*CurlCurlC));
-      //      a_HCurl->AddDomainIntegrator(new VectorFEMassIntegrator(*massC));
-      a_HCurl->Assemble();
-      a_HCurl->Finalize();
-      SparseMatrix &matHCurl(a_HCurl->SpMat());
-      for (int dof=0; dof<HCurlKernel_essDof.Size();
-           dof++) if (HCurlKernel_essDof[dof]<0) { matHCurl.EliminateRowCol(dof); }
-      HCurlMat = a_HCurl->ParallelAssemble();
-      delete a_HCurl;
-      smootherCurl = new HypreSmoother(*HCurlMat, 16, 3);
-
-      f = new Vector(fespace->GetTrueVSize());
-
-      fKernel = new Vector(H1KernelFESpace->GetTrueVSize());
-      uKernel = new Vector(H1KernelFESpace->GetTrueVSize());
-
-      fImage = new Vector(H1_ImageFESpace->GetTrueVSize());
-      uImage = new Vector(H1_ImageFESpace->GetTrueVSize());
-
-      fCurl = new Vector(HCurlKernelFESpace->GetTrueVSize());
-      uCurl = new Vector(HCurlKernelFESpace->GetTrueVSize());
-
-
-      amgH1_Kernel->Mult(*fKernel, *uKernel);
-      amgH1_Image->Mult(*fImage, *uImage);
-
-      pcgKernel = new CGSolver(MPI_COMM_WORLD);
-      pcgKernel->SetOperator(*H1_KernelMat);
-      pcgKernel->SetPreconditioner(*amgH1_Kernel);
-      pcgKernel->SetRelTol(1e-16);
-      pcgKernel->SetMaxIter(100000000);
-      pcgKernel->SetPrintLevel(-2);
-
-      pcgImage = new CGSolver(MPI_COMM_WORLD);
-      pcgImage->SetOperator(*H1_ImageMat);
-      pcgImage->SetPreconditioner(*amgH1_Image);
-      pcgImage->SetRelTol(1e-16);
-      pcgImage->SetMaxIter(100000000);
-      pcgImage->SetPrintLevel(-2);
-
-      delete H1KernelFESpace, fecH1Kernel;
-      delete H1_ImageFESpace, fecH1Vec;
-   }
-
-   void setExactSolve(bool exSol)
-   {
-      exactSolves = exSol;
-   }
-
-   virtual void Mult(const Vector &x, Vector &y) const
-   {
-      smootherDivSkew->Mult(x,y);
-
-      P_H1_HDivSkew->MultTranspose(x,*fImage);
-      *uImage = 0.0;
-      if (exactSolves) { pcgImage->Mult(*fImage, *uImage); }
-      else { amgH1_Image->Mult(*fImage, *uImage); }
-      P_H1_HDivSkew->Mult(1.0, *uImage, 1.0, y);
-
-      *uCurl = 0.0;
-      P_d_HCurl_HDivSkew->MultTranspose(x,*fCurl);
-
-      smootherCurl->Mult(*fCurl, *uCurl);
-
-      P_H1_HCurl->MultTranspose(*fCurl,*fKernel);
-      *uKernel = 0.0;
-      if (exactSolves) { pcgKernel->Mult(*fKernel, *uKernel); }
-      else { amgH1_Kernel->Mult(*fKernel, *uKernel); }
-      P_H1_HCurl->Mult(1.0, *uKernel, 1.0, *uCurl);
-
-      P_d_HCurl_HDivSkew->Mult(1.0, *uCurl, 1.0, y);
-   }
-
-   virtual void SetOperator(const Operator &op) {};
-
-};
-
-
-
-
-int main(int argc, char *argv[])
-{
-   // 1. Initialize MPI.
-   int num_procs, myid;
-   MPI_Init(&argc, &argv);
-   MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
-   MPI_Comm_rank(MPI_COMM_WORLD, &myid);
-
-   bool verbose = (myid==0);
-
-   // 2. Parse command-line options.
-   const char *mesh_file = "../data/cube4d_96.MFEM";
-   int order = 1;
-   bool set_bc = true;
-   bool static_cond = false;
-   bool visualization = 1;
-   int sequ_ref_levels = 0;
-   int par_ref_levels = 0;
-   double tol = 1e-6;
-   double coeffWeight = 1.0;
-   bool exactH1Solver = false;
-   bool spe10Coeff = false;
-   bool standardCG = true;
-
-   int NExpo = 8;
-   int weightStart = -NExpo;
-   int weightEnd = NExpo;
-
-   OptionsParser args(argc, argv);
-   args.AddOption(&mesh_file, "-m", "--mesh",
-                  "Mesh file to use.");
-   args.AddOption(&sequ_ref_levels, "-sr", "--seqrefinement",
-                  "Number of sequential refinement steps.");
-   args.AddOption(&par_ref_levels, "-pr", "--parrefinement",
-                  "Number of parallel refinement steps.");
-   args.AddOption(&order, "-o", "--order",
-                  "Polynomial order of the finite element space.");
-   args.AddOption(&set_bc, "-bc", "--impose-bc", "-no-bc", "--dont-impose-bc",
-                  "Impose or not essential boundary conditions.");
-   args.AddOption(&tol, "-tol", "--tol",
-                  "A parameter.");
-   args.AddOption(&coeffWeight, "-c", "--coeffMass",
-                  "the weight for the mass term.");
-   args.AddOption(&exactH1Solver, "-exH1Sol", "--exactH1Solver", "-H1prec",
-                  "--H1preconditioner",
-                  "Use exact H1 solvers for the preconditioner.");
-   args.AddOption(&spe10Coeff, "-spe10", "--useSPE10Coeff", "-constCoeff",
-                  "--constCoeff",
-                  "Switch between the coefficients for the mass bilinear form.");
-   args.AddOption(&standardCG, "-sCG", "--stdCG", "-rCG", "--resCG",
-                  "Switch between standard PCG or recompute residuals in every step and use the residuals itself for the stopping criteria.");
-   args.AddOption(&weightStart, "-ws", "--weightStart",
-                  "the exponent for the starting weight (for the mass term).");
-   args.AddOption(&weightEnd, "-we", "--weightEnd",
-                  "the exponent for the weight at the end (for the mass term).");
-   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
-                  "--no-visualization",
-                  "Enable or disable GLVis visualization.");
-   args.Parse();
-   if (!args.Good())
-   {
-      args.PrintUsage(cout);
-      return 1;
-   }
-   if (verbose) { args.PrintOptions(cout); }
-
-   Mesh *mesh;
-   ifstream imesh(mesh_file);
-   if (!imesh)
-   {
-      cerr << "\nCan not open mesh file: " << mesh_file << '\n' << endl;
-      return 2;
-   }
-
-   mesh = new Mesh(imesh, 1, 1);
-   imesh.close();
-
-   int dim = mesh->Dimension();
-   int sdim = mesh->SpaceDimension();
-
-   if (dim !=4 || sdim != 4)
-   {
-      MPI_Finalize();
-      return 0;
-   }
-
-   for (int i=0; i<sequ_ref_levels; i++) { mesh->UniformRefinement(); }
-   if (verbose) { mesh->PrintCharacteristics(); }
-
-   if (verbose) { cout << "now we partition the mesh..." << endl << endl; }
-
-   ParMesh *pmesh = new ParMesh(MPI_COMM_WORLD, *mesh);
-   delete mesh;
-
-   for (int i=0; i<par_ref_levels; i++) { pmesh->UniformRefinement(); }
-
-   pmesh->PrintInfo(std::cout);
-   if (verbose) { cout << endl; }
-
-   // 6. Define a parallel finite element space on the parallel mesh. Here we
-   //    use the Nedelec finite elements of the specified order.
-   FiniteElementCollection *fec;
-   if (order==1) { fec = new DivSkew1_4DFECollection; }
-   //    else fec = new F2K1_4DFECollection;
-
-   ParFiniteElementSpace *fespace = new ParFiniteElementSpace(pmesh, fec);
-   fespace->SetUpdateOperatorType(Operator::Hypre_ParCSR);
-   HYPRE_Int size = fespace->GlobalTrueVSize();
-
-   // 7. Determine the list of true (i.e. parallel conforming) essential
-   //    boundary dofs. In this example, the boundary conditions are defined
-   //    by marking all the boundary attributes from the mesh as essential
-   //    (Dirichlet) and converting them to a list of true dofs.
-   Array<int> ess_tdof_list;
-   Array<int> ess_bdr(pmesh->bdr_attributes.Max());
-   ess_bdr = set_bc ? 1 : 0;
-   if (pmesh->bdr_attributes.Size())
-   {
-      fespace->GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
-   }
-
-   if (myid == 0)
-   {
-      cout << "Number of finite element unknowns: " << size << endl;
-
-   }
-
-   // 8. Set up the parallel linear form b(.) which corresponds to the
-   //    right-hand side of the FEM linear system, which in this case is
-   //    (f,phi_i) where f is given by the function f_exact and phi_i are the
-   //    basis functions in the finite element fespace.
-   MatrixFunctionCoefficient f(sdim, f_exact);
-   MatrixFunctionCoefficient solMat(sdim, E_exact);
-   VectorFunctionCoefficient solVec(6, E_exact_vec);
-
-
-
-
-   // 9. Define the solution vector x as a parallel finite element grid function
-   //    corresponding to fespace. Initialize x by projecting the exact
-   //    solution. Note that only values from the boundary edges will be used
-   //    when eliminating the non-homogeneous boundary condition to modify the
-   //    r.h.s. vector b.
-   ParGridFunction x(fespace);
-
-   for (int expo=weightStart; expo<=weightEnd; expo++)
-   {
-      double weight = pow(10.0,expo);
-
-      x.ProjectCoefficient(solVec);
-
-      ParLinearForm *b = new ParLinearForm(fespace);
-      b->AddDomainIntegrator(new MatFEDomainLFIntegrator(f));
-      b->Assemble();
-
-      //   cout << x << endl;
-      //   x = 0.0;
-
-      // 10. Set up the parallel bilinear form corresponding to the EM diffusion
-      //     operator curl muinv curl + sigma I, by adding the curl-curl and the
-      //     mass domain integrators.
-      //    std::string permFile = "spe_perm.dat";
-      //    InversePermeabilityFunction::ReadPermeabilityFile(permFile, MPI_COMM_WORLD);
-
-      Coefficient *alpha = new ConstantCoefficient(1.0);
-      Coefficient *beta;
-      //    if(spe10Coeff) beta = new FunctionCoefficient(InversePermeabilityFunction::Norm2Permeability);
-      //    else
-      beta = new ConstantCoefficient(weight);
-
-      ParBilinearForm *a = new ParBilinearForm(fespace);
-      a->AddDomainIntegrator(new DivSkewDivSkewIntegrator(*alpha));
-      a->AddDomainIntegrator(new VectorFE_DivSkewMassIntegrator(*beta));
-
-      // 11. Assemble the parallel bilinear form and the corresponding linear
-      //     system, applying any necessary transformations such as: parallel
-      //     assembly, eliminating boundary conditions, applying conforming
-      //     constraints for non-conforming AMR, static condensation, etc.
-      if (static_cond) { a->EnableStaticCondensation(); }
-      a->Assemble();
-
-      HypreParMatrix A;
-      Vector B, X;
-      a->FormLinearSystem(ess_tdof_list, x, *b, A, X, B);
-
-      if (myid == 0)
-      {
-         cout << "Size of linear system: " << A.GetGlobalNumRows() << endl;
-      }
-
-      //Define the preconditioner
-
-      if (myid == 0) { cout << "Set up the preconditioner" << endl; }
-      Solver *prec;
-      if (dim==4) { prec = new DivSkew4dPrec(&A, fespace, alpha, beta, ess_bdr, order, exactH1Solver); }
-
-      IterativeSolver *pcg = new CGSolver(MPI_COMM_WORLD);
-      pcg->SetOperator(A);
-      pcg->SetRelTol(tol);
-      pcg->SetMaxIter(500);
-      pcg->SetPrintLevel(1);
-      pcg->SetPreconditioner(*prec);
-      pcg->Mult(B, X);
-
-      delete prec;
-
-      int iter = pcg->GetNumIterations();
-      if (myid==0)
-      {
-         cout << "Weigth: " << weight << " " << iter << endl;
-
-         int *iters = LoadIterations(10, 2*NExpo+1);
-         putIterationsInArray(iter, sequ_ref_levels+par_ref_levels, expo+NExpo,
-                              2*NExpo+1, iters);
-         WriteIterations(iters, 10, 2*NExpo+1);
-      }
-
-      // 13. Recover the parallel grid function corresponding to X. This is the
-      //     local finite element solution on each processor.
-      a->RecoverFEMSolution(X, *b, x);
-
-      // 14. Compute and print the L^2 norm of the error.
-      {
-         double error = 0.0;
-         for (int i = 0; i < fespace->GetNE(); i++)
-         {
-            const FiniteElement* fe = fespace->GetFE(i);
-            int fdof = fe->GetDof();
-            ElementTransformation* transf = fespace->GetElementTransformation(i);
-            DenseMatrix shape(fdof,dim*dim);
-
-            int intorder = 2*fe->GetOrder() + 1; // <----------
-            const IntegrationRule *ir;
-            ir = &(IntRules.Get(fe->GetGeomType(), intorder));
-
-            Vector elSol(dim*dim);
-            DenseMatrix elSolMat(dim,dim);
-            DenseMatrix exactSol(dim,dim);
-            Vector exactSolVec(dim*dim);
-
-
-
-            Array<int> vdofs;
-            fespace->GetElementVDofs(i, vdofs);
-            for (int j = 0; j < ir->GetNPoints(); j++)
-            {
-               const IntegrationPoint &ip = ir->IntPoint(j);
-               transf->SetIntPoint(&ip);
-
-               fe->CalcVShape(*transf, shape);
-
-               elSol = 0.0;
-               for (int k = 0; k < fdof; k++)
-               {
-                  if (vdofs[k] >= 0)
-                  {
-                     for (int l=0; l<dim*dim; l++) { elSol(l) += shape(k,l)*x(vdofs[k]); }
-                  }
-                  else
-                  {
-                     for (int l=0; l<dim*dim; l++) { elSol(l) -= shape(k,l)*x(-1-vdofs[k]); }
-                  }
-               }
-               for (int k=0; k<dim; k++)
-                  for (int l=0; l<dim; l++)
-                  {
-                     elSolMat(k,l) = elSol(dim*k+l);
-                  }
-
-
-               solMat.Eval(exactSol,*transf, ip);
-               for (int k=0; k<dim; k++)
-                  for (int l=0; l<dim; l++)
-                  {
-                     exactSolVec(dim*k+l) = exactSol(k,l);
-                  }
-               elSol.Add(-1.0, exactSolVec);
-
-               error += ip.weight * fabs(transf->Weight()) * (elSol * elSol);
-            }
-         }
-         double globalError = 0.0;
-         MPI_Allreduce(&error, &globalError, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-         if (myid==0) { std::cout << "L2 error: " << sqrt(globalError) << std::endl; }
-
-
-      }
-
-      delete pcg;
-      delete a;
-      delete alpha;
-      delete beta;
-
-      delete b;
-   }
-
-   // 17. Free the used memory.
-
-
-
-   delete fespace;
-   delete fec;
-   delete pmesh;
-
-
-   MPI_Finalize();
-
-   return 0;
-}
-
-void E_exact_vec(const Vector &x, Vector &E)
-{
-   int dim = x.Size();
-
-   if (dim==4)
-   {
-      E.SetSize(6);
-
-      double s0 = sin(M_PI*x(0)), s1 = sin(M_PI*x(1)), s2 = sin(M_PI*x(2)),
-             s3 = sin(M_PI*x(3));
-      double c0 = cos(M_PI*x(0)), c1 = cos(M_PI*x(1)), c2 = cos(M_PI*x(2)),
-             c3 = cos(M_PI*x(3));
-
-      E(0) =  c0*c1*s2*s3;
-      E(1) = -c0*s1*c2*s3;
-      E(2) =  c0*s1*s2*c3;
-      E(3) =  s0*c1*c2*s3;
-      E(4) = -s0*c1*s2*c3;
-      E(5) =  s0*s1*c2*c3;
-   }
-}
-
-void E_exact(const Vector &x, DenseMatrix &E)
-{
-   int dim = x.Size();
-
-   E.SetSize(dim*dim);
-
-   if (dim==4)
-   {
-      Vector vecE; E_exact_vec(x, vecE);
-
-      E = 0.0;
-
-      E(0,1) = vecE(0);
-      E(0,2) = vecE(1);
-      E(0,3) = vecE(2);
-      E(1,2) = vecE(3);
-      E(1,3) = vecE(4);
-      E(2,3) = vecE(5);
-
-      E(1,0) =  -E(0,1);
-      E(2,0) =  -E(0,2);
-      E(3,0) =  -E(0,3);
-      E(2,1) =  -E(1,2);
-      E(3,1) =  -E(1,3);
-      E(3,2) =  -E(2,3);
-   }
-}
-
-
-
-//f_exact = E + 0.5 * P( curl DivSkew E ), where P is the 4d permutation operator
-void f_exact(const Vector &x, DenseMatrix &f)
-{
-   int dim = x.Size();
-
-   f.SetSize(dim,dim);
-
-   if (dim==4)
-   {
-      f = 0.0;
-
-      double s0 = sin(M_PI*x(0)), s1 = sin(M_PI*x(1)), s2 = sin(M_PI*x(2)),
-             s3 = sin(M_PI*x(3));
-      double c0 = cos(M_PI*x(0)), c1 = cos(M_PI*x(1)), c2 = cos(M_PI*x(2)),
-             c3 = cos(M_PI*x(3));
-
-      f(0,1) =  (1.0 + 1.0  * M_PI*M_PI)*c0*c1*s2*s3;
-      f(0,2) = -(1.0 + 0.0  * M_PI*M_PI)*c0*s1*c2*s3;
-      f(0,3) =  (1.0 + 1.0  * M_PI*M_PI)*c0*s1*s2*c3;
-      f(1,2) =  (1.0 - 1.0  * M_PI*M_PI)*s0*c1*c2*s3;
-      f(1,3) = -(1.0 + 0.0  * M_PI*M_PI)*s0*c1*s2*c3;
-      f(2,3) =  (1.0 + 1.0  * M_PI*M_PI)*s0*s1*c2*c3;
-
-      f(1,0) =  -f(0,1);
-      f(2,0) =  -f(0,2);
-      f(3,0) =  -f(0,3);
-      f(2,1) =  -f(1,2);
-      f(3,1) =  -f(1,3);
-      f(3,2) =  -f(2,3);
-   }
-}
@@ -1,800 +0,0 @@
-//                       MFEM Example 4 - Parallel Version
-//
-// Compile with: make ex4p
-//
-// Sample runs:  mpirun -np 4 ex4p -m ../data/square-disc.mesh
-//               mpirun -np 4 ex4p -m ../data/star.mesh
-//               mpirun -np 4 ex4p -m ../data/beam-tet.mesh
-//               mpirun -np 4 ex4p -m ../data/beam-hex.mesh
-//               mpirun -np 4 ex4p -m ../data/escher.mesh -o 2 -sc
-//               mpirun -np 4 ex4p -m ../data/fichera.mesh -o 2 -hb
-//               mpirun -np 4 ex4p -m ../data/fichera-q2.vtk
-//               mpirun -np 4 ex4p -m ../data/fichera-q3.mesh -o 2 -sc
-//               mpirun -np 4 ex4p -m ../data/square-disc-nurbs.mesh -o 3
-//               mpirun -np 4 ex4p -m ../data/beam-hex-nurbs.mesh -o 3
-//               mpirun -np 4 ex4p -m ../data/periodic-square.mesh -no-bc
-//               mpirun -np 4 ex4p -m ../data/periodic-cube.mesh -no-bc
-//               mpirun -np 4 ex4p -m ../data/amr-quad.mesh
-//               mpirun -np 4 ex4p -m ../data/amr-hex.mesh -o 2 -sc
-//               mpirun -np 4 ex4p -m ../data/amr-hex.mesh -o 2 -hb
-//               mpirun -np 4 ex4p -m ../data/star-surf.mesh -o 3 -hb
-//
-// Description:  This example code solves a simple 2D/3D H(div) diffusion
-//               problem corresponding to the second order definite equation
-//               -grad(alpha div F) + beta F = f with boundary condition F dot n
-//               = <given normal field>. Here, we use a given exact solution F
-//               and compute the corresponding r.h.s. f.  We discretize with
-//               Raviart-Thomas finite elements.
-//
-//               The example demonstrates the use of H(div) finite element
-//               spaces with the grad-div and H(div) vector finite element mass
-//               bilinear form, as well as the computation of discretization
-//               error when the exact solution is known. Bilinear form
-//               hybridization and static condensation are also illustrated.
-//
-//               We recommend viewing examples 1-3 before viewing this example.
-
-#include "mfem.hpp"
-#include <fstream>
-#include <iostream>
-#include "./spe10_coeff.cpp"
-
-using namespace std;
-using namespace mfem;
-
-
-int* LoadIterations(int NRows, int NCol)
-{
-   ifstream in("iter_div.txt");
-
-   //initialize
-   int *iters = new int[NCol*NRows];
-   for (int col = 0; col < NCol; col++)
-   {
-      for (int row = 0; row < NRows; row++)
-      {
-         iters[row*NCol+col] = -1;
-      }
-   }
-
-   if (!in)
-   {
-      cout << "Cannot open file.\n";
-      return iters;
-   }
-
-   for (int row = 0; row < NRows; row++)
-      for (int col = 0; col < NCol; col++)
-      {
-         if (in.eof())
-         {
-            in.close();
-            return iters;
-         }
-         in >> iters[row*NCol+col];
-      }
-
-
-   in.close();
-
-   return iters;
-}
-
-void putIterationsInArray(int iter, int row, int col, int NCol, int* iters)
-{
-   iters[row*NCol+col] = iter;
-}
-
-void WriteIterations(int *iters, int NRows, int NCol)
-{
-   ofstream out;
-   out.open("iter_div.txt",fstream::out);
-
-   if (!out)
-   {
-      cout << "Cannot open file.\n";
-      delete[] iters;
-
-      return;
-   }
-
-   for (int row = 0; row < NRows; row++)
-   {
-      for (int col = 0; col < NCol; col++)
-      {
-         out << iters[row*NCol+col] << "\t";
-      }
-      out << endl;
-   }
-   out.close();
-
-   delete[] iters;
-}
-
-
-// Exact solution, F, and r.h.s., f. See below for implementation.
-void F_exact(const Vector &, Vector &);
-void f_exact(const Vector &, Vector &);
-double freq = 1.0, kappa;
-
-
-
-class div4dPrec : public Solver
-{
-
-private:
-   HypreParMatrix *A;
-   ParFiniteElementSpace *fespace;
-
-   Coefficient *alpha_, *beta_;
-
-   //kernel operators
-   HypreParMatrix *P_d_HSkewDiv_Hdiv;
-
-   HypreParMatrix *P_H1_HDivSkew;
-   HypreParMatrix *H1_KernelMat;
-   HypreBoomerAMG *amgH1_Kernel;
-
-   //"image" operators
-   HypreParMatrix *P_H1_Hdiv;
-   HypreParMatrix *H1_ImageMat;
-   HypreBoomerAMG *amgH1_Image;
-
-   HypreParMatrix *HDivSkewMat;
-   HypreSmoother * smootherdiv;
-   HypreSmoother * smootherDivSkew;
-
-   CGSolver *pcgKernel;
-   CGSolver *pcgImage;
-
-   Vector *f;
-   Vector *fKernel, *uKernel;
-   Vector *fImage, *uImage;
-   Vector *fDivSkew, *uDivSkew;
-
-   FiniteElementCollection* fecHDivSkewKernel;
-   ParFiniteElementSpace *HDivSkewKernelFESpace;
-
-   bool exactSolves;
-
-public:
-   ~div4dPrec()
-   {
-      delete pcgImage;
-      delete pcgKernel;
-
-      delete uDivSkew, fDivSkew, uImage, fImage, uKernel, fKernel, f;
-
-      delete smootherDivSkew;
-      delete HDivSkewMat;
-
-      delete P_d_HSkewDiv_Hdiv;
-      delete P_H1_Hdiv;
-      delete P_H1_HDivSkew;
-
-      delete amgH1_Image, H1_ImageMat;
-      delete amgH1_Kernel, H1_KernelMat;
-
-      delete smootherdiv;
-
-      delete HDivSkewKernelFESpace;
-      delete fecHDivSkewKernel;
-   }
-   div4dPrec(HypreParMatrix *AUser, ParFiniteElementSpace *fespaceUser,
-             Coefficient *alpha, Coefficient *beta, const Array<int> &essBnd,
-             int orderKernel=1, bool exactSolvesUser=false)
-   {
-      A = AUser;
-      fespace = fespaceUser;
-      alpha_ = alpha;
-      beta_ = beta;
-
-
-      ParMesh *pmesh = fespace->GetParMesh();
-      int dim = pmesh->Dimension();
-
-      exactSolves = exactSolvesUser;
-
-
-
-
-      int orderIm=1;  //H1  --> H(div)
-      int orderKer=orderKernel; //DivSkew V --> H(div)
-
-
-
-      smootherdiv = new HypreSmoother(*A, 16, 3);
-
-      Array<int> Hdiv_essDof(fespace->GetVSize()); Hdiv_essDof = 0;
-      fespace->GetEssentialVDofs(essBnd, Hdiv_essDof);
-
-
-
-
-      //setup the H1 FESpace for the kernel
-      FiniteElementCollection* fecH1Kernel;
-      if (orderKer==1) { fecH1Kernel = new LinearFECollection; }
-      else { fecH1Kernel = new QuadraticFECollection; }
-      ParFiniteElementSpace *H1KernelFESpace = new ParFiniteElementSpace(pmesh,
-                                                                         fecH1Kernel, 6, Ordering::byVDIM);
-      Array<int> H1Kernel_essDof(H1KernelFESpace->GetVSize()); H1Kernel_essDof = 0;
-      H1KernelFESpace->GetEssentialVDofs(essBnd, H1Kernel_essDof);
-
-
-      //setup the H(DivSkew) FESpace for the kernel
-      if (orderKer==1) { fecHDivSkewKernel = new DivSkew1_4DFECollection; }
-      //       else fecHDivSkewKernel = new DivSkewFull1_4DFECollection;
-      HDivSkewKernelFESpace = new ParFiniteElementSpace(pmesh, fecHDivSkewKernel);
-      Array<int> HDivSkewKernel_essDof(HDivSkewKernelFESpace->GetVSize());
-      HDivSkewKernel_essDof = 0;
-      HDivSkewKernelFESpace->GetEssentialVDofs(essBnd, HDivSkewKernel_essDof);
-
-
-      //setup the FESpace for the H1 injection
-      FiniteElementCollection* fecH1Vec;
-      if (orderIm==1) { fecH1Vec = new LinearFECollection; }
-      else { fecH1Vec = new QuadraticFECollection; }
-      ParFiniteElementSpace *H1_ImageFESpace = new ParFiniteElementSpace(pmesh,
-                                                                         fecH1Vec, dim, Ordering::byVDIM);
-      Array<int> H1Image_essDof(H1_ImageFESpace->GetVSize()); H1Image_essDof = 0;
-      H1_ImageFESpace->GetEssentialVDofs(essBnd, H1Image_essDof);
-
-
-
-      //setup the H1 preconditioner for the kernel
-      ParBilinearForm* H1Varf = new ParBilinearForm(H1KernelFESpace);
-      //    H1Varf->AddDomainIntegrator(new VectorDiffusionIntegrator(*alpha_, 6));
-      //    H1Varf->AddDomainIntegrator(new VectorMassIntegrator(6, beta_));
-
-      H1Varf->AddDomainIntegrator(new VectorDiffusionIntegrator(*beta_, 6));
-      H1Varf->Assemble();
-      H1Varf->Finalize();
-      SparseMatrix &matH1(H1Varf->SpMat());
-      for (int dof=0; dof<H1Kernel_essDof.Size(); dof++) if (H1Kernel_essDof[dof]<0) { matH1.EliminateRowCol(dof); }
-      H1_KernelMat = H1Varf->ParallelAssemble();
-      delete H1Varf;
-      amgH1_Kernel = new HypreBoomerAMG(*H1_KernelMat);
-      amgH1_Kernel->SetSystemsOptions(6);
-
-      //setup the H1 preconditioner for the image
-      ParBilinearForm* H1VecVarf = new ParBilinearForm(H1_ImageFESpace);
-      H1VecVarf->AddDomainIntegrator(new VectorDiffusionIntegrator(*alpha_));
-      H1VecVarf->AddDomainIntegrator(new VectorMassIntegrator(-1, beta_));
-      H1VecVarf->Assemble();
-      H1VecVarf->Finalize();
-      SparseMatrix &matH1Vec(H1VecVarf->SpMat());
-      for (int dof=0; dof<H1Image_essDof.Size(); dof++) if (H1Image_essDof[dof]<0) { matH1Vec.EliminateRowCol(dof); }
-      H1_ImageMat = H1VecVarf->ParallelAssemble();
-      delete H1VecVarf;
-      amgH1_Image = new HypreBoomerAMG(*H1_ImageMat);
-      amgH1_Image->SetSystemsOptions(dim);
-
-
-      //setup the injection of H1 into H(DivSkew)
-      ParDiscreteLinearOperator *disInterpolIm = new ParDiscreteLinearOperator(
-         H1KernelFESpace, HDivSkewKernelFESpace);
-      disInterpolIm->AddDomainInterpolator(new IdentityInterpolator);
-      disInterpolIm->Assemble();
-      disInterpolIm->Finalize();
-      SparseMatrix* smatIDIm = &(disInterpolIm->SpMat());
-      smatIDIm->EliminateCols(H1Kernel_essDof);
-      for (int dof=0; dof<HDivSkewKernel_essDof.Size();
-           dof++) if (HDivSkewKernel_essDof[dof]<0) { smatIDIm->EliminateRow(dof); }
-      P_H1_HDivSkew = disInterpolIm->ParallelAssemble();
-      delete disInterpolIm;
-
-      //setup the injection of H1 into H(div)
-      ParDiscreteLinearOperator *disInterpol = new ParDiscreteLinearOperator(
-         H1_ImageFESpace, fespace);
-      disInterpol->AddDomainInterpolator(new IdentityInterpolator);
-      disInterpol->Assemble();
-      disInterpol->Finalize();
-      SparseMatrix* smatID = &(disInterpol->SpMat());
-      smatID->EliminateCols(H1Image_essDof);
-      for (int dof=0; dof<Hdiv_essDof.Size(); dof++) if (Hdiv_essDof[dof]<0) { smatID->EliminateRow(dof); }
-      P_H1_Hdiv = disInterpol->ParallelAssemble();
-      delete disInterpol;
-
-
-
-
-      //setup the injection of the DivSkew(H(DivSkew)) into H(div)
-      ParDiscreteLinearOperator *disDivSkew = new ParDiscreteLinearOperator(
-         HDivSkewKernelFESpace, fespace);
-      disDivSkew->AddDomainInterpolator(new DivSkewInterpolator);
-      disDivSkew->Assemble();
-      disDivSkew->Finalize();
-      SparseMatrix* smatDivSkew= &(disDivSkew->SpMat());
-      smatDivSkew->EliminateCols(HDivSkewKernel_essDof);
-      for (int dof=0; dof<Hdiv_essDof.Size(); dof++) if (Hdiv_essDof[dof]<0) { smatDivSkew->EliminateRow(dof); }
-      P_d_HSkewDiv_Hdiv = disDivSkew->ParallelAssemble();
-      delete disDivSkew;
-
-
-      //setup the smoother for H(DivSkew)
-      ParBilinearForm *a_HDivSkew = new ParBilinearForm(HDivSkewKernelFESpace);
-      //    a_HDivSkew->AddDomainIntegrator(new DivSkewDivSkewIntegrator(*alpha_));
-      //    a_HDivSkew->AddDomainIntegrator(new VectorFE_DivSkewMassIntegrator(*beta_));
-
-      a_HDivSkew->AddDomainIntegrator(new DivSkewDivSkewIntegrator(*beta_));
-
-      a_HDivSkew->Assemble();
-      a_HDivSkew->Finalize();
-      SparseMatrix &matHDivSkew(a_HDivSkew->SpMat());
-      for (int dof=0; dof<HDivSkewKernel_essDof.Size();
-           dof++) if (HDivSkewKernel_essDof[dof]<0) { matHDivSkew.EliminateRowCol(dof); }
-      HDivSkewMat = a_HDivSkew->ParallelAssemble();
-      delete a_HDivSkew;
-      smootherDivSkew = new HypreSmoother(*HDivSkewMat, 16, 3);
-
-
-
-      f = new Vector(fespace->GetTrueVSize());
-
-      fKernel = new Vector(H1KernelFESpace->GetTrueVSize());
-      uKernel = new Vector(H1KernelFESpace->GetTrueVSize());
-
-      fImage = new Vector(H1_ImageFESpace->GetTrueVSize());
-      uImage = new Vector(H1_ImageFESpace->GetTrueVSize());
-
-      fDivSkew = new Vector(HDivSkewKernelFESpace->GetTrueVSize());
-      uDivSkew = new Vector(HDivSkewKernelFESpace->GetTrueVSize());
-
-      amgH1_Kernel->Mult(*fKernel, *uKernel);
-      amgH1_Image->Mult(*fImage, *uImage);
-
-      pcgKernel = new CGSolver(MPI_COMM_WORLD);
-      pcgKernel->SetOperator(*H1_KernelMat);
-      pcgKernel->SetPreconditioner(*amgH1_Kernel);
-      pcgKernel->SetRelTol(1e-16);
-      pcgKernel->SetMaxIter(100000000);
-      pcgKernel->SetPrintLevel(-2);
-
-      pcgImage = new CGSolver(MPI_COMM_WORLD);
-      pcgImage->SetOperator(*H1_ImageMat);
-      pcgImage->SetPreconditioner(*amgH1_Image);
-      pcgImage->SetRelTol(1e-16);
-      pcgImage->SetMaxIter(100000000);
-      pcgImage->SetPrintLevel(-2);
-
-      delete H1_ImageFESpace;
-      delete H1KernelFESpace;
-      delete fecH1Kernel;
-      delete fecH1Vec;
-   }
-
-   void setExactSolve(bool exSol)
-   {
-      exactSolves = exSol;
-   }
-
-   virtual void Mult(const Vector &x, Vector &y) const
-   {
-      smootherdiv->Mult(x,y);
-
-      P_H1_Hdiv->MultTranspose(x,*fImage);
-      *uImage = 0.0;
-      if (exactSolves) { pcgImage->Mult(*fImage, *uImage); }
-      else { amgH1_Image->Mult(*fImage, *uImage); }
-      P_H1_Hdiv->Mult(1.0, *uImage, 1.0, y);
-
-
-      *uDivSkew = 0.0;
-      P_d_HSkewDiv_Hdiv->MultTranspose(x,*fDivSkew);
-
-      smootherDivSkew->Mult(*fDivSkew, *uDivSkew);
-
-      P_H1_HDivSkew->MultTranspose(*fDivSkew,*fKernel);
-      *uKernel = 0.0;
-      if (exactSolves) { pcgKernel->Mult(*fKernel, *uKernel); }
-      else { amgH1_Kernel->Mult(*fKernel, *uKernel); }
-      P_H1_HDivSkew->Mult(1.0, *uKernel, 1.0, *uDivSkew);
-
-      P_d_HSkewDiv_Hdiv->Mult(1.0, *uDivSkew, 1.0, y);
-   }
-
-   virtual void SetOperator(const Operator &op) {};
-
-};
-
-
-
-
-int main(int argc, char *argv[])
-{
-   // 1. Initialize MPI.
-   int num_procs, myid;
-   MPI_Init(&argc, &argv);
-   MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
-   MPI_Comm_rank(MPI_COMM_WORLD, &myid);
-
-   bool verbose = (myid==0);
-
-   // 2. Parse command-line options.
-   const char *mesh_file = "../data/star.mesh";
-   int order = 1;
-   bool set_bc = true;
-   bool static_cond = false;
-   bool hybridization = false;
-   bool visualization = 1;
-   int sequ_ref_levels = 0;
-   int par_ref_levels = 0;
-   double tol = 1e-6;
-   double coeffWeight = 1.0;
-   bool spe10Coeff = false;
-   bool exactH1Solver = false;
-   bool standardCG = true;
-
-   int NExpo = 8;
-   int weightStart = -NExpo;
-   int weightEnd = NExpo;
-
-   OptionsParser args(argc, argv);
-   args.AddOption(&mesh_file, "-m", "--mesh",
-                  "Mesh file to use.");
-   args.AddOption(&order, "-o", "--order",
-                  "Finite element order (polynomial degree).");
-   args.AddOption(&sequ_ref_levels, "-sr", "--seqrefinement",
-                  "Number of sequential refinement steps.");
-   args.AddOption(&par_ref_levels, "-pr", "--parrefinement",
-                  "Number of parallel refinement steps.");
-   args.AddOption(&set_bc, "-bc", "--impose-bc", "-no-bc", "--dont-impose-bc",
-                  "Impose or not essential boundary conditions.");
-   args.AddOption(&freq, "-f", "--frequency", "Set the frequency for the exact"
-                  " solution.");
-   args.AddOption(&static_cond, "-sc", "--static-condensation", "-no-sc",
-                  "--no-static-condensation", "Enable static condensation.");
-   args.AddOption(&hybridization, "-hb", "--hybridization", "-no-hb",
-                  "--no-hybridization", "Enable hybridization.");
-   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
-                  "--no-visualization",
-                  "Enable or disable GLVis visualization.");
-   args.AddOption(&tol, "-tol", "--tol",
-                  "A parameter.");
-   args.AddOption(&coeffWeight, "-c", "--coeffMass",
-                  "the weight for the mass term.");
-   args.AddOption(&exactH1Solver, "-exH1Sol", "--exactH1Solver", "-H1prec",
-                  "--H1preconditioner",
-                  "Use exact H1 solvers for the preconditioner.");
-   args.AddOption(&spe10Coeff, "-spe10", "--useSPE10Coeff", "-constCoeff",
-                  "--constCoeff",
-                  "Switch between the coefficients for the mass bilinear form.");
-   args.AddOption(&standardCG, "-sCG", "--stdCG", "-rCG", "--resCG",
-                  "Switch between standard PCG or recompute residuals in every step and use the residuals itself for the stopping criteria.");
-   args.AddOption(&weightStart, "-ws", "--weightStart",
-                  "the exponent for the starting weight (for the mass term).");
-   args.AddOption(&weightEnd, "-we", "--weightEnd",
-                  "the exponent for the weight at the end (for the mass term).");
-
-   args.Parse();
-   if (!args.Good())
-   {
-      if (myid == 0)
-      {
-         args.PrintUsage(cout);
-      }
-      MPI_Finalize();
-      return 1;
-   }
-   if (myid == 0)
-   {
-      args.PrintOptions(cout);
-   }
-   kappa = freq * M_PI;
-
-   // 3. Read the (serial) mesh from the given mesh file on all processors.  We
-   //    can handle triangular, quadrilateral, tetrahedral, hexahedral, surface
-   //    and volume, as well as periodic meshes with the same code.
-   Mesh *mesh = new Mesh(mesh_file, 1, 1);
-   int dim = mesh->Dimension();
-   int sdim = mesh->SpaceDimension();
-
-   // 4. Refine the serial mesh on all processors to increase the resolution. In
-   //    this example we do 'ref_levels' of uniform refinement. We choose
-   //    'ref_levels' to be the largest number that gives a final mesh with no
-   //    more than 1,000 elements.
-   {
-      for (int l = 0; l < sequ_ref_levels; l++)
-      {
-         mesh->UniformRefinement();
-      }
-   }
-
-   // 5. Define a parallel mesh by a partitioning of the serial mesh. Refine
-   //    this mesh further in parallel to increase the resolution. Once the
-   //    parallel mesh is defined, the serial mesh can be deleted. Tetrahedral
-   //    meshes need to be reoriented before we can define high-order Nedelec
-   //    spaces on them (this is needed in the ADS solver below).
-   ParMesh *pmesh = new ParMesh(MPI_COMM_WORLD, *mesh);
-   delete mesh;
-   {
-      for (int l = 0; l < par_ref_levels; l++)
-      {
-         pmesh->UniformRefinement();
-      }
-   }
-   pmesh->ReorientTetMesh();
-
-   // 6. Define a parallel finite element space on the parallel mesh. Here we
-   //    use the Raviart-Thomas finite elements of the specified order.
-   FiniteElementCollection *fec;
-   if (dim==4) { fec = new RT0_4DFECollection; }
-   else { fec = new RT_FECollection(order-1, dim); }
-   ParFiniteElementSpace *fespace = new ParFiniteElementSpace(pmesh, fec);
-   HYPRE_Int size = fespace->GlobalTrueVSize();
-   if (myid == 0)
-   {
-      cout << "Number of finite element unknowns: " << size << endl;
-   }
-
-   // 7. Determine the list of true (i.e. parallel conforming) essential
-   //    boundary dofs. In this example, the boundary conditions are defined
-   //    by marking all the boundary attributes from the mesh as essential
-   //    (Dirichlet) and converting them to a list of true dofs.
-   Array<int> ess_tdof_list;
-   Array<int> ess_bdr(pmesh->bdr_attributes.Max());
-   ess_bdr = set_bc ? 1 : 0;
-   if (pmesh->bdr_attributes.Size())
-   {
-      fespace->GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
-   }
-
-
-   // 8. Set up the parallel linear form b(.) which corresponds to the
-   //    right-hand side of the FEM linear system, which in this case is
-   //    (f,phi_i) where f is given by the function f_exact and phi_i are the
-   //    basis functions in the finite element fespace.
-
-
-   // 9. Define the solution vector x as a parallel finite element grid function
-   //    corresponding to fespace. Initialize x by projecting the exact
-   //    solution. Note that only values from the boundary faces will be used
-   //    when eliminating the non-homogeneous boundary condition to modify the
-   //    r.h.s. vector b.
-   ParGridFunction x(fespace);
-   VectorFunctionCoefficient F(sdim, F_exact);
-
-   for (int expo=weightStart; expo<=weightEnd; expo++)
-   {
-      double weight = pow(10.0,expo);
-      kappa = weight;
-
-      x.ProjectCoefficient(F);
-
-      VectorFunctionCoefficient f(sdim, f_exact);
-      ParLinearForm *b = new ParLinearForm(fespace);
-      b->AddDomainIntegrator(new VectorFEDomainLFIntegrator(f));
-      b->Assemble();
-
-      // 10. Set up the parallel bilinear form corresponding to the H(div)
-      //     diffusion operator grad alpha div + beta I, by adding the div-div and
-      //     the mass domain integrators.
-
-      //    std::string permFile = "spe_perm.dat";
-      //    InversePermeabilityFunction::ReadPermeabilityFile(permFile, MPI_COMM_WORLD);
-
-      Coefficient *alpha = new ConstantCoefficient(1.0);
-      Coefficient *beta;
-      //    if(spe10Coeff) beta = new FunctionCoefficient(InversePermeabilityFunction::Norm2Permeability);
-      //    else
-      beta = new ConstantCoefficient(weight);
-
-      ParBilinearForm *a = new ParBilinearForm(fespace);
-      a->AddDomainIntegrator(new DivDivIntegrator(*alpha));
-      a->AddDomainIntegrator(new VectorFEMassIntegrator(*beta));
-
-      // 11. Assemble the parallel bilinear form and the corresponding linear
-      //     system, applying any necessary transformations such as: parallel
-      //     assembly, eliminating boundary conditions, applying conforming
-      //     constraints for non-conforming AMR, static condensation,
-      //     hybridization, etc.
-      FiniteElementCollection *hfec = NULL;
-      ParFiniteElementSpace *hfes = NULL;
-      if (static_cond)
-      {
-         a->EnableStaticCondensation();
-      }
-      else if (hybridization)
-      {
-         hfec = new DG_Interface_FECollection(order-1, dim);
-         hfes = new ParFiniteElementSpace(pmesh, hfec);
-         a->EnableHybridization(hfes, new NormalTraceJumpIntegrator(),
-                                ess_tdof_list);
-      }
-      a->Assemble();
-
-      HypreParMatrix A;
-      Vector B, X;
-      a->FormLinearSystem(ess_tdof_list, x, *b, A, X, B);
-
-      HYPRE_Int glob_size = A.GetGlobalNumRows();
-      if (myid == 0)
-      {
-         cout << "Size of linear system: " << glob_size << endl;
-      }
-
-      // 12. Define and apply a parallel PCG solver for A X = B with the 2D AMS or
-      //     the 3D ADS preconditioners from hypre. If using hybridization, the
-      //     system is preconditioned with hypre's BoomerAMG.
-      Solver *prec = NULL;
-      if (hybridization) { prec = new HypreBoomerAMG(A); }
-      else
-      {
-         ParFiniteElementSpace *prec_fespace =
-            (a->StaticCondensationIsEnabled() ? a->SCParFESpace() : fespace);
-         if (dim == 2)   { prec = new HypreAMS(A, prec_fespace); }
-         else if (dim==3) { prec = new HypreADS(A, prec_fespace); }
-         else if (dim==4) { prec = new div4dPrec(&A, fespace, alpha, beta, ess_bdr, order, exactH1Solver); }
-         else { prec = NULL; }
-      }
-
-      int iter = -1;
-      if (standardCG)
-      {
-         IterativeSolver *pcg = new CGSolver(MPI_COMM_WORLD);
-         pcg->SetOperator(A);
-         pcg->SetRelTol(tol);
-         pcg->SetMaxIter(500);
-         pcg->SetPrintLevel(1);
-         pcg->SetPreconditioner(*prec);
-         pcg->Mult(B, X);
-
-         iter = pcg->GetNumIterations();
-
-         delete pcg;
-      }
-      else
-      {
-         HyprePCG *pcg = new HyprePCG(A);
-         pcg->SetTol(tol);
-         pcg->SetMaxIter(5000);
-         pcg->SetResidualConvergenceOptions(1,tol);
-         pcg->SetPrintLevel(2);
-         //          pcg->SetPreconditioner(*prec);
-         pcg->Mult(B, X);
-
-         pcg->GetNumIterations(iter);
-
-         delete pcg;
-      }
-
-      if (myid==0)
-      {
-         cout << "Weigth: " << weight << " " << iter << endl;
-
-         int *iters = LoadIterations(10, 2*NExpo+1);
-         putIterationsInArray(iter, sequ_ref_levels+par_ref_levels, expo+NExpo,
-                              2*NExpo+1, iters);
-         WriteIterations(iters, 10, 2*NExpo+1);
-      }
-
-
-      // 13. Recover the parallel grid function corresponding to X. This is the
-      //     local finite element solution on each processor.
-      a->RecoverFEMSolution(X, *b, x);
-
-      // 14. Compute and print the L^2 norm of the error.
-      {
-         double err = x.ComputeL2Error(F);
-         if (myid == 0)
-         {
-            cout << "\n|| F_h - F ||_{L^2} = " << err << '\n' << endl;
-         }
-      }
-
-      // 15. Save the refined mesh and the solution in parallel. This output can
-      //     be viewed later using GLVis: "glvis -np <np> -m mesh -g sol".
-      //    {
-      //      ostringstream mesh_name, sol_name;
-      //      mesh_name << "mesh." << setfill('0') << setw(6) << myid;
-      //      sol_name << "sol." << setfill('0') << setw(6) << myid;
-      //
-      //      ofstream mesh_ofs(mesh_name.str().c_str());
-      //      mesh_ofs.precision(8);
-      //      pmesh->Print(mesh_ofs);
-      //
-      //      ofstream sol_ofs(sol_name.str().c_str());
-      //      sol_ofs.precision(8);
-      //      x.Save(sol_ofs);
-      //    }
-
-      // 16. Send the solution by socket to a GLVis server.
-      //    if (visualization)
-      //    {
-      //      char vishost[] = "localhost";
-      //      int  visport   = 19916;
-      //      socketstream sol_sock(vishost, visport);
-      //      sol_sock << "parallel " << num_procs << " " << myid << "\n";
-      //      sol_sock.precision(8);
-      //      sol_sock << "solution\n" << *pmesh << x << flush;
-      //    }
-
-      if (prec!=NULL) { delete prec; }
-      delete hfes;
-      delete hfec;
-      delete a;
-      delete alpha;
-      delete beta;
-
-      delete b;
-   }
-
-   // 17. Free the used memory.
-
-
-   delete fespace;
-   delete fec;
-   delete pmesh;
-
-   MPI_Finalize();
-
-   return 0;
-}
-
-
-// The exact solution (for non-surface meshes)
-void F_exact(const Vector &p, Vector &F)
-{
-   int dim = p.Size();
-
-   if (dim==4)
-   {
-      double s0 = sin(M_PI*p(0)), s1 = sin(M_PI*p(1)), s2 = sin(M_PI*p(2)),
-             s3 = sin(M_PI*p(3));
-      double c0 = cos(M_PI*p(0)), c1 = cos(M_PI*p(1)), c2 = cos(M_PI*p(2)),
-             c3 = cos(M_PI*p(3));
-
-      F(0) = c0 * s1 * s2 * s3;
-      F(1) = s0 * c1 * s2 * s3;
-      F(2) = s0 * s1 * c2 * s3;
-      F(3) = s0 * s1 * s2 * c3;
-   }
-   else
-   {
-      double x = p(0);
-      double y = p(1);
-      // double z = (dim == 3) ? p(2) : 0.0;
-
-      F(0) = cos(kappa*x)*sin(kappa*y);
-      F(1) = cos(kappa*y)*sin(kappa*x);
-      if (dim == 3)
-      {
-         F(2) = 0.0;
-      }
-   }
-}
-
-// The right hand side
-void f_exact(const Vector &p, Vector &f)
-{
-   int dim = p.Size();
-   if (dim==4)
-   {
-      double s0 = sin(M_PI*p(0)), s1 = sin(M_PI*p(1)), s2 = sin(M_PI*p(2)),
-             s3 = sin(M_PI*p(3));
-      double c0 = cos(M_PI*p(0)), c1 = cos(M_PI*p(1)), c2 = cos(M_PI*p(2)),
-             c3 = cos(M_PI*p(3));
-
-      f(0) = c0 * s1 * s2 * s3;
-      f(1) = s0 * c1 * s2 * s3;
-      f(2) = s0 * s1 * c2 * s3;
-      f(3) = s0 * s1 * s2 * c3;
-
-      f *= (kappa + 4.0 * M_PI*M_PI);
-   }
-   else
-   {
-      double x = p(0);
-      double y = p(1);
-      // double z = (dim == 3) ? p(2) : 0.0;
-
-      double temp = 1 + 2*kappa*kappa;
-
-      f(0) = temp*cos(kappa*x)*sin(kappa*y);
-      f(1) = temp*cos(kappa*y)*sin(kappa*x);
-      if (dim == 3)
-      {
-         f(2) = 0;
-      }
-   }
-}
@@ -23,15 +23,14 @@ MFEM_LIB_FILE = mfem_is_not_built

 SEQ_EXAMPLES = ex0 ex1 ex2 ex3 ex4 ex5 ex6 ex7 ex8 ex9 ex10 ex14 ex15 ex16 \
   ex17 ex18 ex19 ex20 ex21 ex22 ex23 ex24 ex25 ex26 ex27 ex28 ex29 ex30 \
-   ex31 ex33 ex34 ex36 ex37 ex38 ex39 ex40
+   ex31 ex33 ex34 ex36 ex37 ex38 ex39
 PAR_EXAMPLES = ex0p ex1p ex2p ex3p ex4p ex5p ex6p ex7p ex8p ex9p ex10p ex11p \
   ex12p ex13p ex14p ex15p ex16p ex17p ex18p ex19p ex20p ex21p ex22p ex24p \
   ex25p ex26p ex27p ex28p ex29p ex30p ex31p ex32p ex33p ex34p ex35p ex36p \
-   ex37p ex39p ex40p \
-   ex1p_4d ex3p_4d ex4D_DivSkew
-SEQ_DEVICE_EXAMPLES = ex1 ex3 ex4 ex5 ex6 ex9 ex14 ex22 ex24 ex25 ex26 ex34
-PAR_DEVICE_EXAMPLES = ex1p ex2p ex3p ex4p ex5p ex6p ex7p ex9p ex13p ex14p \
-   ex22p ex24p ex25p ex26p ex34p ex35p
+   ex37p ex39p
+SEQ_DEVICE_EXAMPLES = ex1 ex3 ex4 ex5 ex6 ex9 ex22 ex24 ex25 ex26 ex34
+PAR_DEVICE_EXAMPLES = ex1p ex2p ex3p ex4p ex5p ex6p ex7p ex9p ex13p ex22p \
+   ex24p ex25p ex26p ex34p ex35p

 ifeq ($(MFEM_USE_LAPACK),YES)
   SEQ_EXAMPLES += ex38
@@ -139,14 +138,6 @@ ex10-test-seq: ex10
 	@$(call mfem-test,$<,, Serial example,-tf 5)
 ex10p-test-par: ex10p
 	@$(call mfem-test,$<, $(RUN_MPI), Parallel example,-tf 5)
-ex14-test-seq-cuda: ex14
-	@$(call mfem-test,$<,, Serial CUDA example,-r 2 -pa -d cuda)
-ex14p-test-par-cuda: ex14p
-	@$(call mfem-test,$<, $(RUN_MPI), Parallel CUDA example,-rs 2 -rp 0 -pa -d cuda)
-ex14-test-seq-hip: ex14
-	@$(call mfem-test,$<,, Serial HIP example,-r 2 -pa -d hip)
-ex14p-test-par-hip: ex14p
-	@$(call mfem-test,$<, $(RUN_MPI), Parallel HIP example,-rs 2 -rp 0 -pa -d hip)
 ex15-test-seq: ex15
 	@$(call mfem-test,$<,, Serial example,-e 1)
 ex15p-test-par: ex15p
@@ -0,0 +1,510 @@
+//                                MFEM Maxwell example (with imaginary mass coeff)
+//
+//                   ∇×(1/μ ∇×E) - (ω^2 ϵ + i ω σ) E = J ,   in Ω   (by default ϵ=0)
+//                                               E×n = E_0, on ∂Ω
+//
+// Compile with: pmaxwell
+//
+// Sample runs:
+
+
+// mpirun -np 8 ./pmaxwell -o 1 -sref 0  -m ../data/inline-hex.mesh -rnum 3.0  -pref 4 -sigma 1.0 -no-herm -vis
+/*
+  Ref |    Dofs    |    ω    | H(curl) Error |  Rate  | Solv it |
+-----------------------------------------------------------------
+    0 |        300 |  6.0 π  |     2.697e+01 |   0.00 |  28 (20)|
+    1 |       1944 |  6.0 π  |     2.183e+01 |  -0.34 |  28 (19)|
+    2 |      13872 |  6.0 π  |     1.227e+01 |  -0.88 |  30 (19)|
+    3 |     104544 |  6.0 π  |     6.341e+00 |  -0.98 |  36 (19)|
+    4 |     811200 |  6.0 π  |     3.197e+00 |  -1.00 |  46 (19)|
+*/
+
+// mpirun -np 8 ./pmaxwell -o 2 -sref 0  -m ../data/inline-hex.mesh -rnum 3.0  -pref 3 -sigma 1.0 -vis
+/*
+  Ref |    Dofs    |    ω    | H(curl) Error |  Rate  | Solv it |
+-----------------------------------------------------------------
+    0 |       1944 |  6.0 π  |     2.121e+01 |   0.00 |  28 (24)|
+    1 |      13872 |  6.0 π  |     7.291e+00 |  -1.63 |  34 (19)|
+    2 |     104544 |  6.0 π  |     1.926e+00 |  -1.98 |  48 (19)|
+    3 |     811200 |  6.0 π  |     4.862e-01 |  -2.02 |  60 (19)|
+*/
+
+
+// mpirun -np 8 ./pmaxwell -o 3 -sref 0  -m ../data/inline-hex.mesh -rnum 3.0  -pref 2 -sigma 1.0 -vis
+/*
+  Ref |    Dofs    |    ω    | H(curl) Error |  Rate  | Solv it |
+-----------------------------------------------------------------
+    0 |       6084 |  6.0 π  |     9.797e+00 |   0.00 |  36 (22)|
+    1 |      45000 |  6.0 π  |     1.475e+00 |  -2.84 |  56 (19)|
+    2 |     345744 |  6.0 π  |     1.918e-01 |  -3.00 |  78 (19)|
+*/
+// Note: (*) indicates a priconditioner with exact inverse of the diagonal blocks
+
+#include "mfem.hpp"
+#include <fstream>
+#include <iostream>
+
+using namespace std;
+using namespace mfem;
+
+void E_exact_r(const Vector &x, Vector & E_r);
+void E_exact_i(const Vector &x, Vector & E_i);
+
+void  rhs_func_r(const Vector &x, Vector & J_r);
+void  rhs_func_i(const Vector &x, Vector & J_i);
+
+void curlE_exact_r(const Vector &x, Vector &curlE_r);
+void curlE_exact_i(const Vector &x, Vector &curlE_i);
+
+void maxwell_solution(const Vector & X,
+                      std::vector<complex<real_t>> &E);
+
+void maxwell_solution_curl(const Vector & X,
+                           std::vector<complex<real_t>> &curlE);
+
+void maxwell_solution_curlcurl(const Vector & X,
+                               std::vector<complex<real_t>> &curlcurlE);
+
+int dim;
+int dimc;
+real_t omega;
+real_t mu = 1.0;
+real_t epsilon = 0.0;
+real_t sigma = 0.1;
+
+complex<real_t> zi = complex<real_t>(0., 1.);
+
+int main(int argc, char *argv[])
+{
+   Mpi::Init();
+   int myid = Mpi::WorldRank();
+   int num_procs = Mpi::WorldSize();
+   Hypre::Init();
+
+   const char *mesh_file = "../data/inline-hex.mesh";
+
+   int order = 1;
+   bool visualization = false;
+   real_t rnum=1.0;
+   int sr = 0;
+   int pr = 0;
+   bool paraview = false;
+   bool mumps_solver = false;
+   bool herm_conv = true;
+
+   OptionsParser args(argc, argv);
+   args.AddOption(&mesh_file, "-m", "--mesh",
+                  "Mesh file to use.");
+   args.AddOption(&order, "-o", "--order",
+                  "Finite element order (polynomial degree)");
+   args.AddOption(&rnum, "-rnum", "--number_of_wavelenths",
+                  "Number of wavelengths");
+   args.AddOption(&mu, "-mu", "--permeability",
+                  "Permeability of free space (or 1/(spring constant)).");
+   args.AddOption(&epsilon, "-eps", "--permittivity",
+                  "Permittivity of free space (or mass constant).");
+   args.AddOption(&sigma, "-sigma", "--conductivity",
+                  "Conductivity");
+   args.AddOption(&sr, "-sref", "--serial_ref",
+                  "Number of serial refinements.");
+   args.AddOption(&pr, "-pref", "--parallel_ref",
+                  "Number of parallel refinements.");
+   args.AddOption(&herm_conv, "-herm", "--hermitian", "-no-herm",
+                  "--no-hermitian", "Use convention for Hermitian operators.");
+   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
+                  "--no-visualization",
+                  "Enable or disable GLVis visualization.");
+   args.AddOption(&paraview, "-paraview", "--paraview", "-no-paraview",
+                  "--no-paraview",
+                  "Enable or disable ParaView visualization.");
+   args.AddOption(&mumps_solver, "-mumps-solver", "--mumps-solver",
+                  "-no-mumps-solver",
+                  "--no-mumps-solver",
+                  "Enable or disable mumps solver");
+   args.Parse();
+   if (!args.Good())
+   {
+      if (myid == 0)
+      {
+         args.PrintUsage(cout);
+      }
+      return 1;
+   }
+   if (myid == 0)
+   {
+      args.PrintOptions(cout);
+   }
+
+   ComplexOperator::Convention conv =
+      herm_conv ? ComplexOperator::HERMITIAN : ComplexOperator::BLOCK_SYMMETRIC;
+
+
+   socketstream E_out_r;
+   socketstream E_out_i;
+
+   omega = real_t(2.0 * M_PI)*rnum;
+
+   Mesh mesh(mesh_file, 1, 1);
+   dim = mesh.Dimension();
+   dimc = (dim == 3) ? 3 : 1;
+
+   for (int i = 0; i<sr; i++)
+   {
+      mesh.UniformRefinement();
+   }
+
+   ParMesh pmesh(MPI_COMM_WORLD, mesh);
+   mesh.Clear();
+
+   ND_FECollection fec(order, dim);
+   ParFiniteElementSpace E_fes(&pmesh, &fec);
+
+   // Bilinear form coefficients
+   ConstantCoefficient one(1.0);
+   ConstantCoefficient muinv(1./mu);
+   ConstantCoefficient omeg(omega);
+   ConstantCoefficient eps(epsilon);
+
+   ConstantCoefficient negomeg2eps(-omega*omega*epsilon);
+   ConstantCoefficient omegsigma(omega*sigma);
+
+   VectorFunctionCoefficient Jr(dim,rhs_func_r);
+   VectorFunctionCoefficient Ji(dim,rhs_func_i);
+
+   VectorFunctionCoefficient Er(dim,E_exact_r);
+   VectorFunctionCoefficient Ei(dim,E_exact_i);
+
+   VectorFunctionCoefficient CurlEr(dim,curlE_exact_r);
+   VectorFunctionCoefficient CurlEi(dim,curlE_exact_i);
+
+   ParComplexLinearForm b(&E_fes, conv);
+   b.Vector::operator=(0.0);
+   b.AddDomainIntegrator(new VectorFEDomainLFIntegrator(Jr),
+                         new VectorFEDomainLFIntegrator(Ji));
+
+
+   ParSesquilinearForm a(&E_fes, conv);
+   a.AddDomainIntegrator(new CurlCurlIntegrator(muinv),nullptr);
+   a.AddDomainIntegrator(new VectorFEMassIntegrator(negomeg2eps),
+                         new VectorFEMassIntegrator(omegsigma));
+
+
+
+   ParBilinearForm prec(&E_fes);
+   prec.AddDomainIntegrator(new CurlCurlIntegrator(muinv));
+   prec.AddDomainIntegrator(new VectorFEMassIntegrator(omegsigma));
+
+   ParComplexGridFunction E_gf(&E_fes);
+   E_gf.real() = 0.0;
+   E_gf.imag() = 0.0;
+
+   ParaViewDataCollection * paraview_dc = nullptr;
+
+   if (paraview)
+   {
+      paraview_dc = new ParaViewDataCollection(mesh_file, &pmesh);
+      paraview_dc->SetPrefixPath("ParaView");
+      paraview_dc->SetLevelsOfDetail(order);
+      paraview_dc->SetCycle(0);
+      paraview_dc->SetDataFormat(VTKFormat::BINARY);
+      paraview_dc->SetHighOrderOutput(true);
+      paraview_dc->SetTime(0.0); // set the time
+      paraview_dc->RegisterField("E_r",&E_gf.real());
+      paraview_dc->RegisterField("E_i",&E_gf.imag());
+   }
+
+   if (Mpi::Root())
+   {
+      std::cout << "\n  Ref |"
+                << "    Dofs    |"
+                << "    ω    |"
+                << " H(curl) Error |"
+                << "  Rate  |"
+                << " Solv it |" << endl;
+      std::cout << std::string(65,'-')
+                << endl;
+   }
+
+   real_t err0 = 0.;
+   int dof0;
+
+   for (int it = 0; it<=pr; it++)
+   {
+      b.Assemble();
+      a.Assemble();
+      prec.Assemble();
+
+      Array<int> ess_tdof_list;
+      Array<int> ess_bdr;
+
+      if (pmesh.bdr_attributes.Size())
+      {
+         ess_bdr.SetSize(pmesh.bdr_attributes.Max());
+         ess_bdr = 1;
+         E_fes.GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
+      }
+
+      E_gf.real() = 0.0;
+      E_gf.imag() = 0.0;
+      E_gf.ProjectBdrCoefficientTangent(Er,Ei, ess_bdr);
+
+      OperatorPtr A;
+      Vector B, X;
+      a.FormLinearSystem(ess_tdof_list, E_gf, b, A, X, B);
+
+      HypreParMatrix M;
+      prec.FormSystemMatrix(ess_tdof_list, M);
+
+      Array<int> offsets(3);
+      offsets[0] = 0;
+      offsets[1] = E_fes.TrueVSize();
+      offsets[2] = E_fes.TrueVSize();
+      offsets.PartialSum();
+      BlockDiagonalPreconditioner BlockPrec(offsets);
+
+      std::unique_ptr<Operator> pc_r;
+      std::unique_ptr<Operator> pc_i;
+      int s = (conv == ComplexOperator::HERMITIAN) ? -1 : 1;
+
+#ifdef MFEM_USE_MUMPS
+      if (mumps_solver)
+      {
+         pc_r.reset(new MUMPSSolver(M));
+         pc_i.reset(new ScaledOperator(pc_r.get(), s));
+      }
+#else
+      mumps_solver = false;
+#endif
+      if (!mumps_solver)
+      {
+         pc_r.reset(new HypreAMS(M,&E_fes));
+         pc_i.reset(new ScaledOperator(pc_r.get(), s));
+      }
+
+      BlockPrec.SetDiagonalBlock(0,pc_r.get());
+      BlockPrec.SetDiagonalBlock(1,pc_i.get());
+
+      std::unique_ptr<IterativeSolver> solver;
+      if (conv == ComplexOperator::HERMITIAN)
+      {
+         solver.reset(new FGMRESSolver(MPI_COMM_WORLD));
+      }
+      else
+      {
+         solver.reset(new MINRESSolver(MPI_COMM_WORLD));
+      }
+      solver.get()->SetRelTol(1e-12);
+      solver.get()->SetMaxIter(2000);
+      solver.get()->SetPrintLevel(0);
+      solver.get()->SetPreconditioner(BlockPrec);
+      solver.get()->SetOperator(*A);
+      solver.get()->Mult(B, X);
+      int num_iter = solver.get()->GetNumIterations();
+
+      a.RecoverFEMSolution(X, b, E_gf);
+
+      real_t err_r = E_gf.real().ComputeHCurlError(&Er,&CurlEr);
+      real_t err_i = E_gf.imag().ComputeHCurlError(&Ei,&CurlEi);
+
+      real_t totalerr = std::sqrt(err_r*err_r + err_i*err_i);
+
+      int dofs = E_fes.GlobalTrueVSize();
+
+      real_t rate_err = (it) ? dim*log(err0/totalerr)/log((real_t)dof0/dofs) : 0.0;
+
+      err0 = totalerr;
+      dof0 = dofs;
+
+      if (Mpi::Root())
+      {
+         std::ios oldState(nullptr);
+         oldState.copyfmt(std::cout);
+         std::cout << std::right << std::setw(5) << it << " | "
+                   << std::setw(10) <<  dof0 << " | "
+                   << std::setprecision(1) << std::fixed
+                   << std::setw(4) <<  2.0*rnum << " π  | "
+                   << std::setprecision(3);
+         std::cout << std::setw(13) << std::scientific <<  err0 << " | "
+                   << std::setprecision(2)
+                   << std::setw(6) << std::fixed << rate_err << " | "
+                   << std::setw(7) << std::fixed << num_iter << " | "
+                   << std::endl;
+         std::cout.copyfmt(oldState);
+      }
+
+      if (visualization)
+      {
+         // Define visualization keys for GLVis (see GLVis documentation)
+         string keys;
+         keys = (dim == 3) ? "keys macF\n" : keys = "keys amrRljcUUuu\n";
+
+         char vishost[] = "localhost";
+         int visport = 19916;
+
+         {
+            socketstream sol_sock_re(vishost, visport);
+            sol_sock_re.precision(8);
+            sol_sock_re << "parallel " << num_procs << " " << myid << "\n"
+                        << "solution\n" << pmesh << E_gf.real() << keys
+                        << "window_title 'Solution real part'" << flush;
+         }
+
+         {
+            socketstream sol_sock_im(vishost, visport);
+            sol_sock_im.precision(8);
+            sol_sock_im << "parallel " << num_procs << " " << myid << "\n"
+                        << "solution\n" << pmesh << E_gf.imag() << keys
+                        << "window_title 'Solution imag part'" << flush;
+         }
+      }
+
+      if (paraview)
+      {
+         paraview_dc->SetCycle(it);
+         paraview_dc->SetTime((real_t)it);
+         paraview_dc->Save();
+      }
+
+      pmesh.UniformRefinement();
+
+      E_fes.Update();
+      E_gf.Update();
+      a.Update();
+      b.Update();
+      prec.Update();
+   }
+   if (paraview)
+   {
+      delete paraview_dc;
+   }
+
+   return 0;
+}
+
+void maxwell_solution(const Vector & X, std::vector<complex<real_t>> &E)
+{
+   E.resize(dim);
+   for (int i = 0; i < dim; ++i)
+   {
+      E[i] = 0.0;
+   }
+   E[0] = exp(zi * omega * (X.Sum()));
+}
+
+void maxwell_solution_curl(const Vector & X,
+                           std::vector<complex<real_t>> &curlE)
+{
+   curlE.resize(dimc);
+   for (int i = 0; i < dimc; ++i)
+   {
+      curlE[i] = 0.0;
+   }
+   std::complex<real_t> pw = exp(zi * omega * (X.Sum()));
+   if (dim == 3)
+   {
+      curlE[0] = 0.0;
+      curlE[1] = zi * omega * pw;
+      curlE[2] = -zi * omega * pw;
+   }
+   else
+   {
+      curlE[0] = -zi * omega * pw;
+   }
+}
+
+void maxwell_solution_curlcurl(const Vector & X,
+                               std::vector<complex<real_t>> &curlcurlE)
+{
+   curlcurlE.resize(dim);
+   for (int i = 0; i < dim; ++i)
+   {
+      curlcurlE[i] = 0.0;;
+   }
+   std::complex<real_t> pw = exp(zi * omega * (X.Sum()));
+   if (dim == 3)
+   {
+      curlcurlE[0] = 2_r * omega * omega * pw;
+      curlcurlE[1] = - omega * omega * pw;
+      curlcurlE[2] = - omega * omega * pw;
+   }
+   else
+   {
+      curlcurlE[0] = omega * omega * pw;
+      curlcurlE[1] = -omega * omega * pw;
+   }
+}
+
+void E_exact_r(const Vector &x, Vector & E_r)
+{
+   std::vector<std::complex<real_t>> E;
+   maxwell_solution(x,E);
+   E_r.SetSize(E.size());
+   for (unsigned i = 0; i < E.size(); i++)
+   {
+      E_r[i]= E[i].real();
+   }
+}
+
+void E_exact_i(const Vector &x, Vector & E_i)
+{
+   std::vector<std::complex<real_t>> E;
+   maxwell_solution(x, E);
+   E_i.SetSize(E.size());
+   for (unsigned i = 0; i < E.size(); i++)
+   {
+      E_i[i]= E[i].imag();
+   }
+}
+
+void curlE_exact_r(const Vector &x, Vector &curlE_r)
+{
+   std::vector<std::complex<real_t>> curlE;
+   maxwell_solution_curl(x, curlE);
+   curlE_r.SetSize(curlE.size());
+   for (unsigned i = 0; i < curlE.size(); i++)
+   {
+      curlE_r[i]= curlE[i].real();
+   }
+}
+
+void curlE_exact_i(const Vector &x, Vector &curlE_i)
+{
+   std::vector<std::complex<real_t>> curlE;
+   maxwell_solution_curl(x, curlE);
+   curlE_i.SetSize(curlE.size());
+   for (unsigned i = 0; i < curlE.size(); i++)
+   {
+      curlE_i[i]= curlE[i].imag();
+   }
+}
+
+void  rhs_func_r(const Vector &x, Vector & J_r)
+{
+   std::vector<std::complex<real_t>> curlcurlE;
+   std::vector<std::complex<real_t>> E;
+   maxwell_solution(x,E);
+   maxwell_solution_curlcurl(x, curlcurlE);
+   J_r.SetSize(dim);
+   for (int i = 0; i<dim; i++)
+   {
+      const complex<real_t> tmp = 1_r/mu*curlcurlE[i]
+                                  + zi * omega *(sigma+zi*omega*epsilon) *E[i];
+      J_r(i) = tmp.real();
+   }
+}
+
+void  rhs_func_i(const Vector &x, Vector & J_i)
+{
+   std::vector<std::complex<real_t>> curlcurlE;
+   std::vector<std::complex<real_t>> E;
+   maxwell_solution(x,E);
+   maxwell_solution_curlcurl(x, curlcurlE);
+   J_i.SetSize(dim);
+   for (int i = 0; i<dim; i++)
+   {
+      const complex<real_t> tmp = 1_r/mu*curlcurlE[i]
+                                  + zi * omega *(sigma+zi*omega*epsilon) *E[i];
+      J_i(i) = tmp.imag();
+   }
+}
+
@@ -66,6 +66,7 @@ int main(int argc, char *argv[])
 {
   // 1. Initialize MPI (required by PUMI) and HYPRE.
   Mpi::Init(argc, argv);
+   int num_procs = Mpi::WorldSize();
   int myid = Mpi::WorldRank();
   Hypre::Init();

@@ -80,6 +80,8 @@ int main(int argc, char *argv[])
 {
   // 1. Initialize MPI (required by PUMI) and HYPRE.
   Mpi::Init(argc, argv);
+   int num_proc = Mpi::WorldSize();
+   int myId = Mpi::WorldRank();
   Hypre::Init();

   // 2. Parse command-line options.
@@ -1,352 +0,0 @@
-/*
- * spe10_coeff.cpp
- *
- *  Created on: Aug 23, 2017
- *      Author: neumueller
- */
-
-#include "mfem.hpp"
-#include <fstream>
-#include <iostream>
-
-using namespace std;
-using namespace mfem;
-
-class InversePermeabilityFunction
-{
-public:
-
-   enum SliceOrientation {NONE, XY, XZ, YZ};
-
-   static void SetNumberCells(int Nx_, int Ny_, int Nz_);
-   static void SetMeshSizes(double hx, double hy, double hz);
-   static void Set2DSlice(SliceOrientation o, int npos );
-
-   static void ReadPermeabilityFile(const std::string fileName);
-#ifdef MFEM_USE_MPI
-   static void ReadPermeabilityFile(const std::string fileName, MPI_Comm comm);
-#endif
-   static void SetConstantInversePermeability(double ipx, double ipy, double ipz);
-
-   template<class F>
-   static void Transform(const F & f)
-   {
-      for (int i = 0; i < 3*Nx*Ny*Nz; ++i)
-      {
-         inversePermeability[i] = f(inversePermeability[i]);
-      }
-   }
-
-   static void InversePermeability(const Vector & x, Vector & val);
-   static double PermeabilityXY(Vector &x);
-   static void NegativeInversePermeability(const Vector & x, Vector & val);
-   static void Permeability(const Vector & x, Vector & val);
-
-   static double Norm2Permeability(const Vector & x);
-
-   static double Norm2InversePermeability(const Vector & x);
-   static double Norm1InversePermeability(const Vector & x);
-   static double NormInfInversePermeability(const Vector & x);
-
-   static double InvNorm2(const Vector & x);
-   static double InvNorm1(const Vector & x);
-   static double InvNormInf(const Vector & x);
-
-
-   static void ClearMemory();
-
-private:
-   static int Nx;
-   static int Ny;
-   static int Nz;
-   static double hx;
-   static double hy;
-   static double hz;
-   static double * inversePermeability;
-
-   static SliceOrientation orientation;
-   static int npos;
-};
-
-
-void InversePermeabilityFunction::SetNumberCells(int Nx_, int Ny_, int Nz_)
-{
-   Nx = Nx_;
-   Ny = Ny_;
-   Nz = Nz_;
-}
-
-void InversePermeabilityFunction::SetMeshSizes(double hx_, double hy_,
-                                               double hz_)
-{
-   hx = hx_;
-   hy = hy_;
-   hz = hz_;
-}
-
-void InversePermeabilityFunction::Set2DSlice(SliceOrientation o, int npos_ )
-{
-   orientation = o;
-   npos = npos_;
-}
-
-void InversePermeabilityFunction::SetConstantInversePermeability(double ipx,
-                                                                 double ipy, double ipz)
-{
-   int compSize = Nx*Ny*Nz;
-   int size = 3*compSize;
-   inversePermeability = new double [size];
-   double *ip = inversePermeability;
-
-   for (int i(0); i < compSize; ++i)
-   {
-      ip[i] = ipx;
-      ip[i+compSize] = ipy;
-      ip[i+2*compSize] = ipz;
-   }
-
-}
-
-#ifdef MFEM_USE_MPI
-void InversePermeabilityFunction::ReadPermeabilityFile(const std::string
-                                                       fileName, MPI_Comm comm)
-{
-   int num_procs, myid;
-   MPI_Comm_size(comm, &num_procs);
-   MPI_Comm_rank(comm, &myid);
-
-   StopWatch chrono;
-
-   chrono.Start();
-   if (myid == 0)
-   {
-      ReadPermeabilityFile(fileName);
-   }
-   else
-   {
-      inversePermeability = new double [3*Nx*Ny*Nz];
-   }
-   chrono.Stop();
-
-   if (myid==0)
-   {
-      std::cout<<"Permeability file read in " << chrono.RealTime() << ".s \n";
-   }
-
-   chrono.Clear();
-
-   chrono.Start();
-   MPI_Bcast(inversePermeability, 3*Nx*Ny*Nz, MPI_DOUBLE, 0, comm);
-   chrono.Stop();
-
-   if (myid==0)
-   {
-      std::cout<<"Permeability field distributed in " << chrono.RealTime() <<
-               ".s \n";
-   }
-
-}
-#endif
-
-void InversePermeabilityFunction::ReadPermeabilityFile(const std::string
-                                                       fileName)
-{
-   std::ifstream permfile(fileName.c_str());
-
-   if (!permfile.is_open())
-   {
-      std::cout << "Error in opening file " << fileName << "\n";
-      mfem_error("File do not exists");
-   }
-
-   inversePermeability = new double [3*Nx*Ny*Nz];
-   double *ip = inversePermeability;
-   double tmp;
-   for (int l = 0; l < 3; l++)
-   {
-      for (int k = 0; k < Nz; k++)
-      {
-         for (int j = 0; j < Ny; j++)
-         {
-            for (int i = 0; i < Nx; i++)
-            {
-               permfile >> *ip;
-               *ip = 1./(*ip);
-               ip++;
-            }
-            for (int i = 0; i < 60-Nx; i++)
-            {
-               permfile >> tmp;   // skip unneeded part
-            }
-         }
-         for (int j = 0; j < 220-Ny; j++)
-            for (int i = 0; i < 60; i++)
-            {
-               permfile >> tmp;   // skip unneeded part
-            }
-      }
-
-      if (l < 2) // if not processing Kz, skip unneeded part
-         for (int k = 0; k < 85-Nz; k++)
-            for (int j = 0; j < 220; j++)
-               for (int i = 0; i < 60; i++)
-               {
-                  permfile >> tmp;
-               }
-   }
-
-}
-
-void InversePermeabilityFunction::InversePermeability(const Vector & x,
-                                                      Vector & val)
-{
-   val.SetSize(3);
-
-   unsigned int i,j,k;
-
-   switch (orientation)
-   {
-      case NONE:
-         i = Nx-1-(int)floor(x[0]/hx/(1.+3e-16));
-         j = (int)floor(x[1]/hy/(1.+3e-16));
-         k = Nz-1-(int)floor(x[2]/hz/(1.+3e-16));
-         break;
-      case XY:
-         i = Nx-1-(int)floor(x[0]/hx/(1.+3e-16));
-         j = (int)floor(x[1]/hy/(1.+3e-16));
-         k = npos;
-         break;
-      case XZ:
-         i = Nx-1-(int)floor(x[0]/hx/(1.+3e-16));
-         j = npos;
-         k = Nz-1-(int)floor(x[2]/hz/(1.+3e-16));
-         break;
-      case YZ:
-         i = npos;
-         j = (int)floor(x[1]/hy/(1.+3e-16));
-         k = Nz-1-(int)floor(x[2]/hz/(1.+3e-16));
-         break;
-      default:
-      {
-         mfem_error("InversePermeabilityFunction::InversePermeability");
-      }
-   }
-
-
-   int NMax = 3*Nx*Ny*Nz-1;
-   if (Ny*Nx*k + Nx*j + i>NMax || Ny*Nx*k + Nx*j + i + Nx*Ny*Nz>NMax ||
-       Ny*Nx*k + Nx*j + i + 2*Nx*Ny*Nz>NMax)
-   {
-      cout << " the indicies are wrong!" << endl;
-      cout << i << " " << j << " " << k << endl;
-   }
-
-   val[0] = inversePermeability[Ny*Nx*k + Nx*j + i];
-   val[1] = inversePermeability[Ny*Nx*k + Nx*j + i + Nx*Ny*Nz];
-
-   if (orientation == NONE)
-   {
-      val[2] = inversePermeability[Ny*Nx*k + Nx*j + i + 2*Nx*Ny*Nz];
-   }
-
-}
-
-double InversePermeabilityFunction::PermeabilityXY(Vector &x)
-{
-   unsigned int i,j,k;
-
-   i = Nx-1-(int)floor(x[0]/hx/(1.+3e-16));
-   j = (int)floor(x[1]/hy/(1.+3e-16));
-   k = npos;
-
-   return 1./inversePermeability[Ny*Nx*k + Nx*j + i];
-}
-
-void InversePermeabilityFunction::NegativeInversePermeability(const Vector & x,
-                                                              Vector & val)
-{
-   InversePermeability(x,val);
-   val *= -1.;
-}
-
-
-void InversePermeabilityFunction::Permeability(const Vector & x, Vector & val)
-{
-   InversePermeability(x,val);
-
-   for (double * it = val.GetData(), *end = val.GetData()+val.Size(); it != end;
-        ++it )
-   {
-      (*it) = 1./ (*it);
-   }
-}
-
-double InversePermeabilityFunction::Norm2Permeability(const Vector & x)
-{
-   Vector val(3);
-   Permeability(x,val);
-   return val.Norml2();
-}
-
-
-double InversePermeabilityFunction::Norm2InversePermeability(const Vector & x)
-{
-   Vector val(3);
-   InversePermeability(x,val);
-   return val.Norml2();
-}
-
-double InversePermeabilityFunction::Norm1InversePermeability(const Vector & x)
-{
-   Vector val(3);
-   InversePermeability(x,val);
-   return val.Norml1();
-}
-
-double InversePermeabilityFunction::NormInfInversePermeability(const Vector & x)
-{
-   Vector val(3);
-   InversePermeability(x,val);
-   return val.Normlinf();
-}
-
-double InversePermeabilityFunction::InvNorm2(const Vector & x)
-{
-   Vector val(3);
-   InversePermeability(x,val);
-   return 1./val.Norml2();
-}
-
-double InversePermeabilityFunction::InvNorm1(const Vector & x)
-{
-   Vector val(3);
-   InversePermeability(x,val);
-   return 1./val.Norml1();
-}
-
-double InversePermeabilityFunction::InvNormInf(const Vector & x)
-{
-   Vector val(3);
-   InversePermeability(x,val);
-   return 1./val.Normlinf();
-}
-
-
-void InversePermeabilityFunction::ClearMemory()
-{
-   delete[] inversePermeability;
-}
-
-int InversePermeabilityFunction::Nx(60);
-int InversePermeabilityFunction::Ny(220);
-int InversePermeabilityFunction::Nz(85);
-double InversePermeabilityFunction::hx(20);
-double InversePermeabilityFunction::hy(10);
-double InversePermeabilityFunction::hz(2);
-double * InversePermeabilityFunction::inversePermeability(NULL);
-InversePermeabilityFunction::SliceOrientation
-InversePermeabilityFunction::orientation( InversePermeabilityFunction::NONE );
-int InversePermeabilityFunction::npos(-1);
-
-
-
@@ -1833,6 +1833,7 @@ void MixedBilinearForm::FormRectangularSystemMatrix(
   const Array<int> &trial_tdof_list,
   const Array<int> &test_tdof_list,
   OperatorHandle &A)
+
 {
   if (ext)
   {
@@ -1911,14 +1912,8 @@ void MixedBilinearForm::FormRectangularLinearSystem(
   B.SetSubVector(test_tdof_list, 0.0);
 }

-void MixedBilinearForm::Update(FiniteElementSpace *ntr_fes,
-      FiniteElementSpace *nte_fes)
+void MixedBilinearForm::Update()
 {
-   if ((ntr_fes && nte_fes) && (ntr_fes != trial_fes || nte_fes != test_fes))
-   {
-      trial_fes = ntr_fes;
-      test_fes = nte_fes;
-   }
   delete mat;
   mat = NULL;
   delete mat_e;
@@ -706,10 +706,6 @@ public:
   */
   void SetDiagonalPolicy(DiagonalPolicy policy);

-   void SetIntegratorOwnership(int _extern_bfs)
-   {
-      extern_bfs = _extern_bfs;
-   }
   /// Indicate that integrators are not owned by the BilinearForm
   void UseExternalIntegrators() { extern_bfs = 1; }

@@ -1072,13 +1068,8 @@ public:
      A.MakeRef(*A_ptr);
   }

-   virtual void Update(FiniteElementSpace *ntr_fes = NULL,
-                       FiniteElementSpace *nte_fes = NULL);
-
-   void SetIntegratorOwnership(int _extern_bfs)
-   {
-      extern_bfs = _extern_bfs;
-   }
+   /// Must be called after making changes to #trial_fes or #test_fes.
+   void Update();

   /// Return the trial FE space associated with the BilinearForm.
   FiniteElementSpace *TrialFESpace() { return trial_fes; }
@@ -1999,11 +1999,7 @@ void CurlCurlIntegrator::AssembleElementMatrix
 {
   int nd = el.GetDof();
   dim = el.GetDim();
-   // in main
-   // int dimc = el.GetCurlDim();
-   // Taken from 4d_dev:
-   int dimc = (dim == 3) ? 3 : 1;
-   if (dim==4) { dimc = 6; }
+   int dimc = el.GetCurlDim();
   real_t w;

 #ifdef MFEM_THREAD_SAFE
@@ -2040,43 +2036,8 @@ void CurlCurlIntegrator::AssembleElementMatrix

      Trans.SetIntPoint (&ip);

-      if (dim ==4)
-      {
-         DenseMatrix tSh(4,4);
-         DenseMatrix trShTemp(4,4);
-
-         DenseMatrix J = Trans.Jacobian();
-         DenseMatrix invJ(4,4); CalcInverse(J, invJ);
-         DenseMatrix invJtr(invJ); invJtr.Transpose();
-
-         el.CalcCurlShape(ip, curlshape);
-         for (int dof=0; dof<nd; dof++)
-         {
-            tSh = 0.; trShTemp = 0.;
-            tSh(0,1) =  curlshape(dof,0); tSh(0,2) =  curlshape(dof,1);
-            tSh(0,3) =  curlshape(dof,2);
-            tSh(1,0) = -curlshape(dof,0);
-            tSh(1,2) =  curlshape(dof,3); tSh(1,3) =  curlshape(dof,4);
-            tSh(2,0) = -curlshape(dof,1); tSh(2,1) = -curlshape(dof,3);
-            tSh(2,3) =  curlshape(dof,5);
-            tSh(3,0) = -curlshape(dof,2); tSh(3,1) = -curlshape(dof,4);
-            tSh(3,2) = -curlshape(dof,5);
-
-            Mult(tSh, invJ, trShTemp);
-            Mult(invJtr, trShTemp, tSh);
-
-            curlshape_dFt(dof,0) = tSh(0,1);
-            curlshape_dFt(dof,1) = tSh(0,2);
-            curlshape_dFt(dof,2) = tSh(0,3);
-            curlshape_dFt(dof,3) = tSh(1,2);
-            curlshape_dFt(dof,4) = tSh(1,3);
-            curlshape_dFt(dof,5) = tSh(2,3);
-         }
-      }
-      else
-            el.CalcPhysCurlShape(Trans, curlshape_dFt);
-
      w = ip.weight * Trans.Weight();
+      el.CalcPhysCurlShape(Trans, curlshape_dFt);

      if (MQ)
      {
@@ -3454,7 +3415,6 @@ void DGTraceIntegrator::AssembleFaceMatrix(const FiniteElement &el1,
         }
      }
   }
-   //    elmat.PrintMatlab(std::cout);
 }


@@ -4595,85 +4555,4 @@ VectorInnerProductInterpolator::AssembleElementMatrix2(
   ran_fe.Project(dom_shape_coeff, Trans, elmat_as_vec);
 }

-void HeatEquationIntegrator::AssembleElementMatrix
-( const FiniteElement &el, ElementTransformation &Trans,
-  DenseMatrix &elmat )
-{
-   int nd = el.GetDof();
-   int dim = el.GetDim();
-   int spaceDim = Trans.GetSpaceDim();
-   double w;
-
-#ifdef MFEM_THREAD_SAFE
-   DenseMatrix dshape(nd,dim), dshapedxt(nd,spaceDim), invdfdx(dim,spaceDim);
-   Vector shape(nd), vec(nd);
-#else
-   dshape.SetSize(nd,dim);
-   dshapedxt.SetSize(nd,spaceDim);
-   invdfdx.SetSize(dim,spaceDim);
-   shape.SetSize(nd);
-   dtshape.SetSize(nd);
-#endif
-   elmat.SetSize(nd);
-
-   const IntegrationRule *ir = IntRule;
-   if (ir == NULL)
-   {
-      int order;
-      if (el.Space() == FunctionSpace::Pk)
-      {
-         order = 2*el.GetOrder() - 2;
-      }
-      else
-         // order = 2*el.GetOrder() - 2;  // <-- this seems to work fine too
-      {
-         order = 2*el.GetOrder() + dim - 1;
-      }
-
-      if (el.Space() == FunctionSpace::rQk)
-      {
-         ir = &RefinedIntRules.Get(el.GetGeomType(), order);
-      }
-      else
-      {
-         ir = &IntRules.Get(el.GetGeomType(), order);
-      }
-   }
-
-   elmat = 0.0;
-   for (int i = 0; i < ir->GetNPoints(); i++)
-   {
-      const IntegrationPoint &ip = ir->IntPoint(i);
-      el.CalcShape(ip,shape);
-      el.CalcDShape(ip, dshape);
-
-      Trans.SetIntPoint(&ip);
-      w = Trans.Weight();
-      w *= ip.weight;
-      CalcInverse(Trans.Jacobian(), invdfdx);
-      Mult(dshape, invdfdx, dshapedxt);
-
-      dshapedxt.GetColumn(spaceDim - 1, dtshape); // d_t u
-      dshapedxt.SetCol(spaceDim - 1, 0.);
-
-      AddMult_a_VWt(w,shape,dtshape,elmat); // d_t u * v
-      if (!MQ)
-      {
-         if (Q)
-         {
-            w *= Q->Eval(Trans, ip);
-         }
-         AddMult_a_AAt(w, dshapedxt, elmat);
-      }
-      else
-      {
-         MQ->Eval(invdfdx, Trans, ip);
-         invdfdx *= w;
-         Mult(dshapedxt, invdfdx, dshape);
-         AddMultABt(dshape, dshapedxt, elmat);
-      }
-   }
-}
-
-
 }
@@ -266,9 +266,6 @@ public:
                                    Vector &flux, Vector *d_energy = NULL)
   { return 0.0; }

-   // I think this got deleted
-   // void SetIntRule(const IntegrationRule *ir) { IntRule = ir; }
-
   /** @brief For bilinear forms on element faces, specifies if the normal
              derivatives are needed on the faces or just the face restriction.

@@ -301,6 +298,7 @@ public:
   */
   virtual void AddMultPAFaceNormalDerivatives(const Vector &x, const Vector &dxdn,
                                               Vector &y, Vector &dydn) const;
+
   virtual ~BilinearFormIntegrator() { }
 };

@@ -1743,7 +1741,7 @@ public:
   { vector_fe.CalcPhysDShape(Trans, shape); }
 };

-/** Class for integrating the bilinear form $a(u,v) := (-\hat{V} \cdot \nabla u, \nabla \cdot v)$ in 2D
+/** Class for integrating the bilinear form $a(u,v) := (-\hat{V} \cdot  \nabla \cdot u, \nabla \cdot v)$ in 2D
    or 3D and where $\hat{V}$ is a vector coefficient, $u$ is in $H^1$ and $v$ is in $H(div)$. */
 class MixedGradDivIntegrator : public MixedScalarVectorIntegrator
 {
@@ -1782,7 +1780,7 @@ public:
   { scalar_fe.CalcPhysDivShape(Trans, shape); }
 };

-/** Class for integrating the bilinear form $a(u,v) := (-\hat{V} \nabla \cdot u, \nabla v)$ in 2D
+/** Class for integrating the bilinear form $a(u,v) := (-\hat{V} \nabla \cdot u, \nabla \cdot v)$ in 2D
    or 3D and where $\hat{V}$ is a vector coefficient, $u$ is in $H(div)$ and $v$ is in $H^1$. */
 class MixedDivGradIntegrator : public MixedScalarVectorIntegrator
 {
@@ -1822,7 +1820,7 @@ public:
   { scalar_fe.CalcPhysDivShape(Trans, shape); }
 };

-/** Class for integrating the bilinear form $a(u,v) := (-\hat{V} u, \nabla v)$ in 2D or 3D
+/** Class for integrating the bilinear form $a(u,v) := (-\hat{V} u, \nabla \cdot v)$ in 2D or 3D
    and where $\hat{V}$ is a vector coefficient, $u$ is in $H^1$ or $L_2$ and $v$ is in $H^1$. */
 class MixedScalarWeakDivergenceIntegrator : public MixedScalarVectorIntegrator
 {
@@ -3682,16 +3680,6 @@ public:
 };


-class DivSkewInterpolator : public DiscreteInterpolator
-{
-public:
-   virtual void AssembleElementMatrix2(const FiniteElement &dom_fe,
-                                       const FiniteElement &ran_fe,
-                                       ElementTransformation &Trans,
-                                       DenseMatrix &elmat)
-   { ran_fe.ProjectDivSkew(dom_fe, Trans, elmat); }
-};
-
 /** Class for constructing the (local) discrete divergence matrix which can
    be used as an integrator in a DiscreteLinearOperator object to assemble
    the global discrete divergence matrix.
@@ -3823,179 +3811,5 @@ protected:
   VectorCoefficient *VQ;
 };

-class DivSkewDivSkewIntegrator: public BilinearFormIntegrator
-{
-private:
-   DenseMatrix DivSkewshape, DivSkew_dFt;
-
-   Coefficient *Q;
-
-public:
-   DivSkewDivSkewIntegrator() { Q = NULL; }
-   /// Construct a bilinear form integrator for Nedelec elements
-   DivSkewDivSkewIntegrator(Coefficient &q) : Q(&q) { }
-
-   /* Given a particular Finite Element, compute the
-      element DivSkew-DivSkew matrix elmat */
-   virtual void AssembleElementMatrix(const FiniteElement &el,
-                                      ElementTransformation &Trans,
-                                      DenseMatrix &elmat)
-   {
-      int nd = el.GetDof();
-      int dim = el.GetDim();
-      real_t w;
-
-      DivSkewshape.SetSize(nd,dim);
-      DivSkew_dFt.SetSize(nd,dim);
-
-      elmat.SetSize(nd);
-
-      const IntegrationRule *ir = IntRule;
-      if (ir == NULL)
-      {
-         int order = 2*el.GetOrder()+2;
-
-         ir = &IntRules.Get(el.GetGeomType(), order);
-      }
-
-      elmat = 0.0;
-      for (int i = 0; i < ir->GetNPoints(); i++)
-      {
-         const IntegrationPoint &ip = ir->IntPoint(i);
-
-         Trans.SetIntPoint (&ip);
-
-         el.CalcDivSkewShape(ip, DivSkewshape);
-
-         MultABt(DivSkewshape, Trans.Jacobian(), DivSkew_dFt);
-
-         DivSkew_dFt *= (1.0 / Trans.Weight());
-
-         w = ip.weight * fabs(Trans.Weight());
-
-         if (Q)
-         {
-            w *= Q->Eval(Trans, ip);
-         }
-
-         AddMult_a_AAt(w, DivSkew_dFt, elmat);
-      }
-   }
-
-};
-
-class VectorFE_DivSkewMassIntegrator: public BilinearFormIntegrator
-{
-private:
-   DenseMatrix shape;
-
-   Coefficient *Q;
-
-public:
-   VectorFE_DivSkewMassIntegrator() { Q = NULL; }
-   /// Construct a bilinear form integrator for Nedelec elements
-   VectorFE_DivSkewMassIntegrator(Coefficient &q) : Q(&q) { }
-
-   /* Given a particular Finite Element, compute the
-      element curl-curl matrix elmat */
-   virtual void AssembleElementMatrix(const FiniteElement &el,
-                                      ElementTransformation &Trans,
-                                      DenseMatrix &elmat)
-   {
-      int nd = el.GetDof();
-      int dim = el.GetDim();
-      real_t w;
-
-      shape.SetSize(nd,dim*dim);
-
-      elmat.SetSize(nd);
-
-      const IntegrationRule *ir = IntRule;
-      if (ir == NULL)
-      {
-         int order = Trans.OrderW() + 2 * el.GetOrder();
-
-         ir = &IntRules.Get(el.GetGeomType(), order);
-      }
-
-      elmat = 0.0;
-      for (int i = 0; i < ir->GetNPoints(); i++)
-      {
-         const IntegrationPoint &ip = ir->IntPoint(i);
-         Trans.SetIntPoint (&ip);
-
-         w = ip.weight * fabs(Trans.Weight());
-
-
-         el.CalcVShape(Trans, shape);
-
-
-         if (Q)
-         {
-            w *= Q->Eval(Trans, ip);
-         }
-
-         AddMult_a_AAt(w, shape, elmat);
-      }
-   }
-
-};
-
-/** Class for integrating the bilinear form a(u,v) := (d_t u, v) + (Q grad_x u, grad_x v) where Q
-    can be a scalar or a matrix coefficient and grad_x is the gradient wrt to the spatial variables.
-    Here we use the space-time f.e. scheme by [Steinbach2015]. */
-class HeatEquationIntegrator: public BilinearFormIntegrator
-{
-private:
-   Vector vec, pointflux, shape, dtshape;
-#ifndef MFEM_THREAD_SAFE
-   DenseMatrix dshape, dshapedxt, invdfdx, mq;
-   DenseMatrix te_dshape, te_dshapedxt;
-#endif
-   Coefficient *Q;
-   MatrixCoefficient *MQ;
-
-public:
-   /// Construct a diffusion integrator with coefficient Q = 1
-   HeatEquationIntegrator() { Q = NULL; MQ = NULL; }
-
-   /// Construct a diffusion integrator with a scalar coefficient q
-   HeatEquationIntegrator (Coefficient &q) : Q(&q) { MQ = NULL; }
-
-   /// Construct a diffusion integrator with a matrix coefficient q
-   HeatEquationIntegrator (MatrixCoefficient &q) : MQ(&q) { Q = NULL; }
-
-   /** Given a particular Finite Element
-       computes the element stiffness matrix elmat. */
-   virtual void AssembleElementMatrix(const FiniteElement &el,
-                                      ElementTransformation &Trans,
-                                      DenseMatrix &elmat);
-   /** Given a trial and test Finite Element computes the element stiffness
-       matrix elmat. */
-   virtual void AssembleElementMatrix2(const FiniteElement &trial_fe,
-                                       const FiniteElement &test_fe,
-                                       ElementTransformation &Trans,
-                                       DenseMatrix &elmat)
-   { mfem_error("HeatEquationIntegrator::AssembleElementMatrix2: not implemented!"); }
-
-   /// Perform the local action of the BilinearFormIntegrator
-   virtual void AssembleElementVector(const FiniteElement &el,
-                                      ElementTransformation &Tr,
-                                      const Vector &elfun, Vector &elvect)
-   { mfem_error("HeatEquationIntegrator::AssembleElementVector: not implemented!"); }
-
-   virtual void ComputeElementFlux(const FiniteElement &el,
-                                   ElementTransformation &Trans,
-                                   Vector &u, const FiniteElement &fluxelem,
-                                   Vector &flux, int with_coef = 1)
-   { mfem_error("HeatEquationIntegrator::ComputeElementFlux: not implemented!"); }
-
-   virtual double ComputeFluxEnergy(const FiniteElement &fluxelem,
-                                    ElementTransformation &Trans,
-                                    Vector &flux, Vector *d_energy = NULL)
-   { mfem_error("HeatEquationIntegrator::ComputeFluxEnergy: not implemented!"); return -1;}
-};
-
-
 }
 #endif
@@ -129,10 +129,8 @@ real_t PWCoefficient::Eval(ElementTransformation &T,
 real_t FunctionCoefficient::Eval(ElementTransformation & T,
                                 const IntegrationPoint & ip)
 {
-   // real_t x[Geometry::MaxDim];
-   // Vector transip(x, Geometry::MaxDim);
-   real_t x[4];
-   Vector transip(x, 4);
+   real_t x[3];
+   Vector transip(x, 3);

   T.Transform(ip, transip);

@@ -368,10 +366,8 @@ void PositionVectorCoefficient::Eval(Vector &V, ElementTransformation &T,
 void VectorFunctionCoefficient::Eval(Vector &V, ElementTransformation &T,
                                     const IntegrationPoint &ip)
 {
-   // real_t x[Geometry::MaxDim];
-   // Vector transip(x, Geometry::MaxDim);
-   real_t x[4];
-   Vector transip(x, 4);
+   real_t x[3];
+   Vector transip(x, 3);

   T.Transform(ip, transip);

@@ -811,7 +807,6 @@ void SymmetricMatrixCoefficient::ProjectSymmetric(QuadratureFunction &qf)

   QuadratureSpaceBase &qspace = *qf.GetSpace();
   const int ne = qspace.GetNE();
-   qf.HostWrite();
   DenseMatrix values;
   DenseSymmetricMatrix matrix;
   for (int iel = 0; iel < ne; ++iel)
@@ -823,7 +818,7 @@ void SymmetricMatrixCoefficient::ProjectSymmetric(QuadratureFunction &qf)
      {
         const IntegrationPoint &ip = ir[iq];
         T.SetIntPoint(&ip);
-         matrix.UseExternalData(&values(0, iq), height);
+         matrix.UseExternalData(&values(0, iq), vdim);
         Eval(matrix, T, ip);
      }
   }
@@ -833,12 +828,13 @@ void SymmetricMatrixCoefficient::ProjectSymmetric(QuadratureFunction &qf)
 void SymmetricMatrixCoefficient::Eval(DenseMatrix &K, ElementTransformation &T,
                                      const IntegrationPoint &ip)
 {
-   Eval(mat_aux, T, ip);
+   mat.SetSize(height);
+   Eval(mat, T, ip);
   for (int j = 0; j < width; ++j)
   {
      for (int i = 0; i < height; ++ i)
      {
-         K(i, j) = mat_aux(i, j);
+         K(i, j) = mat(i, j);
      }
   }
 }
@@ -928,75 +924,6 @@ void MatrixArrayCoefficient::Eval(DenseMatrix &K, ElementTransformation &T,
   }
 }

-MatrixArrayVectorCoefficient::MatrixArrayVectorCoefficient (int dim)
-   : MatrixCoefficient (dim)
-{
-   Coeff.SetSize(height);
-   ownCoeff.SetSize(height);
-   for (int i = 0; i < height; i++)
-   {
-      Coeff[i] = NULL;
-      ownCoeff[i] = true;
-   }
-}
-
-void MatrixArrayVectorCoefficient::SetTime(real_t t)
-{
-   for (int i=0; i < height; i++)
-   {
-      if (Coeff[i]) { Coeff[i]->SetTime(t); }
-   }
-   this->MatrixCoefficient::SetTime(t);
-}
-
-void MatrixArrayVectorCoefficient::Set(int i, VectorCoefficient * c, bool own)
-{
-   MFEM_ASSERT(i < height && i >= 0, "Row "
-               << i << " does not exist. " <<
-               "Matrix height = " << height << ".");
-   if (ownCoeff[i]) { delete Coeff[i]; }
-   Coeff[i] = c;
-   ownCoeff[i] = own;
-}
-
-MatrixArrayVectorCoefficient::~MatrixArrayVectorCoefficient ()
-{
-   for (int i=0; i < height; i++)
-   {
-      if (ownCoeff[i]) { delete Coeff[i]; }
-   }
-}
-
-void MatrixArrayVectorCoefficient::Eval(int i, Vector &V,
-                                        ElementTransformation &T,
-                                        const IntegrationPoint &ip)
-{
-   MFEM_ASSERT(i < height && i >= 0, "Row "
-               << i << " does not exist. " <<
-               "Matrix height = " << height << ".");
-   if (Coeff[i])
-   {
-      Coeff[i] -> Eval(V, T, ip);
-   }
-   else
-   {
-      V = 0.0;
-   }
-}
-
-void MatrixArrayVectorCoefficient::Eval(DenseMatrix &K,
-                                        ElementTransformation &T,
-                                        const IntegrationPoint &ip)
-{
-   K.SetSize(height, width);
-   Vector V(width);
-   for (int i = 0; i < height; i++)
-   {
-      this->Eval(i, V, T, ip);
-      K.SetRow(i, V);
-   }
-}
-
 void MatrixRestrictedCoefficient::SetTime(real_t t)
 {
   if (c) { c->SetTime(t); }
@@ -1114,27 +1041,6 @@ real_t DeterminantCoefficient::Eval(ElementTransformation &T,
   return ma.Det();
 }

-TraceCoefficient::TraceCoefficient(MatrixCoefficient &A)
-   : a(&A), ma(A.GetHeight(), A.GetWidth())
-{
-   MFEM_ASSERT(A.GetHeight() == A.GetWidth(),
-               "TraceCoefficient:  "
-               "Argument must be a square matrix.");
-}
-
-void TraceCoefficient::SetTime(real_t t)
-{
-   if (a) { a->SetTime(t); }
-   this->Coefficient::SetTime(t);
-}
-
-real_t TraceCoefficient::Eval(ElementTransformation &T,
-                              const IntegrationPoint &ip)
-{
-   a->Eval(ma, T, ip);
-   return ma.Trace();
-}
-
 VectorSumCoefficient::VectorSumCoefficient(int dim)
   : VectorCoefficient(dim),
     ACoef(NULL), BCoef(NULL),
@@ -1420,30 +1326,6 @@ void InverseMatrixCoefficient::Eval(DenseMatrix &M,
   M.Invert();
 }

-ExponentialMatrixCoefficient::ExponentialMatrixCoefficient(MatrixCoefficient &A)
-   : MatrixCoefficient(A.GetHeight(), A.GetWidth()), a(&A)
-{
-   MFEM_ASSERT(A.GetHeight() == A.GetWidth() && A.GetHeight() == 2,
-               "ExponentialMatrixCoefficient:  "
-               << "Argument must be a square 2x2 matrix."
-               << "  Height = " << A.GetHeight()
-               << ", Width = " << A.GetWidth());
-}
-
-void ExponentialMatrixCoefficient::SetTime(real_t t)
-{
-   if (a) { a->SetTime(t); }
-   this->MatrixCoefficient::SetTime(t);
-}
-
-void ExponentialMatrixCoefficient::Eval(DenseMatrix &M,
-                                        ElementTransformation &T,
-                                        const IntegrationPoint &ip)
-{
-   a->Eval(M, T, ip);
-   M.Exponential();
-}
-
 OuterProductCoefficient::OuterProductCoefficient(VectorCoefficient &A,
                                                 VectorCoefficient &B)
   : MatrixCoefficient(A.GetVDim(), B.GetVDim()), a(&A), b(&B),
@@ -1334,46 +1334,6 @@ public:
   virtual ~MatrixArrayCoefficient();
 };

-/** @brief Matrix coefficient defined row-wise by an array of vector
-    coefficients. Rows that are not set will evaluate to zero. The
-    matrix coefficient is stored as an array indexing the rows of
-    the matrix. */
-class MatrixArrayVectorCoefficient : public MatrixCoefficient
-{
-private:
-   Array<VectorCoefficient *> Coeff;
-   Array<bool> ownCoeff;
-
-public:
-   /** @brief Construct a coefficient matrix of dimensions @a dim * @a dim. The
-       actual coefficients still need to be added with Set(). */
-   explicit MatrixArrayVectorCoefficient (int dim);
-
-   /// Set the time for internally stored coefficients
-   void SetTime(real_t t) override;
-
-   /// Get the vector coefficient located at the i-th row of the matrix
-   VectorCoefficient* GetCoeff (int i) { return Coeff[i]; }
-
-   /** @brief Set the coefficient located at the i-th row of the matrix.
-       By this will take ownership of the Coefficient passed in, but this
-       can be overridden with the @a own parameter. */
-   void Set(int i, VectorCoefficient * c, bool own=true);
-
-   using MatrixCoefficient::Eval;
-
-   /// Evaluate coefficient located at the i-th row of the matrix using integration
-   /// point @a ip.
-   void Eval(int i, Vector &V, ElementTransformation &T,
-             const IntegrationPoint &ip);
-
-   /// Evaluate the matrix coefficient @a ip.
-   void Eval(DenseMatrix &K, ElementTransformation &T,
-             const IntegrationPoint &ip) override;
-
-   virtual ~MatrixArrayVectorCoefficient();
-};
-

 /** @brief Derived matrix coefficient that has the value of the parent matrix
    coefficient where it is active and is zero otherwise. */
@@ -1466,13 +1426,12 @@ public:
 class SymmetricMatrixCoefficient : public MatrixCoefficient
 {
 protected:
-
   /// Internal matrix used when evaluating this coefficient as a DenseMatrix.
-   mutable DenseSymmetricMatrix mat_aux;
+   DenseSymmetricMatrix mat;
 public:
   /// Construct a dim x dim matrix coefficient.
   explicit SymmetricMatrixCoefficient(int dimension)
-      : MatrixCoefficient(dimension, true), mat_aux(height) { }
+      : MatrixCoefficient(dimension, true) { }

   /// Get the size of the matrix.
   int GetSize() const { return height; }
@@ -1505,9 +1464,8 @@ public:
   virtual void Eval(DenseMatrix &K, ElementTransformation &T,
                     const IntegrationPoint &ip);

-
-   /// @deprecated Return a reference to the internal matrix used when evaluating this coefficient as a DenseMatrix.
-   MFEM_DEPRECATED const DenseSymmetricMatrix& GetMatrix() { return mat_aux; }
+   /// Return a reference to the constant matrix.
+   const DenseSymmetricMatrix& GetMatrix() { return mat; }

   virtual ~SymmetricMatrixCoefficient() { }
 };
@@ -1527,10 +1485,6 @@ public:
   /// Evaluate the matrix coefficient at @a ip.
   virtual void Eval(DenseSymmetricMatrix &M, ElementTransformation &T,
                     const IntegrationPoint &ip) { M = mat; }
-
-   /// Return a reference to the constant matrix.
-   const DenseSymmetricMatrix& GetMatrix() { return mat; }
-
 };


@@ -1807,31 +1761,6 @@ public:
                       const IntegrationPoint &ip);
 };

-/// Scalar coefficient defined as the trace of a matrix coefficient
-class TraceCoefficient : public Coefficient
-{
-private:
-   MatrixCoefficient * a;
-
-   mutable DenseMatrix ma;
-
-public:
-   /// Construct with the matrix.
-   TraceCoefficient(MatrixCoefficient &A);
-
-   /// Set the time for internally stored coefficients
-   void SetTime(real_t t);
-
-   /// Reset the matrix coefficient
-   void SetACoef(MatrixCoefficient &A) { a = &A; }
-   /// Return the matrix coefficient
-   MatrixCoefficient * GetACoef() const { return a; }
-
-   /// Evaluate the trace coefficient at @a ip.
-   virtual real_t Eval(ElementTransformation &T,
-                       const IntegrationPoint &ip);
-};
-
 /// Vector coefficient defined as the linear combination of two vectors
 class VectorSumCoefficient : public VectorCoefficient
 {
@@ -2183,7 +2112,7 @@ public:
                     const IntegrationPoint &ip);
 };

-/// Matrix coefficient defined as the transpose of a matrix coefficient
+/// Matrix coefficient defined as the transpose a matrix coefficient
 class TransposeMatrixCoefficient : public MatrixCoefficient
 {
 private:
@@ -2206,7 +2135,7 @@ public:
                     const IntegrationPoint &ip);
 };

-/// Matrix coefficient defined as the inverse of a matrix coefficient.
+/// Matrix coefficient defined as the inverse a matrix coefficient.
 class InverseMatrixCoefficient : public MatrixCoefficient
 {
 private:
@@ -2229,29 +2158,6 @@ public:
                     const IntegrationPoint &ip);
 };

-/// Matrix coefficient defined as the exponential of a matrix coefficient.
-class ExponentialMatrixCoefficient : public MatrixCoefficient
-{
-private:
-   MatrixCoefficient * a;
-
-public:
-   /// Construct the matrix coefficient.  Result is $ \exp(A) $.
-   ExponentialMatrixCoefficient(MatrixCoefficient &A);
-
-   /// Set the time for internally stored coefficients
-   void SetTime(real_t t);
-
-   /// Reset the matrix coefficient
-   void SetACoef(MatrixCoefficient &A) { a = &A; }
-   /// Return the matrix coefficient
-   MatrixCoefficient * GetACoef() const { return a; }
-
-   /// Evaluate the matrix coefficient at @a ip.
-   virtual void Eval(DenseMatrix &M, ElementTransformation &T,
-                     const IntegrationPoint &ip);
-};
-
 /// Matrix coefficient defined as the outer product of two vector coefficients.
 class OuterProductCoefficient : public MatrixCoefficient
 {
@@ -180,7 +180,7 @@ int InverseElementTransformation::NewtonSolve(const Vector &pt,
   const int dim = T->GetDimension();
   const int sdim = T->GetSpaceDim();
   IntegrationPoint xip, prev_xip;
-   double xd[4], yd[4], dxd[4], dx_norm = -1.0, err_phys, real_dx_norm = -1.0;
+   real_t xd[3], yd[3], dxd[3], dx_norm = -1.0, err_phys, real_dx_norm = -1.0;
   Vector x(xd, dim), y(yd, sdim), dx(dxd, dim);
   bool hit_bdr = false, prev_hit_bdr = false;

@@ -389,8 +389,6 @@ void IsoparametricTransformation::SetIdentityTransformation(
      case Geometry::CUBE :        FElem = &HexahedronFE; break;
      case Geometry::PRISM :       FElem = &WedgeFE; break;
      case Geometry::PYRAMID :     FElem = &PyramidFE; break;
-      case Geometry::PENTATOPE:    FElem = &PentatopeFE; break;
-      case Geometry::TESSERACT:    FElem = &TesseractFE; break;
      default:
         MFEM_ABORT("unknown Geometry::Type!");
   }
@@ -545,9 +543,7 @@ void IsoparametricTransformation::Transform (const DenseMatrix &matrix,
 void IntegrationPointTransformation::Transform (const IntegrationPoint &ip1,
                                                IntegrationPoint &ip2)
 {
-   // real_t vec[Geometry::MaxDim];
-   real_t vec[4];
-
+   real_t vec[3];
   Vector v (vec, Transf.GetPointMat().Height());

   Transf.Transform (ip1, v);
@@ -43,10 +43,6 @@ LinearWedgeFiniteElement WedgeFE;
 // Defined here to ensure it is constructed before 'Geometries'.
 LinearPyramidFiniteElement PyramidFE;

-// Object declared in mesh/pentatope.hpp.
-// Defined here to ensure it is constructed before 'Geometries'.
-Linear4DFiniteElement PentatopeFE;
-
 // Object declared in geom.hpp.
 // Construct 'Geometries' after 'TriangleFE', 'TetrahedronFE', 'WedgeFE', and
 // PyramidFE.
@@ -93,13 +93,6 @@ void FiniteElement::CalcPhysCurlShape(ElementTransformation &Trans,
   }
 }

-void FiniteElement::CalcDivSkewShape(const IntegrationPoint &ip,
-                                     DenseMatrix &curl_shape) const
-{
-   mfem_error ("FiniteElement::CalcDivSkewShape (ip, ...)\n"
-               "   is not implemented for this class!");
-}
-
 void FiniteElement::GetFaceDofs(int face, int **dofs, int *ndofs) const
 {
   MFEM_ABORT("method is not overloaded");
@@ -186,14 +179,6 @@ void FiniteElement::ProjectDiv(
   MFEM_ABORT("method is not implemented for this element");
 }

-void FiniteElement::ProjectDivSkew(
-   const FiniteElement &fe, ElementTransformation &Trans,
-   DenseMatrix &DivSkew) const
-{
-   mfem_error("FiniteElement::ProjectDivSkew(...) is not implemented for "
-              "this element!");
-}
-
 void FiniteElement::CalcPhysShape(ElementTransformation &Trans,
                                  Vector &shape) const
 {
@@ -1027,19 +1012,9 @@ void VectorFiniteElement::SetDerivMembers()
         deriv_range_type = SCALAR;
         deriv_map_type = INTEGRAL;
         break;
-      case H_DIV_SKEW:
-         deriv_type = DIV_SKEW;
-         deriv_range_type = VECTOR;
-         deriv_map_type = H_DIV;
-         break;
      case H_CURL:
         switch (dim)
         {
-            case 4: // curl: 4D H_CURL -> 4D H_DIV(skew)
-               deriv_type = CURL;
-               deriv_range_type = MAT_SKEW;
-               deriv_map_type = H_DIV_SKEW;
-               break;
            case 3: // curl: 3D H_CURL -> 3D H_DIV
               deriv_type = CURL;
               deriv_range_type = VECTOR;
@@ -1088,74 +1063,6 @@ void VectorFiniteElement::CalcVShape_ND(
   Mult(vshape, Trans.InverseJacobian(), shape);
 }

-void VectorFiniteElement::CalcVShape_DivSkew (
-   ElementTransformation &Trans, DenseMatrix &shape) const
-{
-   if (dim!=4) { return; }
-
-   MFEM_ASSERT(map_type == H_DIV_SKEW, "");
-   const DenseMatrix &J = Trans.Jacobian();
-
-#ifdef MFEM_THREAD_SAFE
-   DenseMatrix vshape(dof, dim*dim);
-   DenseMatrix Jinv(J.Width(), J.Height());
-#else
-   Jinv.SetSize(J.Width(), J.Height());
-#endif
-
-   if (vshape.Width()!=dim*dim) { vshape.SetSize(dof,dim*dim); }
-
-   CalcVShape(Trans.GetIntPoint(), vshape);
-
-   CalcInverse(J, Jinv);
-   DenseMatrix invJtr(Jinv); invJtr.Transpose();
-
-   CalcVShape(Trans.GetIntPoint(), vshape);
-
-   DenseMatrix mat(dim,dim); mat = 0.0;
-   DenseMatrix tempMat(dim,dim);
-
-   for (int o=0; o<dof; o++)
-   {
-      //    for(int ik=0; ik<dim; ik++)
-      //       for(int jk=0; jk<dim; jk++)
-      //       {
-      //          mat(ik,jk) = vshape(o,dim*ik+jk);
-      //       }
-      //
-      //    Mult(mat, Jinv, tempMat);
-      //    Mult(invJtr, tempMat, mat);
-      //
-      //    for(int ik=0; ik<dim; ik++)
-      //       for(int jk=0; jk<dim; jk++)
-      //       {
-      //          shape(o,dim*ik+jk) = mat(ik,jk);
-      //       }
-
-
-      mat(0,0) =  0.0;            mat(0,1) =  vshape(o,11);
-      mat(0,2) =  vshape(o,13); mat(0,3) =  vshape(o,6);
-      mat(1,0) =  vshape(o,14); mat(1,1) =  0.0;
-      mat(1,2) =  vshape(o,3);  mat(1,3) =  vshape(o,8);
-      mat(2,0) =  vshape(o,7);  mat(2,1) =  vshape(o,12); mat(2,2) =  0.0;
-      mat(2,3) =  vshape(o,1);
-      mat(3,0) =  vshape(o,9);  mat(3,1) =  vshape(o,2);
-      mat(3,2) =  vshape(o,4);  mat(3,3) =  0.0;
-
-      Mult(mat, Jinv, tempMat);
-      Mult(invJtr, tempMat, mat);
-
-      shape(o,0) =  0.0;      shape(o,1) =  mat(2,3); shape(o,2) =  mat(3,1);
-      shape(o,3) =  mat(1,2);
-      shape(o,4) =  mat(3,2); shape(o,5) =  0.0;      shape(o,6) =  mat(0,3);
-      shape(o,7) =  mat(2,0);
-      shape(o,8) =  mat(1,3); shape(o,9) =  mat(3,0); shape(o,10) = 0.0;
-      shape(o,11) = mat(0,1);
-      shape(o,12) = mat(2,1); shape(o,13) = mat(0,2); shape(o,14) = mat(1,0);
-      shape(o,15) = 0.0;
-   }
-}
-
 void VectorFiniteElement::Project_RT(
   const real_t *nk, const Array<int> &d2n,
   VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const
@@ -259,7 +259,7 @@ protected:

 public:
   /// Enumeration for range_type and deriv_range_type
-   enum RangeType { UNKNOWN_RANGE_TYPE = -1, SCALAR, VECTOR, MAT_SKEW };
+   enum RangeType { UNKNOWN_RANGE_TYPE = -1, SCALAR, VECTOR };

   /** @brief Enumeration for MapType: defines how reference functions are
       mapped to physical space.
@@ -281,11 +281,10 @@ public:
                          $ u(x) = (1/w) \hat u(\hat x) $ */
      H_DIV,     /**< For vector fields; preserves surface integrals of the
                          normal component $ u(x) = (J/w) \hat u(\hat x) $ */
-      H_CURL,    /**< For vector fields; preserves line integrals of the
+      H_CURL     /**< For vector fields; preserves line integrals of the
                          tangential component
                          $ u(x) = J^{-t} \hat u(\hat x) $ (square J),
                          $ u(x) = J(J^t J)^{-1} \hat u(\hat x) $ (general J) */
-      H_DIV_SKEW
   };

   /** @brief Enumeration for DerivType: defines which derivative method
@@ -300,8 +299,7 @@ public:
      NONE, ///< No derivatives implemented
      GRAD, ///< Implements CalcDShape methods
      DIV,  ///< Implements CalcDivShape methods
-      CURL, ///< Implements CalcCurlShape methods
-      DIV_SKEW
+      CURL  ///< Implements CalcCurlShape methods
   };

   /** @brief Construct FiniteElement with given
@@ -450,10 +448,6 @@ public:
   virtual void CalcPhysCurlShape(ElementTransformation &Trans,
                                  DenseMatrix &curl_shape) const;

-   virtual void CalcDivSkewShape(const IntegrationPoint &ip,
-                                 DenseMatrix &curl_shape) const;
-
-
   /** @brief Get the dofs associated with the given @a face.
       @a *dofs is set to an internal array of the local dofc on the
       face, while *ndofs is set to the number of dofs on that face.
@@ -583,10 +577,6 @@ public:
                           ElementTransformation &Trans,
                           DenseMatrix &div) const;

-   virtual void ProjectDivSkew(const FiniteElement &fe,
-                               ElementTransformation &Trans,
-                               DenseMatrix &DivSkew) const;
-
   /** @brief Return a DofToQuad structure corresponding to the given
       IntegrationRule using the given DofToQuad::Mode. */
   /** See the documentation for DofToQuad for more details. */
@@ -822,7 +812,7 @@ private:
 protected:
   bool is_nodal;
 #ifndef MFEM_THREAD_SAFE
-   mutable DenseMatrix JtJ, J, Jinv;
+   mutable DenseMatrix JtJ;
   mutable DenseMatrix curlshape, curlshape_J;
 #endif
   void SetDerivMembers();
@@ -833,10 +823,6 @@ protected:
   void CalcVShape_ND(ElementTransformation &Trans,
                      DenseMatrix &shape) const;

-   void CalcVShape_DivSkew(ElementTransformation &Trans,
-                           DenseMatrix &shape) const;
-
-
   /** @brief Project a vector coefficient onto the RT basis functions
       @param nk    Face normal vectors for this element type
       @param d2n   Offset into nk for each degree of freedom
@@ -450,74 +450,6 @@ public:
   { dofs = 0.0; dofs(vertex) = 1.0; }
 };

-/// Class for quad-linear FE on tesseract (4d element)
-class QuadLinear4DFiniteElement : public NodalFiniteElement
-{
-public:
-   /// Construct a quad-linear FE on tesseract
-   QuadLinear4DFiniteElement();
-
-   /** virtual function which evaluates the values of all
-       shape functions at a given point ip and stores
-       them in the vector shape of dimension Dof (16) */
-   virtual void CalcShape(const IntegrationPoint &ip, Vector &shape) const;
-
-   /** virtual function which evaluates the values of all
-       partial derivatives of all shape functions at a given
-       point ip and stores them in the matrix dshape (Dof x Dim) (16 x 4)
-       so that each row contains the derivatives of one shape function */
-   virtual void CalcDShape(const IntegrationPoint &ip,
-                           DenseMatrix &dshape) const;
-
-   virtual void CalcHessian (const IntegrationPoint &ip,
-                             DenseMatrix &h) const;
-
-   virtual void ProjectDelta(int vertex, Vector &dofs) const
-   { dofs = 0.0; dofs(vertex) = 1.0; }
-};
-
-/// Class for linear FE on a pentatope
-class Linear4DFiniteElement : public NodalFiniteElement
-{
-public:
-   /// Construct a linear FE on tetrahedron
-   Linear4DFiniteElement();
-
-   /** virtual function which evaluates the values of all
-       shape functions at a given point ip and stores
-       them in the vector shape of dimension Dof (4) */
-   virtual void CalcShape(const IntegrationPoint &ip, Vector &shape) const;
-
-   /** virtual function which evaluates the values of all
-       partial derivatives of all shape functions at a given
-       point ip and stores them in the matrix dshape (Dof x Dim) (4 x 3)
-       so that each row contains the derivatives of one shape function */
-   virtual void CalcDShape(const IntegrationPoint &ip,
-                           DenseMatrix &dshape) const;
-
-   virtual void ProjectDelta(int vertex, Vector &dofs) const
-   { dofs = 0.0; dofs(vertex) = 1.0; }
-
-   virtual void GetFaceDofs(int face, int **dofs, int *ndofs) const;
-
-   virtual void CalcHessian(const IntegrationPoint &ip, DenseMatrix &h) const;
-};
-
-/// Class for quadratic FE on pentatope
-class Quadratic4DFiniteElement : public NodalFiniteElement
-{
-public:
-   /// Construct a quadratic FE on pentatope
-   Quadratic4DFiniteElement();
-
-   virtual void CalcShape(const IntegrationPoint &ip, Vector &shape) const;
-
-   virtual void CalcDShape(const IntegrationPoint &ip,
-                           DenseMatrix &dshape) const;
-
-   virtual void CalcHessian(const IntegrationPoint &ip,
-                            DenseMatrix &h) const;
-};

 /// A 2D Crouzeix-Raviart element on triangle
 class CrouzeixRaviartFiniteElement : public NodalFiniteElement
@@ -1257,126 +1189,7 @@ public:
                           DenseMatrix &dshape) const;
 };

-//lowest order first kind nedelec element for a pentatope
-class Nedelec1PentFiniteElement : public VectorFiniteElement
-{
-private:
-   static const double tk[10][4];

-public:
-   Nedelec1PentFiniteElement();
-   virtual void CalcVShape(const IntegrationPoint &ip,
-                           DenseMatrix &shape) const;
-   virtual void CalcVShape(ElementTransformation &Trans,
-                           DenseMatrix &shape) const
-   { CalcVShape_ND(Trans, shape); }
-   virtual void CalcCurlShape(const IntegrationPoint &ip,
-                              DenseMatrix &curl_shape) const;
-   virtual void GetLocalInterpolation (ElementTransformation &Trans,
-                                       DenseMatrix &I) const;
-   using FiniteElement::Project;
-   virtual void Project (VectorCoefficient &vc,
-                         ElementTransformation &Trans, Vector &dofs) const;
-
-   virtual void Project(const FiniteElement &fe, ElementTransformation &Trans,
-                        DenseMatrix &I) const;
-
-   virtual void ProjectGrad(const FiniteElement &fe,
-                            ElementTransformation &Trans,
-                            DenseMatrix &grad) const;
-};
-
-//lowest order second kind nedelec element for a pentatope
-class Nedelec1FullPentFiniteElement : public VectorFiniteElement
-{
-private:
-   static const double tk[10][4];
-
-public:
-   Nedelec1FullPentFiniteElement();
-   virtual void CalcVShape(const IntegrationPoint &ip,
-                           DenseMatrix &shape) const;
-   virtual void CalcVShape(ElementTransformation &Trans,
-                           DenseMatrix &shape) const
-   { CalcVShape_ND(Trans, shape); }
-   virtual void CalcCurlShape(const IntegrationPoint &ip,
-                              DenseMatrix &curl_shape) const;
-   virtual void GetLocalInterpolation (ElementTransformation &Trans,
-                                       DenseMatrix &I) const {};
-   using FiniteElement::Project;
-   virtual void Project (VectorCoefficient &vc,
-                         ElementTransformation &Trans, Vector &dofs) const;
-
-   virtual void Project(const FiniteElement &fe, ElementTransformation &Trans,
-                        DenseMatrix &I) const;
-
-   virtual void ProjectGrad(const FiniteElement &fe,
-                            ElementTransformation &Trans,
-                            DenseMatrix &grad) const;
-};
-
-class DivSkew1PentFiniteElement : public VectorFiniteElement
-{
-private:
-   static const double tk1[10][4];
-   static const double tk2[10][4];
-
-public:
-   DivSkew1PentFiniteElement();
-   virtual void CalcVShape(const IntegrationPoint &ip,
-                           DenseMatrix &shape) const;
-   virtual void CalcVShape(ElementTransformation &Trans,
-                           DenseMatrix &shape) const
-   { CalcVShape_DivSkew(Trans, shape); }
-   virtual void CalcDivSkewShape(const IntegrationPoint &ip,
-                                 DenseMatrix &divSkew_shape) const;
-   virtual void GetLocalInterpolation (ElementTransformation &Trans,
-                                       DenseMatrix &I) const;
-   using FiniteElement::Project;
-   virtual void Project (VectorCoefficient &vc,
-                         ElementTransformation &Trans, Vector &dofs) const;
-
-   virtual void Project(const FiniteElement &fe, ElementTransformation &Trans,
-                        DenseMatrix &I) const;
-
-   virtual void ProjectCurl(const FiniteElement &fe,
-                            ElementTransformation &Trans,
-                            DenseMatrix &curl) const;
-};
-
-class RT0PentFiniteElement : public VectorFiniteElement
-{
-private:
-   static const double nk[5][4];
-
-public:
-   RT0PentFiniteElement();
-
-   virtual void CalcVShape(const IntegrationPoint &ip,
-                           DenseMatrix &shape) const;
-
-   virtual void CalcVShape(ElementTransformation &Trans,
-                           DenseMatrix &shape) const
-   { CalcVShape_RT(Trans, shape); };
-
-   virtual void CalcDivShape(const IntegrationPoint &ip,
-                             Vector &divshape) const;
-
-   virtual void GetLocalInterpolation (ElementTransformation &Trans,
-                                       DenseMatrix &I) const;
-
-   using FiniteElement::Project;
-
-   virtual void Project (VectorCoefficient &vc,
-                         ElementTransformation &Trans, Vector &dofs) const;
-
-   virtual void Project(const FiniteElement &fe, ElementTransformation &Trans,
-                        DenseMatrix &I) const;
-
-   virtual void ProjectDivSkew(const FiniteElement &fe,
-                               ElementTransformation &Trans,
-                               DenseMatrix &DivSkew) const;
-};
 } // namespace mfem

 #endif
@@ -1040,345 +1040,4 @@ void H1_WedgeElement::CalcDShape(const IntegrationPoint &ip,
   }
 }

-H1_PentatopeElement::H1_PentatopeElement(const int p, const int type)
-   : NodalFiniteElement(4, Geometry::PENTATOPE,
-                        ((p + 1)*(p + 2)*(p + 3)*(p + 4))/24,
-                        p, FunctionSpace::Pk)
-{
-   const double *cp = poly1d.ClosedPoints(p, VerifyClosed(type));
-
-#ifndef MFEM_THREAD_SAFE
-   shape_x.SetSize(p + 1);
-   shape_y.SetSize(p + 1);
-   shape_z.SetSize(p + 1);
-   shape_t.SetSize(p + 1);
-   shape_l.SetSize(p + 1);
-   dshape_x.SetSize(p + 1);
-   dshape_y.SetSize(p + 1);
-   dshape_z.SetSize(p + 1);
-   dshape_t.SetSize(p + 1);
-   dshape_l.SetSize(p + 1);
-   ddshape_x.SetSize(p + 1);
-   ddshape_y.SetSize(p + 1);
-   ddshape_z.SetSize(p + 1);
-   ddshape_t.SetSize(p + 1);
-   ddshape_l.SetSize(p + 1);
-   u.SetSize(dof);
-   du.SetSize(dof, dim);
-   ddu.SetSize(dof,dim*(dim+1)/2 );
-#else
-   Vector shape_x(p + 1), shape_y(p + 1), shape_z(p + 1), shape_t(p+1),
-          shape_l(p + 1);
-#endif
-
-   // vertices
-   Nodes.IntPoint(0).Set4(cp[0], cp[0], cp[0], cp[0]);
-   Nodes.IntPoint(1).Set4(cp[p], cp[0], cp[0], cp[0]);
-   Nodes.IntPoint(2).Set4(cp[0], cp[p], cp[0], cp[0]);
-   Nodes.IntPoint(3).Set4(cp[0], cp[0], cp[p], cp[0]);
-   Nodes.IntPoint(4).Set4(cp[0], cp[0], cp[0], cp[p]);
-
-   // edges (see Tetrahedron::edges in mesh/tetrahedron.cpp)
-   int o = 5;
-   for (int i = 1; i < p; i++)  // (0,1)
-   {
-      Nodes.IntPoint(o++).Set4(cp[i], cp[0], cp[0], cp[0]);
-   }
-   for (int i = 1; i < p; i++)  // (0,2)
-   {
-      Nodes.IntPoint(o++).Set4(cp[0], cp[i], cp[0], cp[0]);
-   }
-   for (int i = 1; i < p; i++)  // (0,3)
-   {
-      Nodes.IntPoint(o++).Set4(cp[0], cp[0], cp[i], cp[0]);
-   }
-   for (int i = 1; i < p; i++)  // (0,4)
-   {
-      Nodes.IntPoint(o++).Set4(cp[0], cp[0], cp[0], cp[i]);
-   }
-   for (int i = 1; i < p; i++)  // (1,2)
-   {
-      Nodes.IntPoint(o++).Set4(cp[p-i], cp[i], cp[0], cp[0]);
-   }
-   for (int i = 1; i < p; i++)  // (1,3)
-   {
-      Nodes.IntPoint(o++).Set4(cp[p-i], cp[0], cp[i], cp[0]);
-   }
-   for (int i = 1; i < p; i++)  // (1,4)
-   {
-      Nodes.IntPoint(o++).Set4(cp[p-i], cp[0], cp[0], cp[i]);
-   }
-   for (int i = 1; i < p; i++)  // (2,3)
-   {
-      Nodes.IntPoint(o++).Set4(cp[0], cp[p-i], cp[i], cp[0]);
-   }
-   for (int i = 1; i < p; i++)  // (2,4)
-   {
-      Nodes.IntPoint(o++).Set4(cp[0], cp[p-i], cp[0], cp[i]);
-   }
-   for (int i = 1; i < p; i++)  // (3,4)
-   {
-      Nodes.IntPoint(o++).Set4(cp[0], cp[0], cp[p-i], cp[i]);
-   }
-
-   // planars (see Mesh::GeneratePlanars in mesh/mesh.cpp)
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (0,1,2)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[i]/w, cp[j]/w, cp[0], cp[0]);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (0,1,3)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[i]/w, cp[0], cp[j]/w, cp[0]);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (0,1,4)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[i]/w, cp[0], cp[0], cp[j]/w);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (0,2,3)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[0], cp[i]/w, cp[j]/w, cp[0]);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (0,2,4)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[0], cp[i]/w, cp[0], cp[j]/w);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (0,3,4)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[0], cp[0], cp[i]/w, cp[j]/w);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (1,2,3)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[p-i-j]/w, cp[i]/w, cp[j]/w, cp[0]);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (1,2,4)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[p-i-j]/w, cp[i]/w, cp[0], cp[j]/w);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (1,3,4)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[p-i-j]/w, cp[0], cp[i]/w, cp[j]/w);
-      }
-   for (int j = 1; j < p; j++)
-      for (int i=1; i + j < p; i++) // (2,3,4)
-      {
-         double w = cp[i] + cp[j] + cp[p-i-j];
-         Nodes.IntPoint(o++).Set4(cp[0], cp[p-i-j]/w, cp[i]/w, cp[j]/w);
-      }
-
-   // face(volumes)s (see Mesh::GenerateFaces in mesh/mesh.cpp)
-   for (int k = 1; k < p; k++)
-      for (int j = 1; j + k < p; j++)
-         for (int i = 1; i + j + k < p; i++)  // (0,1,2,3)
-         {
-            double w = cp[i] + cp[j] + cp[k] + cp[p-i-j-k];
-            Nodes.IntPoint(o++).Set4(cp[i]/w, cp[j]/w, cp[k]/w, cp[0]);
-         }
-   for (int k = 1; k < p; k++)
-      for (int j = 1; j + k < p; j++)
-         for (int i = 1; i + j + k < p; i++)  // (0,2,1,4)
-         {
-            double w = cp[i] + cp[j] + cp[k] + cp[p-i-j-k];
-            Nodes.IntPoint(o++).Set4(cp[j]/w, cp[i]/w, cp[0], cp[k]/w);
-         }
-   for (int k = 1; k < p; k++)
-      for (int j = 1; j + k < p; j++)
-         for (int i = 1; i + j + k < p; i++)  // (0,1,3,4)
-         {
-            double w = cp[i] + cp[j] + cp[k] + cp[p-i-j-k];
-            Nodes.IntPoint(o++).Set4(cp[i]/w, cp[0], cp[j]/w, cp[k]/w);
-         }
-   for (int k = 1; k < p; k++)
-      for (int j = 1; j + k < p; j++)
-         for (int i = 1; i + j + k < p; i++)  // (0,3,2,4)
-         {
-            double w = cp[i] + cp[j] + cp[k] + cp[p-i-j-k];
-            Nodes.IntPoint(o++).Set4(cp[0], cp[j]/w, cp[i]/w, cp[k]/w);
-         }
-   for (int k = 1; k < p; k++)
-      for (int j = 1; j + k < p; j++)
-         for (int i = 1; i + j + k < p; i++)  // (1,2,3,4)
-         {
-            double w = cp[i] + cp[j] + cp[k] + cp[p-i-j-k];
-            Nodes.IntPoint(o++).Set4(cp[p-i-j-k]/w, cp[i]/w, cp[j]/w, cp[k]/w);
-         }
-
-   // interior
-   for (int l = 1; l < p; l++)
-      for (int k = 1; k + l < p; k++)
-         for (int j = 1; j + k + l < p; j++)
-            for (int i = 1; i + j + k + l < p; i++)
-            {
-               double w = cp[i] + cp[j] + cp[k] + cp[l] + cp[p-i-j-k-l];
-               Nodes.IntPoint(o++).Set4(cp[i]/w, cp[j]/w, cp[k]/w, cp[l]/w);
-            }
-
-   DenseMatrix T(dof);
-   for (int m = 0; m < dof; m++)
-   {
-      IntegrationPoint &ip = Nodes.IntPoint(m);
-      poly1d.CalcBasis(p, ip.x, shape_x);
-      poly1d.CalcBasis(p, ip.y, shape_y);
-      poly1d.CalcBasis(p, ip.z, shape_z);
-      poly1d.CalcBasis(p, ip.t, shape_t);
-      poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l);
-
-      o = 0;
-      for (int l = 0; l <= p; l++)
-         for (int k = 0; k + l <= p; k++)
-            for (int j = 0; j + k +l <= p; j++)
-               for (int i = 0; i + j + k + l <= p; i++)
-               {
-                  T(o++, m) = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(l)*shape_l(p-i-j-k-l);
-               }
-   }
-
-   Ti.Factor(T);
-   // cout << "H1_PentatopeElement(" << p << ") : "; Ti.TestInversion();
-}
-
-void H1_PentatopeElement::CalcShape(const IntegrationPoint &ip,
-                                    Vector &shape) const
-{
-   const int p = order;
-
-#ifdef MFEM_THREAD_SAFE
-   Vector shape_x(p + 1), shape_y(p + 1), shape_z(p + 1), shape_t(p+1),
-          shape_l(p + 1);
-   Vector u(Dof);
-#endif
-
-   poly1d.CalcBasis(p, ip.x, shape_x);
-   poly1d.CalcBasis(p, ip.y, shape_y);
-   poly1d.CalcBasis(p, ip.z, shape_z);
-   poly1d.CalcBasis(p, ip.t, shape_t);
-   poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l);
-
-   for (int o = 0, l = 0; l <= p; l++)
-      for (int k = 0; k + l <= p; k++)
-         for (int j = 0; j + k + l <= p; j++)
-            for (int i = 0; i + j + k + l <= p; i++)
-            {
-               u(o++) = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(l)*shape_l(p-i-j-k-l);
-            }
-
-   Ti.Mult(u, shape);
-}
-
-void H1_PentatopeElement::CalcDShape(const IntegrationPoint &ip,
-                                     DenseMatrix &dshape) const
-{
-   const int p = order;
-
-#ifdef MFEM_THREAD_SAFE
-   Vector  shape_x(p + 1),  shape_y(p + 1),  shape_z(p + 1),  shape_t(p+1),
-           shape_l(p + 1);
-   Vector dshape_x(p + 1), dshape_y(p + 1), dshape_z(p + 1), dshape_t(p+1),
-          dshape_l(p + 1);
-   DenseMatrix du(Dof, Dim);
-#endif
-
-   poly1d.CalcBasis(p, ip.x, shape_x, dshape_x);
-   poly1d.CalcBasis(p, ip.y, shape_y, dshape_y);
-   poly1d.CalcBasis(p, ip.z, shape_z, dshape_z);
-   poly1d.CalcBasis(p, ip.t, shape_t, dshape_t);
-   poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l, dshape_l);
-
-   for (int o = 0, l = 0; l <= p; l++)
-      for (int k = 0; k + l <= p; k++)
-         for (int j = 0; j + k + l <= p; j++)
-            for (int i = 0; i + j + k + l <= p; i++)
-            {
-               int m = p - i - j - k - l;
-               du(o,0) = ((dshape_x(i)* shape_l(m)) -
-                          ( shape_x(i)*dshape_l(m)))*shape_y(j)*shape_z(k)*shape_t(l);
-               du(o,1) = ((dshape_y(j)* shape_l(m)) -
-                          ( shape_y(j)*dshape_l(m)))*shape_x(i)*shape_z(k)*shape_t(l);
-               du(o,2) = ((dshape_z(k)* shape_l(m)) -
-                          ( shape_z(k)*dshape_l(m)))*shape_x(i)*shape_y(j)*shape_t(l);
-               du(o,3) = ((dshape_t(l)* shape_l(m)) -
-                          ( shape_t(l)*dshape_l(m)))*shape_x(i)*shape_y(j)*shape_z(k);
-               o++;
-            }
-
-   Ti.Mult(du, dshape);
-}
-
-void H1_PentatopeElement::CalcHessian(const IntegrationPoint &ip,
-                                      DenseMatrix &ddshape) const
-{
-   const int p = order;
-#ifdef MFEM_THREAD_SAFE
-   Vector   shape_x(p + 1),   shape_y(p + 1),   shape_z(p + 1),   shape_t(p+1),
-            shape_l(p + 1);
-   Vector  dshape_x(p + 1),  dshape_y(p + 1),  dshape_z(p + 1),  dshape_t(p+1),
-           dshape_l(p + 1);
-   Vector ddshape_x(p + 1), ddshape_y(p + 1), ddshape_z(p + 1), ddshape_t(p+1),
-          ddshape_l(p + 1);
-   DenseMatrix ddu(Dof, ((Dim+1)*Dim)/2);
-#endif
-
-   poly1d.CalcBasis(p, ip.x, shape_x, dshape_x, ddshape_x);
-   poly1d.CalcBasis(p, ip.y, shape_y, dshape_y, ddshape_y);
-   poly1d.CalcBasis(p, ip.z, shape_z, dshape_z, ddshape_z);
-   poly1d.CalcBasis(p, ip.t, shape_t, dshape_t, ddshape_t);
-   poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l, dshape_l,
-                    ddshape_l);
-
-   for (int o = 0, l = 0; l <= p; l++)
-      for (int k = 0; k + l <= p; k++)
-         for (int j = 0; j + k + l <= p; j++)
-            for (int i = 0; i + j + k + l <= p; i++)
-            {
-               // u_xx, u_xy, u_xz, u_xt, u_yy, u_yz, u_yt, u_zz, u_zt, u_tt
-               int m = p - i - j - k - l;
-               ddu(o,0) = ((ddshape_x(i)*shape_l(m)) - 2.* (dshape_x(i)*dshape_l(m)) +
-                           (shape_x(i)*ddshape_l(m))) * shape_y(j) * shape_z(k) * shape_t(l);
-               ddu(o,1) = ((dshape_y(j)* ( (dshape_x(i)*shape_l(m)) - (shape_x(i)*dshape_l(
-                                                                          m))) ) + (shape_y(j)* ((ddshape_l(m)*shape_x(i)) - (dshape_x(i) * dshape_l(
-                                                                                       m)) ) ) )* shape_z(k) * shape_t(l);
-               ddu(o,2) = ((dshape_z(k)* ( (dshape_x(i)*shape_l(m)) - (shape_x(i)*dshape_l(
-                                                                          m))) ) + (shape_z(k)* ((ddshape_l(m)*shape_x(i)) - (dshape_x(i) * dshape_l(
-                                                                                       m)) ) ) )* shape_y(j) * shape_t(l);
-               ddu(o,3) = ((dshape_t(l)* ( (dshape_x(i)*shape_l(m)) - (shape_x(i)*dshape_l(
-                                                                          m))) ) + (shape_t(l)* ((ddshape_l(m)*shape_x(i)) - (dshape_x(i) * dshape_l(
-                                                                                       m)) ) ) )* shape_y(j) * shape_z(k);
-               ddu(o,4) = ((ddshape_y(j)*shape_l(m)) - 2.* (dshape_y(j)*dshape_l(m)) +
-                           (shape_y(j)*ddshape_l(m))) * shape_x(i) * shape_z(k) * shape_t(l);
-               ddu(o,5) = ((dshape_z(k)* ( (dshape_y(j)*shape_l(m)) - (shape_y(j)*dshape_l(
-                                                                          m))) ) + (shape_z(k)* ((ddshape_l(m)*shape_y(j)) - (dshape_y(j) * dshape_l(
-                                                                                       m)) ) ) )* shape_x(i) * shape_t(l);
-               ddu(o,6) = ((dshape_t(l)* ( (dshape_y(j)*shape_l(m)) - (shape_y(j)*dshape_l(
-                                                                          m))) ) + (shape_t(l)* ((ddshape_l(m)*shape_y(j)) - (dshape_y(j) * dshape_l(
-                                                                                       m)) ) ) )* shape_x(i) * shape_z(k);
-               ddu(o,7) = ((ddshape_z(k)*shape_l(m)) - 2.* (dshape_z(k)*dshape_l(m)) +
-                           (shape_z(k)*ddshape_l(m))) * shape_y(j) * shape_x(i) * shape_t(l);
-               ddu(o,8) = ((dshape_t(l)* ( (dshape_z(k)*shape_l(m)) - (shape_z(k)*dshape_l(
-                                                                          m))) ) + (shape_t(l)* ((ddshape_l(m)*shape_z(k)) - (dshape_z(k) * dshape_l(
-                                                                                       m)) ) ) )* shape_x(i) * shape_y(j);
-               ddu(o,9) = ((ddshape_t(l)*shape_l(m)) - 2.* (dshape_t(l)*dshape_l(m)) +
-                           (shape_t(l)*ddshape_l(m))) * shape_y(j) * shape_x(i) * shape_z(k);
-               o++;
-            }
-   Ti.Mult(ddu, ddshape);
-}
-
-
 }
@@ -148,28 +148,6 @@ public:
                           DenseMatrix &dshape) const;
 };

-class H1_PentatopeElement : public NodalFiniteElement
-{
-private:
-#ifndef MFEM_THREAD_SAFE
-   mutable Vector shape_x, shape_y, shape_z, shape_t, shape_l;
-   mutable Vector dshape_x, dshape_y, dshape_z, dshape_t, dshape_l, u;
-   mutable Vector ddshape_x, ddshape_y, ddshape_z, ddshape_t, ddshape_l;
-   mutable DenseMatrix du, ddu;
-#endif
-   DenseMatrixInverse Ti;
-
-public:
-   H1_PentatopeElement(const int p,
-                       const int btype = BasisType::GaussLobatto);
-   virtual void CalcShape(const IntegrationPoint &ip, Vector &shape) const;
-   virtual void CalcDShape(const IntegrationPoint &ip,
-                           DenseMatrix &dshape) const;
-   virtual void CalcHessian(const IntegrationPoint &ip,
-                            DenseMatrix &ddshape) const;
-};
-
-
 } // namespace mfem

 #endif
@@ -923,175 +923,4 @@ void L2_WedgeElement::CalcDShape(const IntegrationPoint &ip,
   }
 }

-L2_PentatopeElement::L2_PentatopeElement(const int p, const int _type)
-   : NodalFiniteElement(4, Geometry::PENTATOPE,
-                        ((p + 1)*(p + 2)*(p + 3)*(p + 4))/24,
-                        p, FunctionSpace::Pk), T(dof)
-{
-   const double *op;
-
-   type = _type;
-   switch (type)
-   {
-      case 0: op = poly1d.OpenPoints(p); break;
-      case 1:
-      default: op = poly1d.ClosedPoints(p);
-   }
-
-#ifndef MFEM_THREAD_SAFE
-   shape_x.SetSize(p + 1);
-   shape_y.SetSize(p + 1);
-   shape_z.SetSize(p + 1);
-   shape_t.SetSize(p + 1);
-   shape_l.SetSize(p + 1);
-   dshape_x.SetSize(p + 1);
-   dshape_y.SetSize(p + 1);
-   dshape_z.SetSize(p + 1);
-   dshape_t.SetSize(p + 1);
-   dshape_l.SetSize(p + 1);
-   u.SetSize(dof);
-   du.SetSize(dof, dim);
-#else
-   Vector shape_x(p + 1), shape_y(p + 1), shape_z(p + 1), shape_t(p + 1),
-          shape_l(p + 1);
-#endif
-
-   for (int o = 0, l = 0; l <= p; l++)
-      for (int k = 0; l + k <= p; k++)
-         for (int j = 0; j + l + k <= p; j++)
-            for (int i = 0; i + j + l + k <= p; i++)
-            {
-               double w = op[i] + op[j] + op[k] + op[l] + op[p-i-j-k-l];
-               Nodes.IntPoint(o++).Set4(op[i]/w, op[j]/w, op[k]/w, op[l]/w);
-            }
-
-   for (int m = 0; m < dof; m++)
-   {
-      IntegrationPoint &ip = Nodes.IntPoint(m);
-      poly1d.CalcBasis(p, ip.x, shape_x);
-      poly1d.CalcBasis(p, ip.y, shape_y);
-      poly1d.CalcBasis(p, ip.z, shape_z);
-      poly1d.CalcBasis(p, ip.t, shape_t);
-      poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l);
-
-      for (int o = 0, l = 0; l <= p; l++)
-         for (int k = 0; l + k <= p; k++)
-            for (int j = 0; j + l + k <= p; j++)
-               for (int i = 0; i + j + l + k <= p; i++)
-               {
-                  T(o++, m) = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(l)*shape_l(p-i-j-k-l);
-               }
-   }
-
-   T.Invert();
-}
-
-void L2_PentatopeElement::CalcShape(const IntegrationPoint &ip,
-                                    Vector &shape) const
-{
-   const int p = order;
-
-#ifdef MFEM_THREAD_SAFE
-   Vector shape_x(p + 1), shape_y(p + 1), shape_z(p + 1), shape_l(p + 1);
-   Vector u(Dof);
-#endif
-
-   poly1d.CalcBasis(p, ip.x, shape_x);
-   poly1d.CalcBasis(p, ip.y, shape_y);
-   poly1d.CalcBasis(p, ip.z, shape_z);
-   poly1d.CalcBasis(p, ip.t, shape_t);
-   poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l);
-
-   for (int o = 0, l = 0; l <= p; l++)
-      for (int k = 0; l + k <= p; k++)
-         for (int j = 0; j + l + k <= p; j++)
-            for (int i = 0; i + j + l + k <= p; i++)
-            {
-               u(o++) = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(l)*shape_l(p-i-j-k-l);
-            }
-
-   T.Mult(u, shape);
-}
-
-void L2_PentatopeElement::CalcDShape(const IntegrationPoint &ip,
-                                     DenseMatrix &dshape) const
-{
-   const int p = order;
-
-#ifdef MFEM_THREAD_SAFE
-   Vector  shape_x(p + 1),  shape_y(p + 1),  shape_z(p + 1), shape_t(p + 1),
-           shape_l(p + 1);
-   Vector dshape_x(p + 1), dshape_y(p + 1), dshape_z(p + 1), dshape_t(p + 1),
-          dshape_l(p + 1);
-   DenseMatrix du(Dof, Dim);
-#endif
-
-   poly1d.CalcBasis(p, ip.x, shape_x, dshape_x);
-   poly1d.CalcBasis(p, ip.y, shape_y, dshape_y);
-   poly1d.CalcBasis(p, ip.z, shape_z, dshape_z);
-   poly1d.CalcBasis(p, ip.t, shape_t, dshape_t);
-   poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l, dshape_l);
-
-   for (int o = 0, m = 0; m <= p; m++)
-      for (int k = 0; k + m <= p; k++)
-         for (int j = 0; j + k + m <= p; j++)
-            for (int i = 0; i + j + k + m <= p; i++)
-            {
-               int l = p - i - j - k - m;
-               du(o,0) = ((dshape_x(i)* shape_l(l)) -
-                          ( shape_x(i)*dshape_l(l)))*shape_y(j)*shape_z(k)*shape_t(m);
-               du(o,1) = ((dshape_y(j)* shape_l(l)) -
-                          ( shape_y(j)*dshape_l(l)))*shape_x(i)*shape_z(k)*shape_t(m);
-               du(o,2) = ((dshape_z(k)* shape_l(l)) -
-                          ( shape_z(k)*dshape_l(l)))*shape_x(i)*shape_y(j)*shape_t(m);
-               du(o,3) = ((dshape_t(m)* shape_l(l)) -
-                          ( shape_t(m)*dshape_l(l)))*shape_x(i)*shape_y(j)*shape_z(k);
-               o++;
-            }
-
-   Mult(T, du, dshape);
-}
-
-void L2_PentatopeElement::ProjectDelta(int vertex, Vector &dofs) const
-{
-   switch (vertex)
-   {
-      case 0:
-         for (int i = 0; i < dof; i++)
-         {
-            const IntegrationPoint &ip = Nodes.IntPoint(i);
-            dofs[i] = pow(1.0 - ip.x - ip.y - ip.z - ip.t, order);
-         }
-         break;
-      case 1:
-         for (int i = 0; i < dof; i++)
-         {
-            const IntegrationPoint &ip = Nodes.IntPoint(i);
-            dofs[i] = pow(ip.x, order);
-         }
-         break;
-      case 2:
-         for (int i = 0; i < dof; i++)
-         {
-            const IntegrationPoint &ip = Nodes.IntPoint(i);
-            dofs[i] = pow(ip.y, order);
-         }
-         break;
-      case 3:
-         for (int i = 0; i < dof; i++)
-         {
-            const IntegrationPoint &ip = Nodes.IntPoint(i);
-            dofs[i] = pow(ip.z, order);
-         }
-         break;
-      case 4:
-         for (int i = 0; i < dof; i++)
-         {
-            const IntegrationPoint &ip = Nodes.IntPoint(i);
-            dofs[i] = pow(ip.t, order);
-         }
-         break;
-   }
-}
-
 }
@@ -183,25 +183,6 @@ public:
                           DenseMatrix &dshape) const;
 };

-class L2_PentatopeElement : public NodalFiniteElement
-{
-private:
-   int type;
-#ifndef MFEM_THREAD_SAFE
-   mutable Vector shape_x, shape_y, shape_z, shape_t, shape_l;
-   mutable Vector dshape_x, dshape_y, dshape_z, dshape_t, dshape_l, u;
-   mutable DenseMatrix du;
-#endif
-   DenseMatrix T;
-
-public:
-   L2_PentatopeElement(const int p, const int _type = 0);
-   virtual void CalcShape(const IntegrationPoint &ip, Vector &shape) const;
-   virtual void CalcDShape(const IntegrationPoint &ip,
-                           DenseMatrix &dshape) const;
-   virtual void ProjectDelta(int vertex, Vector &dofs) const;
-};
-
 } // namespace mfem

 #endif
@@ -2266,268 +2266,4 @@ void RT_R2D_QuadrilateralElement::CalcDivShape(const IntegrationPoint &ip,
      }
 }

-const double RT_PentatopeElement::nk[20] =
-{ 0,0,0,-1,  0,0,-1,0,  0,-1,0,0,  -1,0,0,0,  1,1,1,1};
-// { .5,.5,.5, -.5,0,0, 0,-.5,0, 0,0,-.5}; // n_F |F|
-
-const double RT_PentatopeElement::c = 1./5.;
-
-RT_PentatopeElement::RT_PentatopeElement(const int p)
-   : VectorFiniteElement(4, Geometry::PENTATOPE, (p + 1)*(p + 2)*(p + 3)*(p + 5)/6,
-                         p + 1, H_DIV, FunctionSpace::Pk),
-     dof2nk(dof)
-{
-   const double *iop = (p > 0) ? poly1d.OpenPoints(p - 1) : NULL;
-   const double *bop = poly1d.OpenPoints(p);
-
-#ifndef MFEM_THREAD_SAFE
-   shape_x.SetSize(p + 1);
-   shape_y.SetSize(p + 1);
-   shape_z.SetSize(p + 1);
-   shape_t.SetSize(p + 1);
-   shape_l.SetSize(p + 1);
-   dshape_x.SetSize(p + 1);
-   dshape_y.SetSize(p + 1);
-   dshape_z.SetSize(p + 1);
-   dshape_t.SetSize(p + 1);
-   dshape_l.SetSize(p + 1);
-   u.SetSize(dof, dim);
-   divu.SetSize(dof);
-#else
-   Vector shape_x(p + 1), shape_y(p + 1), shape_z(p + 1), shape_t(p + 1),
-          shape_l(p + 1);
-#endif
-
-   int o = 0;
-   // faces (see Mesh::GenerateFaces in mesh/mesh.cpp,
-   //        the constructor of H1_PentatopeElement)
-   for (int k = 0; k <= p; k++)
-      for (int j = 0; j + k <= p; j++)
-         for (int i = 0; i + j + k <= p; i++)  // (0,1,2,3)
-         {
-            double w = bop[i] + bop[j] + bop[k] + bop[p-i-j-k];
-            Nodes.IntPoint(o).Set4(bop[i]/w, bop[j]/w, bop[k]/w, 0.);
-            dof2nk[o++] = 0;
-         }
-   for (int k = 0; k <= p; k++)
-      for (int j = 0; j + k <= p; j++)
-         for (int i = 0; i + j + k <= p; i++)  // (0,2,1,4)
-         {
-            double w = bop[i] + bop[j] + bop[k] + bop[p-i-j-k];
-            Nodes.IntPoint(o).Set4(bop[j]/w, bop[i]/w, 0., bop[k]/w);
-            dof2nk[o++] = 1;
-         }
-   for (int k = 0; k <= p; k++)
-      for (int j = 0; j + k <= p; j++)
-         for (int i = 0; i + j + k <= p; i++)  // (0,1,3,4)
-         {
-            double w = bop[i] + bop[j] + bop[k] + bop[p-i-j-k];
-            Nodes.IntPoint(o).Set4(bop[i]/w, 0., bop[j]/w, bop[k]/w);
-            dof2nk[o++] = 2;
-         }
-   for (int k = 0; k <= p; k++)
-      for (int j = 0; j + k <= p; j++)
-         for (int i = 0; i + j + k <= p; i++)  // (0,3,2,4)
-         {
-            double w = bop[i] + bop[j] + bop[k] + bop[p-i-j-k];
-            Nodes.IntPoint(o).Set4(0., bop[j]/w, bop[i]/w, bop[k]/w);
-            dof2nk[o++] = 3;
-         }
-   for (int k = 0; k <= p; k++)
-      for (int j = 0; j + k <= p; j++)
-         for (int i = 0; i + j + k <= p; i++)  // (1,2,3,4)
-         {
-            double w = bop[i] + bop[j] + bop[k] + bop[p-i-j-k];
-            Nodes.IntPoint(o).Set4(bop[p-i-j-k]/w, bop[i]/w, bop[j]/w, bop[k]/w);
-            dof2nk[o++] = 4;
-         }
-
-   // interior
-   for (int l = 0; l < p; l++)
-      for (int k = 0; k + l < p; k++)
-         for (int j = 0; j + k + l < p; j++)
-            for (int i = 0; i + j + k + l < p; i++)
-            {
-               double w = iop[i] + iop[j] + iop[k] + iop[l] + iop[p-1-i-j-k-l];
-               Nodes.IntPoint(o).Set4(iop[i]/w, iop[j]/w, iop[k]/w, iop[l]/w);
-               dof2nk[o++] = 1;
-               Nodes.IntPoint(o).Set4(iop[i]/w, iop[j]/w, iop[k]/w, iop[l]/w);
-               dof2nk[o++] = 2;
-               Nodes.IntPoint(o).Set4(iop[i]/w, iop[j]/w, iop[k]/w, iop[l]/w);
-               dof2nk[o++] = 3;
-               Nodes.IntPoint(o).Set4(iop[i]/w, iop[j]/w, iop[k]/w, iop[l]/w);
-               dof2nk[o++] = 4;
-            }
-
-   DenseMatrix T(dof);
-   for (int m = 0; m < dof; m++)
-   {
-      const IntegrationPoint &ip = Nodes.IntPoint(m);
-      poly1d.CalcBasis(p, ip.x, shape_x);
-      poly1d.CalcBasis(p, ip.y, shape_y);
-      poly1d.CalcBasis(p, ip.z, shape_z);
-      poly1d.CalcBasis(p, ip.t, shape_t);
-      poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l);
-      const double *nm = nk + 4*dof2nk[m];
-
-      o = 0;
-      for (int l = 0; l<= p; l++)
-         for (int k = 0; k + l <= p; k++)
-            for (int j = 0; j + k + l <= p; j++)
-               for (int i = 0; i + j + k + l <= p; i++)
-               {
-                  double s = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(l)*shape_l(p-i-j-k-l);
-                  T(o++, m) = s * nm[0];
-                  T(o++, m) = s * nm[1];
-                  T(o++, m) = s * nm[2];
-                  T(o++, m) = s * nm[3];
-               }
-      for (int k = 0; k <= p; k++)
-         for (int j = 0; j + k <= p; j++)
-            for (int i = 0; i + j + k <= p; i++)
-            {
-               double s = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(p-i-j-k);
-               T(o++, m) = s*((ip.x - c)*nm[0] + (ip.y - c)*nm[1] +
-                              (ip.z - c)*nm[2] + (ip.t - c)*nm[3]);
-            }
-   }
-
-   Ti.Factor(T);
-   // mfem::out << "RT_TetrahedronElement(" << p << ") : "; Ti.TestInversion();
-}
-
-void RT_PentatopeElement::CalcVShape(const IntegrationPoint &ip,
-                                     DenseMatrix &shape) const
-{
-   const int p = order - 1;
-
-#ifdef MFEM_THREAD_SAFE
-   Vector shape_x(p + 1), shape_y(p + 1), shape_z(p + 1), shape_t(p + 1),
-          shape_l(p + 1);
-   DenseMatrix u(Dof, Dim);
-#endif
-
-   poly1d.CalcBasis(p, ip.x, shape_x);
-   poly1d.CalcBasis(p, ip.y, shape_y);
-   poly1d.CalcBasis(p, ip.z, shape_z);
-   poly1d.CalcBasis(p, ip.t, shape_t);
-   poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l);
-
-   int o = 0;
-   for (int l = 0; l <= p; l++)
-      for (int k = 0; k + l <= p; k++)
-         for (int j = 0; j + k + l <= p; j++)
-            for (int i = 0; i + j + k + l <= p; i++)
-            {
-               double s = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(l)*shape_l(p-i-j-k-l);
-               u(o,0) = s;  u(o,1) = 0;  u(o,2) = 0;  u(o,3) = 0;  o++;
-               u(o,0) = 0;  u(o,1) = s;  u(o,2) = 0;  u(o,3) = 0;  o++;
-               u(o,0) = 0;  u(o,1) = 0;  u(o,2) = s;  u(o,3) = 0;  o++;
-               u(o,0) = 0;  u(o,1) = 0;  u(o,2) = 0;  u(o,3) = s;  o++;
-            }
-   for (int k = 0; k <= p; k++)
-      for (int j = 0; j + k <= p; j++)
-         for (int i = 0; i + j + k <= p; i++)
-         {
-            double s = shape_x(i)*shape_y(j)*shape_z(k)*shape_t(p-i-j-k);
-            u(o,0) = (ip.x - c)*s;  u(o,1) = (ip.y - c)*s;  u(o,2) = (ip.z - c)*s;
-            u(o,3) = (ip.t - c)*s;
-            o++;
-         }
-
-   Ti.Mult(u, shape);
-}
-
-void RT_PentatopeElement::CalcDivShape(const IntegrationPoint &ip,
-                                       Vector &divshape) const
-{
-   const int p = order - 1;
-
-#ifdef MFEM_THREAD_SAFE
-   Vector shape_x(p + 1),  shape_y(p + 1),  shape_z(p + 1),  shape_l(p + 1);
-   Vector dshape_x(p + 1), dshape_y(p + 1), dshape_z(p + 1), dshape_l(p + 1);
-   Vector divu(Dof);
-#endif
-
-   poly1d.CalcBasis(p, ip.x, shape_x, dshape_x);
-   poly1d.CalcBasis(p, ip.y, shape_y, dshape_y);
-   poly1d.CalcBasis(p, ip.z, shape_z, dshape_z);
-   poly1d.CalcBasis(p, ip.t, shape_t, dshape_t);
-   poly1d.CalcBasis(p, 1. - ip.x - ip.y - ip.z - ip.t, shape_l, dshape_l);
-
-   int o = 0;
-   for (int m = 0; m <= p; m++)
-      for (int k = 0; k + m <= p; k++)
-         for (int j = 0; j + k + m <= p; j++)
-            for (int i = 0; i + j + k + m <= p; i++)
-            {
-               int l = p - i - j - k - m;
-               divu(o++) = (dshape_x(i)*shape_l(l) -
-                            shape_x(i)*dshape_l(l))*shape_y(j)*shape_z(k)*shape_t(m);
-               divu(o++) = (dshape_y(j)*shape_l(l) -
-                            shape_y(j)*dshape_l(l))*shape_x(i)*shape_z(k)*shape_t(m);
-               divu(o++) = (dshape_z(k)*shape_l(l) -
-                            shape_z(k)*dshape_l(l))*shape_x(i)*shape_y(j)*shape_t(m);
-               divu(o++) = (dshape_t(m)*shape_l(l) -
-                            shape_t(m)*dshape_l(l))*shape_x(i)*shape_y(j)*shape_z(k);
-            }
-   for (int l = 0; l <= p; l++)
-      for (int j = 0; j + l<= p; j++)
-         for (int i = 0; i + j + l <= p; i++)
-         {
-            int k = p - i - j - l;
-            divu(o++) =
-               (shape_x(i) + (ip.x - c)*dshape_x(i))*shape_y(j)*shape_z(l)*shape_t(k) +
-               (shape_y(j) + (ip.y - c)*dshape_y(j))*shape_x(i)*shape_z(l)*shape_t(k) +
-               (shape_z(l) + (ip.z - c)*dshape_z(l))*shape_x(i)*shape_y(j)*shape_t(k) +
-               (shape_t(k) + (ip.t - c)*dshape_t(k))*shape_x(i)*shape_y(j)*shape_z(l);
-         }
-
-   Ti.Mult(divu, divshape);
-}
-
-void RT_PentatopeElement::ProjectDivSkew(const FiniteElement& fe,
-                                         ElementTransformation& Trans, DenseMatrix& DivSkew) const
-{
-   int dof = fe.GetDof();
-
-   mfem_warning("RT_PentatopeElement::ProjectDivSkew(...) Implementation not tested!"); // TODO
-
-#ifdef MFEM_THREAD_SAFE
-   DenseMatrix Jinv(dim, dim);
-#endif
-
-   DivSkew.SetSize(dof,dof);
-   DivSkew = 0.0;
-
-   double n[4];
-   Vector ni(n, 4);
-   Vector vecF(4);
-
-   DenseMatrix DivSkewshape(dof,4);
-   DenseMatrix DivSkew_dFt(dof,4);
-   for (int k = 0; k < dof; k++)
-   {
-      Trans.SetIntPoint(&Nodes.IntPoint(k));
-      const DenseMatrix &J = Trans.Jacobian();
-      CalcAdjugateTranspose(J, Jinv);
-
-      fe.CalcDivSkewShape(Nodes.IntPoint(k), DivSkewshape);
-      MultABt(DivSkewshape, J, DivSkew_dFt);
-      DivSkew_dFt *= (1.0 / Trans.Weight());
-
-      Jinv.Mult(nk + dof2nk[k] * dim,n);
-
-      for (int j=0; j<dof; j++)
-      {
-         vecF(0) = DivSkew_dFt(j,0);
-         vecF(1) = DivSkew_dFt(j,1);
-         vecF(2) = DivSkew_dFt(j,2);
-         vecF(3) = DivSkew_dFt(j,3);
-
-         DivSkew(k, j) = vecF * ni;
-      }
-   }
-}
-
 }
@@ -524,53 +524,6 @@ public:
                             Vector &divshape) const;
 };

-class RT_PentatopeElement : public VectorFiniteElement
-{
-   static const double nk[20], c;
-
-#ifndef MFEM_THREAD_SAFE
-   mutable Vector shape_x, shape_y, shape_z, shape_t, shape_l;
-   mutable Vector dshape_x, dshape_y, dshape_z, dshape_t, dshape_l;
-   mutable DenseMatrix u;
-   mutable Vector divu;
-#endif
-   Array<int> dof2nk;
-   DenseMatrixInverse Ti;
-
-public:
-   RT_PentatopeElement(const int p);
-   virtual void CalcVShape(const IntegrationPoint &ip,
-                           DenseMatrix &shape) const;
-   virtual void CalcVShape(ElementTransformation &Trans,
-                           DenseMatrix &shape) const
-   { CalcVShape_RT(Trans, shape); }
-   virtual void CalcDivShape(const IntegrationPoint &ip,
-                             Vector &divshape) const;
-   virtual void GetLocalInterpolation(ElementTransformation &Trans,
-                                      DenseMatrix &I) const
-   { LocalInterpolation_RT(*this, nk, dof2nk, Trans, I); }
-   virtual void GetLocalRestriction(ElementTransformation &Trans,
-                                    DenseMatrix &R) const
-   { LocalRestriction_RT(nk, dof2nk, Trans, R); }
-   virtual void GetTransferMatrix(const FiniteElement &fe,
-                                  ElementTransformation &Trans,
-                                  DenseMatrix &I) const
-   { LocalInterpolation_RT(CheckVectorFE(fe), nk, dof2nk, Trans, I); }
-   using FiniteElement::Project;
-   virtual void Project(VectorCoefficient &vc,
-                        ElementTransformation &Trans, Vector &dofs) const
-   { Project_RT(nk, dof2nk, vc, Trans, dofs); }
-   virtual void ProjectMatrixCoefficient(
-      MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const
-   { ProjectMatrixCoefficient_RT(nk, dof2nk, mc, T, dofs); }
-   virtual void Project(const FiniteElement &fe, ElementTransformation &Trans,
-                        DenseMatrix &I) const
-   { Project_RT(nk, dof2nk, fe, Trans, I); }
-   virtual void ProjectDivSkew(const FiniteElement &fe,
-                               ElementTransformation &Trans,
-                               DenseMatrix &DivSkew) const;
-};
-

 } // namespace mfem

@@ -111,29 +111,12 @@ int FiniteElementCollection::HasFaceDofs(Geometry::Type geom, int p) const
      case Geometry::PYRAMID:
         return max(GetNumDof(Geometry::TRIANGLE, p),
                    GetNumDof(Geometry::SQUARE, p));
-      case Geometry::PENTATOPE:
-         return GetNumDof(Geometry::TETRAHEDRON, p);
-      case Geometry::TESSERACT:
-         return GetNumDof(Geometry::CUBE, p);
      default:
         MFEM_ABORT("unknown geometry type");
   }
   return 0;
 }

-int FiniteElementCollection::HasPlanarDofs(Geometry::Type GeomType, int p) const
-{
-   switch (GeomType)
-   {
-      case Geometry::PENTATOPE:   return GetNumDof(Geometry::TRIANGLE, p);
-      case Geometry::TESSERACT:   return GetNumDof(Geometry::SQUARE, p);
-      default:
-         mfem_error ("FiniteElementCollection::HasPlanarDofs:"
-                     " unknown geometry type.");
-   }
-   return 0;
-}
-
 FiniteElementCollection *FiniteElementCollection::GetTraceCollection() const
 {
   MFEM_ABORT("this method is not implemented in this derived class!");
@@ -670,8 +653,6 @@ LinearFECollection::FiniteElementForGeometry(Geometry::Type GeomType) const
      case Geometry::CUBE:        return &ParallelepipedFE;
      case Geometry::PRISM:       return &WedgeFE;
      case Geometry::PYRAMID:     return &PyramidFE;
-      case Geometry::PENTATOPE:   return &PentatopeFE;
-      case Geometry::TESSERACT:   return &TesseractFE;
      default:
         if (error_mode == RETURN_NULL) { return nullptr; }
         mfem_error ("LinearFECollection: unknown geometry type.");
@@ -691,8 +672,6 @@ int LinearFECollection::DofForGeometry(Geometry::Type GeomType) const
      case Geometry::CUBE:        return 0;
      case Geometry::PRISM:       return 0;
      case Geometry::PYRAMID:     return 0;
-      case Geometry::PENTATOPE:   return 0;
-      case Geometry::TESSERACT:   return 0;
      default:
         mfem_error ("LinearFECollection: unknown geometry type.");
   }
@@ -718,7 +697,6 @@ QuadraticFECollection::FiniteElementForGeometry(Geometry::Type GeomType) const
      case Geometry::TETRAHEDRON: return &TetrahedronFE;
      case Geometry::CUBE:        return &ParallelepipedFE;
      case Geometry::PRISM:       return &WedgeFE;
-      case Geometry::PENTATOPE:   return &PentatopeFE;
      default:
         if (error_mode == RETURN_NULL) { return nullptr; }
         mfem_error ("QuadraticFECollection: unknown geometry type.");
@@ -737,7 +715,6 @@ int QuadraticFECollection::DofForGeometry(Geometry::Type GeomType) const
      case Geometry::TETRAHEDRON: return 0;
      case Geometry::CUBE:        return 1;
      case Geometry::PRISM:       return 0;
-      case Geometry::PENTATOPE:   return 0;
      default:
         mfem_error ("QuadraticFECollection: unknown geometry type.");
   }
@@ -1564,135 +1541,6 @@ const int *ND1_3DFECollection::DofOrderForOrientation(Geometry::Type GeomType,
   return ind_neg;
 }

-const FiniteElement *
-ND1_4DFECollection::FiniteElementForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::PENTATOPE:   return &NedPentatopFE;
-      default:
-         mfem_error ("ND1_4DFECollection: unknown geometry type.");
-   }
-   return &NedPentatopFE; // Make some compilers happy
-}
-
-int ND1_4DFECollection::DofForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::POINT:       return 0;
-      case Geometry::SEGMENT:     return 1;
-      case Geometry::TRIANGLE:    return 0;
-      case Geometry::SQUARE:      return 0;
-      case Geometry::TETRAHEDRON: return 0;
-      case Geometry::CUBE:        return 0;
-      case Geometry::PENTATOPE:   return 0;
-      default:
-         mfem_error ("ND1_4DFECollection: unknown geometry type.");
-   }
-   return 0; // Make some compilers happy
-}
-
-const int * ND1_4DFECollection::DofOrderForOrientation(Geometry::Type GeomType,
-                                                       int Or)
-const
-{
-   static int ind_pos[] = { 0 };
-   static int ind_neg[] = { -1 };
-
-   if (Or > 0)
-   {
-      return ind_pos;
-   }
-   return ind_neg;
-}
-
-
-const FiniteElement *
-ND2_4DFECollection::FiniteElementForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::PENTATOPE:   return &NedPentatopFE;
-      default:
-         mfem_error ("ND2_4DFECollection: unknown geometry type.");
-   }
-   return &NedPentatopFE; // Make some compilers happy
-}
-
-int ND2_4DFECollection::DofForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::POINT:       return 0;
-      case Geometry::SEGMENT:     return 2;
-      case Geometry::TRIANGLE:    return 0;
-      case Geometry::SQUARE:      return 0;
-      case Geometry::TETRAHEDRON: return 0;
-      case Geometry::CUBE:        return 0;
-      case Geometry::PENTATOPE:   return 0;
-      default:
-         mfem_error ("ND2_4DFECollection: unknown geometry type.");
-   }
-   return 0; // Make some compilers happy
-}
-
-const int * ND2_4DFECollection::DofOrderForOrientation(Geometry::Type GeomType,
-                                                       int Or)
-const
-{
-   static int ind_pos[] = { 0, 1 };
-   static int ind_neg[] = { -2, -1};
-
-   if (Or > 0)
-   {
-      return ind_pos;
-   }
-   return ind_neg;
-}
-
-const FiniteElement *
-DivSkew1_4DFECollection::FiniteElementForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::PENTATOPE:   return &DivSkew0PentatopFE;
-      default:
-         mfem_error ("DivSkew1_4DFECollection: unknown geometry type 1.");
-   }
-   return &DivSkew0PentatopFE; // Make some compilers happy
-}
-
-int DivSkew1_4DFECollection::DofForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::POINT:       return 0;
-      case Geometry::SEGMENT:     return 0;
-      case Geometry::TRIANGLE:    return 1;
-      case Geometry::SQUARE:      return 0;
-      case Geometry::TETRAHEDRON: return 0;
-      case Geometry::CUBE:        return 0;
-      case Geometry::PENTATOPE:   return 0;
-      default:
-         mfem_error ("DivSkew1_4DFECollection: unknown geometry type 2.");
-   }
-   return 0; // Make some compilers happy
-}
-
-const int * DivSkew1_4DFECollection::DofOrderForOrientation(
-   Geometry::Type GeomType, int Or)
-const
-{
-   static int ind_pos[] = { 0 };
-   static int ind_neg[] = { -1 };
-
-   if (Or %2 == 0)
-   {
-      return ind_pos;
-   }
-   return ind_neg;
-}

 const FiniteElement *
 RT0_3DFECollection::FiniteElementForGeometry(Geometry::Type GeomType) const
@@ -1798,57 +1646,13 @@ const int *RT1_3DFECollection::DofOrderForOrientation(Geometry::Type GeomType,
   }
 }

-const FiniteElement *
-RT0_4DFECollection::FiniteElementForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::TETRAHEDRON: return &TetrahedronFE;
-      case Geometry::PENTATOPE: return &PentatopeFE;
-      default:
-         mfem_error ("RT0_4DFECollection: unknown geometry type.");
-   }
-   return &PentatopeFE; // Make some compilers happy
-}
-
-int RT0_4DFECollection::DofForGeometry(Geometry::Type GeomType) const
-{
-   switch (GeomType)
-   {
-      case Geometry::POINT:       return 0;
-      case Geometry::SEGMENT:     return 0;
-      case Geometry::TRIANGLE:    return 0;
-      case Geometry::SQUARE:      return 0;
-      case Geometry::TETRAHEDRON: return 1;
-      case Geometry::CUBE:        return 0;
-      case Geometry::PENTATOPE:   return 0;
-      default:
-         mfem_error ("RT0_4DFECollection: unknown geometry type.");
-   }
-   return 0; // Make some compilers happy
-}
-
-const int * RT0_4DFECollection::DofOrderForOrientation(Geometry::Type GeomType,
-                                                       int Or)
-const
-{
-   static int ind_pos[] = { 0 };
-   static int ind_neg[] = { -1 };
-
-   if (GeomType == Geometry::TETRAHEDRON)
-   {
-      if (Or % 2 == 0) { return ind_pos; }
-      return ind_neg;
-   }
-   return NULL;
-}

 H1_FECollection::H1_FECollection(const int p, const int dim, const int btype)
   : FiniteElementCollection(p)
   , dim(dim)
 {
   MFEM_VERIFY(p >= 1, "H1_FECollection requires order >= 1.");
-   MFEM_VERIFY(dim >= 0 && dim <= 4, "H1_FECollection requires 0 <= dim <= 4.");
+   MFEM_VERIFY(dim >= 0 && dim <= 3, "H1_FECollection requires 0 <= dim <= 3.");

   const int pm1 = p - 1, pm2 = pm1 - 1, pm3 = pm2 - 1, pm4 = pm3 - 1;

@@ -2149,20 +1953,6 @@ H1_FECollection::H1_FECollection(const int p, const int dim, const int btype)
               }
            }
         }
-
-         if (dim >= 4)
-         {
-            H1_dof[Geometry::PENTATOPE] = (TriDof*pm3*pm4)/12;
-            H1_dof[Geometry::TESSERACT] = QuadDof*pm1*pm1;
-            if (b_type == BasisType::Positive)
-            {
-               mfem_error("H1_FECollection: BasisType::Positive not implemented");
-            }
-            else
-            {
-               H1_Elements[Geometry::PENTATOPE] = new H1_PentatopeElement(p, pt_type);
-            }
-         }
      }
   }
 }
@@ -2540,38 +2330,6 @@ L2_FECollection::L2_FECollection(const int p, const int dim, const int btype,
         OtherDofOrd[j] = j; // for Or == 0
      }
   }
-   else if (dim == 4)
-   {
-      if (b_type == BasisType::Positive)
-      {
-         mfem::err <<
-                   "L2_FECollection::L2_FECollection : BasisType::Positive not implemented" <<
-                   endl;
-         mfem_error();
-      }
-      else
-      {
-         L2_Elements[Geometry::PENTATOPE] =
-            new L2_PentatopeElement(p, btype);
-
-         // 2025 November: check this
-         L2_Elements[Geometry::TESSERACT] = new L2_HexahedronElement(p, btype);
-      }
-      L2_Elements[Geometry::PENTATOPE]->SetMapType(map_type);
-      L2_Elements[Geometry::TESSERACT]->SetMapType(map_type);
-      // All trace element use the default Gauss-Legendre nodal points
-      Tr_Elements[Geometry::TETRAHEDRON] = new L2_TetrahedronElement(p);
-      Tr_Elements[Geometry::CUBE] = new L2_HexahedronElement(p);
-
-      const int PentDof = L2_Elements[Geometry::PENTATOPE]->GetDof();
-      const int TessDof = L2_Elements[Geometry::TESSERACT]->GetDof();
-      const int MaxDof = std::max(PentDof, TessDof);
-      OtherDofOrd = new int[MaxDof];
-      for (int j = 0; j < MaxDof; j++)
-      {
-         OtherDofOrd[j] = j; // for Or == 0
-      }
-   }
   else
   {
      mfem::err << "L2_FECollection::L2_FECollection : dim = "
@@ -2610,9 +2368,6 @@ const int *L2_FECollection::DofOrderForOrientation(Geometry::Type GeomType,
      case Geometry::TETRAHEDRON:
         return TetDofOrd[Or%24];

-      case Geometry::PENTATOPE:
-         return TetDofOrd[Or%120];
-
      default:
         return (Or == 0) ? OtherDofOrd : NULL;
   }
@@ -2697,13 +2452,6 @@ RT_FECollection::RT_FECollection(const int order, const int dim,
      RT_Elements[Geometry::PYRAMID] = new RT0PyrFiniteElement(false);
      RT_dof[Geometry::PYRAMID] = 0;
   }
-   else if (dim == 4)
-   {
-      RT_Elements[Geometry::PENTATOPE] = new RT_PentatopeElement(p);
-      RT_dof[Geometry::PENTATOPE] = p*pp1*(p + 2)*(p + 3)/6;
-
-      //TODO: tesseracts
-   }
   else
   {
      MFEM_ABORT("invalid dim = " << dim);
@@ -2736,7 +2484,7 @@ void RT_FECollection::InitFaces(const int p, const int dim_,
   MFEM_VERIFY(Quadrature1D::CheckOpen(op_type) != Quadrature1D::Invalid,
               "invalid open point type");

-   const int pp1 = p + 1, pp2 = p + 2, pp3 = p + 3;
+   const int pp1 = p + 1, pp2 = p + 2;

   for (int g = 0; g < Geometry::NumGeom; g++)
   {
@@ -2756,10 +2504,6 @@ void RT_FECollection::InitFaces(const int p, const int dim_,
   {
      QuadDofOrd[i] = NULL;
   }
-   for (int i = 0; i < 24; i++)
-   {
-      TetDofOrd[i] = NULL;
-   }

   if (dim_ == 2)
   {
@@ -2848,89 +2592,6 @@ void RT_FECollection::InitFaces(const int p, const int dim_,
         }
      }
   }
-   else if (dim == 4)
-   {
-      L2_TetrahedronElement *l2_tet = new L2_TetrahedronElement(p, ob_type);
-      l2_tet->SetMapType(map_type);
-      RT_Elements[Geometry::TETRAHEDRON] = l2_tet;
-      RT_dof[Geometry::TETRAHEDRON] = pp1*pp2*pp3/6;
-
-      int TetDof = RT_dof[Geometry::TETRAHEDRON];
-      int TriDof2 = pp2*pp1/2;
-      TetDofOrd[0] = new int[24*TetDof];
-      for (int i = 1; i < 24; i++)
-      {
-         TetDofOrd[i] = TetDofOrd[i-1] + TetDof;
-      }
-      // see Mesh::GetTriOrientation in mesh/mesh.cpp,
-      // the constructor of H1_FECollection
-      for (int k=0; k<=p; k++)
-      {
-         for (int j=0; j+k<=p; j++)
-         {
-            for (int i=0; i+j+k<=p; i++)
-            {
-               int o = TetDof + TriDof2 - ((pp3-k)*(pp2-k)*(pp1-k))/6 - (pp2-j)*
-                       (pp1-j)/2 - k*j + i;
-               int l = p-k-j-i;
-               TetDofOrd[0][o] = o;
-               TetDofOrd[1][o] =  -1 - (TetDof + TriDof2 - ((pp3-k)*(pp2-k)*(pp1-k))/6 -
-                                        (pp2-j)*(pp1-j)/2 - k*j + l);
-               TetDofOrd[2][o] =        TetDof + TriDof2 - ((pp3-k)*(pp2-k)*(pp1-k))/6 -
-                                        (pp2-i)*(pp1-i)/2 - k*i + l;
-               TetDofOrd[3][o] =  -1 - (TetDof + TriDof2 - ((pp3-k)*(pp2-k)*(pp1-k))/6 -
-                                        (pp2-l)*(pp1-l)/2 - k*l + i);
-               TetDofOrd[4][o] =        TetDof + TriDof2 - ((pp3-k)*(pp2-k)*(pp1-k))/6 -
-                                        (pp2-l)*(pp1-l)/2 - k*l + j;
-               TetDofOrd[5][o] =  -1 - (TetDof + TriDof2 - ((pp3-k)*(pp2-k)*(pp1-k))/6 -
-                                        (pp2-i)*(pp1-i)/2 - k*i + j);
-               TetDofOrd[6][o] =        TetDof + TriDof2 - ((pp3-j)*(pp2-j)*(pp1-j))/6 -
-                                        (pp2-i)*(pp1-i)/2 - j*i + k;
-               TetDofOrd[7][o] =  -1 - (TetDof + TriDof2 - ((pp3-j)*(pp2-j)*(pp1-j))/6 -
-                                        (pp2-l)*(pp1-l)/2 - j*l + k);
-               TetDofOrd[8][o] =        TetDof + TriDof2 - ((pp3-i)*(pp2-i)*(pp1-i))/6 -
-                                        (pp2-l)*(pp1-l)/2 - i*l + k;
-               TetDofOrd[9][o] =  -1 - (TetDof + TriDof2 - ((pp3-l)*(pp2-l)*(pp1-l))/6 -
-                                        (pp2-i)*(pp1-i)/2 - l*i + k);
-               TetDofOrd[10][o] =       TetDof + TriDof2 - ((pp3-l)*(pp2-l)*(pp1-l))/6 -
-                                        (pp2-j)*(pp1-j)/2 - l*j + k;
-               TetDofOrd[11][o] = -1 - (TetDof + TriDof2 - ((pp3-i)*(pp2-i)*(pp1-i))/6 -
-                                        (pp2-j)*(pp1-j)/2 - i*j + k);
-               TetDofOrd[12][o] =       TetDof + TriDof2 - ((pp3-i)*(pp2-i)*(pp1-i))/6 -
-                                        (pp2-k)*(pp1-k)/2 - i*k + j;
-               TetDofOrd[13][o] = -1 - (TetDof + TriDof2 - ((pp3-l)*(pp2-l)*(pp1-l))/6 -
-                                        (pp2-k)*(pp1-k)/2 - l*k + j);
-               TetDofOrd[14][o] =       TetDof + TriDof2 - ((pp3-l)*(pp2-l)*(pp1-l))/6 -
-                                        (pp2-k)*(pp1-k)/2 - l*k + i;
-               TetDofOrd[15][o] = -1 - (TetDof + TriDof2 - ((pp3-i)*(pp2-i)*(pp1-i))/6 -
-                                        (pp2-k)*(pp1-k)/2 - i*k + l);
-               TetDofOrd[16][o] =       TetDof + TriDof2 - ((pp3-j)*(pp2-j)*(pp1-j))/6 -
-                                        (pp2-k)*(pp1-k)/2 - j*k + l;
-               TetDofOrd[17][o] = -1 - (TetDof + TriDof2 - ((pp3-j)*(pp2-j)*(pp1-j))/6 -
-                                        (pp2-k)*(pp1-k)/2 - j*k + i);
-               TetDofOrd[18][o] =       TetDof + TriDof2 - ((pp3-j)*(pp2-j)*(pp1-j))/6 -
-                                        (pp2-l)*(pp1-l)/2 - j*l + i;
-               TetDofOrd[19][o] = -1 - (TetDof + TriDof2 - ((pp3-j)*(pp2-j)*(pp1-j))/6 -
-                                        (pp2-i)*(pp1-i)/2 - j*i + l);
-               TetDofOrd[20][o] =       TetDof + TriDof2 - ((pp3-i)*(pp2-i)*(pp1-i))/6 -
-                                        (pp2-j)*(pp1-j)/2 - i*j + l;
-               TetDofOrd[21][o] = -1 - (TetDof + TriDof2 - ((pp3-l)*(pp2-l)*(pp1-l))/6 -
-                                        (pp2-j)*(pp1-j)/2 - l*j + i);
-               TetDofOrd[22][o] =       TetDof + TriDof2 - ((pp3-l)*(pp2-l)*(pp1-l))/6 -
-                                        (pp2-i)*(pp1-i)/2 - l*i + j;
-               TetDofOrd[23][o] = -1 - (TetDof + TriDof2 - ((pp3-i)*(pp2-i)*(pp1-i))/6 -
-                                        (pp2-l)*(pp1-l)/2 - i*l + j);
-               if (!signs)
-               {
-                  for (int m = 0; m < 24; m+=2)
-                  {
-                     TetDofOrd[m][o] = -1 - TetDofOrd[m][o];
-                  }
-               }
-            }
-         }
-      }
-   }
 }

 const FiniteElement *
@@ -2964,10 +2625,6 @@ const int *RT_FECollection::DofOrderForOrientation(Geometry::Type GeomType,
   {
      return QuadDofOrd[Or%8];
   }
-   else if (GeomType == Geometry::TETRAHEDRON)
-   {
-      return TetDofOrd[Or%24];
-   }
   return NULL;
 }

@@ -94,8 +94,6 @@ public:

   int HasFaceDofs(Geometry::Type geom, int p) const;

-   int HasPlanarDofs(Geometry::Type GeomType, int p) const;
-
   virtual const FiniteElement *TraceFiniteElementForGeometry(
      Geometry::Type GeomType) const
   {
@@ -393,7 +391,7 @@ protected:
   char rt_name[32];
   FiniteElement *RT_Elements[Geometry::NumGeom];
   int RT_dof[Geometry::NumGeom];
-   int *SegDofOrd[2], *TriDofOrd[6], *QuadDofOrd[8], *TetDofOrd[24];
+   int *SegDofOrd[2], *TriDofOrd[6], *QuadDofOrd[8];

   // Initialize only the face elements
   void InitFaces(const int p, const int dim, const int map_type,
@@ -748,8 +746,6 @@ private:
   const TriLinear3DFiniteElement ParallelepipedFE;
   const LinearWedgeFiniteElement WedgeFE;
   const LinearPyramidFiniteElement PyramidFE;
-   const Linear4DFiniteElement PentatopeFE;
-   const QuadLinear4DFiniteElement TesseractFE;
 public:
   LinearFECollection() : FiniteElementCollection(1) {}

@@ -777,7 +773,6 @@ private:
   const Quadratic3DFiniteElement TetrahedronFE;
   const LagrangeHexFiniteElement ParallelepipedFE;
   const H1_WedgeElement WedgeFE;
-   const Quadratic4DFiniteElement PentatopeFE;

 public:
   QuadraticFECollection()
@@ -1295,65 +1290,6 @@ public:
   int GetContType() const override { return TANGENTIAL; }
 };

-class ND1_4DFECollection : public FiniteElementCollection
-{
-private:
-   const Nedelec1PentFiniteElement NedPentatopFE;
-
-public:
-   ND1_4DFECollection() { }
-
-   virtual const FiniteElement *
-   FiniteElementForGeometry(Geometry::Type GeomType) const;
-
-   virtual int DofForGeometry(Geometry::Type GeomType) const;
-
-   virtual const int * DofOrderForOrientation(Geometry::Type GeomType,
-                                              int Or) const;
-
-   virtual const char * Name() const { return "ND1_4D"; }
-};
-
-class ND2_4DFECollection : public FiniteElementCollection
-{
-private:
-   const Nedelec1FullPentFiniteElement NedPentatopFE;
-
-public:
-   ND2_4DFECollection() { }
-
-   virtual const FiniteElement *
-   FiniteElementForGeometry(Geometry::Type GeomType) const;
-
-   virtual int DofForGeometry(Geometry::Type GeomType) const;
-
-   virtual const int * DofOrderForOrientation(Geometry::Type GeomType,
-                                              int Or) const;
-
-   virtual const char * Name() const { return "ND2_4D"; }
-};
-
-
-class DivSkew1_4DFECollection : public FiniteElementCollection
-{
-private:
-   const DivSkew1PentFiniteElement DivSkew0PentatopFE;
-
-public:
-   DivSkew1_4DFECollection() { }
-
-   virtual const FiniteElement *
-   FiniteElementForGeometry(Geometry::Type GeomType) const;
-
-   virtual int DofForGeometry(Geometry::Type GeomType) const;
-
-   virtual const int * DofOrderForOrientation(Geometry::Type GeomType,
-                                              int Or) const;
-
-   virtual const char * Name() const { return "F2K0_4D"; }
-};
-
-
 /** @brief First order Raviart-Thomas finite elements in 3D. This class is kept
    only for backward compatibility, consider using RT_FECollection instead. */
 class RT0_3DFECollection : public FiniteElementCollection
@@ -1405,26 +1341,6 @@ public:
   int GetContType() const override { return NORMAL; }
 };

-/** First order Raviart-Thomas finite elements in 4D. */
-class RT0_4DFECollection : public FiniteElementCollection
-{
-private:
-   const P0TetFiniteElement TetrahedronFE;
-   const RT0PentFiniteElement PentatopeFE;
-public:
-   RT0_4DFECollection() { };
-
-   virtual const FiniteElement *
-   FiniteElementForGeometry(Geometry::Type GeomType) const;
-
-   virtual int DofForGeometry(Geometry::Type GeomType) const;
-
-   virtual const int * DofOrderForOrientation(Geometry::Type GeomType,
-                                              int Or) const;
-
-   virtual const char * Name() const { return "RT0_4D"; };
-};
-
 /// Discontinuous collection defined locally by a given finite element.
 class Local_FECollection : public FiniteElementCollection
 {
@@ -58,8 +58,8 @@ DofsToVDofs<Ordering::byVDIM>(int ndofs, int vdim, Array<int> &dofs)

 FiniteElementSpace::FiniteElementSpace()
   : mesh(NULL), fec(NULL), vdim(0), ordering(Ordering::byNODES),
-     ndofs(0), nvdofs(0), nedofs(0), nfdofs(0), nbdofs(0), npdofs(0),
-     bdofs(NULL), pdofs(NULL),
+     ndofs(0), nvdofs(0), nedofs(0), nfdofs(0), nbdofs(0),
+     bdofs(NULL),
     elem_dof(NULL), elem_fos(NULL), bdr_elem_dof(NULL), bdr_elem_fos(NULL),
     face_dof(NULL),
     NURBSext(NULL), own_ext(false),
@@ -319,12 +319,6 @@ void FiniteElementSpace::GetFaceVDofs(int i, Array<int> &vdofs) const
   DofsToVDofs(vdofs);
 }

-void FiniteElementSpace::GetPlanarVDofs(int i, Array<int> &vdofs) const
-{
-   GetPlanarDofs(i, vdofs);
-   DofsToVDofs(vdofs);
-}
-
 void FiniteElementSpace::GetEdgeVDofs(int i, Array<int> &vdofs) const
 {
   GetEdgeDofs(i, vdofs);
@@ -546,13 +540,7 @@ void FiniteElementSpace::GetEssentialVDofs(const Array<int> &bdr_attr_is_ess,
   // local DOFs affected by boundary elements on other processors
   if (Nonconforming())
   {
-      Array<int> bdr_verts, bdr_edges, bdr_faces, bdr_planars;
-      // if (mesh->Dimension() > 3)
-      // {
-      //    mesh->ncmesh->GetBoundaryClosure(bdr_attr_is_ess, bdr_verts, bdr_edges,
-      //                                     bdr_faces, bdr_planars);
-      // }
-      // else
+      Array<int> bdr_verts, bdr_edges, bdr_faces;
      mesh->ncmesh->GetBoundaryClosure(bdr_attr_is_ess, bdr_verts, bdr_edges,
                                       bdr_faces);
      for (auto v : bdr_verts)
@@ -594,20 +582,6 @@ void FiniteElementSpace::GetEssentialVDofs(const Array<int> &bdr_attr_is_ess,
         }
         MarkDofs(dofs, ess_vdofs);
      }
-      for (int i = 0; i < bdr_planars.Size(); i++)
-      {
-         if (component < 0)
-         {
-            GetPlanarVDofs(bdr_planars[i], dofs);
-         }
-         else
-         {
-            GetPlanarVDofs(bdr_planars[i], dofs);
-            for (int d = 0; d < dofs.Size(); d++)
-            { dofs[d] = DofToVDof(dofs[d], component); }
-         }
-         MarkDofs(dofs, ess_vdofs);
-      }
   }
 }

@@ -1015,8 +989,6 @@ void FiniteElementSpace::BuildConformingInterpolation() const
               "This method should not be used with a ParFiniteElementSpace!");
 #endif

-   if (mesh->Dimension() == 4) { BuildConformingInterpolation4D(); return; }
-
   if (cP_is_set) { return; }
   cP_is_set = true;

@@ -1299,178 +1271,6 @@ void FiniteElementSpace::BuildConformingInterpolation() const
   }
 }

-void FiniteElementSpace::BuildConformingInterpolation4D() const
-{
-   #if 0
-#ifdef MFEM_USE_MPI
-   MFEM_VERIFY(dynamic_cast<const ParFiniteElementSpace*>(this) == NULL,
-               "This method should not be used with a ParFiniteElementSpace!");
-#endif
-
-   if (cP_is_set) { return; }
-   cP_is_set = true;
-
-   // For each slave DOF, the dependency matrix will contain a row that
-   // expresses the slave DOF as a linear combination of its immediate master
-   // DOFs. Rows of independent DOFs will remain empty.
-   SparseMatrix deps(ndofs);
-
-   // collect local edge/planar/face dependencies
-   for (int entity = 1; entity <= 3; entity++)
-   {
-      const NCMesh::NCList &list = (entity > 2) ? mesh->ncmesh->GetFaceList()
-                                   /*        */ : ( (entity > 1) ? mesh->ncmesh->GetPlanarList() :
-                                                    mesh->ncmesh->GetEdgeList() );
-      if (!list.masters.size()) { continue; }
-
-      IsoparametricTransformation T;
-      if (entity > 2) { T.SetFE(&TetrahedronFE); }
-      else if (entity > 1) { T.SetFE(&TriangleFE); }
-      else { T.SetFE(&SegmentFE); }
-
-      Geometry::Type geom = (entity > 2) ? Geometry::TETRAHEDRON : ( (
-                                                                        entity > 1) ? Geometry::TRIANGLE : Geometry::SEGMENT );
-      const FiniteElement* fe = fec->FiniteElementForGeometry(geom);
-      if (!fe) { continue; }
-
-      Array<int> master_dofs, slave_dofs;
-      DenseMatrix I(fe->GetDof());
-
-      // loop through all master edges/faces, constrain their slave edges/faces
-      for (unsigned mi = 0; mi < list.masters.size(); mi++)
-      {
-         const NCMesh::Master &master = list.masters[mi];
-         GetEntityDofs4D(entity, master.index, master_dofs);
-         if (!master_dofs.Size()) { continue; }
-
-         //         mfem::out << "--------------------\n";
-         //         master_dofs.Print(mfem::out,master_dofs.Size());
-
-         for (int si = master.slaves_begin; si < master.slaves_end; si++)
-         {
-            const NCMesh::Slave &slave = list.slaves[si];
-            GetEntityDofs4D(entity, slave.index, slave_dofs);
-            if (!slave_dofs.Size()) { continue; }
-
-            slave.OrientedPointMatrix(T.GetPointMat());
-            T.FinalizeTransformation();
-            fe->GetLocalInterpolation(T, I);
-
-            //            mfem::out << "********************\n";
-            //            slave_dofs.Print(mfem::out,slave_dofs.Size());
-            //            mfem::out << "++++++++++++++++++++\n";
-            //            I.PrintMatlab(mfem::out);
-            //            mfem::out << "++++++++++++++++++++\n";
-
-            // make each slave DOF dependent on all master DOFs
-            AddDependencies(deps, master_dofs, slave_dofs, I);
-         }
-      }
-   }
-
-   deps.Finalize();
-   //   deps.PrintMatlab(mfem::out);
-
-   // DOFs that stayed independent are true DOFs
-   int n_true_dofs = 0;
-   for (int i = 0; i < ndofs; i++)
-   {
-      if (!deps.RowSize(i)) { n_true_dofs++; }
-   }
-
-   // if all dofs are true dofs leave cP and cR NULL
-   if (n_true_dofs == ndofs)
-   {
-      cP = cR = NULL; // will be treated as identities
-      return;
-   }
-
-   // create the conforming restriction matrix cR
-   int *cR_J;
-   {
-      int *cR_I = new int[n_true_dofs+1];
-      double *cR_A = new double[n_true_dofs];
-      cR_J = new int[n_true_dofs];
-      for (int i = 0; i < n_true_dofs; i++)
-      {
-         cR_I[i] = i;
-         cR_A[i] = 1.0;
-      }
-      cR_I[n_true_dofs] = n_true_dofs;
-      cR = new SparseMatrix(cR_I, cR_J, cR_A, n_true_dofs, ndofs);
-   }
-
-   // create the conforming prolongation matrix cP
-   cP = new SparseMatrix(ndofs, n_true_dofs);
-
-   Array<bool> finalized(ndofs);
-   finalized = false;
-
-   // put identity in the restriction and prolongation matrices for true DOFs
-   for (int i = 0, true_dof = 0; i < ndofs; i++)
-   {
-      if (!deps.RowSize(i))
-      {
-         cR_J[true_dof] = i;
-         cP->Add(i, true_dof++, 1.0);
-         finalized[i] = true;
-      }
-   }
-
-   // Now calculate cP rows of slave DOFs as combinations of cP rows of their
-   // master DOFs. It is possible that some slave DOFs depend on DOFs that are
-   // themselves slaves. Here we resolve such indirect constraints by first
-   // calculating rows of the cP matrix for DOFs whose master DOF cP rows are
-   // already known (in the first iteration these are the true DOFs). In the
-   // second iteration, slaves of slaves can be 'finalized' (given a row in the
-   // cP matrix), in the third iteration slaves of slaves of slaves, etc.
-   bool finished;
-   int n_finalized = n_true_dofs;
-   Array<int> cols;
-   Vector srow;
-   do
-   {
-      finished = true;
-      for (int dof = 0; dof < ndofs; dof++)
-      {
-         if (!finalized[dof] && DofFinalizable(dof, finalized, deps))
-         {
-            const int* dep_col = deps.GetRowColumns(dof);
-            const double* dep_coef = deps.GetRowEntries(dof);
-            int n_dep = deps.RowSize(dof);
-
-            for (int j = 0; j < n_dep; j++)
-            {
-               cP->GetRow(dep_col[j], cols, srow);
-               srow *= dep_coef[j];
-               cP->AddRow(dof, cols, srow);
-            }
-
-            finalized[dof] = true;
-            n_finalized++;
-            finished = false;
-         }
-      }
-   }
-   while (!finished);
-
-   // if everything is consistent (mesh, face orientations, etc.), we should
-   // be able to finalize all slave DOFs, otherwise it's a serious error
-   if (n_finalized != ndofs)
-   {
-      MFEM_ABORT("Error creating cP matrix.");
-   }
-
-   cP->Finalize();
-
-   if (vdim > 1)
-   {
-      MakeVDimMatrix(*cP);
-      MakeVDimMatrix(*cR);
-   }
-   #endif
-}
-
 void FiniteElementSpace::MakeVDimMatrix(SparseMatrix &mat) const
 {
   if (vdim == 1) { return; }
@@ -2504,10 +2304,8 @@ void FiniteElementSpace::UpdateNURBS()

   nvdofs = 0;
   nedofs = 0;
-   npdofs = 0;
   nfdofs = 0;
   nbdofs = 0;
-   pdofs = NULL;
   bdofs = NULL;

   delete face_dof;
@@ -2590,8 +2388,6 @@ void FiniteElementSpace::Construct()
   face_dof = NULL;

   ndofs = 0;
-   npdofs = 0;
-   pdofs = NULL;
   nvdofs = nedofs = nfdofs = nbdofs = 0;
   bdofs = NULL;

@@ -2664,24 +2460,6 @@ void FiniteElementSpace::Construct()
      }
   }

-   if (mesh->Dimension() >= 4 && mesh->GetNE())
-   {
-      // Here we assume that all planars in the mesh have the same base
-      // geometry -- the base geometry of the 0-th face element.
-      int pdof = fec->DofForGeometry(mesh->GetPlanarBaseGeometry(0));
-      if (pdof > 0)
-      {
-         pdofs = new int[mesh->GetNPlanars()+1];
-         pdofs[0] = 0;
-         for (int i = 0; i < mesh->GetNPlanars(); i++)
-         {
-            npdofs += pdof;
-            // npdofs += fec->DofForGeometry(mesh->GetPlanarBaseGeometry(i));
-            pdofs[i+1] = npdofs;
-         }
-      }
-   }
-
   // assign internal ("bubble") DOFs
   if (mesh->GetNE() && dim > 0)
   {
@@ -2705,7 +2483,7 @@ void FiniteElementSpace::Construct()
      }
   }

-   ndofs = nvdofs + nedofs + npdofs + nfdofs + nbdofs;
+   ndofs = nvdofs + nedofs + nfdofs + nbdofs;

   ConstructDoFTransArray();

@@ -2978,7 +2756,7 @@ void FiniteElementSpace::GetElementDofs(int elem, Array<int> &dofs,
      return;
   }

-   Array<int> V, E, Eo, F, Fo, P, Po; // TODO: LocalArray
+   Array<int> V, E, Eo, F, Fo; // TODO: LocalArray

   int dim = mesh->Dimension();
   auto geom = mesh->GetElementGeometry(elem);
@@ -2987,11 +2765,9 @@ void FiniteElementSpace::GetElementDofs(int elem, Array<int> &dofs,
   int nv = fec->GetNumDof(Geometry::POINT, order);
   int ne = (dim > 1) ? fec->GetNumDof(Geometry::SEGMENT, order) : 0;
   int nb = (dim > 0) ? fec->GetNumDof(geom, order) : 0;
-   int np = (dim > 3) ? fec->GetNumDof(Geometry::TRIANGLE, order) : 0;

   if (nv) { mesh->GetElementVertices(elem, V); }
   if (ne) { mesh->GetElementEdges(elem, E, Eo); }
-   if (np) { mesh->GetElementPlanars(elem, P, Po); }

   int nfd = 0;
   if (dim > 2 && fec->HasFaceDofs(geom, order))
@@ -3011,7 +2787,7 @@ void FiniteElementSpace::GetElementDofs(int elem, Array<int> &dofs,
   }

   dofs.SetSize(0);
-   dofs.Reserve(nv*V.Size() + ne*E.Size() + np*P.Size() + nfd + nb);
+   dofs.Reserve(nv*V.Size() + ne*E.Size() + nfd + nb);

   if (nv) // vertex DOFs
   {
@@ -3038,20 +2814,6 @@ void FiniteElementSpace::GetElementDofs(int elem, Array<int> &dofs,
      }
   }

-   if(np)
-   {
-      for (int i = 0; i < P.Size(); i++)
-      {
-         int pbase = /* IsVariableOrder() ? FindEdgeDof(E[i], ne) :  */P[i]*np;
-         const int *ind = fec->GetDofOrdering(Geometry::TRIANGLE, order, Po[i]);
-
-         for (int j = 0; j < np; j++)
-         {
-            dofs.Append(EncodeDof(nvdofs + nedofs + pbase, ind[j]));
-         }
-      }
-   }
-
   if (nfd) // face DOFs
   {
      for (int i = 0; i < F.Size(); i++)
@@ -3064,7 +2826,7 @@ void FiniteElementSpace::GetElementDofs(int elem, Array<int> &dofs,

         for (int j = 0; j < nf; j++)
         {
-            dofs.Append(EncodeDof(nvdofs + nedofs + npdofs + fbase, ind[j]));
+            dofs.Append(EncodeDof(nvdofs + nedofs + fbase, ind[j]));
         }
      }
   }
@@ -3072,7 +2834,7 @@ void FiniteElementSpace::GetElementDofs(int elem, Array<int> &dofs,
   if (nb) // interior ("bubble") DOFs
   {
      int bbase = bdofs ? bdofs[elem] : elem*nb;
-      bbase += nvdofs + nedofs + npdofs + nfdofs;
+      bbase += nvdofs + nedofs + nfdofs;

      for (int j = 0; j < nb; j++)
      {
@@ -3110,7 +2872,7 @@ void FiniteElementSpace::GetBdrElementDofs(int bel, Array<int> &dofs,
      return;
   }

-   Array<int> V, E, Eo, P, Po; // TODO: LocalArray
+   Array<int> V, E, Eo; // TODO: LocalArray
   int F, oF;

   int dim = mesh->Dimension();
@@ -3127,13 +2889,9 @@ void FiniteElementSpace::GetBdrElementDofs(int bel, Array<int> &dofs,
   int nv = fec->GetNumDof(Geometry::POINT, order);
   int ne = (dim > 1) ? fec->GetNumDof(Geometry::SEGMENT, order) : 0;
   int nf = (dim > 2) ? fec->GetNumDof(geom, order) : 0;
-   int np = (dim > 3) ? fec->DofForGeometry(Geometry::TRIANGLE) : (0);

   if (nv) { mesh->GetBdrElementVertices(bel, V); }
   if (ne) { mesh->GetBdrElementEdges(bel, E, Eo); }
-
-   if (np) { mesh->GetBdrElementPlanars(bel, P, Po); }
-
   if (nf)
   {
      mesh->GetBdrElementFace(bel, &F, &oF);
@@ -3150,7 +2908,7 @@ void FiniteElementSpace::GetBdrElementDofs(int bel, Array<int> &dofs,
   }

   dofs.SetSize(0);
-   dofs.Reserve(nv*V.Size() + ne*E.Size() + np * P.Size() + nf);
+   dofs.Reserve(nv*V.Size() + ne*E.Size() + nf);

   if (nv) // vertex DOFs
   {
@@ -3177,20 +2935,6 @@ void FiniteElementSpace::GetBdrElementDofs(int bel, Array<int> &dofs,
      }
   }

-   if(np)
-   {
-      for (int i = 0; i < P.Size(); i++)
-      {
-         int pbase = /* IsVariableOrder() ? FindEdgeDof(E[i], ne) :  */P[i]*np;
-         const int *ind = fec->GetDofOrdering(Geometry::TRIANGLE, order, Po[i]);
-
-         for (int j = 0; j < np; j++)
-         {
-            dofs.Append(EncodeDof(nvdofs + nedofs + pbase, ind[j]));
-         }
-      }
-   }
-
   if (nf) // face DOFs
   {
      int fbase = (var_face_dofs.Size() > 0) ? FindFaceDof(F, nf) : F*nf;
@@ -3260,12 +3004,10 @@ int FiniteElementSpace::GetFaceDofs(int face, Array<int> &dofs,
   // for 1D, 2D and 3D faces
   int nv = fec->GetNumDof(Geometry::POINT, order);
   int ne = (dim > 1) ? fec->GetNumDof(Geometry::SEGMENT, order) : 0;
-   int np = (dim > 3) ? fec->GetNumDof(Geometry::TRIANGLE, order) : 0;

-   Array<int> V, E, Eo, P, Po;
+   Array<int> V, E, Eo;
   if (nv) { mesh->GetFaceVertices(face, V); }
   if (ne) { mesh->GetFaceEdges(face, E, Eo); }
-   if (np) { mesh->GetFacePlanars(face, P, Po); }

   dofs.SetSize(0);
   dofs.Reserve(V.Size() * nv + E.Size() * ne + nf);
@@ -3293,92 +3035,14 @@ int FiniteElementSpace::GetFaceDofs(int face, Array<int> &dofs,
         }
      }
   }
-   if(np)
-   {
-      for (int i = 0; i < P.Size(); i++)
-      {
-         int pbase = /* IsVariableOrder() ? FindEdgeDof(E[i], ne) :  */P[i]*np;
-         const int *ind = fec->GetDofOrdering(Geometry::TRIANGLE, order, Po[i]);
-
-         for (int j = 0; j < np; j++)
-         {
-            dofs.Append(EncodeDof(nvdofs + nedofs + pbase, ind[j]));
-         }
-      }
-   }
   for (int j = 0; j < nf; j++)
   {
-      dofs.Append(nvdofs + nedofs + npdofs + fbase + j);
+      dofs.Append(nvdofs + nedofs + fbase + j);
   }

   return order;
 }

-void FiniteElementSpace::GetPlanarDofs(int planar, Array<int> &dofs) const
-{
-   MFEM_VERIFY(!orders_changed, msg_orders_changed);
-
-   // if (planar_dof)
-   // {
-   //    planar_dof->GetRow(planar, dofs);
-   //    return;
-   // }
-
-   Array<int> V, E, Eo; // TODO: LocalArray
-
-   int dim = mesh->Dimension();
-   int order = fec->GetOrder();
-
-   // if (IsVariableOrder()) // determine order from adjacent element
-   // {
-   //    int elem, info;
-   //    mesh->GetBdrElementAdjacentElement(bel, elem, info);
-   //    order = elem_order[elem];
-   // }
-
-   int nv = fec->GetNumDof(Geometry::POINT, order);
-   int ne = (dim > 1) ? fec->GetNumDof(Geometry::SEGMENT, order) : 0;
-   int np = fec->GetNumDof(Geometry::TRIANGLE, order);
-
-   if (nv) { mesh->GetPlanVertices(planar, V); }
-   if (ne) { mesh->GetPlanarEdges(planar, E, Eo); }
-
-   dofs.SetSize(0);
-   dofs.Reserve(nv*V.Size() + ne*E.Size() + np);
-
-   if (nv) // vertex DOFs
-   {
-      for (int i = 0; i < V.Size(); i++)
-      {
-         for (int j = 0; j < nv; j++)
-         {
-            dofs.Append(V[i]*nv + j);
-         }
-      }
-   }
-
-   if (ne) // edge DOFs
-   {
-      for (int i = 0; i < E.Size(); i++)
-      {
-         int ebase = IsVariableOrder() ? FindEdgeDof(E[i], ne) : E[i]*ne;
-         const int *ind = fec->GetDofOrdering(Geometry::SEGMENT, order, Eo[i]);
-
-         for (int j = 0; j < ne; j++)
-         {
-            dofs.Append(EncodeDof(nvdofs + ebase, ind[j]));
-         }
-      }
-   }
-
-   int pbase = planar*np;
-   for (int i = 0; i < np; i++)
-   {
-      dofs.Append(nvdofs + nedofs + pbase + i);
-   }
-
-}
-
 int FiniteElementSpace::GetEdgeDofs(int edge, Array<int> &dofs,
                                    int variant) const
 {
@@ -3445,7 +3109,7 @@ void FiniteElementSpace::GetElementInteriorDofs(int i, Array<int> &dofs) const
   int base = bdofs ? bdofs[i] : i*nb;

   dofs.SetSize(nb);
-   base += nvdofs + nedofs + npdofs + nfdofs;
+   base += nvdofs + nedofs + nfdofs;
   for (int j = 0; j < nb; j++)
   {
      dofs[j] = base + j;
@@ -3600,11 +3264,6 @@ const FiniteElement *FiniteElementSpace::GetFaceElement(int i) const
   return fe;
 }

-const FiniteElement *FiniteElementSpace::GetPlanarElement(int i) const
-{
-   return fec->FiniteElementForGeometry(mesh->GetPlanarBaseGeometry(i));
-}
-
 const FiniteElement *FiniteElementSpace::GetEdgeElement(int i,
                                                        int variant) const
 {
@@ -3674,8 +3333,6 @@ void FiniteElementSpace::Destroy()
      delete bdr_elem_fos;
      delete face_dof;
      delete [] bdofs;
-
-      delete [] pdofs;
   }
   ceed::RemoveBasisAndRestriction(this);
 }
@@ -245,9 +245,9 @@ protected:
       to be of the default order (fec->GetOrder()). */
   Array<char> elem_order;

-   int nvdofs, nedofs, nfdofs, nbdofs, npdofs;
+   int nvdofs, nedofs, nfdofs, nbdofs;
   int uni_fdof; ///< # of single face DOFs if all faces uniform; -1 otherwise
-   int *bdofs, *pdofs; ///< internal DOFs of elements if mixed/var-order; NULL otherwise
+   int *bdofs; ///< internal DOFs of elements if mixed/var-order; NULL otherwise

   /** Variable order spaces only: DOF assignments for edges and faces, see
       docs in MakeDofTable. For constant order spaces the tables are empty. */
@@ -396,7 +396,6 @@ protected:

   /// Calculate the cP and cR matrices for a nonconforming mesh.
   void BuildConformingInterpolation() const;
-   void BuildConformingInterpolation4D() const;

   static void AddDependencies(SparseMatrix& deps, Array<int>& master_dofs,
                               Array<int>& slave_dofs, DenseMatrix& I,
@@ -731,7 +730,6 @@ public:
   int GetNVDofs() const { return nvdofs; }
   /// Number of all scalar edge-interior dofs
   int GetNEDofs() const { return nedofs; }
-   int GetNPDofs() const { return npdofs; }
   /// Number of all scalar face-interior dofs
   int GetNFDofs() const { return nfdofs; }

@@ -747,9 +745,6 @@ public:
       the edges. */
   inline int GetNF() const { return mesh->GetNumFaces(); }

-   /// Returns number of planars (i.e. co-dimension 2 entities) in the mesh.
-   inline int GetNP() const { return mesh->GetNPlanars(); }
-
   /// Returns number of boundary elements in the mesh.
   inline int GetNBE() const { return mesh->GetNBE(); }

@@ -791,8 +786,6 @@ public:

   int GetBdrAttribute(int i) const { return mesh->GetBdrAttribute(i); }

-   virtual void GetPlanarDofs(int i, Array<int> &dofs) const;
-
   /// @anchor getdof @name Local DoF Access Members
   /// These member functions produce arrays of local degree of freedom
   /// indices, see @ref ldof. If @b vdim == 1 these indices can be used to
@@ -1094,9 +1087,6 @@ public:
   /// not necessarily equal to 1. See GetFaceDofs() for more information.
   void GetFaceVDofs(int i, Array<int> &vdofs) const;

-   /// Returns indexes of degrees of freedom for i'th planar element (4D).
-   void GetPlanarVDofs(int i, Array<int> &vdofs) const;
-
   /// @brief Returns the indices of the degrees of freedom for the specified
   /// edge, including the DOFs for the vertices of the edge.
   ///
@@ -1188,8 +1178,6 @@ public:
        points.*/
   const FiniteElement *GetFaceElement(int i) const;

-   const FiniteElement *GetPlanarElement(int i) const;
-
   /** @brief Returns pointer to the FiniteElement in the FiniteElementCollection
        associated with i'th edge in the mesh object. */
   const FiniteElement *GetEdgeElement(int i, int variant = 0) const;
@@ -19,11 +19,11 @@ namespace mfem
 const char *Geometry::Name[NumGeom] =
 {
   "Point", "Segment", "Triangle", "Square", "Tetrahedron", "Cube", "Prism",
-   "Pyramid", "Pentatope", "Tesseract"
+   "Pyramid"
 };

 const real_t Geometry::Volume[NumGeom] =
-{ 1.0, 1.0, 0.5, 1.0, 1./6, 1.0, 0.5, 1./3, 1./24., 1.0 };
+{ 1.0, 1.0, 0.5, 1.0, 1./6, 1.0, 0.5, 1./3 };

 Geometry::Geometry()
 {
@@ -165,36 +165,6 @@ Geometry::Geometry()
   GeomVert[7]->IntPoint(4).y = 0.0;
   GeomVert[7]->IntPoint(4).z = 1.0;

-   // Vertices for Geometry::PENTATOPE
-   GeomVert[8] = new IntegrationRule(5);
-   GeomVert[8]->IntPoint(0).x = 0.0;
-   GeomVert[8]->IntPoint(0).y = 0.0;
-   GeomVert[8]->IntPoint(0).z = 0.0;
-   GeomVert[8]->IntPoint(0).t = 0.0;
-
-   GeomVert[8]->IntPoint(1).x = 1.0;
-   GeomVert[8]->IntPoint(1).y = 0.0;
-   GeomVert[8]->IntPoint(1).z = 0.0;
-   GeomVert[8]->IntPoint(1).t = 0.0;
-
-   GeomVert[8]->IntPoint(2).x = 0.0;
-   GeomVert[8]->IntPoint(2).y = 1.0;
-   GeomVert[8]->IntPoint(2).z = 0.0;
-   GeomVert[8]->IntPoint(2).t = 0.0;
-
-   GeomVert[8]->IntPoint(3).x = 0.0;
-   GeomVert[8]->IntPoint(3).y = 0.0;
-   GeomVert[8]->IntPoint(3).z = 1.0;
-   GeomVert[8]->IntPoint(3).t = 0.0;
-
-   GeomVert[8]->IntPoint(4).x = 0.0;
-   GeomVert[8]->IntPoint(4).y = 0.0;
-   GeomVert[8]->IntPoint(4).z = 0.0;
-   GeomVert[8]->IntPoint(4).t = 1.0;
-
-   // Vertices for Geometry::TESSERACT
-   // TODO
-
   GeomCenter[POINT].x = 0.0;
   GeomCenter[POINT].y = 0.0;
   GeomCenter[POINT].z = 0.0;
@@ -227,14 +197,6 @@ Geometry::Geometry()
   GeomCenter[PYRAMID].y = 0.375;
   GeomCenter[PYRAMID].z = 0.25;

-   GeomCenter[PENTATOPE].x = 0.2;
-   GeomCenter[PENTATOPE].y = 0.2;
-   GeomCenter[PENTATOPE].z = 0.2;
-   GeomCenter[PENTATOPE].t = 0.2;
-
-   // GeomCenter[TESSERACT]
-   // TODO
-
   GeomToPerfGeomJac[POINT]       = NULL;
   GeomToPerfGeomJac[SEGMENT]     = new DenseMatrix(1);
   GeomToPerfGeomJac[TRIANGLE]    = new DenseMatrix(2);
@@ -243,7 +205,6 @@ Geometry::Geometry()
   GeomToPerfGeomJac[CUBE]        = new DenseMatrix(3);
   GeomToPerfGeomJac[PRISM]       = new DenseMatrix(3);
   GeomToPerfGeomJac[PYRAMID]     = new DenseMatrix(3);
-   GeomToPerfGeomJac[PENTATOPE]   = new DenseMatrix(4);

   PerfGeomToGeomJac[POINT]       = NULL;
   PerfGeomToGeomJac[SEGMENT]     = NULL;
@@ -253,7 +214,6 @@ Geometry::Geometry()
   PerfGeomToGeomJac[CUBE]        = NULL;
   PerfGeomToGeomJac[PRISM]       = new DenseMatrix(3);
   PerfGeomToGeomJac[PYRAMID]     = new DenseMatrix(3);
-   PerfGeomToGeomJac[PENTATOPE]   = new DenseMatrix(4);

   GeomToPerfGeomJac[SEGMENT]->Diag(1.0, 1);
   {
@@ -290,16 +250,6 @@ Geometry::Geometry()
      *GeomToPerfGeomJac[PYRAMID] = pyr_T.Jacobian();
      CalcInverse(pyr_T.Jacobian(), *PerfGeomToGeomJac[PYRAMID]);
   }
-   {
-      Linear4DFiniteElement PentFE;
-      IsoparametricTransformation pent_T;
-      pent_T.SetFE(&PentFE);
-      GetPerfPointMat (PENTATOPE, pent_T.GetPointMat());
-      // pent_T.FinalizeTransformation();
-      pent_T.SetIntPoint(&GeomCenter[PENTATOPE]);
-      *GeomToPerfGeomJac[PENTATOPE] = pent_T.Jacobian();
-      CalcInverse(pent_T.Jacobian(), *PerfGeomToGeomJac[PENTATOPE]);
-   }
 }

 template <Geometry::Type GEOM>
@@ -352,8 +302,6 @@ const IntegrationRule *Geometry::GetVertices(int GeomType) const
      case Geometry::CUBE:        return GeomVert[5];
      case Geometry::PRISM:       return GeomVert[6];
      case Geometry::PYRAMID:     return GeomVert[7];
-      case Geometry::PENTATOPE:   return GeomVert[8];
-      case Geometry::TESSERACT:   return GeomVert[9];
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         mfem_error("Geometry::GetVertices(...)");
@@ -451,45 +399,6 @@ void Geometry::GetRandomPoint(int GeomType, IntegrationPoint &ip)
            ip.x = 1.0 - z;
         }
         break;
-      case Geometry::PENTATOPE:
-         ip.x = real_t(rand()) / real_t(RAND_MAX);
-         ip.y = real_t(rand()) / real_t(RAND_MAX);
-         ip.z = real_t(rand()) / real_t(RAND_MAX);
-         ip.t = real_t(rand()) / real_t(RAND_MAX);
-         // map to the triangular 4D wedge obtained by extruding the reference
-         // tetrahedron in t direction
-         // needs to be updated
-         // if (ip.x + ip.y > 1.0)
-         // {
-         //    ip.x = 1.0 - ip.x;
-         //    ip.y = 1.0 - ip.y;
-         // }
-         // // split the prism into 3 parts: 1 is the reference tet, and the
-         // // other two tets (as given below) are mapped to the reference tet
-         // if (ip.x + ip.z > 1.0)
-         // {
-         //    // tet with vertices: (0,0,1),(1,0,1),(0,1,1),(1,0,0)
-         //    ip.x = ip.x + ip.z - 1.0;
-         //    // ip.y = ip.y;
-         //    ip.z = 1.0 - ip.z;
-         //    // mapped to: (0,0,0),(1,0,0),(0,1,0),(0,0,1)
-         // }
-         // else if (ip.x + ip.y + ip.z > 1.0)
-         // {
-         //    // tet with vertices: (0,1,1),(0,1,0),(0,0,1),(1,0,0)
-         //    real_t x = ip.x;
-         //    ip.x = 1.0 - x - ip.z;
-         //    ip.y = 1.0 - x - ip.y;
-         //    ip.z = x;
-         //    // mapped to: (0,0,0),(1,0,0),(0,1,0),(0,0,1)
-         // }
-         // break;
-      case Geometry::TESSERACT:
-         ip.x = real_t(rand()) / real_t(RAND_MAX);
-         ip.y = real_t(rand()) / real_t(RAND_MAX);
-         ip.z = real_t(rand()) / real_t(RAND_MAX);
-         ip.t = real_t(rand()) / real_t(RAND_MAX);
-         break;
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -556,14 +465,6 @@ bool Geometry::CheckPoint(int GeomType, const IntegrationPoint &ip)
         if (ip.x < 0.0 || ip.y < 0.0 || ip.x+ip.z > 1.0 || ip.y+ip.z > 1.0 ||
             ip.z < 0.0 || ip.z > 1.0) { return false; }
         break;
-      case Geometry::PENTATOPE:
-         if (ip.x < 0.0 || ip.y < 0.0 || ip.z < 0.0 || ip.t < 0 ||
-             ip.x+ip.y+ip.z+ip.t > 1.0) { return false; }
-         break;
-      case Geometry::TESSERACT:
-         if (ip.x < 0.0 || ip.x > 1.0 || ip.y < 0.0 || ip.y > 1.0 ||
-             ip.z < 0.0 || ip.z > 1.0 || ip.t < 0.0 || ip.t > 1.0) { return false; }
-         break;
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -647,29 +548,6 @@ bool Geometry::CheckPoint(int GeomType, const IntegrationPoint &ip, real_t eps)
            return false;
         }
         break;
-      case Geometry::PENTATOPE:
-         if ( internal::FuzzyLT(ip.x, 0.0, eps)
-              || internal::FuzzyLT(ip.y, 0.0, eps)
-              || internal::FuzzyLT(ip.z, 0.0, eps)
-              || internal::FuzzyLT(ip.t, 0.0, eps)
-              || internal::FuzzyGT(ip.x+ip.y+ip.z+ip.t, 1.0, eps) )
-         {
-            return false;
-         }
-         break;
-      case Geometry::TESSERACT:
-         if ( internal::FuzzyLT(ip.x, 0.0, eps)
-              || internal::FuzzyGT(ip.x, 1.0, eps)
-              || internal::FuzzyLT(ip.y, 0.0, eps)
-              || internal::FuzzyGT(ip.y, 1.0, eps)
-              || internal::FuzzyLT(ip.z, 0.0, eps)
-              || internal::FuzzyGT(ip.z, 1.0, eps)
-              || internal::FuzzyLT(ip.t, 0.0, eps)
-              || internal::FuzzyGT(ip.t, 1.0, eps) )
-         {
-            return false;
-         }
-         break;
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -732,81 +610,6 @@ inline bool ProjectTriangle(real_t &x, real_t &y)
   return true;
 }

-inline bool ProjectTetrahedron(double &x, double &y, double &z)
-{
-   if (z < 0.0)
-   {
-      z = 0.0;
-      internal::ProjectTriangle(x, y);
-      return false;
-   }
-   if (y < 0.0)
-   {
-      y = 0.0;
-      internal::ProjectTriangle(x, z);
-      return false;
-   }
-   if (x < 0.0)
-   {
-      x = 0.0;
-      internal::ProjectTriangle(y, z);
-      return false;
-   }
-   const double l4 = 1.0-x-y-z;
-   if (l4 < 0.0)
-   {
-      const double l4_3 = l4/3;
-      x += l4_3;
-      y += l4_3;
-      internal::ProjectTriangle(x, y);
-      z = 1.0-x-y;
-      return false;
-   }
-   return true;
-}
-
-inline bool ProjectPentatope(double &x, double &y, double &z, double &t)
-{
-   if (t < 0.0)
-   {
-      t = 0.0;
-      internal::ProjectTetrahedron(x, y, z);
-      return false;
-   }
-   if (z < 0.0)
-   {
-      z = 0.0;
-      internal::ProjectTetrahedron(x, y, t);
-      return false;
-   }
-   if (y < 0.0)
-   {
-      y = 0.0;
-      internal::ProjectTetrahedron(x, z, t);
-      return false;
-   }
-   if (x < 0.0)
-   {
-      x = 0.0;
-      internal::ProjectTetrahedron(y, z, t);
-      return false;
-   }
-   const double l5 = 1.0-x-y-z-t;
-   if (l5 < 0.0)
-   {
-      const double l5_4 = l5/4;
-      // TODO
-      // In Geometry::ProjectPoint 4d origianlly had const double l5_4 = l5/5
-      x += l5_4;
-      y += l5_4;
-      z += l5_4;
-      internal::ProjectTetrahedron(x, y, z);
-      t = 1.0-x-y-z;
-      return false;
-   }
-   return true;
-}
-
 }

 // static method
@@ -872,22 +675,6 @@ bool Geometry::ProjectPoint(int GeomType, const IntegrationPoint &beg,
                          };
         return internal::IntersectSegment<6,3>(lbeg, lend, end);
      }
-      case Geometry::PENTATOPE:
-      {
-         real_t lend[5] = { end.x, end.y, end.z, end.t, fone-end.x-end.y-end.z-end.t };
-         real_t lbeg[5] = { beg.x, beg.y, beg.z, beg.t, fone-beg.x-beg.y-beg.z-beg.t };
-         return internal::IntersectSegment<5,4>(lbeg,lend,end);
-      }
-      case Geometry::TESSERACT:
-      {
-         real_t lend[8] = { end.x, end.y, end.z, end.t,
-                            fone-end.x, fone-end.y, fone-end.z, fone-end.t
-                          };
-         real_t lbeg[8] = { beg.x, beg.y, beg.z, beg.t,
-                            fone-beg.x, fone-beg.y, fone-beg.z, fone-beg.t
-                          };
-         return internal::IntersectSegment<8,3>(lbeg, lend, end);
-      }
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -930,7 +717,35 @@ bool Geometry::ProjectPoint(int GeomType, IntegrationPoint &ip)

      case TETRAHEDRON:
      {
-         return internal::ProjectTetrahedron(ip.x, ip.y, ip.z);
+         if (ip.z < 0.0)
+         {
+            ip.z = 0.0;
+            internal::ProjectTriangle(ip.x, ip.y);
+            return false;
+         }
+         if (ip.y < 0.0)
+         {
+            ip.y = 0.0;
+            internal::ProjectTriangle(ip.x, ip.z);
+            return false;
+         }
+         if (ip.x < 0.0)
+         {
+            ip.x = 0.0;
+            internal::ProjectTriangle(ip.y, ip.z);
+            return false;
+         }
+         const real_t l4 = 1.0-ip.x-ip.y-ip.z;
+         if (l4 < 0.0)
+         {
+            const real_t l4_3 = l4/3;
+            ip.x += l4_3;
+            ip.y += l4_3;
+            internal::ProjectTriangle(ip.x, ip.y);
+            ip.z = 1.0-ip.x-ip.y;
+            return false;
+         }
+         return true;
      }

      case CUBE:
@@ -995,29 +810,6 @@ bool Geometry::ProjectPoint(int GeomType, IntegrationPoint &ip)
         }
      }

-      case PENTATOPE:
-      {
-         return internal::ProjectPentatope(ip.x, ip.y, ip.z, ip.t);
-      }
-
-      case TESSERACT:
-      {
-         bool in_x, in_y, in_z, in_t;
-         if (ip.x < 0.0)      { in_x = false; ip.x = 0.0; }
-         else if (ip.x > 1.0) { in_x = false; ip.x = 1.0; }
-         else                 { in_x = true; }
-         if (ip.y < 0.0)      { in_y = false; ip.y = 0.0; }
-         else if (ip.y > 1.0) { in_y = false; ip.y = 1.0; }
-         else                 { in_y = true; }
-         if (ip.z < 0.0)      { in_z = false; ip.z = 0.0; }
-         else if (ip.z > 1.0) { in_z = false; ip.z = 1.0; }
-         else                 { in_z = true; }
-         if (ip.t < 0.0)      { in_t = false; ip.t = 0.0; }
-         else if (ip.t > 1.0) { in_t = false; ip.t = 1.0; }
-         else                 { in_t = true; }
-         return in_x && in_y && in_z && in_t;
-      }
-
      case Geometry::POINT:
         MFEM_ABORT("Reference element type is not supported!");
      case Geometry::INVALID:
@@ -1106,42 +898,6 @@ void Geometry::GetPerfPointMat(int GeomType, DenseMatrix &pm) const
      }
      break;

-      case Geometry::PENTATOPE:
-      {
-         pm.SetSize(4,5);
-         pm(0,0) = 0.0;  pm(1,0) = 0.0;  pm(2,0) = 0.0; pm(3,0) = 0.0;
-         pm(0,1) = 1.0;  pm(1,1) = 0.0;  pm(2,1) = 0.0; pm(3,1) = 0.0;
-         pm(0,2) = 0.5;  pm(1,2) = 0.86602540378443864676;  pm(2,2) = 0.0; pm(3,2) = 0.0;
-         pm(0,3) = 0.5;  pm(1,3) = 0.28867513459481288225;
-         pm(2,3) = 0.81649658092772603273; pm(3,3) = 0.0;
-         pm(0,4) = 0.5;  pm(1,4) = 0.28867513459481288225;
-         pm(2,4) = 0.20412414523193150819; pm(3,4) = 0.7905694150420948330;
-      }
-      break;
-
-      case Geometry::TESSERACT:
-      {
-         pm.SetSize (4, 16);
-         pm(0,0)  = 0.0;  pm(1,0)  = 0.0;  pm(2,0)  = 0.0; pm(4,0)  = 0.0;
-         pm(0,1)  = 1.0;  pm(1,1)  = 0.0;  pm(2,1)  = 0.0; pm(4,1)  = 0.0;
-         pm(0,2)  = 1.0;  pm(1,2)  = 1.0;  pm(2,2)  = 0.0; pm(4,2)  = 0.0;
-         pm(0,3)  = 0.0;  pm(1,3)  = 1.0;  pm(2,3)  = 0.0; pm(4,3)  = 0.0;
-         pm(0,4)  = 0.0;  pm(1,4)  = 0.0;  pm(2,4)  = 1.0; pm(4,4)  = 0.0;
-         pm(0,5)  = 1.0;  pm(1,5)  = 0.0;  pm(2,5)  = 1.0; pm(4,5)  = 0.0;
-         pm(0,6)  = 1.0;  pm(1,6)  = 1.0;  pm(2,6)  = 1.0; pm(4,6)  = 0.0;
-         pm(0,7)  = 0.0;  pm(1,7)  = 1.0;  pm(2,7)  = 1.0; pm(4,7)  = 0.0;
-
-         pm(0,8)  = 0.0;  pm(1,8)  = 0.0;  pm(2,8)  = 0.0; pm(4,8)  = 1.0;
-         pm(0,9)  = 1.0;  pm(1,9)  = 0.0;  pm(2,9)  = 0.0; pm(4,9)  = 1.0;
-         pm(0,10) = 1.0;  pm(1,10) = 1.0;  pm(2,10) = 0.0; pm(4,10) = 1.0;
-         pm(0,11) = 0.0;  pm(1,11) = 1.0;  pm(2,11) = 0.0; pm(4,11) = 1.0;
-         pm(0,12) = 0.0;  pm(1,12) = 0.0;  pm(2,12) = 1.0; pm(4,12) = 1.0;
-         pm(0,13) = 1.0;  pm(1,13) = 0.0;  pm(2,13) = 1.0; pm(4,13) = 1.0;
-         pm(0,14) = 1.0;  pm(1,14) = 1.0;  pm(2,14) = 1.0; pm(4,14) = 1.0;
-         pm(0,15) = 0.0;  pm(1,15) = 1.0;  pm(2,15) = 1.0; pm(4,15) = 1.0;
-      }
-      break;
-
      case Geometry::POINT:
         MFEM_ABORT("Reference element type is not supported!");
      case Geometry::INVALID:
@@ -1163,13 +919,13 @@ void Geometry::JacToPerfJac(int GeomType, const DenseMatrix &J,
   }
 }

-const int Geometry::NumBdrArray[NumGeom] = { 0, 2, 3, 4, 4,  6, 5, 5,  5, 24 };
-const int Geometry::Dimension[NumGeom]   = { 0, 1, 2, 2, 3,  3, 3, 3,  4,  4 };
-const int Geometry::DimStart[MaxDim+2]   =
-{ POINT, SEGMENT, TRIANGLE, TETRAHEDRON, PENTATOPE, NUM_GEOMETRIES };
-const int Geometry::NumVerts[NumGeom]    = { 1, 2, 3, 4, 4,  8, 6, 5,  5, 16 };
-const int Geometry::NumEdges[NumGeom]    = { 0, 1, 3, 4, 6, 12, 9, 8, 10, 32 };
-const int Geometry::NumFaces[NumGeom]    = { 0, 0, 1, 1, 4,  6, 5, 5,  5, 24 };
+const int Geometry::NumBdrArray[NumGeom] = { 0, 2, 3, 4, 4, 6, 5, 5 };
+const int Geometry::Dimension[NumGeom] = { 0, 1, 2, 2, 3, 3, 3, 3 };
+const int Geometry::DimStart[MaxDim+2] =
+{ POINT, SEGMENT, TRIANGLE, TETRAHEDRON, NUM_GEOMETRIES };
+const int Geometry::NumVerts[NumGeom] = { 1, 2, 3, 4, 4, 8, 6, 5 };
+const int Geometry::NumEdges[NumGeom] = { 0, 1, 3, 4, 6, 12, 9, 8 };
+const int Geometry::NumFaces[NumGeom] = { 0, 0, 1, 1, 4, 6, 5, 5 };

 const int Geometry::
 Constants<Geometry::POINT>::Orient[1][1] = {{0}};
@@ -1340,63 +1096,6 @@ Constants<Geometry::PYRAMID>::VertToVert::J[8][2] =
   {4, 7}                  // 3,4:7
 };

-const int Geometry::
-Constants<Geometry::PENTATOPE>::Edges[10][2] =
-{{0, 1}, {0, 2}, {0, 3}, {0, 4}, {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}};
-const int Geometry::
-Constants<Geometry::PENTATOPE>::FaceTypes[5] =
-{
-   Geometry::TETRAHEDRON, Geometry::TETRAHEDRON,
-   Geometry::TETRAHEDRON, Geometry::TETRAHEDRON,
-   Geometry::TETRAHEDRON
-};
-const int Geometry::
-Constants<Geometry::PENTATOPE>::FaceVert[5][4] =
-{
-   //   {0, 1, 2, 3}, {0, 1, 2, 4},
-   //   {0, 1, 3, 4}, {0, 2, 3, 4},
-   //   {1, 2, 3, 4}
-   {0, 1, 2, 3}, {0, 2, 1, 4},     //<---- sorted such that the normal vectors are outer normal vectors
-   {0, 1, 3, 4}, {0, 3, 2, 4},
-   {1, 2, 3, 4}
-};
-const int Geometry::
-Constants<Geometry::PENTATOPE>::PlanarVert[10][3] =
-{
-   {0, 1, 2}, {0, 1, 3}, {0, 1, 4},
-   {0, 2, 3}, {0, 2, 4}, {0, 3, 4},
-   {1, 2, 3}, {1, 2, 4}, {1, 3, 4},
-   {2, 3, 4}
-};
-
-//const int Geometry::
-//Constants<Geometry::PENTATOPE>::VertToVert::I[4] = {0, 3, 5, 6};
-//const int Geometry::
-//Constants<Geometry::PENTATOPE>::VertToVert::J[6][2] =
-//{{1, 0}, {2, 1}, {3, 2}, {2, 3}, {3, 4}, {3, 5}};
-
-
-const int Geometry::
-Constants<Geometry::TESSERACT>::FaceVert[8][8] =
-{
-   // {8,11,12,15,0,3,4,7},   //x bottom
-   // {1,2,6,5,9,10,14,13},   //x top
-   // {0,1,5,4,8,9,13,12},    //y bottom
-   // {2,3,7,6,10,11,15,14},  //y top
-   // {8,9,10,11,0,1,2,3},    // z bottom
-   // {4,5,6,7,12,13,14,15},  //z top
-   // {0,1,2,3,4,5,6,7},      //t botom
-   // {12,13,14,15,8,9,10,11} //t top
-   {8,11,15,12,0,3,7,4},   //x bottom
-   {1,2,6,5,9,10,14,13},   //x top
-   {0,1,5,4,8,9,13,12},    //y bottom
-   {2,3,7,6,10,11,15,14},  //y top
-   {8,9,10,11,0,1,2,3},    // z bottom
-   {4,5,6,7,12,13,14,15},  //z top
-   {0,1,2,3,4,5,6,7},      //t botom
-   {12,13,14,15,8,9,10,11} //t top
-};
-

 GeometryRefiner::~GeometryRefiner()
 {
@@ -1957,9 +1656,7 @@ RefinedGeometry *GeometryRefiner::Refine(Geometry::Type Geom, int Times,
               RGeom[Geometry::PRISM].Append(RG);
            }
            break;
-            case Geometry::PENTATOPE:
-            case Geometry::TESSERACT:
-                MFEM_ABORT("Reference element type is not supported!");
+
            case Geometry::INVALID:
            case Geometry::NUM_GEOMETRIES:
               MFEM_ABORT("Unknown type of reference element!");
@@ -2071,8 +1768,6 @@ const IntegrationRule *GeometryRefiner::RefineInterior(Geometry::Type Geom,
      case Geometry::CUBE:
      case Geometry::PYRAMID:
      case Geometry::PRISM:
-      case Geometry::PENTATOPE:
-      case Geometry::TESSERACT:
         MFEM_ABORT("Reference element type is not supported!");
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
@@ -2142,24 +1837,6 @@ int GeometryRefiner::GetRefinementLevelFromPoints(Geometry::Type geom, int Npts)
      }
      case Geometry::PYRAMID:
         MFEM_ABORT("Reference element type is not supported!");
-      case Geometry::PENTATOPE:
-      {
-         for (int n = 0, np = 0; (n < 15) && (np < Npts) ; n++)
-         {
-            np = (n+4)*(n+3)*(n+2)*(n+1)/24;
-            if (np == Npts) { return n; }
-         }
-         return -1;
-      }
-      case Geometry::TESSERACT:
-      {
-         for (int n = 0, np = 0; (n < 15) && (np < Npts) ; n++)
-         {
-            np = (n+1)*(n+1)*(n+1)*(n+1);
-            if (np == Npts) { return n; }
-         }
-         return -1;
-      }
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -2202,15 +1879,6 @@ int GeometryRefiner::GetRefinementLevelFromElems(Geometry::Type geom, int Nels)
      }
      case Geometry::PYRAMID:
         MFEM_ABORT("Reference element type is not supported!");
-      case Geometry::PENTATOPE:
-      case Geometry::TESSERACT:
-      {
-         for (int n = 0; (n < 15) && (n*n*n*n < Nels+1) ; n++)
-         {
-            if (n*n*n*n == Nels) { return n-1; }
-         }
-         return -1;
-      }
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -28,8 +28,6 @@ namespace mfem
    Geometry::CUBE - the unit cube
    Geometry::PRISM - w/ vert. (0,0,0),(1,0,0),(0,1,0),(0,0,1),(1,0,1),(0,1,1)
    Geometry::PYRAMID - w/ vert. (0,0,0),(1,0,0),(1,1,0),(0,1,0),(0,0,1)
-    Geometry::PENTATOPE - w/ vert. (0,0,0,0),(1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)
-    Geometry::TESSERACT - the 4d unit cube
 */
 class MFEM_EXPORT Geometry
 {
@@ -37,12 +35,12 @@ public:
   enum Type
   {
      INVALID = -1,
-      POINT = 0, SEGMENT, TRIANGLE, SQUARE, TETRAHEDRON, CUBE, PRISM, PYRAMID, PENTATOPE, TESSERACT,
+      POINT = 0, SEGMENT, TRIANGLE, SQUARE, TETRAHEDRON, CUBE, PRISM, PYRAMID,
      NUM_GEOMETRIES
   };

   static const int NumGeom = NUM_GEOMETRIES;
-   static const int MaxDim = 4;
+   static const int MaxDim = 3;
   static const int NumBdrArray[NumGeom];
   static const char *Name[NumGeom];
   static const real_t Volume[NumGeom];
@@ -120,7 +118,6 @@ public:
         case 1: return SEGMENT;
         case 2: return SQUARE;
         case 3: return CUBE;
-         case 4: return TESSERACT;
         default: MFEM_ABORT("Invalid dimension."); return INVALID;
      }
   }
@@ -308,53 +305,6 @@ template <> struct
   };
 };

-template <> struct
-/// @cond Suppress_Doxygen_warnings
-   MFEM_EXPORT
-/// @endcond
-   Geometry::Constants<Geometry::PENTATOPE>
-{
-   static const int Dimension = 4;
-   static const int NumVert = 5;
-   static const int NumEdges = 10;
-   static const int Edges[NumEdges][2];
-   static const int NumFaces = 5;
-   static const int FaceTypes[NumFaces];
-   static const int MaxFaceVert = 4;
-   static const int FaceVert[NumFaces][MaxFaceVert];
-   static const int NumPlanar = 10;
-   static const int MaxPlanarVert = 3;
-   static const int PlanarVert[NumPlanar][MaxPlanarVert];
-   // Lower-triangular part of the local vertex-to-vertex graph.
-   struct VertToVert
-   {
-      static const int I[NumVert];
-      static const int J[NumEdges][2]; // {end,edge_idx}
-   };
-};
-
-template <> struct
-/// @cond Suppress_Doxygen_warnings
-   MFEM_EXPORT
-/// @endcond
-   Geometry::Constants<Geometry::TESSERACT>
-{
-   static const int Dimension = 4;
-   static const int NumVert = 16;
-   static const int NumEdges = 32;
-   static const int Edges[NumEdges][2];
-   static const int NumFaces = 8;
-   static const int FaceTypes[NumFaces];
-   static const int MaxFaceVert = 8;
-   static const int FaceVert[NumFaces][MaxFaceVert];
-   // Lower-triangular part of the local vertex-to-vertex graph.
-   struct VertToVert
-   {
-      static const int I[NumVert];
-      static const int J[NumEdges][2]; // {end,edge_idx}
-   };
-};
-
 // Defined in fe.cpp to ensure construction after 'mfem::TriangleFE' and
 // `mfem::TetrahedronFE`.
 extern MFEM_EXPORT Geometry Geometries;
@@ -39,7 +39,7 @@ GridFunction::GridFunction(Mesh *m, std::istream &input)
   UseDevice(true);

   fes = new FiniteElementSpace;
-   fec_owned = fes->Load(m, input);
+   fec = fes->Load(m, input);

   skip_comment_lines(input, '#');
   istream::int_type next_char = input.peek();
@@ -81,10 +81,10 @@ GridFunction::GridFunction(Mesh *m, GridFunction *gf_array[], int num_pieces)
   int vdim, ordering;

   fes = gf_array[0]->FESpace();
-   fec_owned = FiniteElementCollection::New(fes->FEColl()->Name());
+   fec = FiniteElementCollection::New(fes->FEColl()->Name());
   vdim = fes->GetVDim();
   ordering = fes->GetOrdering();
-   fes = new FiniteElementSpace(m, fec_owned, vdim, ordering);
+   fes = new FiniteElementSpace(m, fec, vdim, ordering);
   SetSize(fes->GetVSize());

   if (m->NURBSext)
@@ -153,11 +153,11 @@ GridFunction::GridFunction(Mesh *m, GridFunction *gf_array[], int num_pieces)

 void GridFunction::Destroy()
 {
-   if (fec_owned)
+   if (fec)
   {
      delete fes;
-      delete fec_owned;
-      fec_owned = NULL;
+      delete fec;
+      fec = NULL;
   }
 }

@@ -325,9 +325,10 @@ int GridFunction::VectorDim() const
   const FiniteElement *fe;
   if (!fes->GetNE())
   {
+      const FiniteElementCollection *fe_coll = fes->FEColl();
      static const Geometry::Type geoms[3] =
      { Geometry::SEGMENT, Geometry::TRIANGLE, Geometry::TETRAHEDRON };
-      fe = fes->FEColl()->
+      fe = fe_coll->
           FiniteElementForGeometry(geoms[fes->GetMesh()->Dimension()-1]);
   }
   else
@@ -349,8 +350,8 @@ int GridFunction::CurlDim() const
   {
      static const Geometry::Type geoms[3] =
      { Geometry::SEGMENT, Geometry::TRIANGLE, Geometry::TETRAHEDRON };
-      fe = fes->FEColl()->
-           FiniteElementForGeometry(geoms[fes->GetMesh()->Dimension()-1]);
+      fe = fes->FEColl()->FiniteElementForGeometry(geoms[fes->GetMesh()->Dimension()
+                                                         -1]);
   }
   else
   {
@@ -1321,9 +1322,9 @@ void GridFunction::ProjectVectorFieldOn(GridFunction &vec_field, int comp)
   }
 }

-void GridFunction::AccumulateAndCountDerivativeValues(
-   int comp, int der_comp, GridFunction &der,
-   Array<int> &zones_per_dof) const
+void GridFunction::AccumulateAndCountDerivativeValues(int comp, int der_comp,
+                                                      GridFunction &der,
+                                                      Array<int> &zones_per_dof)
 {
   FiniteElementSpace * der_fes = der.FESpace();
   ElementTransformation * transf;
@@ -1374,8 +1375,7 @@ void GridFunction::AccumulateAndCountDerivativeValues(
   }
 }

-void GridFunction::GetDerivative(int comp, int der_comp,
-                                 GridFunction &der) const
+void GridFunction::GetDerivative(int comp, int der_comp, GridFunction &der)
 {
   Array<int> overlap;
   AccumulateAndCountDerivativeValues(comp, der_comp, der, overlap);
@@ -2062,37 +2062,41 @@ void GridFunction::AccumulateAndCountBdrValues(
   Coefficient *coeff[], VectorCoefficient *vcoeff, const Array<int> &attr,
   Array<int> &values_counter)
 {
+   int i, j, fdof, d, ind, vdim;
+   real_t val;
+   const FiniteElement *fe;
+   ElementTransformation *transf;
   Array<int> vdofs;
   Vector vc;

   values_counter.SetSize(Size());
   values_counter = 0;

-   const int vdim = fes->GetVDim();
+   vdim = fes->GetVDim();
+
   HostReadWrite();

-   for (int i = 0; i < fes->GetNBE(); i++)
+   for (i = 0; i < fes->GetNBE(); i++)
   {
      if (attr[fes->GetBdrAttribute(i) - 1] == 0) { continue; }

-      const FiniteElement *fe = fes->GetBE(i);
-      const int fdof = fe->GetDof();
-      ElementTransformation *transf = fes->GetBdrElementTransformation(i);
+      fe = fes->GetBE(i);
+      fdof = fe->GetDof();
+      transf = fes->GetBdrElementTransformation(i);
      const IntegrationRule &ir = fe->GetNodes();
      fes->GetBdrElementVDofs(i, vdofs);

-      for (int j = 0; j < fdof; j++)
+      for (j = 0; j < fdof; j++)
      {
         const IntegrationPoint &ip = ir.IntPoint(j);
         transf->SetIntPoint(&ip);
         if (vcoeff) { vcoeff->Eval(vc, *transf, ip); }
-         for (int d = 0; d < vdim; d++)
+         for (d = 0; d < vdim; d++)
         {
            if (!vcoeff && !coeff[d]) { continue; }

-            real_t val = vcoeff ? vc(d) : coeff[d]->Eval(*transf, ip);
-            int ind = vdofs[fdof*d+j];
-            if ( ind < 0 )
+            val = vcoeff ? vc(d) : coeff[d]->Eval(*transf, ip);
+            if ( (ind = vdofs[fdof*d+j]) < 0 )
            {
               val = -val, ind = -1-ind;
            }
@@ -2114,38 +2118,37 @@ void GridFunction::AccumulateAndCountBdrValues(
   // iff A_ij != 0. It is sufficient to resolve just the first level of
   // dependency, since A is a projection matrix: A^n = A due to cR.cP = I.
   // Cases like these arise in 3D when boundary edges are constrained by
-   // (depend on) internal faces/elements, or for internal boundaries in 2 or
-   // 3D. We use the virtual method GetBoundaryClosure from NCMesh to resolve
-   // the dependencies.
-   if (fes->Nonconforming() && (fes->GetMesh()->Dimension() == 2 ||
-                                fes->GetMesh()->Dimension() == 3))
+   // (depend on) internal faces/elements. We use the virtual method
+   // GetBoundaryClosure from NCMesh to resolve the dependencies.
+
+   if (fes->Nonconforming() && fes->GetMesh()->Dimension() == 3)
   {
      Vector vals;
      Mesh *mesh = fes->GetMesh();
      NCMesh *ncmesh = mesh->ncmesh;
-      Array<int> bdr_edges, bdr_vertices, bdr_faces, bdr_planars;
-      // if (mesh->Dimension() < 4)
-      // {
-          ncmesh->GetBoundaryClosure(attr, bdr_vertices, bdr_edges, bdr_faces);
-      // }
-      // else
-      // {
-      //     ncmesh->GetBoundaryClosure(attr, bdr_vertices, bdr_edges, bdr_faces, bdr_planars);
-      // }
+      Array<int> bdr_edges, bdr_vertices, bdr_faces;
+      ncmesh->GetBoundaryClosure(attr, bdr_vertices, bdr_edges, bdr_faces);

-      auto mark_dofs = [&](ElementTransformation &transf, const FiniteElement &fe)
+      for (i = 0; i < bdr_edges.Size(); i++)
      {
+         int edge = bdr_edges[i];
+         fes->GetEdgeVDofs(edge, vdofs);
+         if (vdofs.Size() == 0) { continue; }
+
+         transf = mesh->GetEdgeTransformation(edge);
+         transf->Attribute = -1; // TODO: set the boundary attribute
+         fe = fes->GetEdgeElement(edge);
         if (!vcoeff)
         {
-            vals.SetSize(fe.GetDof());
-            for (int d = 0; d < vdim; d++)
+            vals.SetSize(fe->GetDof());
+            for (d = 0; d < vdim; d++)
            {
               if (!coeff[d]) { continue; }

-               fe.Project(*coeff[d], transf, vals);
+               fe->Project(*coeff[d], *transf, vals);
               for (int k = 0; k < vals.Size(); k++)
               {
-                  const int ind = vdofs[d*vals.Size()+k];
+                  ind = vdofs[d*vals.Size()+k];
                  if (++values_counter[ind] == 1)
                  {
                     (*this)(ind) = vals(k);
@@ -2159,62 +2162,11 @@ void GridFunction::AccumulateAndCountBdrValues(
         }
         else // vcoeff != NULL
         {
-            vals.SetSize(vdim*fe.GetDof());
-            fe.Project(*vcoeff, transf, vals);
+            vals.SetSize(vdim*fe->GetDof());
+            fe->Project(*vcoeff, *transf, vals);
            for (int k = 0; k < vals.Size(); k++)
            {
-               const int ind = vdofs[k];
-               if (++values_counter[ind] == 1)
-               {
-                  (*this)(ind) = vals(k);
-               }
-               else
-               {
-                  (*this)(ind) += vals(k);
-               }
-            }
-         }
-      };
-
-      for (auto edge : bdr_edges)
-      {
-         fes->GetEdgeVDofs(edge, vdofs);
-         if (vdofs.Size() == 0) { continue; }
-
-         ElementTransformation *transf = mesh->GetEdgeTransformation(edge);
-         const FiniteElement *fe = fes->GetEdgeElement(edge);
-         mark_dofs(*transf, *fe);
-      }
-
-      for (auto face : bdr_faces)
-      {
-         fes->GetFaceVDofs(face, vdofs);
-         if (vdofs.Size() == 0) { continue; }
-
-         ElementTransformation *transf = mesh->GetFaceTransformation(face);
-         const FiniteElement *fe = fes->GetFaceElement(face);
-         mark_dofs(*transf, *fe);
-      }
-      for (int i = 0; i < bdr_planars.Size(); i++)
-      {
-         const FiniteElement *fe;
-         ElementTransformation *transf;
-         int planar = bdr_planars[i];
-         fes->GetPlanarVDofs(planar, vdofs);
-         if (vdofs.Size() == 0) { continue; }
-
-         transf = mesh->GetPlanarTransformation(planar);
-         transf->Attribute = -1; // FIXME: set the boundary attribute
-         fe = fes->GetPlanarElement(planar);
-         vals.SetSize(fe->GetDof());
-         for (int d = 0; d < vdim; d++)
-         {
-            if (!coeff[d]) { continue; }
-
-            fe->Project(*coeff[d], *transf, vals);
-            for (int k = 0; k < vals.Size(); k++)
-            {
-               int ind = vdofs[d*vals.Size()+k];
+               ind = vdofs[k];
               if (++values_counter[ind] == 1)
               {
                  (*this)(ind) = vals(k);
@@ -2277,37 +2229,26 @@ void GridFunction::AccumulateAndCountBdrTangentValues(
      accumulate_dofs(dofs, lvec, *this, values_counter);
   }

-   if (fes->Nonconforming() && (fes->GetMesh()->Dimension() == 2 ||
-                                fes->GetMesh()->Dimension() == 3))
+   if (fes->Nonconforming() && fes->GetMesh()->Dimension() == 3)
   {
      Mesh *mesh = fes->GetMesh();
      NCMesh *ncmesh = mesh->ncmesh;
      Array<int> bdr_edges, bdr_vertices, bdr_faces;
      ncmesh->GetBoundaryClosure(bdr_attr, bdr_vertices, bdr_edges, bdr_faces);

-      for (auto edge : bdr_edges)
+      for (int i = 0; i < bdr_edges.Size(); i++)
      {
+         int edge = bdr_edges[i];
         fes->GetEdgeDofs(edge, dofs);
         if (dofs.Size() == 0) { continue; }

         T = mesh->GetEdgeTransformation(edge);
+         T->Attribute = -1; // TODO: set the boundary attribute
         fe = fes->GetEdgeElement(edge);
         lvec.SetSize(fe->GetDof());
         fe->Project(vcoeff, *T, lvec);
         accumulate_dofs(dofs, lvec, *this, values_counter);
      }
-
-      for (auto face : bdr_faces)
-      {
-         fes->GetFaceDofs(face, dofs);
-         if (dofs.Size() == 0) { continue; }
-
-         T = mesh->GetFaceTransformation(face);
-         fe = fes->GetFaceElement(face);
-         lvec.SetSize(fe->GetDof());
-         fe->Project(vcoeff, *T, lvec);
-         accumulate_dofs(dofs, lvec, *this, values_counter);
-      }
   }
 }

@@ -3964,7 +3905,7 @@ void GridFunction::LegacyNCReorder()
      mesh->GetEdgeVertices(i, ev);
      if (old_vertex[ev[0]] > old_vertex[ev[1]])
      {
-         const int *ind = fes->FEColl()->DofOrderForOrientation(Geometry::SEGMENT, -1);
+         const int *ind = fec->DofOrderForOrientation(Geometry::SEGMENT, -1);

         fes->GetEdgeInteriorDofs(i, dofs);
         for (int k = 0; k < dofs.Size(); k++)
@@ -30,14 +30,14 @@ namespace mfem
 class GridFunction : public Vector
 {
 protected:
-   /// FE space on which the grid function lives. Owned if #fec_owned is not NULL.
+   /// FE space on which the grid function lives. Owned if #fec is not NULL.
   FiniteElementSpace *fes;

   /** @brief Used when the grid function is read from a file. It can also be
       set explicitly, see MakeOwner().

       If not NULL, this pointer is owned by the GridFunction. */
-   FiniteElementCollection *fec_owned;
+   FiniteElementCollection *fec;

   long fes_sequence; // see FiniteElementSpace::sequence, Mesh::sequence

@@ -72,16 +72,16 @@ protected:

 public:

-   GridFunction() { fes = NULL; fec_owned = NULL; fes_sequence = 0; UseDevice(true); }
+   GridFunction() { fes = NULL; fec = NULL; fes_sequence = 0; UseDevice(true); }

   /// Copy constructor. The internal true-dof vector #t_vec is not copied.
   GridFunction(const GridFunction &orig)
-      : Vector(orig), fes(orig.fes), fec_owned(NULL), fes_sequence(orig.fes_sequence)
+      : Vector(orig), fes(orig.fes), fec(NULL), fes_sequence(orig.fes_sequence)
   { UseDevice(true); }

   /// Construct a GridFunction associated with the FiniteElementSpace @a *f.
   GridFunction(FiniteElementSpace *f) : Vector(f->GetVSize())
-   { fes = f; fec_owned = NULL; fes_sequence = f->GetSequence(); UseDevice(true); }
+   { fes = f; fec = NULL; fes_sequence = f->GetSequence(); UseDevice(true); }

   /// Construct a GridFunction using previously allocated array @a data.
   /** The GridFunction does not assume ownership of @a data which is assumed to
@@ -91,13 +91,13 @@ public:
    */
   GridFunction(FiniteElementSpace *f, real_t *data)
      : Vector(data, f->GetVSize())
-   { fes = f; fec_owned = NULL; fes_sequence = f->GetSequence(); UseDevice(true); }
+   { fes = f; fec = NULL; fes_sequence = f->GetSequence(); UseDevice(true); }

   /** @brief Construct a GridFunction using previously allocated Vector @a base
       starting at the given offset, @a base_offset. */
   GridFunction(FiniteElementSpace *f, Vector &base, int base_offset = 0)
      : Vector(base, base_offset, f->GetVSize())
-   { fes = f; fec_owned = NULL; fes_sequence = f->GetSequence(); UseDevice(true); }
+   { fes = f; fec = NULL; fes_sequence = f->GetSequence(); UseDevice(true); }

   /// Construct a GridFunction on the given Mesh, using the data from @a input.
   /** The content of @a input should be in the format created by the method
@@ -116,12 +116,12 @@ public:
   GridFunction &operator=(const GridFunction &rhs)
   { return operator=((const Vector &)rhs); }

-   /// Make the GridFunction the owner of #fec_owned and #fes.
-   /** If the new FiniteElementCollection, @a fec_, is NULL, ownership of #fec_owned
+   /// Make the GridFunction the owner of #fec and #fes.
+   /** If the new FiniteElementCollection, @a fec_, is NULL, ownership of #fec
       and #fes is taken away. */
-   void MakeOwner(FiniteElementCollection *fec_) { fec_owned = fec_; }
+   void MakeOwner(FiniteElementCollection *fec_) { fec = fec_; }

-   FiniteElementCollection *OwnFEC() { return fec_owned; }
+   FiniteElementCollection *OwnFEC() { return fec; }

   int VectorDim() const;
   int CurlDim() const;
@@ -321,7 +321,7 @@ public:
       @param[out] der       The resulting derivative (scalar function). The
                             FiniteElementSpace of this function must be set
                             before the call. */
-   void GetDerivative(int comp, int der_comp, GridFunction &der) const;
+   void GetDerivative(int comp, int der_comp, GridFunction &der);

   real_t GetDivergence(ElementTransformation &tr) const;

@@ -443,7 +443,7 @@ protected:
       GetDerivative() method; see its documentation. */
   void AccumulateAndCountDerivativeValues(int comp, int der_comp,
                                           GridFunction &der,
-                                           Array<int> &zones_per_dof) const;
+                                           Array<int> &zones_per_dof);

   void AccumulateAndCountBdrValues(Coefficient *coeff[],
                                    VectorCoefficient *vcoeff,
@@ -1393,10 +1393,8 @@ GSOPGSLIB::~GSOPGSLIB()
 void GSOPGSLIB::UpdateIdentifiers(const Array<long long> &ids)
 {
   long long minval = ids.Min();
-#ifdef MFEM_USE_MPI
   MPI_Allreduce(MPI_IN_PLACE, &minval, 1, MPI_LONG_LONG_INT,
                 MPI_MIN, gsl_comm->c);
-#endif
   MFEM_VERIFY(minval >= 0, "Unique identifier cannot be negative.");
   if (gsl_data != NULL) { gslib_gs_free(gsl_data); }
   num_ids = ids.Size();
@@ -151,14 +151,10 @@ void IntegrationRule::GrundmannMollerSimplexRule(int s, int n)
         ip.weight = weight;
         ip.x = real_t(2*beta[0] + 1)/(d + n - 2*i);
         ip.y = real_t(2*beta[1] + 1)/(d + n - 2*i);
-         if (n >= 3)
+         if (n == 3)
         {
            ip.z = real_t(2*beta[2] + 1)/(d + n - 2*i);
         }
-         if (n == 4)
-         {
-            ip.t = real_t(2*beta[3] + 1)/(d + n - 2*i);
-         }

         int j = 0;
         while (sums[j] == k)
@@ -998,12 +994,6 @@ IntegrationRules::IntegrationRules(int ref, int type)
   CubeIntRules.SetSize(32, h_mt);
   CubeIntRules = NULL;

-   PentatopeIntRules.SetSize(32, h_mt);
-   PentatopeIntRules = NULL;
-
-   TesseractIntRules.SetSize(32, h_mt);
-   TesseractIntRules = NULL;
-
 #if defined(MFEM_THREAD_SAFE) && defined(MFEM_USE_OPENMP)
   IntRuleLocks.SetSize(Geometry::NUM_GEOMETRIES, h_mt);
   for (int i = 0; i < Geometry::NUM_GEOMETRIES; i++)
@@ -1027,8 +1017,6 @@ const IntegrationRule &IntegrationRules::Get(int GeomType, int Order)
      case Geometry::CUBE:        ir_array = &CubeIntRules; break;
      case Geometry::PRISM:       ir_array = &PrismIntRules; break;
      case Geometry::PYRAMID:     ir_array = &PyramidIntRules; break;
-      case Geometry::PENTATOPE:   ir_array = &PentatopeIntRules; break;
-      case Geometry::TESSERACT:   ir_array = &TesseractIntRules; break;
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -1079,8 +1067,6 @@ void IntegrationRules::Set(int GeomType, int Order, IntegrationRule &IntRule)
      case Geometry::CUBE:        ir_array = &CubeIntRules; break;
      case Geometry::PRISM:       ir_array = &PrismIntRules; break;
      case Geometry::PYRAMID:     ir_array = &PyramidIntRules; break;
-      case Geometry::PENTATOPE:   ir_array = &PentatopeIntRules; break;
-      case Geometry::TESSERACT:   ir_array = &TesseractIntRules; break;
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -1139,8 +1125,6 @@ IntegrationRules::~IntegrationRules()
   DeleteIntRuleArray(CubeIntRules);
   DeleteIntRuleArray(PrismIntRules);
   DeleteIntRuleArray(PyramidIntRules);
-   DeleteIntRuleArray(PentatopeIntRules);
-   DeleteIntRuleArray(TesseractIntRules);
 }


@@ -1165,10 +1149,6 @@ IntegrationRule *IntegrationRules::GenerateIntegrationRule(int GeomType,
         return PrismIntegrationRule(Order);
      case Geometry::PYRAMID:
         return PyramidIntegrationRule(Order);
-      case Geometry::PENTATOPE:
-         return PentatopeIntegrationRule(Order);
-      case Geometry::TESSERACT:
-         return TesseractIntegrationRule(Order);
      case Geometry::INVALID:
      case Geometry::NUM_GEOMETRIES:
         MFEM_ABORT("Unknown type of reference element!");
@@ -1882,179 +1862,6 @@ IntegrationRule *IntegrationRules::CubeIntegrationRule(int Order)
   return CubeIntRules[Order];
 }

-IntegrationRule *IntegrationRules::PentatopeIntegrationRule(int Order)
-{
-   IntegrationRule *ir;
-
-#ifdef MFEM_DEBUG_INTRULES
-   mfem::out << "requesting integration rules for pentatopes ( order = " << Order << " )!" << endl;
-#endif
-
-   switch (Order)
-   {
-      case 0:  // 1 point - degree 1
-      case 1:
-         PentatopeIntRules[0] = PentatopeIntRules[1] = ir = new IntegrationRule(1);
-         ir->AddPentMidPoint(0, 1./24.);
-         ir->SetOrder(1);
-         return ir;
-
-      case 2:  // 5 points - degree 2 -- taken from https://doi.org/10.1016/j.camwa.2020.07.004
-         PentatopeIntRules[2] = ir = new IntegrationRule(5);
-         ir->AddPentPoints5(0, 0.11835034190722738822731940899757, 1/120.);
-         ir->SetOrder(2);
-         return ir;
-
-      case 3:  // 15 points - degree 3 -- taken from https://doi.org/10.1016/j.camwa.2020.07.004
-         PentatopeIntRules[3] = ir = new IntegrationRule(15);
-         ir->AddPentPoints5(0, 0.05666638104005152637432374262971, 0.01971744594977651449108080328187 / 24.);
-         ir->AddPentPoints10(5, 0.08282378463560803594223358459203, 0.5 - 1.5 * 0.08282378463560803594223358459203, 0.09014127702511173789723386562400 / 24.);
-         ir->SetOrder(3);
-         return ir;
-
-      case 4:  // 35 points - degree 5 -- taken from https://doi.org/10.1016/j.camwa.2020.07.004
-      case 5:
-         PentatopeIntRules[4] = PentatopeIntRules[5] = ir = new IntegrationRule(35);
-         ir->AddPentPoints5(0, 0.08639272923225102540634168235556, 0.05144687284129603743743075483508 / 24.);
-         ir->AddPentPoints10(5, 0.02401496720062019571417799568280, 0.5 - 1.5 * 0.02401496720062019571417799568280, 0.01075810672318828174753857496171 / 24.);
-         ir->AddPentPoints20(15, 0.29381800402893687440553094347706, 0.06247517556258090631882140542075, 0.03175922842808185514451579933848 / 24.);
-         ir->SetOrder(5);
-         return ir;
-      
-      case 6:  // 70 points - degree 6 -- taken from https://doi.org/10.1016/j.camwa.2020.07.004
-         PentatopeIntRules[6] = ir = new IntegrationRule(70);
-         ir->AddPentPoints5(0, 0.154743213149364, 0.027287104452858 / 24.);
-         ir->AddPentPoints5(5, 0.243583446244066, 0.030022493650412 / 24.);
-         ir->AddPentPoints10(10, 0.045742589279674, 0.5 - 1.5 * 0.045742589279674, 0.010857537843152 / 24.);
-         ir->AddPentPoints20(20, 0.034061388191316, 0.153237752298796, 0.004213752156913 / 24.);
-         ir->AddPentPoints30(40, 0.042203997139861, 0.211681755872075, 0.017353386263795 / 24.);
-         ir->SetOrder(6);
-         return ir;
-
-      case 7:  // 126 points - degree 8 -- taken from https://doi.org/10.1016/j.camwa.2020.07.004
-      case 8:
-         PentatopeIntRules[7] = PentatopeIntRules[8]  = ir = new IntegrationRule(126);
-         ir->AddPentMidPoint(0, 0.018477072894310 / 24.);
-         ir->AddPentPoints5(1, 0.041850193209872, 0.003356028785577 / 24.);
-         ir->AddPentPoints20(6, 0.013234490721597, 0.279965061732618,  0.001166950584118 / 24.);
-         ir->AddPentPoints20(26, 0.183538643543872, 0.051063845643639, 0.019804745119265 / 24.);
-         ir->AddPentPoints20(46, 0.311385773831175, 0.014631015332223, 0.005373375682319 / 24.);
-         ir->AddPentPoints30(66,  0.032042227982220, 0.160928155464441, 0.007544402046650 / 24.);
-         ir->AddPentPoints30(96, 0.088725307776945, 0.403464343042675, 0.007050309802142 / 24.);
-         ir->SetOrder(8);
-         return ir;
-
-      case -1:
-      {
-         //construct the higher integration rules with the duffy transformation --> 1d integral in time and a tet quad-rule w.r.t space
-
-         IntegrationRule *timeIR = SegmentIntegrationRule(Order + 2);
-         IntegrationRule *tetIR = TetrahedronIntegrationRule(Order);
-
-         int NIP = timeIR->GetNPoints() * tetIR->GetNPoints();
-         AllocIntRule(PentatopeIntRules, Order);
-         PentatopeIntRules[Order] = ir = new IntegrationRule(NIP);
-
-#ifdef MFEM_DEBUG
-         mfem::out << "higher integration rules for pentatopes implemented with duffy ( order = " << Order << " ) --> " << NIP << " int. points!" << endl;
-#endif
-
-         double xi,yi,zi,ti, weight;
-
-         int pos = 0;
-         for (int i=0; i<timeIR->GetNPoints(); i++)
-         {
-            ti = timeIR->IntPoint(i).x;
-
-            for (int j=0; j<tetIR->GetNPoints(); j++)
-            {
-               xi = (1. - ti) * tetIR->IntPoint(j).x;
-               yi = (1. - ti) * tetIR->IntPoint(j).y;
-               zi = (1. - ti) * tetIR->IntPoint(j).z;
-               weight = timeIR->IntPoint(i).weight * tetIR->IntPoint(j).weight * (1.-ti) *
-                        (1.-ti) * (1.-ti);
-#ifdef MFEM_DEBUG
-               if(weight<0) mfem::out << "warning weight is negative!" << endl;
-#endif
-               ir->AddPentPoint(pos, xi,yi,zi,ti,weight);
-
-               pos++;
-            }
-         }
-#ifdef MFEM_DEBUG_INTRULES
-         char str[256];
-         mfem::out << "The points and weights are:" << endl;
-         for (int k = 0; k < ir->Size(); ++k)
-         {
-             const IntegrationPoint &ip = ir->IntPoint(k);
-             sprintf(str, "{%.16f, {%.16f, %.16f, %.16f, %.16f}},", ip.weight, ip.x, ip.y, ip.z, ip.t);
-             mfem::out << str << endl;
-         }
-#endif
-         // 2025 November: Don't we need "return ir;"? It was not there
-         return ir;
-         break;
-      }
-      default:
-      {
-         int i = (Order / 2) * 2 + 1;   // Get closest odd # >= Order
-         AllocIntRule(PentatopeIntRules, i);
-         ir = new IntegrationRule;
-         ir->GrundmannMollerSimplexRule(i/2,4);
-         PentatopeIntRules[i-1] = PentatopeIntRules[i] = ir;
-         return ir;
-      }
-   }
-
-   return PentatopeIntRules[Order];
-
-}
-
-IntegrationRule *IntegrationRules::TesseractIntegrationRule(int Order)
-{
-   int k, l, m, n, np, index;
-   int i = (Order / 2) * 2 + 1;   // Get closest odd # >= Order
-
-   if (!HaveIntRule(SegmentIntRules, i))
-   {
-      SegmentIntegrationRule(i);
-   }
-   AllocIntRule(TesseractIntRules, i);
-   np = SegmentIntRules[i] -> GetNPoints();
-   TesseractIntRules[i-1] = TesseractIntRules[i] = new IntegrationRule(
-      np*np*np*np);
-   index = 0;
-   for (k = 0; k < np; k++)
-      for (l = 0; l < np; l++)
-         for (m = 0; m < np; m++)
-            for (n = 0; n < np; n++)
-            {
-               //           index = ((k*np+l)*np+m)*np + n;
-
-               TesseractIntRules[i] -> IntPoint(index).x =
-                  SegmentIntRules[i] -> IntPoint(n).x;
-
-               TesseractIntRules[i] -> IntPoint(index).y =
-                  SegmentIntRules[i] -> IntPoint(m).x;
-
-               TesseractIntRules[i] -> IntPoint(index).z =
-                  SegmentIntRules[i] -> IntPoint(l).x;
-
-               TesseractIntRules[i] -> IntPoint(index).t =
-                  SegmentIntRules[i] -> IntPoint(k).x;
-
-               TesseractIntRules[i] -> IntPoint(index).weight =
-                  SegmentIntRules[i] -> IntPoint(k).weight *
-                  SegmentIntRules[i] -> IntPoint(l).weight *
-                  SegmentIntRules[i] -> IntPoint(m).weight *
-                  SegmentIntRules[i] -> IntPoint(n).weight;
-
-               index++;
-            }
-   TesseractIntRules[i]->SetOrder(i);
-   return TesseractIntRules[i];
-}
-
 IntegrationRule& NURBSMeshRules::GetElementRule(const int elem,
                                                const int patch, const int *ijk,
                                                Array<const KnotVector*> const& kv,
@@ -34,18 +34,18 @@ class Mesh;
 class IntegrationPoint
 {
 public:
-   real_t x, y, z, t, weight;
+   real_t x, y, z, weight;
   int index;

   void Init(int const i)
   {
-      x = y = z = t = weight = 0.0;
+      x = y = z = weight = 0.0;
      index = i;
   }

   void Set(const real_t *p, const int dim)
   {
-      MFEM_ASSERT(1 <= dim && dim <= 4, "invalid dim: " << dim);
+      MFEM_ASSERT(1 <= dim && dim <= 3, "invalid dim: " << dim);
      x = p[0];
      if (dim > 1)
      {
@@ -53,17 +53,13 @@ public:
         if (dim > 2)
         {
            z = p[2];
-            if (dim > 3)
-            {
-               t = p[3];
-            }
         }
      }
   }

   void Get(real_t *p, const int dim) const
   {
-      MFEM_ASSERT(1 <= dim && dim <= 4, "invalid dim: " << dim);
+      MFEM_ASSERT(1 <= dim && dim <= 3, "invalid dim: " << dim);
      p[0] = x;
      if (dim > 1)
      {
@@ -71,10 +67,6 @@ public:
         if (dim > 2)
         {
            p[2] = z;
-            if (dim > 3)
-            {
-               p[3] = t;
-            }
         }
      }
   }
@@ -82,17 +74,6 @@ public:
   void Set(const real_t x1, const real_t x2, const real_t x3, const real_t w)
   { x = x1; y = x2; z = x3; weight = w; }

-   void Set4w(const real_t *p) { x = p[0]; y = p[1]; z = p[2]; t = p[3]; weight = p[4]; }
-
-   void Set4w(const real_t x1, const real_t x2, const real_t x3, const real_t x4,
-              const real_t w)
-   { x = x1; y = x2; z = x3; t = x4; weight = w; }
-
-   void Set4(const real_t *p) { x = p[0]; y = p[1]; z = p[2]; t = p[3]; }
-
-   void Set4(const real_t x1, const real_t x2, const real_t x3, const real_t x4)
-   { x = x1; y = x2; z = x3; t = x4; }
-
   void Set3w(const real_t *p) { x = p[0]; y = p[1]; z = p[2]; weight = p[3]; }

   void Set3(const real_t x1, const real_t x2, const real_t x3)
@@ -238,103 +219,6 @@ private:
      AddTetPoints6(off + 6, a, b, c, weight);
   }

-   void AddPentMidPoint(const int off, const double weight)
-   { IntPoint(off).Set4w(0.2, 0.2, 0.2, 0.2, weight); }
-
-   void AddPentPoint(const int off, const double x, const double y, const double z,
-                     const double t, double weight)
-   {
-      IntPoint(off).Set4w(x, y, z, t, weight);
-   }
-
-   // given (a), add the permuations of (a,a,a,a,b), b = 1 - 4*a
-   void AddPentPoints5(const int off, const double a,
-                       double weight)
-   {
-      const double b = 1. - 4 * a;
-      IntPoint(off + 0).Set4w(a, a, a, a, weight);
-      IntPoint(off + 1).Set4w(b, a, a, a, weight);
-      IntPoint(off + 2).Set4w(a, b, a, a, weight);
-      IntPoint(off + 3).Set4w(a, a, b, a, weight);
-      IntPoint(off + 4).Set4w(a, a, a, b, weight);
-   }
-
-   // given (a,b), add the permuations of (a,a,a,b,b)
-   void AddPentPoints10(const int off, const double a, const double b, double weight)
-   {
-      IntPoint(off + 0).Set4w(a, a, a, b, weight);
-      IntPoint(off + 1).Set4w(a, a, b, a, weight);
-      IntPoint(off + 2).Set4w(a, a, b, b, weight);
-      IntPoint(off + 3).Set4w(a, b, a, a, weight);
-      IntPoint(off + 4).Set4w(a, b, a, b, weight);
-      IntPoint(off + 5).Set4w(a, b, b, a, weight);
-      IntPoint(off + 6).Set4w(b, a, a, a, weight);
-      IntPoint(off + 7).Set4w(b, a, a, b, weight);
-      IntPoint(off + 8).Set4w(b, a, b, a, weight);
-      IntPoint(off + 9).Set4w(b, b, a, a, weight);
-   }
-
-   // given (a,b,c), add the permuations of (a,a,a,b,c), c = 1 - 3 a - b
-   void AddPentPoints20(const int off, const double a, const double b, double weight)
-   {
-      const double c = 1. - 3. * a - b;
-      IntPoint(off + 0).Set4w(a, a, a, b, weight);
-      IntPoint(off + 1).Set4w(a, a, a, c, weight);
-      IntPoint(off + 2).Set4w(a, a, b, a, weight);
-      IntPoint(off + 3).Set4w(a, a, b, c, weight);
-      IntPoint(off + 4).Set4w(a, a, c, a, weight);
-      IntPoint(off + 5).Set4w(a, a, c, b, weight);
-      IntPoint(off + 6).Set4w(a, b, a, a, weight);
-      IntPoint(off + 7).Set4w(a, b, a, c, weight);
-      IntPoint(off + 8).Set4w(a, b, c, a, weight);
-      IntPoint(off + 9).Set4w(a, c, a, a, weight);
-      IntPoint(off + 10).Set4w(a, c, a, b, weight);
-      IntPoint(off + 11).Set4w(a, c, b, a, weight);
-      IntPoint(off + 12).Set4w(b, a, a, a, weight);
-      IntPoint(off + 13).Set4w(b, a, a, c, weight);
-      IntPoint(off + 14).Set4w(b, a, c, a, weight);
-      IntPoint(off + 15).Set4w(b, c, a, a, weight);
-      IntPoint(off + 16).Set4w(c, a, a, a, weight);
-      IntPoint(off + 17).Set4w(c, a, a, b, weight);
-      IntPoint(off + 18).Set4w(c, a, b, a, weight);
-      IntPoint(off + 19).Set4w(c, b, a, a, weight);
-   }
-   // given (a,b,c), add the permutations of (a,a,b,b,c), c = 1 - 2 a - 2 b
-   void AddPentPoints30(const int off, const double a, const double b, double weight)
-   {
-      double c = 1. - 2. * a - 2. * b;
-      IntPoint(off + 0).Set4w(a, a, b, b, weight);
-      IntPoint(off + 1).Set4w(a, a, b, c, weight);
-      IntPoint(off + 2).Set4w(a, a, c, b, weight);
-      IntPoint(off + 3).Set4w(a, b, a, b, weight);
-      IntPoint(off + 4).Set4w(a, b, a, c, weight);
-      IntPoint(off + 5).Set4w(a, b, b, a, weight);
-      IntPoint(off + 6).Set4w(a, b, b, c, weight);
-      IntPoint(off + 7).Set4w(a, b, c, a, weight);
-      IntPoint(off + 8).Set4w(a, b, c, b, weight);
-      IntPoint(off + 9).Set4w(a, c, a, b, weight);
-      IntPoint(off + 10).Set4w(a, c, b, a, weight);
-      IntPoint(off + 11).Set4w(a, c, b, b, weight);
-      IntPoint(off + 12).Set4w(b, a, a, b, weight);
-      IntPoint(off + 13).Set4w(b, a, a, c, weight);
-      IntPoint(off + 14).Set4w(b, a, b, a, weight);
-      IntPoint(off + 15).Set4w(b, a, b, c, weight);
-      IntPoint(off + 16).Set4w(b, a, c, a, weight);
-      IntPoint(off + 17).Set4w(b, a, c, b, weight);
-      IntPoint(off + 18).Set4w(b, b, a, a, weight);
-      IntPoint(off + 19).Set4w(b, b, a, c, weight);
-      IntPoint(off + 20).Set4w(b, b, c, a, weight);
-      IntPoint(off + 21).Set4w(b, c, a, a, weight);
-      IntPoint(off + 22).Set4w(b, c, a, b, weight);
-      IntPoint(off + 23).Set4w(b, c, b, a, weight);
-      IntPoint(off + 24).Set4w(c, a, a, b, weight);
-      IntPoint(off + 25).Set4w(c, a, b, a, weight);
-      IntPoint(off + 26).Set4w(c, a, b, b, weight);
-      IntPoint(off + 27).Set4w(c, b, a, a, weight);
-      IntPoint(off + 28).Set4w(c, b, a, b, weight);
-      IntPoint(off + 29).Set4w(c, b, b, a, weight);
-   }
-
 public:
   IntegrationRule() :
      Array<IntegrationPoint>() { }
@@ -546,8 +430,6 @@ private:
   Array<IntegrationRule *> PyramidIntRules;
   Array<IntegrationRule *> PrismIntRules;
   Array<IntegrationRule *> CubeIntRules;
-   Array<IntegrationRule *> PentatopeIntRules;
-   Array<IntegrationRule *> TesseractIntRules;

 #if defined(MFEM_THREAD_SAFE) && defined(MFEM_USE_OPENMP)
   Array<omp_lock_t> IntRuleLocks;
@@ -582,8 +464,6 @@ private:
   IntegrationRule *PyramidIntegrationRule(int Order);
   IntegrationRule *PrismIntegrationRule(int Order);
   IntegrationRule *CubeIntegrationRule(int Order);
-   IntegrationRule *PentatopeIntegrationRule(int Order);
-   IntegrationRule *TesseractIntegrationRule(int Order);

 public:
   /// Sets initial sizes for the integration rule arrays, but rules
@@ -249,12 +249,6 @@ public:
       FiniteElementSpace #fes. */
   LinearForm &operator=(const Vector &v);

-   /// Change ownership of linear form integrators.
-   void SetIntegratorOwnership(int _extern_lfs)
-   {
-      extern_lfs = _extern_lfs;
-   }
-
   /// Destroys linear form.
   ~LinearForm();
 };
@@ -174,6 +174,7 @@ public:
   using LinearFormIntegrator::AssembleRHSElementVect;
 };

+
 /// Class for boundary integration $ L(v) := (g, v) $
 class BoundaryLFIntegrator : public LinearFormIntegrator
 {
@@ -781,57 +782,6 @@ public:
   }
 };

-class MatFEDomainLFIntegrator : public LinearFormIntegrator
-{
-private:
-   MatrixCoefficient &QF;
-   DenseMatrix vshape;
-   DenseMatrix mat;
-   Vector matToVec;
-
-public:
-   MatFEDomainLFIntegrator (MatrixCoefficient &F) : QF(F) { }
-
-   virtual void AssembleRHSElementVect(const FiniteElement &el,
-                                       ElementTransformation &Tr,
-                                       Vector &elvect)
-   {
-      int dof = el.GetDof();
-      int dim = el.GetDim();
-
-      vshape.SetSize(dof,dim*dim);
-      mat.SetSize(dim,dim);
-      matToVec.SetSize(dim*dim);
-
-      elvect.SetSize(dof);
-      elvect = 0.0;
-
-      const IntegrationRule *ir = IntRule;
-      if (ir == NULL)
-      {
-         // int intorder = 2*el.GetOrder() - 1; // ok for O(h^{k+1}) conv. in L2
-         int intorder = 2*el.GetOrder() + 2;
-         ir = &IntRules.Get(el.GetGeomType(), intorder);
-      }
-
-      for (int i = 0; i < ir->GetNPoints(); i++)
-      {
-         const IntegrationPoint &ip = ir->IntPoint(i);
-         Tr.SetIntPoint (&ip);
-
-         el.CalcVShape(Tr, vshape);
-
-         QF.Eval (mat, Tr, ip);
-         mat *= ip.weight * fabs(Tr.Weight());
-         for (int ki=0; ki<dim; ki++) for (int kj=0; kj<dim; kj++) { matToVec(dim*ki+kj) = mat(ki,kj); }
-
-         vshape.AddMult(matToVec, elvect);
-      }
-   }
-
-   using LinearFormIntegrator::AssembleRHSElementVect;
-};
-
 }


@@ -330,18 +330,6 @@ public:
   /// Compute y += a (P^t A P) x, where x and y are vectors on the true dofs
   void TrueAddMult(const Vector &x, Vector &y, const real_t a = 1.0) const;

-   using MixedBilinearForm::Update;
-   virtual void Update(ParFiniteElementSpace *ntr_fes = NULL,
-                       ParFiniteElementSpace *nte_fes = NULL)
-   {
-      MixedBilinearForm::Update(ntr_fes, nte_fes);
-      if (ntr_fes && nte_fes )
-      {
-         trial_pfes = ntr_fes;
-         test_pfes  = nte_fes;
-      }
-   }
-
   virtual ~ParMixedBilinearForm() { }
 };

@@ -174,11 +174,10 @@ void ParFiniteElementSpace::Construct()
         ngfdofs = pncmesh->GetNGhostFaces()
                   * fec->DofForGeometry(Geometry::Type::SQUARE);
      }
-      ngpdofs = 0;

      // total number of ghost DOFs. Ghost DOFs start at index 'ndofs', i.e.,
      // after all regular DOFs
-      ngdofs = ngvdofs + ngedofs + ngfdofs + ngpdofs;
+      ngdofs = ngvdofs + ngedofs + ngfdofs;

      // get P and R matrices, initialize DOF offsets, etc. NOTE: in the NC
      // case this needs to be done here to get the number of true DOFs
@@ -236,11 +235,8 @@ void ParFiniteElementSpace::GetGroupComm(
   int gr;
   int ng = pmesh->GetNGroups();
   int nvd, ned, ntd = 0, nqd = 0;
-   int nted = 0;
   Array<int> dofs;

-   int dim = pmesh->Dimension();
-
   int group_ldof_counter;
   Table &group_ldof = gc.GroupLDofTable();

@@ -257,10 +253,6 @@ void ParFiniteElementSpace::GetGroupComm(
      {
         nqd = fec->DofForGeometry(Geometry::SQUARE);
      }
-      if (mesh->HasGeometry(Geometry::TETRAHEDRON) && dim > 3)
-      {
-         nted = fec->DofForGeometry(Geometry::TETRAHEDRON);
-      }
   }

   if (g_ldof_sign)
@@ -277,11 +269,6 @@ void ParFiniteElementSpace::GetGroupComm(
      group_ldof_counter += ned * pmesh->GroupNEdges(gr);
      group_ldof_counter += ntd * pmesh->GroupNTriangles(gr);
      group_ldof_counter += nqd * pmesh->GroupNQuadrilaterals(gr);
-      if (dim > 3)
-      {
-         group_ldof_counter += nted * pmesh->GroupNTetrahedra(
-                                  gr);   // FIXME: ensure that tet-group is always build
-      }
   }
   if (ldof_type)
   {
@@ -295,14 +282,13 @@ void ParFiniteElementSpace::GetGroupComm(
   group_ldof.GetI()[0] = group_ldof.GetI()[1] = 0;
   for (gr = 1; gr < ng; gr++)
   {
-      int j, k, l, m, o, nv, ne, nt, nq, nte;
+      int j, k, l, m, o, nv, ne, nt, nq;
      const int *ind;

      nv = pmesh->GroupNVertices(gr);
      ne = pmesh->GroupNEdges(gr);
      nt = pmesh->GroupNTriangles(gr);
      nq = pmesh->GroupNQuadrilaterals(gr);
-      nte = (dim>3) ? pmesh->GroupNTetrahedra(gr) : 0;   // FIXME

      // vertices
      if (nvd > 0)
@@ -376,14 +362,7 @@ void ParFiniteElementSpace::GetGroupComm(
            pmesh->GroupTriangle(gr, j, k, o);

            dofs.SetSize(ntd);
-            if (dim == 4)
-            {
-               m = nvdofs+nedofs+pdofs[k];
-            }
-            else
-            {
-               m = nvdofs + nedofs + FirstFaceDof(k);
-            }
+            m = nvdofs + nedofs + FirstFaceDof(k);
            ind = fec->DofOrderForOrientation(Geometry::TRIANGLE, o);
            for (l = 0; l < ntd; l++)
            {
@@ -451,45 +430,6 @@ void ParFiniteElementSpace::GetGroupComm(
         }
      }

-      // tetrahedra (4D)
-      if (nted > 0)
-      {
-         for (j = 0; j < nte; j++)
-         {
-            pmesh->GroupTetrahedron(gr, j, k, o);
-
-            dofs.SetSize(nted);
-            m = nvdofs+nedofs+npdofs+ FirstFaceDof(k);
-            ind = fec->DofOrderForOrientation(
-                     mesh->GetFaceGeometry(k), o);
-            for (l = 0; l < nted; l++)
-            {
-               if (ind[l] < 0)
-               {
-                  dofs[l] = m + (-1-ind[l]);
-                  if (g_ldof_sign)
-                  {
-                     (*g_ldof_sign)[dofs[l]] = -1;
-                  }
-               }
-               else
-               {
-                  dofs[l] = m + ind[l];
-               }
-            }
-
-            if (ldof_type)
-            {
-               DofsToVDofs(dofs);
-            }
-
-            for (l = 0; l < dofs.Size(); l++)
-            {
-               group_ldof.GetJ()[group_ldof_counter++] = dofs[l];
-            }
-         }
-      }
-
      group_ldof.GetI()[gr+1] = group_ldof_counter;
   }

@@ -711,30 +651,6 @@ void ParFiniteElementSpace::GetSharedQuadrilateralDofs(
   }
 }

-void ParFiniteElementSpace::GetSharedTetrahedronDofs(
-   int group, int fi, Array<int> &dofs) const
-{
-   int l_face, ori;
-   MFEM_ASSERT(0 <= fi &&
-               fi < pmesh->GroupNTetrahedra(group), "invalid face index");
-   pmesh->GroupTetrahedron(group, fi, l_face, ori);
-   if (ori == 0)
-   {
-      GetFaceDofs(l_face, dofs);
-   }
-   else
-   {
-      Array<int> rdofs;
-      fec->SubDofOrder(pmesh->GetFaceGeometry(l_face), 2, ori, dofs);
-      GetFaceDofs(l_face, rdofs);
-      for (int i = 0; i < dofs.Size(); i++)
-      {
-         const int di = dofs[i];
-         dofs[i] = (di >= 0) ? rdofs[di] : -1-rdofs[-1-di];
-      }
-   }
-}
-
 void ParFiniteElementSpace::GenerateGlobalOffsets() const
 {
   MFEM_ASSERT(Conforming(), "wrong code path");
@@ -1822,115 +1738,6 @@ void ParFiniteElementSpace::GetGhostFaceDofs(const MeshId &face_id,
   }
 }

-void ParFiniteElementSpace::GetGhostFaceDofs4D(const MeshId &face_id,
-                                               Array<int> &dofs) const
-{
-   #if 0
-   MFEM_ASSERT(mesh->GetFaceBaseGeometry(0) == Geometry::TETRAHEDRON, "");
-
-   int nv = fec->DofForGeometry(Geometry::POINT);
-   int ne = fec->DofForGeometry(Geometry::SEGMENT);
-   int np = fec->DofForGeometry(Geometry::TRIANGLE);
-   int nf = fec->DofForGeometry(Geometry::TETRAHEDRON);
-   dofs.SetSize(4*nv + 6*ne + 4*np + nf);
-
-   int V[4], E[6], Eo[6], P[4], Po[4];
-   pmesh->pncmesh->GetFaceVerticesEdgesPlanars(face_id, V, E, Eo, P, Po);
-
-   int offset = 0;
-   for (int i = 0; i < 4; i++)
-   {
-      int ghost = pncmesh->GetNVertices();
-      int first = (V[i] < ghost) ? V[i]*nv : (ndofs + (V[i] - ghost)*nv);
-      for (int j = 0; j < nv; j++)
-      {
-         dofs[offset++] = first + j;
-      }
-   }
-
-   for (int i = 0; i < 6; i++)
-   {
-      int ghost = pncmesh->GetNEdges();
-      int first = (E[i] < ghost) ? nvdofs + E[i]*ne
-                  /*          */ : ndofs + ngvdofs + (E[i] - ghost)*ne;
-      const int *ind = fec->DofOrderForOrientation(Geometry::SEGMENT, Eo[i]);
-      for (int j = 0; j < ne; j++)
-      {
-         dofs[offset++] = (ind[j] >= 0) ? (first + ind[j])
-                          /*         */ : (-1 - (first + (-1 - ind[j])));
-      }
-   }
-
-   for (int i = 0; i < 4; i++)
-   {
-      // TODO higher order
-      int ghost = pncmesh->GetNPlanars();
-      int first = (P[i] < ghost) ? nvdofs + nedofs +  P[i]*np
-                  /*          */ : ndofs + ngvdofs + nedofs + ngedofs +  (P[i] - ghost)*np;
-      //      const int *ind = fec->DofOrderForOrientation(Geometry::SEGMENT, Eo[i]);
-      for (int j = 0; j < np; j++)
-      {
-         dofs[offset++] = first + j;
-      }
-   }
-
-   int first = ndofs + ngvdofs + ngedofs +
-               (face_id.index - pncmesh->GetNFaces())*nf;
-   for (int j = 0; j < nf; j++)
-   {
-      dofs[offset++] = first + j;
-   }
-   #endif
-}
-
-void ParFiniteElementSpace::GetGhostPlanarDofs(const MeshId &planar_id,
-                                               Array<int> &dofs) const
-{
-   #if 0
-   MFEM_ASSERT(mesh->GetPlanarBaseGeometry(0) == Geometry::TRIANGLE, "");
-
-   int nv = fec->DofForGeometry(Geometry::POINT);
-   int ne = fec->DofForGeometry(Geometry::SEGMENT);
-   int np = fec->DofForGeometry(Geometry::TRIANGLE);
-   dofs.SetSize(3*nv + 3*ne + np);
-
-   int V[3], E[3], Eo[3];
-   pmesh->pncmesh->GetPlanarVerticesEdges(planar_id, V, E, Eo);
-
-   int offset = 0;
-   for (int i = 0; i < 3; i++)
-   {
-      int ghost = pncmesh->GetNVertices();
-      int first = (V[i] < ghost) ? V[i]*nv : (ndofs + (V[i] - ghost)*nv);
-      for (int j = 0; j < nv; j++)
-      {
-         dofs[offset++] = first + j;
-      }
-   }
-
-   for (int i = 0; i < 3; i++)
-   {
-      int ghost = pncmesh->GetNEdges();
-      int first = (E[i] < ghost) ? nvdofs + E[i]*ne
-                  /*          */ : ndofs + ngvdofs + (E[i] - ghost)*ne;
-      const int *ind = fec->DofOrderForOrientation(Geometry::SEGMENT, Eo[i]);
-      for (int j = 0; j < ne; j++)
-      {
-         dofs[offset++] = (ind[j] >= 0) ? (first + ind[j])
-                          /*         */ : (-1 - (first + (-1 - ind[j])));
-      }
-   }
-
-   int first = ndofs + ngvdofs + ngedofs +
-               (planar_id.index - pncmesh->GetNPlanars())*np;
-   for (int j = 0; j < np; j++)
-   {
-      dofs[offset++] = first + j;
-   }
-   #endif
-}
-
-
 void ParFiniteElementSpace::GetGhostDofs(int entity, const MeshId &id,
                                         Array<int> &dofs) const
 {
@@ -1943,19 +1750,6 @@ void ParFiniteElementSpace::GetGhostDofs(int entity, const MeshId &id,
   }
 }

-void ParFiniteElementSpace::GetGhostDofs4D(int entity, const MeshId &id,
-                                           Array<int> &dofs) const
-{
-   // helper to get ghost vertex, ghost edge or ghost face DOFs
-   switch (entity)
-   {
-      case 0: GetGhostVertexDofs(id, dofs); break;
-      case 1: GetGhostEdgeDofs(id, dofs); break;
-      case 2: GetGhostPlanarDofs(id, dofs); break;
-      case 3: GetGhostFaceDofs4D(id, dofs); break;
-   }
-}
-
 void ParFiniteElementSpace::GetBareDofs(int entity, int index,
                                        Array<int> &dofs) const
 {
@@ -2006,55 +1800,6 @@ void ParFiniteElementSpace::GetBareDofs(int entity, int index,
   }
 }

-void ParFiniteElementSpace::GetBareDofs4D(int entity, int index,
-                                          Array<int> &dofs) const
-{
-   #if 0
-   int ned, ghost, first;
-   switch (entity)
-   {
-      case 0:
-         ned = fec->DofForGeometry(Geometry::POINT);
-         ghost = pncmesh->GetNVertices();
-         first = (index < ghost)
-                 ? index*ned // regular vertex
-                 : ndofs + (index - ghost)*ned; // ghost vertex
-         break;
-
-      case 1:
-         ned = fec->DofForGeometry(Geometry::SEGMENT);
-         ghost = pncmesh->GetNEdges();
-         first = (index < ghost)
-                 ? nvdofs + index*ned // regular edge
-                 : ndofs + ngvdofs + (index - ghost)*ned; // ghost edge
-         break;
-
-      case 2:
-         ned = fec->DofForGeometry(mesh->GetPlanarBaseGeometry(0));
-         ghost = pncmesh->GetNPlanars();
-         first = (index < ghost)
-                 ? nvdofs + nedofs + index*ned
-                 : ndofs + ngvdofs + ngedofs + (index - ghost)*ned;
-         break;
-
-      default:
-         ned = fec->DofForGeometry(mesh->GetFaceBaseGeometry(0));
-         ghost = pncmesh->GetNFaces();
-         first = (index < ghost)
-                 ? nvdofs + nedofs + npdofs + index*ned // regular face
-                 : ndofs + ngvdofs + ngedofs + ngpdofs + (index - ghost)*ned; // ghost
-         break;
-   }
-
-   dofs.SetSize(ned);
-   for (int i = 0; i < ned; i++)
-   {
-      dofs[i] = first + i;
-   }
-   #endif
-}
-
-
 int ParFiniteElementSpace::PackDof(int entity, int index, int edof) const
 {
   // DOFs are ordered as follows:
@@ -2661,7 +2406,7 @@ int ParFiniteElementSpace
                                       Array<int> *dof_tdof,
                                       bool partial) const
 {
-   const bool dg = (nvdofs == 0 && nedofs == 0 && nfdofs == 0 && npdofs == 0);
+   const bool dg = (nvdofs == 0 && nedofs == 0 && nfdofs == 0);

 #ifdef MFEM_PMATRIX_STATS
   n_msgs_sent = n_msgs_recv = 0;
@@ -2724,7 +2469,7 @@ int ParFiniteElementSpace

               list.OrientedPointMatrix(sf, T.GetPointMat());
               fe->GetLocalInterpolation(T, I);
-               //               mfem::out << "**************\n";
+
               // make each slave DOF dependent on all master DOFs
               AddDependencies(deps, master_dofs, slave_dofs, I);
            }
@@ -2752,14 +2497,7 @@ int ParFiniteElementSpace
         GroupId owner = pncmesh->GetEntityOwnerId(entity, id.index);
         GroupId group = pncmesh->GetEntityGroupId(entity, id.index);

-         if (pmesh->Dimension() <= 3)
-         {
-            GetBareDofs(entity, id.index, dofs);
-         }
-         else
-         {
-            GetBareDofs4D(entity, id.index, dofs);
-         }
+         GetBareDofs(entity, id.index, dofs);

         for (auto dof : dofs)
         {
@@ -2768,7 +2506,6 @@ int ParFiniteElementSpace
         }
      };

-
      // initialize dof_group[], dof_owner[] in sequence
      for (int entity : {0,1,2})
      {
@@ -45,7 +45,7 @@ private:
   mutable int ltdof_size;

   /// Number of vertex/edge/face/total ghost DOFs (nonconforming case).
-   int ngvdofs, ngedofs, ngfdofs, ngdofs, ngpdofs;
+   int ngvdofs, ngedofs, ngfdofs, ngdofs;

   /// The group of each local dof.
   Array<int> ldof_group;
@@ -126,13 +126,8 @@ private:
   void GetGhostFaceDofs(const MeshId &face_id, Array<int> &dofs) const;
   void GetGhostDofs(int entity, const MeshId &id, Array<int> &dofs) const;

-   void GetGhostFaceDofs4D(const MeshId &face_id, Array<int> &dofs) const;
-   void GetGhostPlanarDofs(const MeshId &planar_id, Array<int> &dofs) const;
-   void GetGhostDofs4D(int entity, const MeshId &id, Array<int> &dofs) const;
-
   /// Return the dofs associated with the interior of the given mesh entity.
   void GetBareDofs(int entity, int index, Array<int> &dofs) const;
-   void GetBareDofs4D(int entity, int index, Array<int> &dofs) const;

   int  PackDof(int entity, int index, int edof) const;
   void UnpackDof(int dof, int &entity, int &index, int &edof) const;
@@ -327,7 +322,6 @@ public:
   void GetSharedEdgeDofs(int group, int ei, Array<int> &dofs) const;
   void GetSharedTriangleDofs(int group, int fi, Array<int> &dofs) const;
   void GetSharedQuadrilateralDofs(int group, int fi, Array<int> &dofs) const;
-   void GetSharedTetrahedronDofs(int group, int fi, Array<int> &dofs) const;

   /// The true dof-to-dof interpolation matrix
   HypreParMatrix *Dof_TrueDof_Matrix() const
@@ -39,10 +39,9 @@ ParGridFunction::ParGridFunction(ParMesh *pmesh, const GridFunction *gf,
 {
   const FiniteElementSpace *glob_fes = gf->FESpace();
   // duplicate the FiniteElementCollection from 'gf'
-   fec_owned = FiniteElementCollection::New(glob_fes->FEColl()->Name());
+   fec = FiniteElementCollection::New(glob_fes->FEColl()->Name());
   // create a local ParFiniteElementSpace from the global one:
-   fes = pfes = new ParFiniteElementSpace(pmesh, glob_fes, partitioning,
-                                          fec_owned);
+   fes = pfes = new ParFiniteElementSpace(pmesh, glob_fes, partitioning, fec);
   SetSize(pfes->GetVSize());

   if (partitioning)
@@ -82,7 +81,7 @@ ParGridFunction::ParGridFunction(ParMesh *pmesh, std::istream &input)
   : GridFunction(pmesh, input)
 {
   // Convert the FiniteElementSpace, fes, to a ParFiniteElementSpace:
-   pfes = new ParFiniteElementSpace(pmesh, fec_owned, fes->GetVDim(),
+   pfes = new ParFiniteElementSpace(pmesh, fec, fes->GetVDim(),
                                    fes->GetOrdering());
   delete fes;
   fes = pfes;
@@ -521,7 +520,7 @@ void ParGridFunction::CountElementsPerVDof(Array<int> &elem_per_vdof) const
 }

 void ParGridFunction::GetDerivative(int comp, int der_comp,
-                                    ParGridFunction &der) const
+                                    ParGridFunction &der)
 {
   Array<int> overlap;
   AccumulateAndCountDerivativeValues(comp, der_comp, der, overlap);
@@ -231,7 +231,7 @@ public:
   void CountElementsPerVDof(Array<int> &elem_per_vdof) const override;

   /// Parallel version of GridFunction::GetDerivative(); see its documentation.
-   void GetDerivative(int comp, int der_comp, ParGridFunction &der) const;
+   void GetDerivative(int comp, int der_comp, ParGridFunction &der);

   /** Sets the output vector @a dof_vals to the values of the degrees of
       freedom of element @a el. If @a el is greater than or equal to the number
@@ -2949,15 +2949,6 @@ void TMOP_Integrator::EnableSurfaceFitting(const GridFunction &s0,
   MFEM_VERIFY(surf_fit_pos == NULL,
               "Using both fitting approaches is not supported.");

-   const int dim = s0.FESpace()->GetMesh()->Dimension();
-   Mesh *mesh = s0.FESpace()->GetMesh();
-   MFEM_VERIFY(mesh->GetNodes()->Size() == dim*s0.Size(),
-               "Mesh and level-set polynomial order must be the same.");
-   const H1_FECollection *fec = dynamic_cast<const H1_FECollection *>
-                                (s0.FESpace()->FEColl());
-   MFEM_VERIFY(fec, "Only H1_FECollection is supported for the surface fitting "
-               "grid function.");
-
   delete surf_fit_gf;
   surf_fit_gf = new GridFunction(s0);
   surf_fit_gf->CountElementsPerVDof(surf_fit_dof_count);
@@ -2996,24 +2987,12 @@ void TMOP_Integrator::EnableSurfaceFitting(const GridFunction &pos,
 void TMOP_Integrator::EnableSurfaceFitting(const ParGridFunction &s0,
                                           const Array<bool> &smarker,
                                           Coefficient &coeff,
-                                           AdaptivityEvaluator &ae,
-                                           AdaptivityEvaluator *aegrad,
-                                           AdaptivityEvaluator *aehess)
+                                           AdaptivityEvaluator &ae)
 {
   // To have both we must duplicate the markers.
   MFEM_VERIFY(surf_fit_pos == NULL,
               "Using both fitting approaches is not supported.");

-   const int dim = s0.FESpace()->GetMesh()->Dimension();
-   ParMesh *pmesh = s0.ParFESpace()->GetParMesh();
-   MFEM_VERIFY(pmesh->GetNodes()->Size() == dim*s0.Size(),
-               "Mesh and level-set polynomial order must be the same.");
-   const H1_FECollection *fec = dynamic_cast<const H1_FECollection *>
-                                (s0.FESpace()->FEColl());
-   MFEM_VERIFY(fec, "Only H1_FECollection is supported for the surface fitting "
-               "grid function.");
-
-
   delete surf_fit_gf;
   surf_fit_gf = new GridFunction(s0);
   s0.CountElementsPerVDof(surf_fit_dof_count);
@@ -3021,80 +3000,11 @@ void TMOP_Integrator::EnableSurfaceFitting(const ParGridFunction &s0,
   surf_fit_coeff = &coeff;
   surf_fit_eval = &ae;

-   surf_fit_eval->SetParMetaInfo(*pmesh, *s0.ParFESpace());
+   surf_fit_eval->SetParMetaInfo(*s0.ParFESpace()->GetParMesh(),
+                                 *s0.ParFESpace());
   surf_fit_eval->SetInitialField
   (*surf_fit_gf->FESpace()->GetMesh()->GetNodes(), *surf_fit_gf);
-
-   if (!aegrad) { return; }
-
-   MFEM_VERIFY(aehess, "AdaptivityEvaluator for Hessians must be provided too.");
-
-   ParFiniteElementSpace *fes = s0.ParFESpace();
-
-   // FE space for gradients.
-   delete surf_fit_grad;
-   H1_FECollection *fec_grad = new H1_FECollection(fec->GetOrder(), dim,
-                                                   fec->GetBasisType());
-   ParFiniteElementSpace *fes_grad = new ParFiniteElementSpace(pmesh, fec_grad,
-                                                               dim);
-   // Initial gradients.
-   surf_fit_grad = new GridFunction(fes_grad);
-   surf_fit_grad->MakeOwner(fec_grad);
-   for (int d = 0; d < dim; d++)
-   {
-      ParGridFunction surf_fit_grad_comp(fes, surf_fit_grad->GetData()+d*s0.Size());
-      s0.GetDerivative(1, d, surf_fit_grad_comp);
-   }
-   surf_fit_eval_grad = aegrad;
-   surf_fit_eval_grad->SetParMetaInfo(*pmesh, *fes_grad);
-   surf_fit_eval_grad->SetInitialField(*pmesh->GetNodes(), *surf_fit_grad);
-
-   // FE space for Hessians.
-   delete surf_fit_hess;
-   H1_FECollection *fec_hess = new H1_FECollection(fec->GetOrder(), dim,
-                                                   fec->GetBasisType());
-   ParFiniteElementSpace *fes_hess = new ParFiniteElementSpace(pmesh, fec_hess,
-                                                               dim*dim);
-   // Initial Hessians.
-   surf_fit_hess = new GridFunction(fes_hess);
-   surf_fit_hess->MakeOwner(fec_hess);
-   int id = 0;
-   for (int d = 0; d < dim; d++)
-   {
-      for (int idir = 0; idir < dim; idir++)
-      {
-         ParGridFunction surf_fit_grad_comp(fes,
-                                            surf_fit_grad->GetData()+d*s0.Size());
-         ParGridFunction surf_fit_hess_comp(fes,
-                                            surf_fit_hess->GetData()+id*s0.Size());
-         surf_fit_grad_comp.GetDerivative(1, idir, surf_fit_hess_comp);
-         id++;
-      }
-   }
-   surf_fit_eval_hess = aehess;
-   surf_fit_eval_hess->SetParMetaInfo(*pmesh, *fes_hess);
-   surf_fit_eval_hess->SetInitialField(*pmesh->GetNodes(), *surf_fit_hess);
-
-   // Store DOF indices that are marked for fitting. Used to reduce work for
-   // transferring information between source/background and current mesh.
-   surf_fit_marker_dof_index.SetSize(0);
-#ifdef MFEM_USE_GSLIB
-   if (dynamic_cast<InterpolatorFP *>(surf_fit_eval) &&
-       dynamic_cast<InterpolatorFP *>(surf_fit_eval_grad) &&
-       dynamic_cast<InterpolatorFP *>(surf_fit_eval_hess))
-   {
-      for (int i = 0; i < surf_fit_marker->Size(); i++)
-      {
-         if ((*surf_fit_marker)[i] == true)
-         {
-            surf_fit_marker_dof_index.Append(i);
-         }
-      }
-   }
-#endif
-
-   *surf_fit_grad = 0.0;
-   *surf_fit_hess = 0.0;
+   surf_fit_gf_bg = false;
 }

 void TMOP_Integrator::EnableSurfaceFittingFromSource(
@@ -3112,17 +3022,16 @@ void TMOP_Integrator::EnableSurfaceFittingFromSource(
   // Setup for level set function
   delete surf_fit_gf;
   surf_fit_gf = new GridFunction(s0);
+   *surf_fit_gf = 0.0;
   surf_fit_marker = &smarker;
   surf_fit_coeff = &coeff;
   surf_fit_eval = &ae;

+   surf_fit_gf_bg = true;
   surf_fit_eval->SetParMetaInfo(*s_bg.ParFESpace()->GetParMesh(),
                                 *s_bg.ParFESpace());
   surf_fit_eval->SetInitialField
   (*s_bg.FESpace()->GetMesh()->GetNodes(), s_bg);
-   GridFunction *nodes = s0.FESpace()->GetMesh()->GetNodes();
-   surf_fit_eval->ComputeAtNewPosition(*nodes, *surf_fit_gf,
-                                       nodes->FESpace()->GetOrdering());

   // Setup for gradient on background mesh
   MFEM_VERIFY(s_bg_grad.ParFESpace()->GetOrdering() ==
@@ -3132,11 +3041,11 @@ void TMOP_Integrator::EnableSurfaceFittingFromSource(
   delete surf_fit_grad;
   surf_fit_grad = new GridFunction(s0_grad);
   *surf_fit_grad = 0.0;
-   surf_fit_eval_grad = &age;
-   surf_fit_eval_hess = &ahe;
-   surf_fit_eval_grad->SetParMetaInfo(*s_bg_grad.ParFESpace()->GetParMesh(),
-                                      *s_bg_grad.ParFESpace());
-   surf_fit_eval_grad->SetInitialField
+   surf_fit_eval_bg_grad = &age;
+   surf_fit_eval_bg_hess = &ahe;
+   surf_fit_eval_bg_grad->SetParMetaInfo(*s_bg_grad.ParFESpace()->GetParMesh(),
+                                         *s_bg_grad.ParFESpace());
+   surf_fit_eval_bg_grad->SetInitialField
   (*s_bg_grad.FESpace()->GetMesh()->GetNodes(), s_bg_grad);

   // Setup for Hessian on background mesh
@@ -3147,9 +3056,9 @@ void TMOP_Integrator::EnableSurfaceFittingFromSource(
   delete surf_fit_hess;
   surf_fit_hess = new GridFunction(s0_hess);
   *surf_fit_hess = 0.0;
-   surf_fit_eval_hess->SetParMetaInfo(*s_bg_hess.ParFESpace()->GetParMesh(),
-                                      *s_bg_hess.ParFESpace());
-   surf_fit_eval_hess->SetInitialField
+   surf_fit_eval_bg_hess->SetParMetaInfo(*s_bg_hess.ParFESpace()->GetParMesh(),
+                                         *s_bg_hess.ParFESpace());
+   surf_fit_eval_bg_hess->SetInitialField
   (*s_bg_hess.FESpace()->GetMesh()->GetNodes(), s_bg_hess);

   // Count number of zones that share each of the DOFs
@@ -3954,7 +3863,7 @@ void TMOP_Integrator::AssembleElemVecSurfFit(const FiniteElement &el_x,

   Vector sigma_e(dof_s);
   DenseMatrix surf_fit_grad_e(dof_s, dim);
-   if (surf_fit_gf)
+   if (surf_fit_gf || surf_fit_gf_bg)
   {
      surf_fit_gf->GetSubVector(vdofs, sigma_e);

@@ -3962,7 +3871,7 @@ void TMOP_Integrator::AssembleElemVecSurfFit(const FiniteElement &el_x,
      // The FE coefficients of the gradient go in surf_fit_grad_e.
      Vector grad_ptr(surf_fit_grad_e.GetData(), dof_s * dim);
      DenseMatrix grad_phys; // This will be (dof x dim, dof).
-      if (surf_fit_grad)
+      if (surf_fit_gf_bg)
      {
         surf_fit_grad->FESpace()->GetElementVDofs(el_id, dofs);
         surf_fit_grad->GetSubVector(dofs, grad_ptr);
@@ -4036,7 +3945,7 @@ void TMOP_Integrator::AssembleElemGradSurfFit(const FiniteElement &el_x,
   Vector sigma_e(dof_s);
   DenseMatrix surf_fit_grad_e(dof_s, dim);
   DenseMatrix surf_fit_hess_e(dof_s, dim*dim);
-   if (surf_fit_gf)
+   if (surf_fit_gf || surf_fit_gf_bg)
   {
      surf_fit_gf->GetSubVector(vdofs, sigma_e);

@@ -4044,7 +3953,7 @@ void TMOP_Integrator::AssembleElemGradSurfFit(const FiniteElement &el_x,
      // The FE coefficients of the gradient go in surf_fit_grad_e.
      Vector grad_ptr(surf_fit_grad_e.GetData(), dof_s * dim);
      DenseMatrix grad_phys; // This will be (dof x dim, dof).
-      if (surf_fit_grad)
+      if (surf_fit_gf_bg)
      {
         surf_fit_grad->FESpace()->GetElementVDofs(el_id, dofs);
         surf_fit_grad->GetSubVector(dofs, grad_ptr);
@@ -4058,7 +3967,7 @@ void TMOP_Integrator::AssembleElemGradSurfFit(const FiniteElement &el_x,
      // Project the Hessian of sigma in the same space.
      // The FE coefficients of the Hessian go in surf_fit_hess_e.
      Vector hess_ptr(surf_fit_hess_e.GetData(), dof_s*dim*dim);
-      if (surf_fit_hess)
+      if (surf_fit_gf_bg)
      {
         surf_fit_hess->FESpace()->GetElementVDofs(el_id, dofs);
         surf_fit_hess->GetSubVector(dofs, hess_ptr);
@@ -4085,7 +3994,7 @@ void TMOP_Integrator::AssembleElemGradSurfFit(const FiniteElement &el_x,
      Tpr.SetIntPoint(&ip);
      real_t w = surf_fit_normal * surf_fit_coeff->Eval(Tpr, ip);

-      if (surf_fit_gf)
+      if (surf_fit_gf || surf_fit_gf_bg)
      {
         Vector gg_ptr(surf_fit_hess_s.GetData(), dim * dim);
         surf_fit_hess_e.GetRow(s, gg_ptr);
@@ -4467,130 +4376,6 @@ void TMOP_Integrator::ComputeMinJac(const Vector &x,
   dx = detv_avg_min / dxscale;
 }

-void TMOP_Integrator::RemapSurfaceFittingLevelSetAtNodes(const Vector &new_x,
-                                                         int new_x_ordering)
-{
-   if (!surf_fit_gf) { return; }
-
-   if (surf_fit_marker_dof_index.Size())
-   {
-      // Interpolate information only at DOFs marked for fitting.
-      const int dim = surf_fit_gf->FESpace()->GetMesh()->Dimension();
-      const int cnt = surf_fit_marker_dof_index.Size();
-      const int total_cnt = new_x.Size()/dim;
-      Vector new_x_sorted(cnt*dim);
-      if (new_x_ordering == 0)
-      {
-         for (int d = 0; d < dim; d++)
-         {
-            for (int i = 0; i < cnt; i++)
-            {
-               int dof_index = surf_fit_marker_dof_index[i];
-               new_x_sorted(i + d*cnt) = new_x(dof_index + d*total_cnt);
-            }
-         }
-      }
-      else
-      {
-         for (int i = 0; i < cnt; i++)
-         {
-            int dof_index = surf_fit_marker_dof_index[i];
-            for (int d = 0; d < dim; d++)
-            {
-               new_x_sorted(d + i*dim) = new_x(d + dof_index*dim);
-            }
-         }
-      }
-
-      // Interpolate values of the LS.
-      Vector surf_fit_gf_int, surf_fit_grad_int, surf_fit_hess_int;
-      surf_fit_eval->ComputeAtNewPosition(new_x_sorted, surf_fit_gf_int,
-                                          new_x_ordering);
-      for (int i = 0; i < cnt; i++)
-      {
-         int dof_index = surf_fit_marker_dof_index[i];
-         (*surf_fit_gf)[dof_index] = surf_fit_gf_int(i);
-      }
-
-      // Interpolate gradients of the LS.
-      surf_fit_eval_grad->ComputeAtNewPosition(new_x_sorted, surf_fit_grad_int,
-                                               new_x_ordering);
-      // Assumes surf_fit_grad and surf_fit_gf share the same space
-      const int grad_dim = surf_fit_grad->VectorDim();
-      const int grad_cnt = surf_fit_grad->Size()/grad_dim;
-      if (surf_fit_grad->FESpace()->GetOrdering() == Ordering::byNODES)
-      {
-         for (int d = 0; d < grad_dim; d++)
-         {
-            for (int i = 0; i < cnt; i++)
-            {
-               int dof_index = surf_fit_marker_dof_index[i];
-               (*surf_fit_grad)[dof_index + d*grad_cnt] =
-                  surf_fit_grad_int(i + d*cnt);
-            }
-         }
-      }
-      else
-      {
-         for (int i = 0; i < cnt; i++)
-         {
-            int dof_index = surf_fit_marker_dof_index[i];
-            for (int d = 0; d < grad_dim; d++)
-            {
-               (*surf_fit_grad)[dof_index*grad_dim + d] =
-                  surf_fit_grad_int(i*grad_dim + d);
-            }
-         }
-      }
-
-      // Interpolate Hessians of the LS.
-      surf_fit_eval_hess->ComputeAtNewPosition(new_x_sorted, surf_fit_hess_int,
-                                               new_x_ordering);
-      // Assumes surf_fit_hess and surf_fit_gf share the same space
-      const int hess_dim = surf_fit_hess->VectorDim();
-      const int hess_cnt = surf_fit_hess->Size()/hess_dim;
-      if (surf_fit_hess->FESpace()->GetOrdering() == Ordering::byNODES)
-      {
-         for (int d = 0; d < hess_dim; d++)
-         {
-            for (int i = 0; i < cnt; i++)
-            {
-               int dof_index = surf_fit_marker_dof_index[i];
-               (*surf_fit_hess)[dof_index + d*hess_cnt] =
-                  surf_fit_hess_int(i + d*cnt);
-            }
-         }
-      }
-      else
-      {
-         for (int i = 0; i < cnt; i++)
-         {
-            int dof_index = surf_fit_marker_dof_index[i];
-            for (int d = 0; d < hess_dim; d++)
-            {
-               (*surf_fit_hess)[dof_index*hess_dim + d] =
-                  surf_fit_hess_int(i*hess_dim + d);
-            }
-         }
-      }
-
-   }
-   else
-   {
-      surf_fit_eval->ComputeAtNewPosition(new_x, *surf_fit_gf, new_x_ordering);
-      if (surf_fit_eval_grad)
-      {
-         surf_fit_eval_grad->ComputeAtNewPosition(new_x, *surf_fit_grad,
-                                                  new_x_ordering);
-      }
-      if (surf_fit_eval_hess)
-      {
-         surf_fit_eval_hess->ComputeAtNewPosition(new_x, *surf_fit_hess,
-                                                  new_x_ordering);
-      }
-   }
-}
-
 void TMOP_Integrator::
 UpdateAfterMeshPositionChange(const Vector &x_new,
                              const FiniteElementSpace &x_fes)
@@ -4621,11 +4406,112 @@ UpdateAfterMeshPositionChange(const Vector &x_new,
      adapt_lim_eval->ComputeAtNewPosition(x_new, *adapt_lim_gf, ordering);
   }

-   // Update surf_fit_gf (and optionally its gradients) if surface
-   // fitting is enabled.
+   // Update surf_fit_gf if surface fitting is enabled.
   if (surf_fit_gf)
   {
-      RemapSurfaceFittingLevelSetAtNodes(x_new, ordering);
+      if (surf_fit_gf_bg)
+      {
+         // Interpolate information for only DOFs marked for fitting.
+         const int dim = surf_fit_gf->FESpace()->GetMesh()->Dimension();
+         const int cnt = surf_fit_marker_dof_index.Size();
+         const int total_cnt = x_new.Size()/dim;
+         Vector new_x_sorted(cnt*dim);
+         if (ordering == 0)
+         {
+            for (int d = 0; d < dim; d++)
+            {
+               for (int i = 0; i < cnt; i++)
+               {
+                  int dof_index = surf_fit_marker_dof_index[i];
+                  new_x_sorted(i + d*cnt) = x_new(dof_index + d*total_cnt);
+               }
+            }
+         }
+         else
+         {
+            for (int i = 0; i < cnt; i++)
+            {
+               int dof_index = surf_fit_marker_dof_index[i];
+               for (int d = 0; d < dim; d++)
+               {
+                  new_x_sorted(d + i*dim) = x_new(d + dof_index*dim);
+               }
+            }
+         }
+
+         Vector surf_fit_gf_int, surf_fit_grad_int, surf_fit_hess_int;
+         surf_fit_eval->ComputeAtNewPosition(
+            new_x_sorted, surf_fit_gf_int, ordering);
+         for (int i = 0; i < cnt; i++)
+         {
+            int dof_index = surf_fit_marker_dof_index[i];
+            (*surf_fit_gf)[dof_index] = surf_fit_gf_int(i);
+         }
+
+         surf_fit_eval_bg_grad->ComputeAtNewPosition(
+            new_x_sorted, surf_fit_grad_int, ordering);
+         // Assumes surf_fit_grad and surf_fit_gf share the same space
+         const int grad_dim = surf_fit_grad->VectorDim();
+         const int grad_cnt = surf_fit_grad->Size()/grad_dim;
+         if (surf_fit_grad->FESpace()->GetOrdering() == Ordering::byNODES)
+         {
+            for (int d = 0; d < grad_dim; d++)
+            {
+               for (int i = 0; i < cnt; i++)
+               {
+                  int dof_index = surf_fit_marker_dof_index[i];
+                  (*surf_fit_grad)[dof_index + d*grad_cnt] =
+                     surf_fit_grad_int(i + d*cnt);
+               }
+            }
+         }
+         else
+         {
+            for (int i = 0; i < cnt; i++)
+            {
+               int dof_index = surf_fit_marker_dof_index[i];
+               for (int d = 0; d < grad_dim; d++)
+               {
+                  (*surf_fit_grad)[dof_index*dim + d] =
+                     surf_fit_grad_int(i*dim + d);
+               }
+            }
+         }
+
+         surf_fit_eval_bg_hess->ComputeAtNewPosition(
+            new_x_sorted, surf_fit_hess_int, ordering);
+         // Assumes surf_fit_hess and surf_fit_gf share the same space
+         const int hess_dim = surf_fit_hess->VectorDim();
+         const int hess_cnt = surf_fit_hess->Size()/hess_dim;
+         if (surf_fit_hess->FESpace()->GetOrdering() == Ordering::byNODES)
+         {
+            for (int d = 0; d < hess_dim; d++)
+            {
+               for (int i = 0; i < cnt; i++)
+               {
+                  int dof_index = surf_fit_marker_dof_index[i];
+                  (*surf_fit_hess)[dof_index + d*hess_cnt] =
+                     surf_fit_hess_int(i + d*cnt);
+               }
+            }
+         }
+         else
+         {
+            for (int i = 0; i < cnt; i++)
+            {
+               int dof_index = surf_fit_marker_dof_index[i];
+               for (int d = 0; d < hess_dim; d++)
+               {
+                  (*surf_fit_hess)[dof_index*dim + d] =
+                     surf_fit_hess_int(i*dim + d);
+               }
+            }
+         }
+      }
+      else
+      {
+         surf_fit_eval->ComputeAtNewPosition(x_new, *surf_fit_gf, ordering);
+      }
   }
 }

@@ -1784,11 +1784,12 @@ protected:
   // Fitting to given physical positions.
   TMOP_QuadraticLimiter *surf_fit_limiter; // Owned. Created internally.
   const GridFunction *surf_fit_pos;        // Not owned. Positions to fit.
-   real_t surf_fit_normal;                  // Normalization factor.
-   GridFunction *surf_fit_grad, *surf_fit_hess; // Owned. Created internally.
-   AdaptivityEvaluator *surf_fit_eval_grad, *surf_fit_eval_hess; // Not owned.
-   Array<int> surf_fit_dof_count;            // Number of dofs per node.
-   Array<int> surf_fit_marker_dof_index;     // Indices of nodes to fit.
+   real_t surf_fit_normal;
+   bool surf_fit_gf_bg;
+   GridFunction *surf_fit_grad, *surf_fit_hess;
+   AdaptivityEvaluator *surf_fit_eval_bg_grad, *surf_fit_eval_bg_hess;
+   Array<int> surf_fit_dof_count;
+   Array<int> surf_fit_marker_dof_index;

   DiscreteAdaptTC *discr_tc;

@@ -1984,10 +1985,6 @@ protected:
   real_t ComputeUntanglerMaxMuBarrier(const Vector &x,
                                       const FiniteElementSpace &fes);

-   // Remaps the internal surface fitting gridfunction object at provided
-   // locations.
-   void RemapSurfaceFittingLevelSetAtNodes(const Vector &new_x,
-                                           int new_x_ordering);
 public:
   /** @param[in] m    TMOP_QualityMetric for r-adaptivity (not owned).
       @param[in] tc   Target-matrix construction algorithm to use (not owned).
@@ -2003,8 +2000,9 @@ public:
        surf_fit_marker(NULL), surf_fit_coeff(NULL),
        surf_fit_gf(NULL), surf_fit_eval(NULL),
        surf_fit_limiter(NULL), surf_fit_pos(NULL),
-        surf_fit_normal(1.0), surf_fit_grad(NULL), surf_fit_hess(NULL),
-        surf_fit_eval_grad(NULL), surf_fit_eval_hess(NULL),
+        surf_fit_normal(1.0),
+        surf_fit_gf_bg(false), surf_fit_grad(NULL), surf_fit_hess(NULL),
+        surf_fit_eval_bg_grad(NULL), surf_fit_eval_bg_hess(NULL),
        discr_tc(dynamic_cast<DiscreteAdaptTC *>(tc)),
        fdflag(false), dxscale(1.0e3), fd_call_flag(false), exact_action(false)
   { PA.enabled = false; }
@@ -2105,15 +2103,9 @@ public:

 #ifdef MFEM_USE_MPI
   /// Parallel support for surface fitting to the zero level set of a function.
-   /// Here, we add two optional inputs: @a aegrad and @a aehess. When provided,
-   /// the first and second derivative of the input level set are computed on
-   /// the initial mesh, and @a aegrad and @a aehess are used to remap grad_s(x)
-   /// from grad_s0(x0) and hess_s(x) from hess_s0(x0), respectively.
   void EnableSurfaceFitting(const ParGridFunction &s0,
                             const Array<bool> &smarker, Coefficient &coeff,
-                             AdaptivityEvaluator &ae,
-                             AdaptivityEvaluator *aegrad = NULL,
-                             AdaptivityEvaluator *aehess = NULL);
+                             AdaptivityEvaluator &ae);

   /** @brief Fitting of certain DOFs in the current mesh to the zero level set
       of a function defined on another (finer) source mesh.
@@ -429,13 +429,11 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,
 #endif

   real_t scale = 1.0;
-   bool fitting = IsSurfaceFittingEnabled();
-   real_t init_fit_avg_err, init_fit_max_err = 0.0;
-   if (fitting && surf_fit_converge_error)
+   real_t avg_surf_fit_err, max_surf_fit_err = 0.0;
+   if (surf_fit_max_threshold > 0.0)
   {
-      GetSurfaceFittingError(x_out_loc, init_fit_avg_err, init_fit_max_err);
-      // Check for convergence
-      if (init_fit_max_err < surf_fit_max_err_limit)
+      GetSurfaceFittingError(x_out_loc, avg_surf_fit_err, max_surf_fit_err);
+      if (max_surf_fit_err < surf_fit_max_threshold)
      {
         if (print_options.iterations)
         {
@@ -446,12 +444,11 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,
         return scale;
      }
   }
-
-   if (surf_fit_adapt_count >= surf_fit_adapt_count_limit)
+   if (adapt_inc_count >= max_adapt_inc_count)
   {
      if (print_options.iterations)
      {
-         mfem::out << "TMOPNewtonSolver terminated "
+         mfem::out << "TMOPNewtonSolver converged "
                   "based on max number of times surface fitting weight can"
                   "be increased. \n";
      }
@@ -470,7 +467,7 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,
      // reference to detect deteriorations.
      MFEM_VERIFY(min_det_ptr != NULL, " Initial mesh was valid, but"
                  " intermediate mesh is invalid. Contact TMOP Developers.");
-      MFEM_VERIFY(min_detJ_limit == 0.0,
+      MFEM_VERIFY(min_detJ_threshold == 0.0,
                  "This setup is not supported. Contact TMOP Developers.");
      *min_det_ptr = untangle_factor * min_detT_in;
   }
@@ -481,7 +478,6 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,
   bool x_out_ok = false;
   real_t energy_out = 0.0, min_detT_out;
   const real_t norm_in = Norm(r);
-   real_t avg_fit_err, max_fit_err = 0.0;

   const real_t detJ_factor = (solver_type == 1) ? 0.25 : 0.5;
   compute_metric_quantile_flag = false;
@@ -492,9 +488,6 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,
   // Perform the line search.
   for (int i = 0; i < 12; i++)
   {
-      avg_fit_err = 0.0;
-      max_fit_err = 0.0;
-
      // Update the mesh and get the L-vector in x_out_loc.
      add(x, -scale, c, x_out);
      if (serial)
@@ -509,7 +502,7 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,

      // Check the changes in detJ.
      min_detT_out = ComputeMinDet(x_out_loc, *fes);
-      if (untangling == false && min_detT_out <= min_detJ_limit)
+      if (untangling == false && min_detT_out <= min_detJ_threshold)
      {
         // No untangling, and detJ got negative (or small) -- no good.
         if (print_options.iterations)
@@ -536,19 +529,18 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,
      // Check the changes in total energy.
      ProcessNewState(x_out);

-      // Ensure sufficient decrease in fitting error if we are trying to
-      // converge based on error.
-      if (fitting && surf_fit_converge_error)
+      real_t avg_fit_err, max_fit_err = 0.0;
+      if (surf_fit_max_threshold > 0.0)
      {
         GetSurfaceFittingError(x_out_loc, avg_fit_err, max_fit_err);
-         if (max_fit_err >= 1.2*init_fit_max_err)
+      }
+      if (surf_fit_max_threshold > 0.0 && max_fit_err >= 1.2*max_surf_fit_err)
+      {
+         if (print_options.iterations)
         {
-            if (print_options.iterations)
-            {
-               mfem::out << "Scale = " << scale << " Surf fit err increased.\n";
-            }
-            scale *= 0.5; continue;
+            mfem::out << "Scale = " << scale << " Surf fit err increased.\n";
         }
+         scale *= 0.5; continue;
      }

      if (serial)
@@ -622,7 +614,7 @@ real_t TMOPNewtonSolver::ComputeScalingFactor(const Vector &x,

   if (x_out_ok == false) { scale = 0.0; }

-   if (surf_fit_scale_factor > 0.0) { surf_fit_coeff_update = true; }
+   if (surf_fit_scale_factor > 0.0) { update_surf_fit_coeff = true; }
   compute_metric_quantile_flag = true;

   return scale;
@@ -665,7 +657,7 @@ void TMOPNewtonSolver::GetSurfaceFittingWeight(Array<real_t> &weights) const
   for (int i = 0; i < integs.Size(); i++)
   {
      ti = dynamic_cast<TMOP_Integrator *>(integs[i]);
-      if (ti && ti->IsSurfaceFittingEnabled())
+      if (ti)
      {
         weight = ti->GetSurfaceFittingWeight();
         weights.Append(weight);
@@ -676,11 +668,8 @@ void TMOPNewtonSolver::GetSurfaceFittingWeight(Array<real_t> &weights) const
         Array<TMOP_Integrator *> ati = co->GetTMOPIntegrators();
         for (int j = 0; j < ati.Size(); j++)
         {
-            if (ati[j]->IsSurfaceFittingEnabled())
-            {
-               weight = ati[j]->GetSurfaceFittingWeight();
-               weights.Append(weight);
-            }
+            weight = ati[j]->GetSurfaceFittingWeight();
+            weights.Append(weight);
         }
      }
   }
@@ -727,39 +716,6 @@ void TMOPNewtonSolver::GetSurfaceFittingError(const Vector &x_loc,
   }
 }

-bool TMOPNewtonSolver::IsSurfaceFittingEnabled() const
-{
-   const NonlinearForm *nlf = dynamic_cast<const NonlinearForm *>(oper);
-   const Array<NonlinearFormIntegrator*> &integs = *nlf->GetDNFI();
-   TMOP_Integrator *ti  = NULL;
-   TMOPComboIntegrator *co = NULL;
-
-   for (int i = 0; i < integs.Size(); i++)
-   {
-      ti = dynamic_cast<TMOP_Integrator *>(integs[i]);
-      if (ti)
-      {
-         if (ti->IsSurfaceFittingEnabled())
-         {
-            return true;
-         }
-      }
-      co = dynamic_cast<TMOPComboIntegrator *>(integs[i]);
-      if (co)
-      {
-         Array<TMOP_Integrator *> ati = co->GetTMOPIntegrators();
-         for (int j = 0; j < ati.Size(); j++)
-         {
-            if (ati[j]->IsSurfaceFittingEnabled())
-            {
-               return true;
-            }
-         }
-      }
-   }
-   return false;
-}
-
 void TMOPNewtonSolver::ProcessNewState(const Vector &x) const
 {
   const NonlinearForm *nlf = dynamic_cast<const NonlinearForm *>(oper);
@@ -845,46 +801,38 @@ void TMOPNewtonSolver::ProcessNewState(const Vector &x) const
   // adaptive surface fitting is enabled. The idea is to increase the
   // coefficient if the surface fitting error does not sufficiently
   // decrease between subsequent TMOPNewtonSolver iterations.
-   if (surf_fit_coeff_update)
+   if (update_surf_fit_coeff)
   {
      // Get surface fitting errors.
-      GetSurfaceFittingError(x_loc, surf_fit_avg_err, surf_fit_max_err);
+      GetSurfaceFittingError(x_loc, surf_fit_err_avg, surf_fit_err_max);
      // Get array with surface fitting weights.
-      Array<real_t> fitweights;
-      GetSurfaceFittingWeight(fitweights);
+      Array<real_t> weights;
+      GetSurfaceFittingWeight(weights);

      if (print_options.iterations)
      {
         mfem::out << "Avg/Max surface fitting error: " <<
-                   surf_fit_avg_err << " " <<
-                   surf_fit_max_err << "\n";
+                   surf_fit_err_avg << " " <<
+                   surf_fit_err_max << "\n";
         mfem::out << "Min/Max surface fitting weight: " <<
-                   fitweights.Min() << " " << fitweights.Max() << "\n";
+                   weights.Min() << " " << weights.Max() << "\n";
      }

-      real_t change_surf_fit_err = surf_fit_avg_err_prvs-surf_fit_avg_err;
-      real_t rel_change_surf_fit_err = change_surf_fit_err/surf_fit_avg_err_prvs;
-
+      real_t change_surf_fit_err = surf_fit_err_avg_prvs-surf_fit_err_avg;
+      real_t rel_change_surf_fit_err = change_surf_fit_err/surf_fit_err_avg_prvs;
      // Increase the surface fitting coefficient if the surface fitting error
-      // does not decrease sufficiently. If we are converging based on residual,
-      // also make sure we have not reached the maximum fitting weight and
-      // error threshold.
-      if (rel_change_surf_fit_err < surf_fit_err_rel_change_limit &&
-          (surf_fit_converge_error ||
-           (fitweights.Max() < surf_fit_weight_limit &&
-            surf_fit_max_err > surf_fit_max_err_limit)))
+      // does not decrease sufficiently.
+      if (rel_change_surf_fit_err < surf_fit_rel_change_threshold)
      {
-         real_t scale_factor = std::min(surf_fit_scale_factor,
-                                        surf_fit_weight_limit/fitweights.Max());
-         UpdateSurfaceFittingWeight(scale_factor);
-         surf_fit_adapt_count += 1;
+         UpdateSurfaceFittingWeight(surf_fit_scale_factor);
+         adapt_inc_count += 1;
      }
      else
      {
-         surf_fit_adapt_count = 0;
+         adapt_inc_count = 0;
      }
-      surf_fit_avg_err_prvs = surf_fit_avg_err;
-      surf_fit_coeff_update = false;
+      surf_fit_err_avg_prvs = surf_fit_err_avg;
+      update_surf_fit_coeff = false;
   }
 }

@@ -134,20 +134,18 @@ protected:
   int solver_type;
   bool parallel;

-   // Line search step is rejected if min(detJ) <= min_detJ_limit.
-   real_t min_detJ_limit = 0.0;
+   // Line search step is rejected if min(detJ) <= min_detJ_threshold.
+   real_t min_detJ_threshold = 0.0;

   // Surface fitting variables.
-   mutable real_t surf_fit_avg_err_prvs = 10000.0;
-   mutable real_t surf_fit_avg_err, surf_fit_max_err;
-   mutable bool surf_fit_coeff_update = false;
-   real_t surf_fit_max_err_limit = -1.0;
-   real_t surf_fit_err_rel_change_limit = 0.001;
+   mutable real_t surf_fit_err_avg_prvs = 10000.0;
+   mutable real_t surf_fit_err_avg, surf_fit_err_max;
+   mutable bool update_surf_fit_coeff = false;
+   real_t surf_fit_max_threshold = -1.0;
+   real_t surf_fit_rel_change_threshold = 0.001;
   real_t surf_fit_scale_factor = 0.0;
-   mutable int surf_fit_adapt_count = 0;
-   mutable int surf_fit_adapt_count_limit = 10;
-   mutable real_t surf_fit_weight_limit = 1e10;
-   bool surf_fit_converge_error = false;
+   mutable int adapt_inc_count = 0;
+   mutable int max_adapt_inc_count = 10;

   // Minimum determinant over the whole mesh. Used for mesh untangling.
   real_t *min_det_ptr = nullptr;
@@ -193,9 +191,6 @@ protected:
   void GetSurfaceFittingWeight(Array<real_t> &weights) const;
   ///@}

-   /// Check if surface fitting is enabled.
-   bool IsSurfaceFittingEnabled() const;
-
 public:
 #ifdef MFEM_USE_MPI
   TMOPNewtonSolver(MPI_Comm comm, const IntegrationRule &irule, int type = 0)
@@ -229,94 +224,38 @@ public:
   /// (ii) surface fitting weight.
   virtual void ProcessNewState(const Vector &x) const;

-   /** @name Methods for adaptive surface fitting.
-       \brief These methods control the behavior of the weight and the
-       termination of the solver. (Experimental)
-
-       Adaptive fitting weight: The weight is modified after each
-       TMOPNewtonSolver iteration as:
-       w_{k+1} = w_{k} * \ref surf_fit_scale_factor if the relative
-       change in average fitting error < \ref surf_fit_err_rel_change_limit.
-       When converging based on the residual, we enforce the fitting weight
-       to be at-most \ref surf_fit_weight_limit, and increase it only if the
-       fitting error is below user prescribed threshold
-       (\ref surf_fit_max_err_limit).
-       See \ref SetAdaptiveSurfaceFittingScalingFactor and
-       \ref SetAdaptiveSurfaceFittingRelativeChangeThreshold.
-
-       Note that the solver stops if the maximum surface fitting error
-       does not sufficiently decrease for \ref surf_fit_adapt_count_limit (default 10)
-       consecutive increments of the fitting weight during weight adaptation.
-       This typically occurs when the mesh cannot align with the level-set
-       without degrading element quality.
-       See \ref SetMaxNumberofIncrementsForAdaptiveFitting.
-
-       Convergence criterion: There are two modes, residual- and error-based,
-       which can be toggled using \ref SetSurfaceFittingConvergenceBasedOnError.
-
-       (i) Residual based (default): Stop when the norm of the gradient of the
-       TMOP objective reaches the prescribed tolerance. This method is best used
-       with a reasonable value for \ref surf_fit_weight_limit when the
-       adaptive surface fitting scheme is used. See method
-       \ref SetSurfaceFittingWeightLimit.
-
-       (ii) Error based: Stop when the maximum fitting error
-       reaches the user-prescribed threshold, \ref surf_fit_max_err_limit.
-       In this case, \ref surf_fit_weight_limit is ignored during weight
-       adaptation.
-   */
-   ///@{
+   /** @name Methods for adaptive surface fitting weight. (Experimental) */
+   /// Enable/Disable adaptive surface fitting weight.
+   /// The weight is modified after each TMOPNewtonSolver iteration as:
+   /// w_{k+1} = w_{k} * @a surf_fit_scale_factor if relative change in
+   /// max surface fitting error < @a surf_fit_rel_change_threshold.
+   /// The solver terminates if the maximum surface fitting error does
+   /// not sufficiently decrease for @a max_adapt_inc_count consecutive
+   /// solver iterations or if the max error falls below @a surf_fit_max_threshold.
+   void EnableAdaptiveSurfaceFitting()
+   {
+      surf_fit_scale_factor = 10.0;
+      surf_fit_rel_change_threshold = 0.001;
+   }
   void SetAdaptiveSurfaceFittingScalingFactor(real_t factor)
   {
-      MFEM_VERIFY(factor > 1.0, "Scaling factor must be greater than 1.");
      surf_fit_scale_factor = factor;
   }
   void SetAdaptiveSurfaceFittingRelativeChangeThreshold(real_t threshold)
   {
-      surf_fit_err_rel_change_limit = threshold;
+      surf_fit_rel_change_threshold = threshold;
   }
-   /// Used for stopping based on the number of consecutive failed weight
-   /// adaptation iterations.
-   // TODO: Rename to SetMaxNumberofIncrementsForAdaptiveSurfaceFitting
-   // in future.
   void SetMaxNumberofIncrementsForAdaptiveFitting(int count)
   {
-      surf_fit_adapt_count_limit = count;
+      max_adapt_inc_count = count;
   }
-   /// Used for error-based surface fitting termination.
   void SetTerminationWithMaxSurfaceFittingError(real_t max_error)
   {
-      surf_fit_max_err_limit = max_error;
-      surf_fit_converge_error = true;
+      surf_fit_max_threshold = max_error;
   }
-   /// Could be used with both error-based or residual-based convergence.
-   void SetSurfaceFittingMaxErrorLimit(real_t max_error)
-   {
-      surf_fit_max_err_limit = max_error;
-   }
-   /// Used for residual-based surface fitting termination.
-   void SetSurfaceFittingWeightLimit(real_t weight)
-   {
-      surf_fit_weight_limit = weight;
-   }
-   /// Toggle convergence based on residual or error.
-   void SetSurfaceFittingConvergenceBasedOnError(bool mode)
-   {
-      surf_fit_converge_error = mode;
-      if (surf_fit_converge_error)
-      {
-         MFEM_VERIFY(surf_fit_max_err_limit >= 0,
-                     "Fitting error based convergence requires the user to "
-                     "first set the error threshold."
-                     "See SetTerminationWithMaxSurfaceFittingError");
-      }
-   }
-   ///@}
-
-   /// Set minimum determinant enforced during line-search.
   void SetMinimumDeterminantThreshold(real_t threshold)
   {
-      min_detJ_limit = threshold;
+      min_detJ_threshold = threshold;
   }

   virtual void Mult(const Vector &b, Vector &x) const
@@ -39,22 +39,12 @@ struct Hashed4
   int next;
 };

-/** A concept for items that should be used in HashTable and be accessible by
- *  hashing 5 IDs. temporary workaround for 4D (need a structure where all 4 ids a stored)
- */
-struct Hashed5
-{
-   int p1, p2, p3, p4; // NOTE: p5 is not hashed nor stored
-   int next;
-};
-

 /** HashTable is a container for items that require associative access through
 *  pairs (or quadruples) of indices:
 *
 *    (p1, p2) -> item
 *    (p1, p2, p3, p4) -> item
- *    (p1, p2, p3, p4, p5) -> item
 *
 *  An example of this are edges and faces in a mesh. Each edge is uniquely
 *  identified by two parent vertices and so can be easily accessed from
@@ -130,7 +120,6 @@ public:

      @warning This method should only be called if T inherits from Hashed4. */
   T* Get(int p1, int p2, int p3, int p4 = -1 /* p4 optional */);
-   T* Get(int p1, int p2, int p3, int p4, int p5);

   /// Get id of item whose parents are p1, p2... Create it if it doesn't exist.
   /** @brief Get the "id" of an item, this "id" corresponding to the index of the
@@ -156,7 +145,6 @@ public:

       @warning This method should only be called if T inherits from Hashed4. */
   int GetId(int p1, int p2, int p3, int p4 = -1);
-   int GetId(int p1, int p2, int p3, int p4, int p5);

   /// Find item whose parents are p1, p2... Return NULL if it doesn't exist.
   /** @brief Item accessor with key (or parents) the pair 'p1', 'p2'. Return
@@ -181,7 +169,6 @@ public:

       @warning This method should only be called if T inherits from Hashed4. */
   T* Find(int p1, int p2, int p3, int p4 = -1);
-   T* Find(int p1, int p2, int p3, int p4, int p5);

   /** @brief Item const accessor with key (or parents) the pair 'p1', 'p2'.
       Return nullptr if no value correspond to the requested key.
@@ -205,7 +192,6 @@ public:

       @warning This method should only be called if T inherits from Hashed4. */
   const T* Find(int p1, int p2, int p3, int p4 = -1) const;
-   const T* Find(int p1, int p2, int p3, int p4, int p5) const;

   /// Find id of item whose parents are p1, p2... Return -1 if it doesn't exist.
   /** @brief Find the "id" of an item, this "id" corresponding to the index of
@@ -231,7 +217,6 @@ public:

       @warning This method should only be called if T inherits from Hashed4. */
   int FindId(int p1, int p2, int p3, int p4 = -1) const;
-   int FindId(int p1, int p2, int p3, int p4, int p5) const;

   /// @brief Return the number of elements currently stored in the HashTable.
   int Size() const { return Base::Size() - unused.Size(); }
@@ -298,8 +283,6 @@ public:

       @warning This method should only be called if T inherits from Hashed4. */
   void Reparent(int id, int new_p1, int new_p2, int new_p3, int new_p4 = -1);
-   void Reparent(int id, int new_p1, int new_p2, int new_p3, int new_p4,
-                 int new_p5);

   /// @brief Return total size of allocated memory (tables plus items), in bytes.
   std::size_t MemoryUsage() const;
@@ -397,9 +380,6 @@ protected:
   inline int Hash(size_t p1, size_t p2, size_t p3) const
   { return (984120265ul*p1 + 125965121ul*p2 + 495698413ul*p3) & mask; }

-   inline int Hash(int p1, int p2, int p3, int p4) const
-   { return (984120265*p1 + 125965121*p2 + 495698413*p3 + 179424673*p4) & mask; }
-
   // Delete() and Reparent() use one of these:
   /// @brief Hash function for items of type T that inherit from Hashed2.
   inline int Hash(const Hashed2& item) const
@@ -409,9 +389,6 @@ protected:
   inline int Hash(const Hashed4& item) const
   { return Hash(item.p1, item.p2, item.p3); }

-   inline int Hash(const Hashed5& item) const
-   { return Hash(item.p1, item.p2, item.p3, item.p4); };
-
   /** @brief Search the index of the item associated to the key (p1,p2)
       starting from the item with index @a id.

@@ -434,7 +411,6 @@ protected:

       @warning This method should only be called if T inherits from Hashed4. */
   int SearchList(int id, int p1, int p2, int p3) const;
-   int SearchList(int id, int p1, int p2, int p3, int p4) const;

   /** @brief Insert the item 'id' into bin 'idx'.

@@ -605,17 +581,6 @@ inline void sort4(int &a, int &b, int &c, int &d)
   sort3(b, c, d);
 }

-inline void sort5(int &a, int &b, int &c, int &d, int &e)
-{
-   sort4(a,b,c,d);
-   sort4(b,c,d,e);
-
-   if (a > b)
-   {
-      int t = a; a = b; b = t;
-   }
-}
-
 inline void sort4_ext(int &a, int &b, int &c, int &d)
 {
   if (d < 0) // support optional last index
@@ -642,12 +607,6 @@ inline T* HashTable<T>::Get(int p1, int p2, int p3, int p4)
   return &(Base::At(GetId(p1, p2, p3, p4)));
 }

-template<typename T>
-inline T* HashTable<T>::Get(int p1, int p2, int p3, int p4, int p5)
-{
-   return &(Base::At(GetId(p1, p2, p3, p4, p5)));
-}
-
 template<typename T>
 int HashTable<T>::GetId(int p1, int p2)
 {
@@ -711,39 +670,6 @@ int HashTable<T>::GetId(int p1, int p2, int p3, int p4)
   return new_id;
 }

-template<typename T>
-int HashTable<T>::GetId(int p1, int p2, int p3, int p4, int p5)
-{
-   // search for the item in the hashtable
-   internal::sort5(p1, p2, p3, p4, p5);
-   int idx = Hash(p1, p2, p3, p4);
-   int id = SearchList(table[idx], p1, p2, p3, p4);
-   if (id >= 0) { return id; }
-
-   // not found - use an unused item or create a new one
-   int new_id;
-   if (unused.Size())
-   {
-      new_id = unused.Last();
-      unused.DeleteLast();
-   }
-   else
-   {
-      new_id = Base::Append();
-   }
-   T& item = Base::At(new_id);
-   item.p1 = p1;
-   item.p2 = p2;
-   item.p3 = p3;
-   item.p4 = p4;
-
-   // insert into hashtable
-   Insert(idx, new_id, item);
-   CheckRehash();
-
-   return new_id;
-}
-
 template<typename T>
 inline T* HashTable<T>::Find(int p1, int p2)
 {
@@ -758,13 +684,6 @@ inline T* HashTable<T>::Find(int p1, int p2, int p3, int p4)
   return (id >= 0) ? &(Base::At(id)) : NULL;
 }

-template<typename T>
-inline T* HashTable<T>::Find(int p1, int p2, int p3, int p4, int p5)
-{
-   int id = FindId(p1, p2, p3, p4, p5);
-   return (id >= 0) ? &(Base::At(id)) : NULL;
-}
-
 template<typename T>
 inline const T* HashTable<T>::Find(int p1, int p2) const
 {
@@ -779,13 +698,6 @@ inline const T* HashTable<T>::Find(int p1, int p2, int p3, int p4) const
   return (id >= 0) ? &(Base::At(id)) : NULL;
 }

-template<typename T>
-inline const T* HashTable<T>::Find(int p1, int p2, int p3, int p4, int p5) const
-{
-   int id = FindId(p1, p2, p3, p4, p5);
-   return (id >= 0) ? &(Base::At(id)) : NULL;
-}
-
 template<typename T>
 int HashTable<T>::FindId(int p1, int p2) const
 {
@@ -800,13 +712,6 @@ int HashTable<T>::FindId(int p1, int p2, int p3, int p4) const
   return SearchList(table[Hash(p1, p2, p3)], p1, p2, p3);
 }

-template<typename T>
-int HashTable<T>::FindId(int p1, int p2, int p3, int p4, int p5) const
-{
-   internal::sort5(p1, p2, p3, p4, p5);
-   return SearchList(table[Hash(p1, p2, p3, p4)], p1, p2, p3, p4);
-}
-
 template<typename T>
 int HashTable<T>::SearchList(int id, int p1, int p2) const
 {
@@ -831,18 +736,6 @@ int HashTable<T>::SearchList(int id, int p1, int p2, int p3) const
   return -1;
 }

-template<typename T>
-int HashTable<T>::SearchList(int id, int p1, int p2, int p3, int p4) const
-{
-   while (id >= 0)
-   {
-      const T& item = Base::At(id);
-      if (item.p1 == p1 && item.p2 == p2 && item.p3 == p3 && item.p4 == p4) { return id; }
-      id = item.next;
-   }
-   return -1;
-}
-
 template<typename T>
 inline void HashTable<T>::CheckRehash()
 {
@@ -984,24 +877,6 @@ void HashTable<T>::Reparent(int id,
   Insert(new_idx, id, item);
 }

-template<typename T>
-void HashTable<T>::Reparent(int id,
-                            int new_p1, int new_p2, int new_p3, int new_p4, int new_p5)
-{
-   T& item = Base::At(id);
-   Unlink(Hash(item), id);
-
-   internal::sort5(new_p1, new_p2, new_p3, new_p4, new_p5);
-   item.p1 = new_p1;
-   item.p2 = new_p2;
-   item.p3 = new_p3;
-   item.p4 = new_p4;
-
-   // reinsert under new parent IDs
-   int new_idx = Hash(new_p1, new_p2, new_p3, new_p4);
-   Insert(new_idx, id, item);
-}
-
 template<typename T>
 std::size_t HashTable<T>::MemoryUsage() const
 {
@@ -51,7 +51,7 @@ int isockstream::establish()
 {
   // char myname[129];
   char   myname[] = "localhost";
-   int    sfd = -1;
+   int    sfd;
   struct addrinfo hints, *res, *rp;

   memset(&hints, 0, sizeof(hints));
@@ -134,7 +134,7 @@ int socketbuf::open(const char hostname[], int port)
      {
         closesocket(socket_descriptor);
         socket_descriptor = -2;
-         continue;
+         return -1;
      }
 #endif

@@ -148,7 +148,7 @@ int socketbuf::open(const char hostname[], int port)
   }

   freeaddrinfo(res);
-   return (socket_descriptor < 0) ? -1 : 0;
+   return 0;
 }

 int socketbuf::close()
@@ -10,7 +10,6 @@
 // CONTRIBUTING.md for details.


-#include <iostream>
 #include "error.hpp"
 #include "stable3d.hpp"

@@ -32,6 +31,36 @@ STable3D::STable3D (int nr)
   NElem = 0;
 }

+inline void Sort3 (int &r, int &c, int &f)
+{
+   int t;
+
+   if (r > c)
+      if (c > f)
+      {
+         t = r;  r = f;  f = t;  //  (r,c,f) --> (f,c,r)
+      }
+      else if (r > f)
+      {
+         t = r;  r = c;  c = f;  f = t;  //  (r,c,f) --> (c,f,r)
+      }
+      else
+      {
+         t = r;  r = c;  c = t;  //  (r,c,f) --> (c,r,f)
+      }
+   else if (c > f)
+   {
+      if (r > f)
+      {
+         t = f;  f = c;  c = r;  r = t;  //  (r,c,f) --> (f,r,c)
+      }
+      else
+      {
+         t = c;  c = f;  f = t;  //  (r,c,f) --> (r,f,c)
+      }
+   }
+}
+
 int STable3D::Push (int r, int c, int f)
 {
   STable3DNode *node;
@@ -196,250 +225,4 @@ void STable3D::Print(std::ostream & os) const
   }
 }

-STable4D::STable4D (int nr)
-{
-   int i;
-
-   Size = nr;
-   Rows = new STable4DNode *[nr];
-   for (i = 0; i < nr; i++)
-   {
-      Rows[i] = NULL;
-   }
-   NElem = 0;
-}
-
-
-int STable4D::Push (int r, int c, int f, int t)
-{
-   STable4DNode *node;
-
-   MFEM_ASSERT(r != c && c != f && f != r && r!=t && c!=t && f!=t,
-               "STable4D::Push : r = " << r << ", c = " << c << ", f = " << f << ", t = " <<
-               t);
-
-   Sort4(r, c, f, t);
-
-   for (node = Rows[r]; node != NULL; node = node->Prev)
-   {
-      if (node->Column == c)
-         if (node->Floor == f)
-            if (node->Trace == t)
-            {
-               return node->Number;
-            }
-   }
-
-#ifdef MFEM_USE_MEMALLOC
-   node = NodesMem.Alloc ();
-#else
-   node = new STable4DNode;
-#endif
-   node->Column = c;
-   node->Floor  = f;
-   node->Trace = t;
-   node->Number = NElem;
-   node->Prev   = Rows[r];
-   Rows[r] = node;
-
-   NElem++;
-   return (NElem-1);
-}
-
-int STable4D::operator() (int r, int c, int f, int t) const
-{
-   STable4DNode *node;
-
-   Sort4(r, c, f, t);
-
-   for (node = Rows[r]; node != NULL; node = node->Prev)
-   {
-      if (node->Column == c)
-         if (node->Floor == f)
-            if (node->Trace == t)
-            {
-               return node->Number;
-            }
-   }
-
-   MFEM_ABORT("STable4D::operator(): (r,c,f,t) = (" << r << "," << c << "," << f <<
-              "," << t <<")");
-
-   return -1;
-}
-
-int STable4D::Index (int r, int c, int f, int t) const
-{
-   STable4DNode *node;
-
-   Sort4(r, c, f, t);
-
-   for (node = Rows[r]; node != NULL; node = node->Prev)
-   {
-      if (node->Column == c)
-         if (node->Floor == f)
-            if (node->Trace == t)
-            {
-               return node->Number;
-            }
-   }
-
-   return -1;
-}
-
-
-STable4D::~STable4D ()
-{
-#ifdef MFEM_USE_MEMALLOC
-   // NodesMem.Clear();  // this is done implicitly
-#else
-   for (int i = 0; i < Size; i++)
-   {
-      STable4DNode *aux, *node_p = Rows[i];
-      while (node_p != NULL)
-      {
-         aux = node_p;
-         node_p = node_p->Prev;
-         delete aux;
-      }
-   }
-#endif
-   delete [] Rows;
-}
-
-
-
-
-STable5D::STable5D (int nr)
-{
-   int i;
-
-   Size = nr;
-   Rows = new STable5DNode *[nr];
-   for (i = 0; i < nr; i++)
-   {
-      Rows[i] = NULL;
-   }
-   NElem = 0;
-}
-
-
-int STable5D::Push (int r, int c, int f, int t, int u)
-{
-   STable5DNode *node;
-
-   MFEM_ASSERT(r != c && c != f && f != r && r!=t && c!=t && f!=t && r!=u &&
-               c!=u && f!=u && t!=u,
-               "STable5D::Push : r = " << r << ", c = " << c << ", f = " << f << ", t = " << t
-               << ", u = " << u);
-
-   Sort5(r, c, f, t, u);
-
-   for (node = Rows[r]; node != NULL; node = node->Prev)
-   {
-      if (node->Column == c)
-         if (node->Floor == f)
-            if (node->Trace == t)
-               if (node->Next == u)
-               {
-                  return node->Number;
-               }
-   }
-
-#ifdef MFEM_USE_MEMALLOC
-   node = NodesMem.Alloc ();
-#else
-   node = new STable5DNode;
-#endif
-   node->Column = c;
-   node->Floor  = f;
-   node->Trace = t;
-   node->Next = u;
-   node->Number = NElem;
-   node->Prev   = Rows[r];
-   Rows[r] = node;
-
-   NElem++;
-   return (NElem-1);
-}
-
-int STable5D::operator() (int r, int c, int f, int t, int u) const
-{
-   STable5DNode *node;
-
-   Sort5(r, c, f, t, u);
-
-   for (node = Rows[r]; node != NULL; node = node->Prev)
-   {
-      if (node->Column == c)
-         if (node->Floor == f)
-            if (node->Trace == t)
-               if (node->Next == u)
-               {
-                  return node->Number;
-               }
-   }
-
-   MFEM_ABORT("STable4D::operator(): (r,c,f,t,u) = (" << r << "," << c << "," << f
-              << "," << t << "," << u <<")");
-
-   return 0;
-}
-
-int STable5D::Index (int r, int c, int f, int t, int u) const
-{
-   STable5DNode *node;
-
-   Sort5(r, c, f, t, u);
-
-   for (node = Rows[r]; node != NULL; node = node->Prev)
-   {
-      if (node->Column == c)
-         if (node->Floor == f)
-            if (node->Trace == t)
-            {
-               return node->Number;
-            }
-   }
-
-   return -1;
-}
-
-int STable5D::Push8 (int u1, int u2, int u3, int u4, int u5, int u6, int u7,
-                     int u8)
-{
-   Sort8(u1, u2, u3, u4, u5, u6, u7, u8);
-
-   return (*this).Push(u1,u2,u3,u4,u5);
-}
-
-int STable5D::operator() (int u1, int u2, int u3, int u4, int u5, int u6,
-                          int u7, int u8) const
-{
-   Sort8(u1, u2, u3, u4, u5, u6, u7, u8);
-
-   return (*this)(u1,u2,u3,u4,u5);
-}
-
-
-STable5D::~STable5D ()
-{
-#ifdef MFEM_USE_MEMALLOC
-   // NodesMem.Clear();  // this is done implicitly
-#else
-   for (int i = 0; i < Size; i++)
-   {
-      STable5DNode *aux, *node_p = Rows[i];
-      while (node_p != NULL)
-      {
-         aux = node_p;
-         node_p = node_p->Prev;
-         delete aux;
-      }
-   }
-#endif
-   delete [] Rows;
-}
-
-
 }
@@ -75,165 +75,6 @@ public:
   ~STable3D ();
 };

-
-class STable4DNode
-{
-public:
-   STable4DNode *Prev;
-   int Column, Floor, Trace, Number;
-};
-
-
-/// Symmetric 4D Table
-class STable4D
-{
-private:
-   int Size, NElem;
-   STable4DNode **Rows;
-
-#ifdef MFEM_USE_MEMALLOC
-   MemAlloc <STable4DNode, 1024> NodesMem;
-#endif
-
-public:
-   explicit STable4D (int nr);
-
-   int Push (int r, int c, int f, int t);
-
-   int operator() (int r, int c, int f, int t) const;
-
-   int Index (int r, int c, int f, int t) const;
-
-   int NumberOfElements() { return NElem; };
-
-   ~STable4D ();
-};
-
-
-
-class STable5DNode
-{
-public:
-   STable5DNode *Prev;
-   int Column, Floor, Trace, Next, Number;
-};
-
-/// Symmetric 5D Table
-class STable5D
-{
-private:
-   int Size, NElem;
-   STable5DNode **Rows;
-
-#ifdef MFEM_USE_MEMALLOC
-   MemAlloc <STable5DNode, 1024> NodesMem;
-#endif
-
-public:
-   explicit STable5D (int nr);
-
-   int Push (int r, int c, int f, int t, int u);
-
-   int operator() (int r, int c, int f, int t, int u) const;
-
-   int Index (int r, int c, int f, int t, int u) const;
-
-   int Push8 (int u1, int u2, int u3, int u4, int u5, int u6, int u7, int u8);
-   int operator() (int u1, int u2, int u3, int u4, int u5, int u6, int u7,
-                   int u8) const;
-
-   int NumberOfElements() { return NElem; };
-
-   ~STable5D ();
-};
-
-
-inline void Sort3 (int &r, int &c, int &f)
-{
-   int t;
-
-   if (r > c)
-      if (c > f)
-      {
-         t = r;  r = f;  f = t;  //  (r,c,f) --> (f,c,r)
-      }
-      else if (r > f)
-      {
-         t = r;  r = c;  c = f;  f = t;  //  (r,c,f) --> (c,f,r)
-      }
-      else
-      {
-         t = r;  r = c;  c = t;  //  (r,c,f) --> (c,r,f)
-      }
-   else if (c > f)
-   {
-      if (r > f)
-      {
-         t = f;  f = c;  c = r;  r = t;  //  (r,c,f) --> (f,r,c)
-      }
-      else
-      {
-         t = c;  c = f;  f = t;  //  (r,c,f) --> (r,f,c)
-      }
-   }
-}
-
-
-inline void Sort4 (int &r, int &c, int &f, int &u)
-{
-   Sort3(c,f,u);
-
-   int t;
-
-   if (r > c)
-   {
-      if (r <= f) //(r, c, f, u) --> (c, r, f, u)
-      {
-         t = r; r = c; c = t;
-      }
-      else if (r <= u) //(r, c, f, u) --> (c, f, r, u)
-      {
-         t = r; r = c; c = t;
-         t = c; c = f; f = t;
-      }
-      else if (r > u) //(r, c, f, u) --> (c, f, u, r)
-      {
-         t = r; r = c; c = t;
-         t = c; c = f; f = t;
-         t = f; f = u; u = t;
-      }
-   }
-}
-
-inline void Sort5 (int &r, int &c, int &f, int &u, int &v)
-{
-   Sort4(r,c,f,u);
-   Sort4(c,f,u,v);
-
-   if (r > c)
-   {
-      int t = r; r = c; c = t;
-   }
-}
-
-//should be optimized
-inline void Sort8 (int &u1, int &u2, int &u3, int &u4, int &u5, int &u6,
-                   int &u7, int &u8)
-{
-   Sort5(u1,u2,u3,u4,u5);
-   Sort5(u4,u5,u6,u7,u8);
-
-   Sort5(u1,u2,u3,u4,u5);
-   Sort5(u4,u5,u6,u7,u8);
-
-   Sort5(u1,u2,u3,u4,u5);
-   Sort5(u4,u5,u6,u7,u8);
-
-   Sort5(u1,u2,u3,u4,u5);
-   Sort5(u4,u5,u6,u7,u8);
-}
-
-
 }

 #endif
@@ -532,69 +532,6 @@ MatrixInverse *DenseMatrix::Inverse() const
   return new DenseMatrixInverse(*this);
 }

-void DenseMatrix::Exponential()
-{
-   MFEM_ASSERT(Height() == Width() && Height() <= 2,
-               "The matrix must be square and "
-               << "of size less than or equal to 2."
-               << "  Height() = " << Height()
-               << ", Width() = " << Width());
-
-   switch (Height())
-   {
-      case 1:
-      {
-         data[0] = std::exp(data[0]);
-         break;
-      }
-      case 2:
-      {
-         /// Formulas from Corollary 2.4 of doi:10.1109/9.233156
-         /// Note typo in the paper, in the prefactor in the equation under (i).
-         const real_t a = data[0];
-         const real_t b = data[1];
-         const real_t c = data[2];
-         const real_t d = data[3];
-         const real_t e = (a - d)*(a - d) + 4*b*c;
-         const real_t f = std::exp((a + d)/2.0);
-         const real_t g = std::sqrt(std::abs(e)) / 2.0;
-
-         if (e == 0)
-         {
-            data[0] = 1.0 + (a - d)/2.0;
-            data[3] = 1.0 - (a - d)/2.0;
-         }
-         else if (e > 0)
-         {
-            data[0] = std::cosh(g) + (a - d)/2 * std::sinh(g) / g;
-            data[1] = b * std::sinh(g) / g;
-            data[2] = c * std::sinh(g) / g;
-            data[3] = std::cosh(g) - (a - d)/2 * std::sinh(g) / g;
-         }
-         else
-         {
-            data[0] = std::cos(g) + (a - d)/2 * std::sin(g) / g;
-            data[1] = b * std::sin(g) / g;
-            data[2] = c * std::sin(g) / g;
-            data[3] = std::cos(g) - (a - d)/2 * std::sin(g) / g;
-         }
-         for (int i = 0; i < 4; i++)
-         {
-            data[i] *= f;
-         }
-         break;
-      }
-      case 3:
-      {
-         MFEM_ABORT("3x3 matrices are not currently supported");
-      }
-      default:
-      {
-         MFEM_ABORT("Only 1x1 and 2x2 matrices are currently supported");
-      }
-   }
-}
-
 real_t DenseMatrix::Det() const
 {
   MFEM_ASSERT(Height() == Width() && Height() > 0,
@@ -647,7 +584,6 @@ real_t DenseMatrix::Det() const
         DenseMatrixInverse lu_factors(*this);

         return lu_factors.Det();
-
      }
   }
   // not reachable
@@ -676,24 +612,6 @@ real_t DenseMatrix::Weight() const
      real_t F = d[0] * d[3] + d[1] * d[4] + d[2] * d[5];
      return sqrt(E * G - F * F);
   }
-   else if ((Height() == 4) && (Width() == 1))
-   {
-      return sqrt(data[0] * data[0] + data[1] * data[1] + data[2] * data[2]
-                  + data[3] * data[3]);
-   }
-   else if ((Height() == 4) && (Width() == 3))
-   {
-      const double *d = data;
-      double A = d[0]*d[0] + d[1]*d[1] + d[2]*d[2] + d[3]*d[3];
-      double B = d[0]*d[4] + d[1]*d[5] + d[2]*d[6] + d[3]*d[7];
-      double C = d[0]*d[8] + d[1]*d[9] + d[2]*d[10] + d[3]*d[11];
-      double D = d[4]*d[4] + d[5]*d[5] + d[6]*d[6] + d[7]*d[7];
-      double E = d[4]*d[8] + d[5]*d[9] + d[6]*d[10] + d[7]*d[11];
-      double F = d[8]*d[8] + d[9]*d[9] + d[10]*d[10] + d[11]*d[11];
-
-
-      return sqrt( C *( 2*B*E - C*D ) - A*E*E + F * ( A * D - B * B) );
-   }
   mfem_error("DenseMatrix::Weight(): mismatched or unsupported dimensions");
   return 0.0;
 }
@@ -1461,7 +1379,7 @@ int DenseMatrix::Rank(real_t tol) const

 real_t DenseMatrix::CalcSingularvalue(const int i) const
 {
-   MFEM_ASSERT(Height() == Width() && Height() > 0 && Height() < 5,
+   MFEM_ASSERT(Height() == Width() && Height() > 0 && Height() < 4,
               "The matrix must be square and sized 1, 2, or 3 to compute the"
               " singular values."
               << "  Height() = " << Height()
@@ -1478,15 +1396,9 @@ real_t DenseMatrix::CalcSingularvalue(const int i) const
   {
      return kernels::CalcSingularvalue<2>(d,i);
   }
-   else if (n == 3)
-   {
-      return kernels::CalcSingularvalue<3>(d,i);
-   }
   else
   {
-      Vector sv(n);
-      SingularValues(sv);
-      return sv(i);
+      return kernels::CalcSingularvalue<3>(d,i);
   }
 }

@@ -2695,7 +2607,7 @@ void AddMult(const DenseMatrix &b, const DenseMatrix &c, DenseMatrix &a)
 void CalcAdjugate(const DenseMatrix &a, DenseMatrix &adja)
 {
 #ifdef MFEM_DEBUG
-   if (a.Width() > a.Height() || a.Width() < 1 || a.Height() > 4)
+   if (a.Width() > a.Height() || a.Width() < 1 || a.Height() > 3)
   {
      mfem_error("CalcAdjugate(...): unsupported dimensions");
   }
@@ -2748,7 +2660,7 @@ void CalcAdjugate(const DenseMatrix &a, DenseMatrix &adja)
      adja(1,0) = -a(1,0);
      adja(1,1) =  a(0,0);
   }
-   else if (a.Width() == 3)
+   else
   {
      adja(0,0) = a(1,1)*a(2,2)-a(1,2)*a(2,1);
      adja(0,1) = a(0,2)*a(2,1)-a(0,1)*a(2,2);
@@ -2762,51 +2674,13 @@ void CalcAdjugate(const DenseMatrix &a, DenseMatrix &adja)
      adja(2,1) = a(0,1)*a(2,0)-a(0,0)*a(2,1);
      adja(2,2) = a(0,0)*a(1,1)-a(0,1)*a(1,0);
   }
-   else if (a.Width() == 4)
-   {
-      adja(0,0) = -a(1,3)*a(2,2)*a(3,1)+a(1,2)*a(2,3)*a(3,1)+a(1,3)*a(2,1)*a(3,2)-a(1,
-                                                                                    1)*a(2,3)*a(3,2)-a(1,2)*a(2,1)*a(3,3)+a(1,1)*a(2,2)*a(3,3);
-      adja(0,1) = a(0,3)*a(2,2)*a(3,1)-a(0,2)*a(2,3)*a(3,1)-a(0,3)*a(2,1)*a(3,2)+a(0,
-                                                                                   1)*a(2,3)*a(3,2)+a(0,2)*a(2,1)*a(3,3)-a(0,1)*a(2,2)*a(3,3);
-      adja(0,2) = -a(0,3)*a(1,2)*a(3,1)+a(0,2)*a(1,3)*a(3,1)+a(0,3)*a(1,1)*a(3,2)-a(0,
-                                                                                    1)*a(1,3)*a(3,2)-a(0,2)*a(1,1)*a(3,3)+a(0,1)*a(1,2)*a(3,3);
-      adja(0,3) = a(0,3)*a(1,2)*a(2,1)-a(0,2)*a(1,3)*a(2,1)-a(0,3)*a(1,1)*a(2,2)+a(0,
-                                                                                   1)*a(1,3)*a(2,2)+a(0,2)*a(1,1)*a(2,3)-a(0,1)*a(1,2)*a(2,3);
-
-      adja(1,0) = a(1,3)*a(2,2)*a(3,0)-a(1,2)*a(2,3)*a(3,0)-a(1,3)*a(2,0)*a(3,2)+a(1,
-                                                                                   0)*a(2,3)*a(3,2)+a(1,2)*a(2,0)*a(3,3)-a(1,0)*a(2,2)*a(3,3);
-      adja(1,1) = -a(0,3)*a(2,2)*a(3,0)+a(0,2)*a(2,3)*a(3,0)+a(0,3)*a(2,0)*a(3,2)-a(0,
-                                                                                    0)*a(2,3)*a(3,2)-a(0,2)*a(2,0)*a(3,3)+a(0,0)*a(2,2)*a(3,3);
-      adja(1,2) = a(0,3)*a(1,2)*a(3,0)-a(0,2)*a(1,3)*a(3,0)-a(0,3)*a(1,0)*a(3,2)+a(0,
-                                                                                   0)*a(1,3)*a(3,2)+a(0,2)*a(1,0)*a(3,3)-a(0,0)*a(1,2)*a(3,3);
-      adja(1,3) = -a(0,3)*a(1,2)*a(2,0)+a(0,2)*a(1,3)*a(2,0)+a(0,3)*a(1,0)*a(2,2)-a(0,
-                                                                                    0)*a(1,3)*a(2,2)-a(0,2)*a(1,0)*a(2,3)+a(0,0)*a(1,2)*a(2,3);
-
-      adja(2,0) = -a(1,3)*a(2,1)*a(3,0)+a(1,1)*a(2,3)*a(3,0)+a(1,3)*a(2,0)*a(3,1)-a(1,
-                                                                                    0)*a(2,3)*a(3,1)-a(1,1)*a(2,0)*a(3,3)+a(1,0)*a(2,1)*a(3,3);
-      adja(2,1) = a(0,3)*a(2,1)*a(3,0)-a(0,1)*a(2,3)*a(3,0)-a(0,3)*a(2,0)*a(3,1)+a(0,
-                                                                                   0)*a(2,3)*a(3,1)+a(0,1)*a(2,0)*a(3,3)-a(0,0)*a(2,1)*a(3,3);
-      adja(2,2) = -a(0,3)*a(1,1)*a(3,0)+a(0,1)*a(1,3)*a(3,0)+a(0,3)*a(1,0)*a(3,1)-a(0,
-                                                                                    0)*a(1,3)*a(3,1)-a(0,1)*a(1,0)*a(3,3)+a(0,0)*a(1,1)*a(3,3);
-      adja(2,3) = a(0,3)*a(1,1)*a(2,0)-a(0,1)*a(1,3)*a(2,0)-a(0,3)*a(1,0)*a(2,1)+a(0,
-                                                                                   0)*a(1,3)*a(2,1)+a(0,1)*a(1,0)*a(2,3)-a(0,0)*a(1,1)*a(2,3);
-
-      adja(3,0) = a(1,2)*a(2,1)*a(3,0)-a(1,1)*a(2,2)*a(3,0)-a(1,2)*a(2,0)*a(3,1)+a(1,
-                                                                                   0)*a(2,2)*a(3,1)+a(1,1)*a(2,0)*a(3,2)-a(1,0)*a(2,1)*a(3,2);
-      adja(3,1) = -a(0,2)*a(2,1)*a(3,0)+a(0,1)*a(2,2)*a(3,0)+a(0,2)*a(2,0)*a(3,1)-a(0,
-                                                                                    0)*a(2,2)*a(3,1)-a(0,1)*a(2,0)*a(3,2)+a(0,0)*a(2,1)*a(3,2);
-      adja(3,2) = a(0,2)*a(1,1)*a(3,0)-a(0,1)*a(1,2)*a(3,0)-a(0,2)*a(1,0)*a(3,1)+a(0,
-                                                                                   0)*a(1,2)*a(3,1)+a(0,1)*a(1,0)*a(3,2)-a(0,0)*a(1,1)*a(3,2);
-      adja(3,3) = -a(0,2)*a(1,1)*a(2,0)+a(0,1)*a(1,2)*a(2,0)+a(0,2)*a(1,0)*a(2,1)-a(0,
-                                                                                    0)*a(1,2)*a(2,1)-a(0,1)*a(1,0)*a(2,2)+a(0,0)*a(1,1)*a(2,2);
-   }
 }

 void CalcAdjugateTranspose(const DenseMatrix &a, DenseMatrix &adjat)
 {
 #ifdef MFEM_DEBUG
   if (a.Height() != a.Width() || adjat.Height() != adjat.Width() ||
-       a.Width() != adjat.Width() || a.Width() < 1 || a.Width() > 4)
+       a.Width() != adjat.Width() || a.Width() < 1 || a.Width() > 3)
   {
      mfem_error("CalcAdjugateTranspose(...): dimension mismatch");
   }
@@ -2822,7 +2696,7 @@ void CalcAdjugateTranspose(const DenseMatrix &a, DenseMatrix &adjat)
      adjat(0,1) = -a(1,0);
      adjat(1,1) =  a(0,0);
   }
-   else if (a.Width() == 3)
+   else
   {
      adjat(0,0) = a(1,1)*a(2,2)-a(1,2)*a(2,1);
      adjat(1,0) = a(0,2)*a(2,1)-a(0,1)*a(2,2);
@@ -2836,17 +2710,11 @@ void CalcAdjugateTranspose(const DenseMatrix &a, DenseMatrix &adjat)
      adjat(1,2) = a(0,1)*a(2,0)-a(0,0)*a(2,1);
      adjat(2,2) = a(0,0)*a(1,1)-a(0,1)*a(1,0);
   }
-   else if (a.Width() == 4)
-   {
-      CalcAdjugate(a, adjat);
-      adjat.Transpose();
-      //    mfem_error("CalcAdjugateTranspose(...) - please implement the case for d = 4");
-   }
 }

 void CalcInverse(const DenseMatrix &a, DenseMatrix &inva)
 {
-   MFEM_ASSERT(a.Width() <= a.Height() && a.Width() >= 1 && a.Height() <= 4, "");
+   MFEM_ASSERT(a.Width() <= a.Height() && a.Width() >= 1 && a.Height() <= 3, "");
   MFEM_ASSERT(inva.Height() == a.Width(), "incorrect dimensions");
   MFEM_ASSERT(inva.Width() == a.Height(), "incorrect dimensions");

@@ -2889,12 +2757,6 @@ void CalcInverse(const DenseMatrix &a, DenseMatrix &inva)
      case 3:
         kernels::CalcInverse<3>(a.Data(), inva.Data());
         break;
-      case 4:
-      {
-         CalcAdjugate(a, inva);
-         inva *= 1./a.Det();
-         break;
-      }
   }
 }

@@ -2934,22 +2796,15 @@ void CalcInverseTranspose(const DenseMatrix &a, DenseMatrix &inva)
         inva(1,2) = (a(0,1)*a(2,0)-a(0,0)*a(2,1))*t;
         inva(2,2) = (a(0,0)*a(1,1)-a(0,1)*a(1,0))*t;
         break;
-      case 4:
-      {
-         CalcAdjugateTranspose(a, inva);
-         inva *= t;
-         break;
-      }
   }
 }

 void CalcOrtho(const DenseMatrix &J, Vector &n)
 {
   MFEM_ASSERT( ((J.Height() == 2 && J.Width() == 1)
-                 || (J.Height() == 3 && J.Width() == 2)
-                 || (J.Height() == 4 && J.Width() == 3))
+                 || (J.Height() == 3 && J.Width() == 2))
                && (J.Height() == n.Size()),
-                "Matrix must be 4x3, 3x2 or 2x1, "
+                "Matrix must be 3x2 or 2x1, "
                << "and the Vector must be sized with the rows. "
                << " J.Height() = " << J.Height()
                << ", J.Width() = " << J.Width()
@@ -2962,23 +2817,12 @@ void CalcOrtho(const DenseMatrix &J, Vector &n)
      n(0) =  d[1];
      n(1) = -d[0];
   }
-   else if (J.Height() == 3)
+   else
   {
      n(0) = d[1]*d[5] - d[2]*d[4];
      n(1) = d[2]*d[3] - d[0]*d[5];
      n(2) = d[0]*d[4] - d[1]*d[3];
   }
-   else if (J.Height() == 4)
-   {
-      n(0) = -d[3]*d[6]*d[9]+d[2]*d[7]*d[9]+d[3]*d[5]*d[10]-d[1]*d[7]*d[10]
-             -d[2]*d[5]*d[11]+d[1]*d[6]*d[11];
-      n(1) = d[3]*d[6]*d[8]-d[2]*d[7]*d[8]-d[3]*d[4]*d[10]+d[0]*d[7]*d[10]
-             +d[2]*d[4]*d[11]-d[0]*d[6]*d[11];
-      n(2) = -d[3]*d[5]*d[8]+d[1]*d[7]*d[8]+d[3]*d[4]*d[9]-d[0]*d[7]*d[9]
-             -d[1]*d[4]*d[11]+d[0]*d[5]*d[11];
-      n(3) = d[2]*d[5]*d[8]-d[1]*d[6]*d[8]-d[2]*d[4]*d[9]+d[0]*d[6]*d[9]
-             +d[1]*d[4]*d[10]-d[0]*d[5]*d[10];
-   }
 }

 void MultAAt(const DenseMatrix &a, DenseMatrix &aat)
@@ -207,10 +207,6 @@ public:
   /// Replaces the current matrix with its square root inverse
   void SquareRootInverse();

-   /// Replaces the current matrix with its exponential
-   /// (currently only supports 2x2 matrices)
-   void Exponential();
-
   /// Calculates the determinant of the matrix
   /// (optimized for 2x2, 3x3, and 4x4 matrices)
   real_t Det() const;
@@ -410,19 +410,19 @@ HYPRE_Int HypreParVector::Randomize(HYPRE_Int seed)
   return hypre_ParVectorSetRandomValues(x,seed);
 }

-void HypreParVector::Print(const std::string &fname) const
+void HypreParVector::Print(const char *fname) const
 {
-   hypre_ParVectorPrint(x, fname.c_str());
+   hypre_ParVectorPrint(x,fname);
 }

-void HypreParVector::Read(MPI_Comm comm, const std::string &fname)
+void HypreParVector::Read(MPI_Comm comm, const char *fname)
 {
   if (own_ParVector)
   {
      hypre_ParVectorDestroy(x);
   }
   data.Delete();
-   x = hypre_ParVectorRead(comm, fname.c_str());
+   x = hypre_ParVectorRead(comm, fname);
   own_ParVector = true;
   _SetDataAndSize_();
 }
@@ -792,44 +792,6 @@ static void SyncBackBoolCSR(Table *bool_csr, MemoryIJData &mem_csr)
   }
 }

-/// @brief Return the size of the partitioning arrays, see @ref
-/// hypre_partitioning_descr.
-static int GetPartitioningArraySize(MPI_Comm comm)
-{
-   if (HYPRE_AssumedPartitionCheck())
-   {
-      return 2;
-   }
-   else
-   {
-      int comm_size;
-      MPI_Comm_size(comm, &comm_size);
-      return comm_size + 1;
-   }
-}
-
-/// @brief Returns true if the row and col arrays are equal (across all MPI
-/// ranks).
-///
-/// Both @a row and @a col are partitioning arrays, whose length is returned by
-/// GetPartitioningArraySize(), see @ref hypre_partitioning_descr.
-static bool RowAndColStartsAreEqual(MPI_Comm comm, HYPRE_BigInt *rows,
-                                    HYPRE_BigInt *cols)
-{
-   const int part_size = GetPartitioningArraySize(comm);
-   bool are_equal = true;
-   for (int i = 0; i < part_size; ++i)
-   {
-      if (rows[i] != cols[i])
-      {
-         are_equal = false;
-         break;
-      }
-   }
-   MPI_Allreduce(MPI_IN_PLACE, &are_equal, 1,  MPI_C_BOOL, MPI_LAND, comm);
-   return are_equal;
-}
-
 // static method
 signed char HypreParMatrix::HypreCsrToMem(hypre_CSRMatrix *h_mat,
                                          MemoryType h_mat_mt,
@@ -962,7 +924,7 @@ HypreParMatrix::HypreParMatrix(MPI_Comm comm,
   hypre_ParCSRMatrixSetNumNonzeros(A);

   /* Make sure that the first entry in each row is the diagonal one. */
-   if (RowAndColStartsAreEqual(comm, row_starts, col_starts))
+   if (row_starts == col_starts)
   {
      HypreReadWrite();
      hypre_CSRMatrixReorder(hypre_ParCSRMatrixDiag(A));
@@ -1012,12 +974,11 @@ HypreParMatrix::HypreParMatrix(MPI_Comm comm,
   hypre_ParCSRMatrixSetNumNonzeros(A);

   /* Make sure that the first entry in each row is the diagonal one. */
-   if (RowAndColStartsAreEqual(comm, row_starts, col_starts))
+   if (row_starts == col_starts)
   {
      HypreReadWrite();
      hypre_CSRMatrixReorder(hypre_ParCSRMatrixDiag(A));
-      // update diag, if needed
-      if (!own_diag_offd) { SyncBackCSR(diag, mem_diag); }
+      SyncBackCSR(diag, mem_diag); // update diag, if needed
   }

   hypre_MatvecCommPkgCreate(A);
@@ -1070,7 +1031,7 @@ HypreParMatrix::HypreParMatrix(
   hypre_ParCSRMatrixSetNumNonzeros(A);

   /* Make sure that the first entry in each row is the diagonal one. */
-   if (RowAndColStartsAreEqual(comm, row_starts, col_starts))
+   if (row_starts == col_starts)
   {
      hypre_CSRMatrixReorder(hypre_ParCSRMatrixDiag(A));
   }
@@ -1132,7 +1093,7 @@ HypreParMatrix::HypreParMatrix(MPI_Comm comm,
   hypre_CSRMatrixDestroy(csr_a);

   /* Make sure that the first entry in each row is the diagonal one. */
-   if (RowAndColStartsAreEqual(comm, row_starts, col_starts))
+   if (row_starts == col_starts)
   {
      hypre_CSRMatrixReorder(hypre_ParCSRMatrixDiag(new_A));
   }
@@ -1171,7 +1132,7 @@ HypreParMatrix::HypreParMatrix(MPI_Comm comm,
   hypre_ParCSRMatrixSetNumNonzeros(A);

   /* Make sure that the first entry in each row is the diagonal one. */
-   if (RowAndColStartsAreEqual(comm, row_starts, col_starts))
+   if (row_starts == col_starts)
   {
      HypreReadWrite();
      hypre_CSRMatrixReorder(hypre_ParCSRMatrixDiag(A));
@@ -1286,10 +1247,11 @@ HypreParMatrix::HypreParMatrix(MPI_Comm comm, int nrows,
   Init();

   // Determine partitioning size, and my column start and end
-   const int part_size = GetPartitioningArraySize(comm);
+   int part_size;
   HYPRE_BigInt my_col_start, my_col_end; // my range: [my_col_start, my_col_end)
   if (HYPRE_AssumedPartitionCheck())
   {
+      part_size = 2;
      my_col_start = cols[0];
      my_col_end = cols[1];
   }
@@ -1297,14 +1259,15 @@ HypreParMatrix::HypreParMatrix(MPI_Comm comm, int nrows,
   {
      int myid;
      MPI_Comm_rank(comm, &myid);
+      MPI_Comm_size(comm, &part_size);
+      part_size++;
      my_col_start = cols[myid];
      my_col_end = cols[myid+1];
   }

   // Copy in the row and column partitionings
-   const bool rows_eq_cols = RowAndColStartsAreEqual(comm, rows, cols);
   HYPRE_BigInt *row_starts, *col_starts;
-   if (rows_eq_cols)
+   if (rows == cols)
   {
      row_starts = col_starts = mfem_hypre_TAlloc_host(HYPRE_BigInt, part_size);
      for (int i = 0; i < part_size; i++)
@@ -1397,14 +1360,14 @@ HypreParMatrix::HypreParMatrix(MPI_Comm comm, int nrows,
   }

   hypre_ParCSRMatrixSetNumNonzeros(A);
-   // Make sure that the first entry in each row is the diagonal one.
-   if (rows_eq_cols)
+   /* Make sure that the first entry in each row is the diagonal one. */
+   if (row_starts == col_starts)
   {
      hypre_CSRMatrixReorder(hypre_ParCSRMatrixDiag(A));
   }
 #if MFEM_HYPRE_VERSION > 22200
   mfem_hypre_TFree_host(row_starts);
-   if (!rows_eq_cols)
+   if (rows != cols)
   {
      mfem_hypre_TFree_host(col_starts);
   }
@@ -1517,7 +1480,16 @@ void HypreParMatrix::CopyRowStarts()
      return;
   }

-   const int row_starts_size = GetPartitioningArraySize(hypre_ParCSRMatrixComm(A));
+   int row_starts_size;
+   if (HYPRE_AssumedPartitionCheck())
+   {
+      row_starts_size = 2;
+   }
+   else
+   {
+      MPI_Comm_size(hypre_ParCSRMatrixComm(A), &row_starts_size);
+      row_starts_size++; // num_proc + 1
+   }

   HYPRE_BigInt *old_row_starts = hypre_ParCSRMatrixRowStarts(A);
   HYPRE_BigInt *new_row_starts = mfem_hypre_CTAlloc_host(HYPRE_BigInt,
@@ -1548,7 +1520,16 @@ void HypreParMatrix::CopyColStarts()
      return;
   }

-   const int col_starts_size = GetPartitioningArraySize(hypre_ParCSRMatrixComm(A));
+   int col_starts_size;
+   if (HYPRE_AssumedPartitionCheck())
+   {
+      col_starts_size = 2;
+   }
+   else
+   {
+      MPI_Comm_size(hypre_ParCSRMatrixComm(A), &col_starts_size);
+      col_starts_size++; // num_proc + 1
+   }

   HYPRE_BigInt *old_col_starts = hypre_ParCSRMatrixColStarts(A);
   HYPRE_BigInt *new_col_starts = mfem_hypre_CTAlloc_host(HYPRE_BigInt,
@@ -2310,8 +2291,13 @@ void HypreParMatrix::Threshold(real_t threshold)
   A = parcsr_A_ptr;

   hypre_ParCSRMatrixSetNumNonzeros(A);
-   // Make sure that the first entry in each row is the diagonal one.
-   if (RowAndColStartsAreEqual(comm, row_starts, col_starts))
+   /* Make sure that the first entry in each row is the diagonal one. */
+#if MFEM_HYPRE_VERSION <= 22200
+   if (row_starts == col_starts)
+#else
+   if ((row_starts[0] == col_starts[0]) &&
+       (row_starts[1] == col_starts[1]))
+#endif
   {
      hypre_CSRMatrixReorder(hypre_ParCSRMatrixDiag(A));
   }
@@ -2637,38 +2623,48 @@ void HypreParMatrix::EliminateBC(const Array<int> &ess_dofs,
   mfem_hypre_TFree(eliminate_col);
 }

-void HypreParMatrix::Print(const std::string &fname, HYPRE_Int offi,
+void HypreParMatrix::Print(const char *fname, HYPRE_Int offi,
                           HYPRE_Int offj) const
 {
   HostRead();
-   hypre_ParCSRMatrixPrintIJ(A, offi, offj, fname.c_str());
+   hypre_ParCSRMatrixPrintIJ(A,offi,offj,fname);
   HypreRead();
 }

-void HypreParMatrix::Read(MPI_Comm comm, const std::string &fname)
+void HypreParMatrix::Read(MPI_Comm comm, const char *fname)
 {
-   HYPRE_ParCSRMatrix A_parcsr;
+   Destroy();
+   Init();
+
   HYPRE_Int base_i, base_j;
-   hypre_ParCSRMatrixReadIJ(comm, fname.c_str(), &base_i, &base_j, &A_parcsr);
-
-   WrapHypreParCSRMatrix(A_parcsr, true);
-
+   hypre_ParCSRMatrixReadIJ(comm, fname, &base_i, &base_j, &A);
   hypre_ParCSRMatrixSetNumNonzeros(A);
+
   if (!hypre_ParCSRMatrixCommPkg(A)) { hypre_MatvecCommPkgCreate(A); }
+
+   height = GetNumRows();
+   width = GetNumCols();
 }

-void HypreParMatrix::Read_IJMatrix(MPI_Comm comm, const std::string &fname)
+void HypreParMatrix::Read_IJMatrix(MPI_Comm comm, const char *fname)
 {
+   Destroy();
+   Init();
+
   HYPRE_IJMatrix A_ij;
-   HYPRE_IJMatrixRead(fname.c_str(), comm, 5555, &A_ij); // HYPRE_PARCSR = 5555
+   HYPRE_IJMatrixRead(fname, comm, 5555, &A_ij); // HYPRE_PARCSR = 5555

   HYPRE_ParCSRMatrix A_parcsr;
   HYPRE_IJMatrixGetObject(A_ij, (void**) &A_parcsr);

-   WrapHypreParCSRMatrix(A_parcsr, true);
+   A = (hypre_ParCSRMatrix*)A_parcsr;

   hypre_ParCSRMatrixSetNumNonzeros(A);
+
   if (!hypre_ParCSRMatrixCommPkg(A)) { hypre_MatvecCommPkgCreate(A); }
+
+   height = GetNumRows();
+   width = GetNumCols();
 }

 void HypreParMatrix::PrintCommPkg(std::ostream &os) const
@@ -3513,7 +3509,6 @@ HypreSmoother::HypreSmoother() : Solver()
   omega = 1.0;
   poly_order = 2;
   poly_fraction = .3;
-   poly_iter = 10;
   lambda = 0.5;
   mu = -0.5;
   taubin_iter = 40;
@@ -364,10 +364,10 @@ public:
   HYPRE_Int Randomize(HYPRE_Int seed);

   /// Prints the locally owned rows in parallel
-   void Print(const std::string &fname) const;
+   void Print(const char *fname) const;

   /// Reads a HypreParVector from files saved with HypreParVector::Print
-   void Read(MPI_Comm comm, const std::string &fname);
+   void Read(MPI_Comm comm, const char *fname);

   /// Calls hypre's destroy function
   ~HypreParVector();
@@ -919,14 +919,12 @@ public:
   const Memory<HYPRE_Int> &GetDiagMemoryJ() const { return mem_diag.J; }
   const Memory<real_t> &GetDiagMemoryData() const { return mem_diag.data; }

-   /// @brief Prints the locally owned rows in parallel. The resulting files can
-   /// be read with Read_IJMatrix().
-   void Print(const std::string &fname, HYPRE_Int offi = 0,
-              HYPRE_Int offj = 0) const;
+   /// Prints the locally owned rows in parallel
+   void Print(const char *fname, HYPRE_Int offi = 0, HYPRE_Int offj = 0) const;
   /// Reads the matrix from a file
-   void Read(MPI_Comm comm, const std::string &fname);
+   void Read(MPI_Comm comm, const char *fname);
   /// Read a matrix saved as a HYPRE_IJMatrix
-   void Read_IJMatrix(MPI_Comm comm, const std::string &fname);
+   void Read_IJMatrix(MPI_Comm comm, const char *fname);

   /// Print information about the hypre_ParCSRCommPkg of the HypreParMatrix.
   void PrintCommPkg(std::ostream &out = mfem::out) const;
@@ -1049,8 +1047,6 @@ protected:
   real_t poly_fraction;
   /// Apply the polynomial smoother to A or D^{-1/2} A D^{-1/2}
   int poly_scale;
-   /// Number of CG iterations to determine eigenvalue estimates, 0 means the max norm
-   int poly_iter;

   /// Taubin's lambda-mu method parameters
   real_t lambda;
@@ -309,51 +309,18 @@ public:


 /// Base abstract class for first order time dependent operators.
-/** Operator of the form: (u,t) -> k(u,t), where k generally solves the
-    algebraic equation F(u,k,t) = G(u,t). The functions F and G represent the
-    _implicit_ and _explicit_ parts of the operator, respectively.
-
-    A common use for this class is representing a differential algebraic
-    equation of the form $ F(y,\frac{dy}{dt},t) = G(y,t) $.
-
-    For example, consider an ordinary differential equation of the form
-    $ M \frac{dy}{dt} = g(y,t) $. There are various ways of expressing this ODE
-    as a TimeDependentOperator depending on the choices for F and G. Here are
-    some common choices:
-
-      1. F(u,k,t) = k and G(u,t) = inv(M) g(u,t),
-      2. F(u,k,t) = M k and G(u,t) = g(u,t),
-      3. F(u,k,t) = M k - g(u,t) and G(u,t) = 0.
-
-    Note that depending on the ODE solver, some of the above choices may be
-    preferable to the others.
-*/
+/** Operator of the form: (x,t) -> f(x,t), where k = f(x,t) generally solves the
+    algebraic equation F(x,k,t) = G(x,t). The functions F and G represent the
+    _implicit_ and _explicit_ parts of the operator, respectively. For explicit
+    operators, F(x,k,t) = k, so f(x,t) = G(x,t). */
 class TimeDependentOperator : public Operator
 {
 public:
-   /// Enum used to describe the form of the time-dependent operator.
-   /** The type should be set by classes derived from TimeDependentOperator to
-       describe the form, in terms of the functions F and G, used by the
-       specific derived class. This information can be queried by classes or
-       functions (like time stepping algorithms) to make choices about the
-       algorithm to use, or to ensure that the TimeDependentOperator uses the
-       form expected by the class/function.
-
-       For example, assume that a derived class is implementing the ODE
-       $M \frac{dy}{dt} = g(y,t)$ and chooses to define $F(u,k,t) = M k$ and
-       $G(u,t) = g(u,t)$. Then it cannot use type EXPLICIT, unless $M = I$, or
-       type HOMOGENEOUS, unless $g(u,t) = 0$. If, on the other hand, the derived
-       class chooses to define $F(u,k,t) = k$ and $G(u,t) = M^{-1} g(y,t)$, then
-       the natural choice is to set the type to EXPLICIT, even though setting it
-       to IMPLICIT is also not wrong -- doing so will simply fail to inform
-       methods that query this information that it uses a more specific
-       implementation, EXPLICIT, that may allow the use of algorithms that
-       support only the EXPLICIT type. */
   enum Type
   {
-      EXPLICIT,   ///< This type assumes F(u,k,t) = k.
+      EXPLICIT,   ///< This type assumes F(x,k,t) = k, i.e. k = f(x,t) = G(x,t).
      IMPLICIT,   ///< This is the most general type, no assumptions on F and G.
-      HOMOGENEOUS ///< This type assumes that G(u,t) = 0.
+      HOMOGENEOUS ///< This type assumes that G(x,t) = 0.
   };

   /// Evaluation mode. See SetEvalMode() for details.
@@ -361,30 +328,29 @@ public:
   {
      /** Normal evaluation. */
      NORMAL,
-      /** Assuming additive split, k(u,t) = k1(u,t) + k2(u,t), evaluate the
-          first term, k1. */
+      /** Assuming additive split, f(x,t) = f1(x,t) + f2(x,t), evaluate the
+          first term, f1. */
      ADDITIVE_TERM_1,
-      /** Assuming additive split, k(u,t) = k1(u,t) + k2(u,t), evaluate the
-          second term, k2. */
+      /** Assuming additive split, f(x,t) = f1(x,t) + f2(x,t), evaluate the
+          second term, f2. */
      ADDITIVE_TERM_2
   };

 protected:
   real_t t;  ///< Current time.
-   Type type; /**< @brief Describes the form of the TimeDependentOperator, see
-                   the documentation of #Type. */
+   Type type; ///< Describes the form of the TimeDependentOperator.
   EvalMode eval_mode; ///< Current evaluation mode.

 public:
-   /** @brief Construct a "square" TimeDependentOperator (u,t) -> k(u,t), where
-       u and k have the same dimension @a n. */
+   /** @brief Construct a "square" TimeDependentOperator y = f(x,t), where x and
+       y have the same dimension @a n. */
   explicit TimeDependentOperator(int n = 0, real_t t_ = 0.0,
                                  Type type_ = EXPLICIT)
      : Operator(n) { t = t_; type = type_; eval_mode = NORMAL; }

-   /** @brief Construct a TimeDependentOperator (u,t) -> k(u,t), where u and k
-       have dimensions @a w and @a h, respectively. */
-   TimeDependentOperator(int h, int w, double t_ = 0.0, Type type_ = EXPLICIT)
+   /** @brief Construct a TimeDependentOperator y = f(x,t), where x and y have
+       dimensions @a w and @a h, respectively. */
+   TimeDependentOperator(int h, int w, real_t t_ = 0.0, Type type_ = EXPLICIT)
      : Operator(h, w) { t = t_; type = type_; eval_mode = NORMAL; }

   /// Read the currently set time.
@@ -407,7 +373,7 @@ public:
   /** The evaluation mode is a switch that allows time-stepping methods to
       request evaluation of separate components/terms of the time-dependent
       operator. For example, IMEX methods typically assume additive split of
-       the operator: k(u,t) = k1(u,t) + k2(u,t) and they rely on the ability to
+       the operator: f(x,t) = f1(x,t) + f2(x,t) and they rely on the ability to
       evaluate the two terms separately.

       Generally, setting the evaluation mode should affect the behavior of all
@@ -418,104 +384,62 @@ public:
   { eval_mode = new_eval_mode; }

   /** @brief Perform the action of the explicit part of the operator, G:
-       @a v = G(@a u, t) where t is the current time.
+       @a y = G(@a x, t) where t is the current time.

       Presently, this method is used by some PETSc ODE solvers, for more
       details, see the PETSc Manual. */
-   virtual void ExplicitMult(const Vector &u, Vector &v) const;
+   virtual void ExplicitMult(const Vector &x, Vector &y) const;

   /** @brief Perform the action of the implicit part of the operator, F:
-       @a v = F(@a u, @a k, t) where t is the current time.
+       @a y = F(@a x, @a k, t) where t is the current time.

       Presently, this method is used by some PETSc ODE solvers, for more
       details, see the PETSc Manual.*/
-   virtual void ImplicitMult(const Vector &u, const Vector &k, Vector &v) const;
+   virtual void ImplicitMult(const Vector &x, const Vector &k, Vector &y) const;

-   /** @brief Perform the action of the operator (u,t) -> k(u,t) where t is the
-       current time set by SetTime() and @a k satisfies
-       F(@a u, @a k, t) = G(@a u, t).
+   /** @brief Perform the action of the operator: @a y = k = f(@a x, t), where
+       k solves the algebraic equation F(@a x, k, t) = G(@a x, t) and t is the
+       current time. */
+   virtual void Mult(const Vector &x, Vector &y) const;

-       For solving an ordinary differential equation of the form
-       $ M \frac{dy}{dt} = g(y,t) $, recall that F and G can be defined in
-       various ways, e.g.:
+   /** @brief Solve the equation: @a k = f(@a x + @a dt @a k, t), for the
+       unknown @a k at the current time t.

-         1. F(u,k,t) = k and G(u,t) = inv(M) g(u,t)
-         2. F(u,k,t) = M k and G(u,t) = g(u,t)
-         3. F(u,k,t) = M k - g(u,t) and G(u,t) = 0.
+       For general F and G, the equation for @a k becomes:
+       F(@a x + @a dt @a k, @a k, t) = G(@a x + @a dt @a k, t).

-       Regardless of the choice of F and G, this function should always compute
-       @a k = inv(M) g(@a u, t). */
-   virtual void Mult(const Vector &u, Vector &v) const override;
+       The input vector @a x corresponds to time index (or cycle) n, while the
+       currently set time, #t, and the result vector @a k correspond to time
+       index n+1. The time step @a dt corresponds to the time interval between
+       cycles n and n+1.

-   /** @brief Solve for the unknown @a k, at the current time t, the following
-       equation:
-       F(@a u + @a gamma @a k, @a k, t) = G(@a u + @a gamma @a k, t).
-
-       For solving an ordinary differential equation of the form
-       $ M \frac{dy}{dt} = g(y,t) $, recall that F and G can be defined in
-       various ways, e.g.:
-
-         1. F(u,k,t) = k and G(u,t) = inv(M) g(u,t)
-         2. F(u,k,t) = M k and G(u,t) = g(u,t)
-         3. F(u,k,t) = M k - g(u,t) and G(u,t) = 0
-
-       Regardless of the choice of F and G, this function should solve for @a k
-       in M @a k = g(@a u + @a gamma @a k, t).
-
-       To see how @a k can be useful, consider the backward Euler method defined
-       by $ y(t + \Delta t) = y(t) + \Delta t k_0 $ where
-       $ M k_0 = g \big( y(t) + \Delta t k_0, t + \Delta t \big) $. A backward
-       Euler integrator can use @a k from this function for $k_0$, with the call
-       using @a u set to $ y(t) $, @a gamma set to $ \Delta t$, and time set to
-       $t + \Delta t$. See class BackwardEulerSolver.
-
-       Generalizing further, consider a diagonally implicit Runge-Kutta (DIRK)
-       method defined by
-       $ y(t + \Delta t) = y(t) + \Delta t \sum_{i=1}^s b_i k_i $ where
-       $ M k_i = g \big( y(t) + \Delta t \sum_{j=1}^i a_{ij} k_j,
-                         t + c_i \Delta t \big) $.
-       A DIRK integrator can use @a k from this function, with @a u set to
-       $ y(t) + \Delta t \sum_{j=1}^{i-1} a_{ij} k_j $ and @a gamma set to
-       $ a_{ii} \Delta t $, for $ k_i $. For example, see class SDIRK33Solver.
+       This method allows for the abstract implementation of some time
+       integration methods, including diagonal implicit Runge-Kutta (DIRK)
+       methods and the backward Euler method in particular.

       If not re-implemented, this method simply generates an error. */
-   virtual void ImplicitSolve(const real_t gamma, const Vector &u, Vector &k);
+   virtual void ImplicitSolve(const real_t dt, const Vector &x, Vector &k);

-   /** @brief Return an Operator representing (dF/dk @a shift + dF/du) at the
-       given @a u, @a k, and the currently set time.
+   /** @brief Return an Operator representing (dF/dk @a shift + dF/dx) at the
+       given @a x, @a k, and the currently set time.

       Presently, this method is used by some PETSc ODE solvers, for more
       details, see the PETSc Manual. */
-   virtual Operator& GetImplicitGradient(const Vector &u, const Vector &k,
+   virtual Operator& GetImplicitGradient(const Vector &x, const Vector &k,
                                         real_t shift) const;

-   /** @brief Return an Operator representing dG/du at the given point @a u and
+   /** @brief Return an Operator representing dG/dx at the given point @a x and
       the currently set time.

       Presently, this method is used by some PETSc ODE solvers, for more
       details, see the PETSc Manual. */
-   virtual Operator& GetExplicitGradient(const Vector &u) const;
+   virtual Operator& GetExplicitGradient(const Vector &x) const;

-   /** @brief Setup a linear system as needed by some SUNDIALS ODE solvers.
+   /** @brief Setup the ODE linear system $ A(x,t) = (I - gamma J) $ or
+       $ A = (M - gamma J) $, where $ J(x,t) = \frac{df}{dt(x,t)} $.

-       For solving an ordinary differential equation of the form
-       $ M \frac{dy}{dt} = g(y,t) $, recall that F and G can be defined as one
-       of the following:
-
-         1. F(u,k,t) = k and G(u,t) = inv(M) g(u,t)
-         2. F(u,k,t) = M k and G(u,t) = g(u,t)
-         3. F(u,k,t) = M k - g(u,t) and G(u,t) = 0
-
-       This function performs setup to solve $ A x = b $ where A is either
-
-         1. A(@a y,t) = I - @a gamma inv(M) J(@a y,t)
-         2. A(@a y,t) = M - @a gamma J(@a y,t)
-         3. A(@a y,t) = M - @a gamma J(@a y,t)
-
-       with J = dg/dy (or a reasonable approximation thereof).
-
-       @param[in]  y     The state at which A(@a y,t) should be evaluated.
-       @param[in]  v     The value of inv(M) g(y,t) for 1 or g(y,t) for 2 & 3.
+       @param[in]  x     The state at which $A(x,t)$ should be evaluated.
+       @param[in]  fx    The current value of the ODE rhs function, $f(x,t)$.
       @param[in]  jok   Flag indicating if the Jacobian should be updated.
       @param[out] jcur  Flag to signal if the Jacobian was updated.
       @param[in]  gamma The scaled time step value.
@@ -524,10 +448,10 @@ public:

       Presently, this method is used by SUNDIALS ODE solvers, for more
       details, see the SUNDIALS User Guides. */
-   virtual int SUNImplicitSetup(const Vector &y, const Vector &v,
+   virtual int SUNImplicitSetup(const Vector &x, const Vector &fx,
                                int jok, int *jcur, real_t gamma);

-   /** @brief Solve the ODE linear system A @a x = @a b, where A is defined by
+   /** @brief Solve the ODE linear system $ A x = b $ as setup by
       the method SUNImplicitSetup().

       @param[in]      b   The linear system right-hand side.
@@ -540,8 +464,7 @@ public:
       details, see the SUNDIALS User Guides. */
   virtual int SUNImplicitSolve(const Vector &b, Vector &x, real_t tol);

-   /** @brief Setup the mass matrix in the ODE system
-       $ M \frac{dy}{dt} = g(y,t) $ .
+   /** @brief Setup the mass matrix in the ODE system $ M y' = f(y,t) $ .

       If not re-implemented, this method simply generates an error.

@@ -549,8 +472,8 @@ public:
       details, see the ARKode User Guide. */
   virtual int SUNMassSetup();

-   /** @brief Solve the mass matrix linear system  M @a x = @a b, where M is
-       defined by the method SUNMassSetup().
+   /** @brief Solve the mass matrix linear system $ M x = b $
+       as setup by the method SUNMassSetup().

       @param[in]      b   The linear system right-hand side.
       @param[in,out]  x   On input, the initial guess. On output, the solution.
@@ -562,8 +485,7 @@ public:
       details, see the ARKode User Guide. */
   virtual int SUNMassSolve(const Vector &b, Vector &x, real_t tol);

-   /** @brief Compute the mass matrix-vector product @a v = M @a x, where M is
-       defined by the method SUNMassSetup().
+   /** @brief Compute the mass matrix-vector product $ v = M x $ .

       @param[in]   x The vector to multiply.
       @param[out]  v The result of the matrix-vector product.
@@ -58,20 +58,6 @@ DenseSymmetricMatrix &DenseSymmetricMatrix::operator=(real_t c)
   return *this;
 }

-DenseSymmetricMatrix &DenseSymmetricMatrix::operator=(const DenseSymmetricMatrix
-                                                      &m)
-{
-   SetSize(m.height);
-
-   const int hw = m.GetStoredSize();
-   for (int i = 0; i < hw; i++)
-   {
-      data[i] = m.data[i];
-   }
-
-   return *this;
-}
-
 real_t &DenseSymmetricMatrix::Elem(int i, int j)
 {
   return (*this)(i,j);
@@ -103,6 +89,11 @@ MatrixInverse *DenseSymmetricMatrix::Inverse() const
   return nullptr;
 }

+void DenseSymmetricMatrix::Print (std::ostream & os, int width_) const
+{
+   mfem_error("DenseSymmetricMatrix::Print() not implemented!");
+}
+
 DenseSymmetricMatrix::~DenseSymmetricMatrix()
 {
   data.Delete();
@@ -102,9 +102,6 @@ public:

   DenseSymmetricMatrix &operator*=(real_t c);

-   /// Sets the matrix size and elements equal to those of m
-   DenseSymmetricMatrix &operator=(const DenseSymmetricMatrix &m);
-
   std::size_t MemoryUsage() const { return data.Capacity() * sizeof(real_t); }

   /// Shortcut for mfem::Read( GetMemory(), TotalSize(), on_dev).
@@ -137,6 +134,9 @@ public:
   /// Returns a pointer to (an approximation) of the matrix inverse.
   virtual MatrixInverse *Inverse() const;

+   /// Prints matrix to stream out.
+   virtual void Print (std::ostream & out = mfem::out, int width_ = 4) const;
+
   /// Destroys the symmetric matrix.
   virtual ~DenseSymmetricMatrix();
 };
@@ -30,8 +30,6 @@ set(SRCS
  vertex.cpp
  vtk.cpp
  wedge.cpp
-  pentatope.cpp
-  tesseract.cpp
  submesh/submesh.cpp
  submesh/submesh_utils.cpp
  submesh/transfermap.cpp
@@ -59,13 +57,11 @@ set(HDRS
  vertex.hpp
  vtk.hpp
  wedge.hpp
-  pentatope.hpp
-  tesseract.hpp
  submesh/submesh.hpp
  submesh/submesh_utils.hpp
  submesh/transfer_category.hpp
  submesh/transfermap.hpp
- )
+  )

 if (MFEM_USE_MPI)
  list(APPEND SRCS
@@ -39,8 +39,7 @@ public:

   /// Constants for the classes derived from Element.
   enum Type { POINT, SEGMENT, TRIANGLE, QUADRILATERAL,
-               TETRAHEDRON, HEXAHEDRON, WEDGE, PYRAMID,
-               PENTATOPE, TESSERACT
+               TETRAHEDRON, HEXAHEDRON, WEDGE, PYRAMID
             };

   /// Default element constructor.
@@ -77,22 +76,8 @@ public:

   virtual int GetNEdges() const = 0;

-   virtual int GetNPlanars() const
-   {
-      mfem_error ("Element::GetNPlanars(...)\n"
-                  "   is not implemented for this class!");
-      return 0;
-   }
-
   virtual const int *GetEdgeVertices(int) const = 0;

-   virtual const int *GetPlanarsVertices(int) const
-   {
-      mfem_error ("Element::GetPlanarsVertices(...)\n"
-                  "   is not implemented for this class!");
-      return NULL;
-   }
-
   /// @deprecated Use GetNFaces(void) and GetNFaceVertices(int) instead.
   MFEM_DEPRECATED virtual int GetNFaces(int &nFaceVertices) const = 0;

@@ -70,7 +70,6 @@ protected:

   int NumOfVertices, NumOfElements, NumOfBdrElements;
   int NumOfEdges, NumOfFaces;
-   int NumOfPlanars;
   /** These variables store the number of Interior and Boundary faces. Calling
       fes->GetMesh()->GetNBE() doesn't return the expected value in 3D because
       periodic meshes in 3D have some of their faces marked as boundary for
@@ -98,13 +97,6 @@ protected:
   Array<Vertex> vertices;
   Array<Element *> boundary;
   Array<Element *> faces;
-   Array<Element *> planars; //only for 4d meshes
-
-   Array<bool> swappedFaces; //only for 4d meshes
-   Array<bool> swappedBdr; //only for 4d meshes
-
-   // Flag to indicate if two neighbours are reflected neighbours (4D)
-   bool is_reflected;

   /** @brief This structure stores the low level information necessary to
       interpret the configuration of elements on a specific face. This
@@ -234,12 +226,10 @@ protected:

   Table *el_to_edge;
   Table *el_to_face;
-   Table *el_to_planar;    // for 4D
   Table *el_to_el;
   Array<int> be_to_face; // faces = vertices (1D), edges (2D), faces (3D)

   Table *bel_to_edge;    // for 3D only
-   Table *bel_to_planar;  // for 4D only

   // Note that the following tables are owned by this class and should not be
   // deleted by the caller. Of these three tables, only face_edge and
@@ -248,13 +238,9 @@ protected:
   mutable Table *face_edge;     // Returned by GetFaceEdgeTable().
   mutable Table *edge_vertex;   // Returned by GetEdgeVertexTable().

-   mutable Table *face_planar;   // for 4D
-   mutable Table *planar_edge;   // for 4D
-
   IsoparametricTransformation Transformation, Transformation2;
   IsoparametricTransformation BdrTransformation;
-   IsoparametricTransformation FaceTransformation, PlanarTransformation,
-                               EdgeTransformation;
+   IsoparametricTransformation FaceTransformation, EdgeTransformation;
   FaceElementTransformations FaceElemTr;

   // refinement embeddings for forward compatibility with NCMesh
@@ -287,8 +273,6 @@ public:
   typedef Geometry::Constants<Geometry::CUBE>        hex_t;
   typedef Geometry::Constants<Geometry::PRISM>       pri_t;
   typedef Geometry::Constants<Geometry::PYRAMID>     pyr_t;
-   typedef Geometry::Constants<Geometry::PENTATOPE>   pent_t;
-   typedef Geometry::Constants<Geometry::TESSERACT>   tess_t;

   enum Operation { NONE, REFINE, DEREFINE, REBALANCE };

@@ -371,10 +355,6 @@ protected:
   void GetEdgeOrdering(const DSTable &v_to_v, Array<int> &order);
   virtual void MarkTetMeshForRefinement(const DSTable &v_to_v);

-   // Removed 2025 November
-   // virtual void MarkTetMeshForRefinement(DSTable &v_to_v);
-   virtual void MakeReflectedPentMesh();
-
   // Methods used to prepare and apply permutation of the mesh nodes assuming
   // that the mesh elements may be rotated (e.g. to mark triangle or tet edges
   // for refinement) between the two calls - PrepareNodeReorder() and
@@ -385,8 +365,6 @@ protected:

   STable3D *GetFacesTable();
   STable3D *GetElementToFaceTable(int ret_ftbl = 0);
-   STable4D *GetElementToFaceTable4D(int ret_ftbl = 0);
-   STable3D *GetElementToPlanarTable(int ret_ftbl = 0);

   /** Red refinement. Element with index i is refined. The default
       red refinement for now is Uniform. */
@@ -409,9 +387,6 @@ protected:
   /// Bisect a boundary triangle: boundary element with index @a i is bisected.
   void BdrBisection(int i, const HashTable<Hashed2> &);

-   void RedRefinementPentatope(int i, HashTable<Hashed2> & v_to_v);
-   void RedRefinementBoundaryTet(int i, HashTable<Hashed2> & v_to_v);
-
   /** Uniform Refinement. Element with index i is refined uniformly. */
   void UniformRefinement(int i, const DSTable &, int *, int *, int *);

@@ -501,8 +476,6 @@ protected:
                                        int i) const;
   void GetLocalQuadToPyrTransformation(IsoparametricTransformation &loc,
                                        int i) const;
-   void GetLocalTetToPentTransformation(IsoparametricTransformation &loc,
-                                        int i) const;

   /** Used in GetFaceElementTransformations to account for the fact that a
       slave face occupies only a portion of its master face. */
@@ -540,8 +513,6 @@ protected:
   /// Returns the orientation of "test" relative to "base"
   static int GetTetOrientation(const int *base, const int *test);

-   static int GetHexOrientation(const int * base, const int * test);
-
   static void GetElementArrayEdgeTable(const Array<Element*> &elem_array,
                                        const DSTable &v_to_v,
                                        Table &el_to_edge);
@@ -563,15 +534,6 @@ protected:

   void AddQuadFaceElement (int lf, int gf, int el,
                            int v0, int v1, int v2, int v3);
-
-   void AddTetrahedralFaceElement(int lf, int gf, int el,
-                                  int v0, int v1, int v2, int v3);
-
-   void AddHexahedralFaceElement(int lf, int gf, int el,
-                                 int v0, int v1, int v2, int v3,
-                                 int v4, int v5, int v6, int v7);
-
-
   /** For a serial Mesh, return true if the face is interior. For a parallel
       ParMesh return true if the face is interior or shared. In parallel, this
       method only works if the face neighbor data is exchanged. */
@@ -580,14 +542,10 @@ protected:
      return FaceIsInterior(FaceNo) || (faces_info[FaceNo].Elem2Inf >= 0);
   }

-   //swap first two entries of *a
-   inline void Swap(int *a) const;
-
   void FreeElement(Element *E);

   void GenerateFaces();
   void GenerateNCFaceInfo();
-   void GeneratePlanars();

   /// Begin construction of a mesh
   void InitMesh(int Dim_, int spaceDim_, int NVert, int NElem, int NBdrElem);
@@ -607,16 +565,6 @@ protected:
                std::string section_delimiter = "",
                const std::string &comments = "") const;

-   /** Creates mesh for the hyper-prism spatial_mesh x[0,st], divided into
-       4*nt*spatial_mesh.NumElem pentatopes. */
-   void Make4D(Mesh* spatial_mesh, int nt, Element::Type type, double st);
-
-   /** Creates mesh for the 4-parallelotope [0,sx]x[0,sy]x[0,sz]x[0,st], divided into
-       nx*ny*nz*nt tesseracts if type=TESSERACT or into 24*nx*ny*nz*nt pentatopes if
-       type=PENTATOPE. */
-   void Make4D(int nx, int ny, int nz, int nt, Element::Type type, double sx,
-               double sy, double sz, double st);
-
   /// @brief Creates a mesh for the parallelepiped [0,sx]x[0,sy]x[0,sz],
   /// divided into nx*ny*nz hexahedra if @a type = HEXAHEDRON or into
   /// 6*nx*ny*nz tetrahedrons if @a type = TETRAHEDRON.
@@ -909,9 +857,7 @@ public:
       vectors using Mesh::CreatePeriodicVertexMapping.
       @note MFEM requires that each edge of the resulting mesh be uniquely
       identifiable by a pair of distinct vertices. As a consequence, periodic
-       boundaries must be separated by at least two interior vertices.
-       @note The resulting mesh uses a discontinuous nodal function, see
-       SetCurvature() for further details. */
+       boundaries must be connected by at least three edges. */
   static Mesh MakePeriodic(const Mesh &orig_mesh, const std::vector<int> &v2v);

   ///@}
@@ -982,11 +928,6 @@ public:
   /// 8 vertices @a vi.
   void AddHexAsPyramids(const int *vi, int attr = 1);

-   int AddPent(const int *vi, int attr = 1);
-   int AddTes(const int *vi, int attr = 1);
-   void AddTesAsPentatopes(const int *vi, int attr = 1);
-   void AddHyperPrismAsPentatopes(const int *vi, int attr = 1);
-
   /// @brief Adds 24 tetrahedrons to the mesh by splitting a hexahedron.
   ///
   /// @a vi are the 8 vertices of the hexahedron, @a hex_face_verts has the
@@ -1028,10 +969,6 @@ public:
   int AddBdrQuad(int v1, int v2, int v3, int v4, int attr = 1);
   int AddBdrQuad(const int *vi, int attr = 1);
   void AddBdrQuadAsTriangles(const int *vi, int attr = 1);
-   int AddBdrTet(const int *vi, int attr = 1);
-   int AddBdrHex(const int *vi, int attr = 1);
-   void AddBdrHexAsTets(const int *vi, int perm, int attr = 1);
-   void AddBdrPrismAsTets(const int *vi, int attr = 1);

   int AddBdrPoint(int v, int attr = 1);

@@ -1051,8 +988,6 @@ public:
   /// Finalize the construction of a hexahedral Mesh.
   void FinalizeHexMesh(int generate_edges = 0, int refine = 0,
                        bool fix_orientation = true);
-   void FinalizeTesMesh(int generate_edges = 0, int refine = 0,
-                        bool fix_orientation = true);
   /// Finalize the construction of any type of Mesh.
   /** This method calls FinalizeTopology() and Finalize(). */
   void FinalizeMesh(int refine = 0, bool fix_orientation = true);
@@ -1218,32 +1153,6 @@ public:

   /// @}

-   /** Creates mesh for the hyper-prism spatial_mesh x[0,st], divided into
-       4*nt*spatial_mesh.NumElem pentatopes. If refine = true (default) the
-       mesh is made conforming for the bisection algorithm, i.e., each
-       pentatope is again subdivided into 60 sub-pentatopes. */
-   Mesh(Mesh* spatial_mesh, int nt, Element::Type type, bool refine = true, double st = 1.0)
-    : attribute_sets(attributes), bdr_attribute_sets(bdr_attributes)
-   {
-
-      Make4D(spatial_mesh, nt, type, st);
-      Finalize(refine, true);
-   }
-
-   /** Creates mesh for the 4-parallelotope [0,sx]x[0,sy]x[0,sz]x[0,st], divided into
-       nx*ny*nz*nt tesseracts if type=TESSERACT or into 24*nx*ny*nz*nt pentatopes if
-       type=PENTATOPE. If refine = true (default) the mesh is made conforming
-       for the bisection algorithm, i.e., each pentatope is again subdivided
-       into 60 sub-pentatopes. */
-   Mesh(int nx, int ny, int nz, int nt, Element::Type type, bool refine = true,
-        double sx = 1.0, double sy = 1.0, double sz = 1.0, double st = 1.0)
-     : attribute_sets(attributes), bdr_attribute_sets(bdr_attributes)
-   {
-        Make4D(nx, ny, nz, nt, type, sx, sy, sz, st);
-        Finalize(refine,true);
-   }
-
-
   /// @name Information about the mesh as a whole
   /// @{

@@ -1260,9 +1169,6 @@ public:
   inline int EulerNumber2D() const
   { return NumOfVertices - NumOfEdges + NumOfElements; }

-   inline int EulerNumber4D() const
-   { return NumOfVertices - NumOfEdges + NumOfPlanars - NumOfFaces + NumOfElements;}
-
   /** @brief Get the mesh generator/type.

       The purpose of this is to be able to quickly tell what type of elements
@@ -1328,9 +1234,6 @@ public:
   /// Return the number of faces in a 3D mesh.
   inline int GetNFaces() const { return NumOfFaces; }

-   /// Return the number of planars in a 4D mesh.
-   inline int GetNPlanars() const { return NumOfPlanars; }
-
   /// Return the number of faces (3D), edges (2D) or vertices (1D).
   int GetNumFaces() const;

@@ -1386,11 +1289,6 @@ public:
   /// the Element object itself should not be deleted by the caller.
   Element *GetElement(int i) { return elements[i]; }

-   bool getSwappedElementInfo(int i) const { return false; }
-   bool getSwappedFaceElementInfo(int i) const { return swappedFaces[i]; }
-   bool getSwappedBdrElementInfo(int i) const { return swappedBdr[i]; }
-
-
   /// @brief Return pointer to the i'th boundary element object
   ///
   /// The index @a i should be in the range [0, Mesh::GetNBE())
@@ -1470,14 +1368,6 @@ public:
   /// Return the Geometry::Type associated with face @a i.
   Geometry::Type GetFaceGeometry(int i) const;

-   const Element *GetPlanar(int i) const
-   { return planars[i]; }
-
-   Geometry::Type GetPlanarBaseGeometry(int i) const
-   {
-      return planars[i]->GetGeometryType();
-   }
-
   Geometry::Type GetElementGeometry(int i) const
   {
      return elements[i]->GetGeometryType();
@@ -1488,8 +1378,6 @@ public:
      return boundary[i]->GetGeometryType();
   }

-   Geometry::Type GetBdrPlanarBaseGeometry(int i) const;
-
   /// Deprecated in favor of Mesh::GetFaceGeometry
   MFEM_DEPRECATED Geometry::Type GetFaceBaseGeometry(int i) const
   { return GetFaceGeometry(i); }
@@ -1560,21 +1448,10 @@ public:
   /// Return the indices and the orientations of all edges of bdr element i.
   void GetBdrElementEdges(int i, Array<int> &edges, Array<int> &cor) const;

-   /// Return the indices and the orientations of all planars of element i.
-   void GetBdrElementPlanars(int i, Array<int> &pls, Array<int> &cor) const;
-
   /** Return the indices and the orientations of all edges of face i.
       Works for both 2D (face=edge) and 3D faces. */
   void GetFaceEdges(int i, Array<int> &edges, Array<int> &o) const;

-   /** Return the indices and the orientations of all edges of planar i.
-       Works only in 4D. */
-   void GetPlanarEdges(int i, Array<int> &, Array<int> &) const;
-
-   /** Return the indices and the orientations of all planars of face i.
-       Works for 4D faces. */
-   void GetFacePlanars(int i, Array<int> &, Array<int> &) const;
-
   /// Returns the indices of the vertices of face i.
   void GetFaceVertices(int i, Array<int> &vert) const
   {
@@ -1591,9 +1468,6 @@ public:
   /// Returns the indices of the vertices of edge i.
   void GetEdgeVertices(int i, Array<int> &vert) const;

-   /// Returns the indices of the vertices of planar i.
-   void GetPlanVertices(int i, Array<int> &vert) const;
-
   /// Return the indices and the orientations of all faces of element i.
   void GetElementFaces(int i, Array<int> &faces, Array<int> &ori) const;

@@ -1609,9 +1483,6 @@ public:
       GetElementEdges/GetBdrElementEdges. */
   void GetBdrElementFace(int i, int *f, int *o) const;

-   /// Return the indices and the orientations of all planars of element i.
-   void GetElementPlanars(int i, Array<int> &pls, Array<int> &cor) const;
-
   /** @brief For the given boundary element, bdr_el, return its adjacent
       element and its info, i.e. 64*local_bdr_index+bdr_orientation.

@@ -1680,15 +1551,6 @@ public:
   /// @note The returned object should NOT be deleted by the caller.
   Table *GetEdgeVertexTable() const;

-   Table *GetFacePlanarTable() const;
-
-   /// Returns the planar-to-edge Table (4D)
-   ///
-   /// @note The returned object should NOT be deleted by the caller.
-   Table *GetPlanarEdgeTable() const;
-
-
-
   /** Return vertex to vertex table. The connections stored in the table
    are from smaller to bigger vertex index, i.e. if i<j and (i, j) is
    in the table, then (j, i) is not stored.
@@ -1818,13 +1680,6 @@ public:
   /// Also, the returned object should NOT be deleted by the caller.
   ElementTransformation *GetEdgeTransformation(int EdgeNo);

-   /** Returns the transformation defining the given planar element.
-       The transformation is stored in a user-defined variable. */
-   void GetPlanarTransformation(int i, IsoparametricTransformation *PlTr);
-
-   /// Returns the transformation defining the given face element
-   ElementTransformation *GetPlanarTransformation(int PlanarNo);
-
   /// Returns (a pointer to an object containing) the following data:
   ///
   /// 1) Elem1No - the index of the first element that contains this face this
@@ -2157,10 +2012,6 @@ public:

   /// @}

-   const Table &ElementToPlanTable() const;
-
-   void ReplaceBoundaryFromFaces();
-
   /// @name Methods related to mesh partitioning
   /// @{

@@ -3064,13 +2915,6 @@ Mesh *Extrude1D(Mesh *mesh, const int ny, const real_t sy,
 /// Extrude a 2D mesh
 Mesh *Extrude2D(Mesh *mesh, const int nz, const real_t sz);

-inline void Mesh::Swap(int *a) const
-{
-   int temp = a[0];
-   a[0] = a[1];
-   a[1] = temp;
-}
-
 // shift cyclically 3 integers left-to-right
 inline void ShiftRight(int &a, int &b, int &c)
 {
@@ -22,8 +22,6 @@
 #include "quadrilateral.hpp"
 #include "hexahedron.hpp"
 #include "tetrahedron.hpp"
-#include "pentatope.hpp"
-#include "tesseract.hpp"
 #include "ncmesh.hpp"
 #include "mesh.hpp"
 #include "mesh_operators.hpp"
@@ -1151,24 +1151,15 @@ void Mesh::ReadXML_VTKMesh(std::istream &input, int &curved, int &read_gf,
   }
   if (cells_xml == NULL) { MFEM_ABORT(erstr); }

-   // Read the element attributes, which are stored as CellData named either
-   // "material" or "attribute". We prioritize "material" over "attribute" for
-   // backwards compatibility.
+   // Read the element attributes, which are stored as CellData named "material"
   Array<int> cell_attributes;
-   bool found_attributes = false;
   for (const XMLElement *cell_data_xml = piece->FirstChildElement();
        cell_data_xml != NULL;
        cell_data_xml = cell_data_xml->NextSiblingElement())
   {
-      const bool is_cell_data =
-         StringCompare(cell_data_xml->Name(), "CellData");
-      const bool is_material =
-         StringCompare(cell_data_xml->Attribute("Scalars"), "material");
-      const bool is_attribute =
-         StringCompare(cell_data_xml->Attribute("Scalars"), "attribute");
-      if (is_cell_data && (is_material || (is_attribute && !found_attributes)))
+      if (StringCompare(cell_data_xml->Name(), "CellData")
+          && StringCompare(cell_data_xml->Attribute("Scalars"), "material"))
      {
-         found_attributes = true;
         const XMLElement *data_xml = cell_data_xml->FirstChildElement();
         if (data_xml != NULL && StringCompare(data_xml->Name(), "DataArray"))
         {
@@ -1283,7 +1274,6 @@ void Mesh::ReadVTKMesh(std::istream &input, int &curved, int &read_gf,
   // Read the cell materials
   // bool found_material = false;
   Array<int> cell_attributes;
-   bool found_attributes = false;
   while ((input.good()))
   {
      getline(input, buff);
@@ -1291,10 +1281,8 @@ void Mesh::ReadVTKMesh(std::istream &input, int &curved, int &read_gf,
      {
         break; // We have entered the POINT_DATA block. Quit.
      }
-      else if (buff.rfind("SCALARS material") == 0 ||
-               (buff.rfind("SCALARS attribute") == 0 && !found_attributes))
+      else if (buff.rfind("SCALARS material") == 0)
      {
-         found_attributes = true;
         getline(input, buff); // LOOKUP_TABLE default
         if (buff.rfind("LOOKUP_TABLE default") != 0)
         {
@@ -2452,7 +2452,7 @@ const real_t* NCMesh::CalcVertexPos(int node) const
   const real_t* pos1 = CalcVertexPos(nd.p1);
   const real_t* pos2 = CalcVertexPos(nd.p2);

-   for (int i = 0; i < Dim; i++) // TODO check if any memory violations occur
+   for (int i = 0; i < 3; i++)
   {
      tv.pos[i] = (pos1[i] + pos2[i]) * 0.5;
   }
@@ -935,7 +935,7 @@ protected: // implementation
   struct Point
   {
      int dim;
-      real_t coord[4];
+      real_t coord[3];

      Point() { dim = 0; }

@@ -950,9 +950,6 @@ protected: // implementation
      Point(real_t x, real_t y, real_t z)
      { dim = 3; coord[0] = x; coord[1] = y; coord[2] = z; }

-      Point(double x, double y, double z, double t)
-      { dim = 4; coord[0] = x; coord[1] = y; coord[2] = z; coord[3] = t; }
-
      Point(const Point& p0, const Point& p1)
      {
         dim = p0.dim;
@@ -1013,14 +1010,13 @@ protected: // implementation
      PointMatrix(const Point& p0, const Point& p1, const Point& p2, const Point& p3)
      { np = 4; points[0] = p0; points[1] = p1; points[2] = p2; points[3] = p3; }

-      PointMatrix(const Point& p0, const Point& p1, const Point& p2, const Point& p3,
-                  const Point& p4)
+      PointMatrix(const Point& p0, const Point& p1, const Point& p2,
+                  const Point& p3, const Point& p4)
      {
         np = 5;
         points[0] = p0; points[1] = p1; points[2] = p2;
         points[3] = p3; points[4] = p4;
      }
-
      PointMatrix(const Point& p0, const Point& p1, const Point& p2,
                  const Point& p3, const Point& p4, const Point& p5)
      {
@@ -1028,7 +1024,6 @@ protected: // implementation
         points[0] = p0; points[1] = p1; points[2] = p2;
         points[3] = p3; points[4] = p4; points[5] = p5;
      }
-
      PointMatrix(const Point& p0, const Point& p1, const Point& p2,
                  const Point& p3, const Point& p4, const Point& p5,
                  const Point& p6, const Point& p7)
@@ -1077,7 +1072,7 @@ protected: // implementation
   struct TmpVertex
   {
      bool valid, visited;
-      real_t pos[4];
+      real_t pos[3];
      TmpVertex() : valid(false), visited(false) {}
   };

@@ -1,246 +0,0 @@
-// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
-// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
-// reserved. See file COPYRIGHT for details.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability see http://mfem.googlecode.com.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the GNU Lesser General Public License (as published by the Free
-// Software Foundation) version 2.1 dated February 1999.
-
-// Implementation of class Pentatope
-
-
-#include "mesh_headers.hpp"
-
-namespace mfem
-{
-
-
-Pentatope::Pentatope(const int *ind, int attr, unsigned char f)
-   : Element(Geometry::PENTATOPE)
-{
-   attribute = attr;
-   for (int i = 0; i < 5; i++)
-   {
-      indices[i] = ind[i];
-   }
-
-   transform = 0;
-   flag = f;
-}
-
-Pentatope::Pentatope(int ind1, int ind2, int ind3, int ind4, int ind5, int attr, unsigned char f)
-   : Element(Geometry::PENTATOPE)
-{
-   attribute  = attr;
-   indices[0] = ind1;
-   indices[1] = ind2;
-   indices[2] = ind3;
-   indices[3] = ind4;
-   indices[4] = ind5;
-
-   transform = 0;
-   flag = f;
-}
-
-// Cancelled and added new version at the end of the file (2025 November)
-// void Pentatope::GetVertices(Array<int> &v) const
-// {
-//    v.SetSize(5);
-//    for (int i = 0; i < 5; i++)
-//    {
-//       v[i] = indices[i];
-//    }
-// }
-//
-// void Pentatope::SetVertices(const int *ind)
-// {
-//    for (int i = 0; i < 5; i++)
-//    {
-//       indices[i] = ind[i];
-//    }
-// }
-
-//static method
-void Pentatope::GetPointMatrix(unsigned transform, DenseMatrix &pm) // FIXME for bisection
-{
-   double* a = &pm(0,0), *b = &pm(0,1), *c = &pm(0,2), *d = &pm(0,3), *e = &pm(0,
-                                                                               4);
-
-   // initialize to identity
-   a[0] = 0.0, a[1] = 0.0, a[2] = 0.0, a[3] = 0.0;
-   b[0] = 1.0, b[1] = 0.0, b[2] = 0.0, b[3] = 0.0;
-   c[0] = 0.0, c[1] = 1.0, c[2] = 0.0, c[3] = 0.0;
-   d[0] = 0.0, d[1] = 0.0, d[2] = 1.0, d[3] = 0.0;
-   e[0] = 0.0, e[1] = 0.0, e[2] = 0.0, e[3] = 1.0;
-
-   int chain[12], n = 0;
-   bool swapped[12];
-   while (transform)
-   {
-      chain[n++] = (transform & 15) - 1;
-      swapped[n-1] = ( (transform & 31) / 16 == 1);
-      transform >>= 5;
-   }
-
-#define ASGN(a, b) (a[0] = b[0], a[1] = b[1], a[2] = b[2], a[3] = b[3])
-#define SWAP(a, b) for (int i = 0; i < 4; i++) { std::swap(a[i], b[i]); }
-#define AVG(a, b, c) for (int i = 0; i < 4; i++) { a[i] = (b[i]+c[i])*0.5; }
-
-   double f[4];
-   while (n)
-   {
-      switch (chain[--n])
-      {
-      case 0:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(e,d); ASGN(d,c); ASGN(c,b); ASGN(b,f);
-         if (!swapped[n]) SWAP(a,e);
-         break; // chilTesseractd 1, tag 0 parent
-      case 1:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(e,d); ASGN(d,c); ASGN(c,b); ASGN(b,f);
-         if (!swapped[n]) SWAP(a,e);
-         break; // child 1, tag 1 parent
-      case 2:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(e,d); ASGN(d,c); ASGN(c,b); ASGN(b,f);
-         if (!swapped[n]) SWAP(a,e);
-         break; // child 1, tag 2 parent
-      case 3:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(e,d); ASGN(d,c); ASGN(c,b); ASGN(b,f);
-         if (!swapped[n]) SWAP(a,e);
-         break; // child 1, tag 3 parent
-      case 10:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(a,e); ASGN(e,b); SWAP(c,d); ASGN(b,f);
-         if (!swapped[n]) SWAP(a,e);
-         break; // child 2, tag 0 parent
-      case 11:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(a,e); ASGN(e,c); ASGN(c,b); ASGN(b,f);
-         if (!swapped[n]) SWAP(a,e);
-         break; // child 2, tag 1 parent
-      case 12:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(a,e); ASGN(e,d); ASGN(d,c); ASGN(c,b); ASGN(b,f);
-         if (swapped[n]) SWAP(a,e);
-         break; // child 2, tag 2 parent
-      case 13:
-         if (swapped[n]) SWAP(a,e);
-         AVG(f,a,e); ASGN(a,e); ASGN(e,d); ASGN(d,c); ASGN(c,b); ASGN(b,f);
-         if (swapped[n]) SWAP(a,e);
-         break; // child 2, tag 3 parent
-   #if 0 // Freudenthal
-         case 0 : AVG(b,a,b); AVG(c,a,c); AVG(d,a,d); AVG(e,a,e); break; // 1,6,7,8,9
-         case 1 : AVG(a,a,b); AVG(c,b,c); AVG(d,b,d); AVG(e,b,e); break; // 6,2,10,11,12
-         case 2 : AVG(a,a,c); AVG(b,b,c); AVG(d,c,d); AVG(e,c,e); break; // 7,10,3,13,14
-         case 3 : AVG(a,a,d); AVG(b,b,d); AVG(c,c,d); AVG(e,d,e); break; // 8,11,13,4,15
-         case 4 : AVG(a,a,e); AVG(b,b,e); AVG(c,c,e); AVG(d,d,e); break; // 9,12,14,15,5
-         case 5 : ASGN(f,e); AVG(e,d,e); AVG(d,c,d); ASGN(g,b); AVG(c,b,c); AVG(b,a,f);
-            AVG(a,a,g); break; // 6,9,10,13,15
-         case 6 : ASGN(f,a); AVG(a,a,b); AVG(b,f,d); ASGN(g,c); AVG(c,f,e); AVG(e,d,e);
-            AVG(d,g,d); break; // 6,8,9,13,15
-         case 7 : ASGN(f,e); AVG(e,d,e); AVG(d,b,d); ASGN(g,c); AVG(c,b,c); AVG(b,a,f);
-            AVG(a,a,g); break; // 7,9,10,11,13
-         case 8 : ASGN(f,a); AVG(a,a,b); AVG(b,f,c); ASGN(g,e); AVG(e,c,d); AVG(c,f,d);
-            AVG(d,f,g); break; // 6,7,8,9,13
-         case 9 : ASGN(f,e); AVG(a,a,e); AVG(e,f,d); ASGN(g,c); AVG(b,b,c); AVG(c,c,d);
-            AVG(d,f,g); break; // 9,10,13,14,15
-         case 10: ASGN(f,a); AVG(a,a,b); AVG(c,b,c); ASGN(g,e); AVG(e,d,e); AVG(d,b,g);
-            AVG(b,f,g); break; // 6,9,10,12,15
-         case 11: ASGN(f,d); AVG(d,c,d); AVG(e,d,e); ASGN(g,a); AVG(a,a,b); AVG(c,b,f);
-            AVG(b,g,f); break; // 6,8,11,13,15
-         case 12: ASGN(f,b); AVG(a,a,b); AVG(b,b,c); ASGN(g,e); AVG(e,d,e); AVG(c,f,d);
-            AVG(d,f,g); break; // 6,10,11,12,15
-         case 13: ASGN(f,c); AVG(c,a,e); AVG(e,c,d); ASGN(g,a); AVG(a,a,b); AVG(d,b,f);
-            AVG(b,f,g); break; // 6,7,9,10,13
-         case 14: ASGN(f,b); AVG(b,b,c); AVG(a,a,e); ASGN(g,e); AVG(e,d,e); AVG(d,c,g);
-            AVG(c,f,g); break; // 9,10,12,14,15
-         case 15: ASGN(f,d); AVG(d,c,d); AVG(a,a,b); ASGN(g,b); AVG(b,b,c); AVG(e,f,e);
-            AVG(c,g,f); break; // 6,10,11,13,15
-   #endif
-         default:
-            MFEM_ABORT("Invalid transform.");
-      }
-   }
-
-}
-
-Element *Pentatope::Duplicate(Mesh *m) const
-{
-   Pentatope *pent = new Pentatope;
-   pent->SetVertices(indices);
-   pent->SetAttribute(attribute);
-   pent->SetFlag(flag);
-   return pent;
-}
-
-int Pentatope::NeedRefinement(HashTable<Hashed2> &v_to_v) const
-{
-   if (v_to_v.FindId(indices[0], indices[1]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[1], indices[2]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[2], indices[0]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[0], indices[3]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[1], indices[3]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[2], indices[3]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[0], indices[4]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[1], indices[4]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[2], indices[4]) != -1) { return 1; }
-   if (v_to_v.FindId(indices[4], indices[3]) != -1) { return 1; }
-   return 0;
-}
-
-void Pentatope::CreateFlag(char t, bool swap)
-{
-   flag = t;
-   flag <<= 1;
-   flag |= swap;
-}
-
-void Pentatope::ParseFlag(char& t, bool& swap)
-{
-   unsigned char f = flag;
-
-   swap = (f & 1);
-   f >>= 1;
-   t = (f & 3);
-}
-
-void Pentatope::GetFace(int fi, int *fv)
-{
-    // const int faces[5][4] = { {0, 1, 2, 3}, {0, 1, 2, 4},
-    //         {0, 1, 3, 4}, {0, 2, 3, 4},
-    //         {1, 2, 3, 4}};
-    const int *v = geom_p::FaceVert[fi];
-    for (int k = 0; k < 4; ++k)
-    {
-        fv[k] = indices[v[k]];
-    }
-
-//    if (fi % 2 == 1)
-//        std::swap(fv[1], fv[2]);
-}
-
-void Pentatope::GetVertices(Array<int> &v) const
-{
-   v.SetSize(5);
-   std::copy(indices, indices + 5, v.begin());
-}
-
-void Pentatope::SetVertices(const Array<int> &v)
-{
-   MFEM_ASSERT(v.Size() == 5, "!");
-   std::copy(v.begin(), v.end(), indices);
-}
-
-void Pentatope::SetVertices(const int *ind)
-{
-   std::copy(ind, ind + 5, indices);
-}
-
-
-}
@@ -1,144 +0,0 @@
-// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
-// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
-// reserved. See file COPYRIGHT for details.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability see http://mfem.googlecode.com.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the GNU Lesser General Public License (as published by the Free
-// Software Foundation) version 2.1 dated February 1999.
-
-
-#ifndef MFEM_PENTATOPE
-#define MFEM_PENTATOPE
-
-#include "../config/config.hpp"
-#include "../fem/fe.hpp"
-#include "element.hpp"
-
-namespace mfem
-{
-
-/// Data type pentatope element
-class Pentatope : public Element
-{
-protected:
-   int indices[5];
-
-   unsigned transform;
-
-   /* Flag holds currently
-    *    One bit indicating if the element has been swapped.
-    *    Two bits indicating the tag of the simplex (0, 1, 2, 3)
-    */
-   unsigned char flag;
-
-public:
-
-   typedef Geometry::Constants<Geometry::PENTATOPE> geom_p;
-
-   Pentatope() : Element(Geometry::PENTATOPE) { transform = 0; flag = 0;};
-
-   /// Constructs pentatope by specifying the indices and the attribute.
-   Pentatope(const int *ind, int attr = 1, unsigned char type = 0);
-
-   /// Constructs pentatope by specifying the indices and the attribute.
-   Pentatope(int ind1, int ind2, int ind3, int ind4, int ind5, int attr = 1, unsigned char type = 0);
-
-
-   virtual int GetRefinementFlag()
-   { MFEM_ABORT("PENTATOPE:: GetRefinementFlag not implemented"); return 0; }
-
-
-   /// Return 1 if the element needs refinement in order to get conforming mesh.
-   virtual int NeedRefinement(HashTable<Hashed2> &v_to_v) const;
-
-   /// Mark the longest edge by assuming/changing the order of the vertices.
-   virtual void MarkEdge(DenseMatrix &pmat)
-   { MFEM_ABORT("PENTATOPE:: MarkEdge not implemented"); }
-
-   /** Reorder the vertices so that the longest edge is from vertex 0
-       to vertex 1. If called it should be once from the mesh constructor,
-       because the order may be used later for setting the edges. **/
-   virtual void MarkEdge(const DSTable &v_to_v, const int *length)
-   { MFEM_ABORT("PENTATOPE:: MarkEdge not implemented"); }
-
-   virtual void GetFace(int fi, int *fv);
-
-   /// Return element's type.
-   virtual Type GetType() const { return Element::PENTATOPE; }
-
-   virtual void CreateFlag(char  t, bool  swap);
-   virtual void  ParseFlag(char &t, bool &swap);
-
-   virtual void SetFlag(const unsigned char t) { flag = t; }
-
-   /// Return flag of element.
-   virtual unsigned char GetFlag() const { return flag; }
-
-   // Cancelled and added new version at the end of the file (2025 November)
-   // /// Set the vertices according to the given input.
-   // virtual void SetVertices(const int *ind);
-   //
-   // /// Returns the indices of the element's  vertices.
-   // virtual void GetVertices(Array<int> &v) const;
-   //
-   // virtual int *GetVertices() { return indices; }
-
-   virtual int GetNVertices() const { return 5; }
-
-   virtual int GetNEdges() const { return 10; }
-
-   virtual int GetNPlanars() const { return 10; }
-
-   virtual const int *GetEdgeVertices(int ei) const { return (geom_p::Edges[ei]); }
-
-   virtual const int *GetPlanarsVertices(int pi) const { return (geom_p::PlanarVert[pi]); }
-
-   MFEM_DEPRECATED virtual int GetNFaces(int &nFaceVertices) const
-   { nFaceVertices = 4; return 5; }
-
-   virtual int GetNFaces() const { return 5; };
-
-   virtual int GetNFaceVertices(int fi) const { return 4; };
-
-   virtual const int *GetFaceVertices(int fi) const
-   { return geom_p::FaceVert[fi]; }
-
-   /// Calculate point matrix corresponding to a chain of transformations.
-   static void GetPointMatrix(unsigned transform, DenseMatrix &pm);
-
-   virtual void ResetTransform(int tr) { transform = tr; }
-   virtual unsigned GetTransform() const { return transform; }
-
-   virtual void PushTransform(int tr)
-   { transform = (transform << 5) | (tr + 1); }
-
-   virtual Element *Duplicate(Mesh *m) const;
-
-   /// Get the indices defining the vertices.
-   void GetVertices(Array<int> &v) const override;
-
-   /// Set the indices defining the vertices.
-   void SetVertices(const Array<int> &v) override;
-
-   /// @note The returned array should NOT be deleted by the caller.
-   int * GetVertices () override { return indices; }
-
-   /// Set the indices defining the vertices.
-   void SetVertices(const int *ind) override;
-
-   virtual ~Pentatope() { }
-
-};
-
-extern MFEM_EXPORT Linear4DFiniteElement PentatopeFE;
-
-}
-
-
-
-
-
-#endif
@@ -63,48 +63,26 @@ protected:
      void Set(int v0, int v1, int v2, int v3)
      { v[0] = v0; v[1] = v1; v[2] = v2; v[3] = v3; }
      void Set(const int *w)
-      { v[0] = w[0]; v[1] = w[1]; v[2] = w[2]; v[3] = w[3];}
+      { v[0] = w[0]; v[1] = w[1]; v[2] = w[2]; v[3] = w[3]; }
   };

-   struct Vert4_tag
-   {
-      int v[4];
-      char tag;
-
-      Vert4_tag() = default;
-      Vert4_tag(int v0, int v1, int v2, int v3, char _tag = 0)
-      {
-          v[0] = v0; v[1] = v1; v[2] = v2; v[3] = v3; tag = _tag;
-      }
-      void Set(int v0, int v1, int v2, int v3,  char _tag = 0)
-      { v[0] = v0; v[1] = v1; v[2] = v2; v[3] = v3; tag = _tag; }
-      void Set(const int *w, char _tag = 0)
-      { v[0] = w[0]; v[1] = w[1]; v[2] = w[2]; v[3] = w[3]; tag = _tag; }
-    };
-
   Array<Element *> shared_edges;
   // shared face id 'i' is:
   //   * triangle id 'i',                  if i < shared_trias.Size()
   //   * quad id 'i-shared_trias.Size()',  otherwise
   Array<Vert3> shared_trias;
   Array<Vert4> shared_quads;
-   Array<Vert4_tag> shared_tetra;
-   //   Array<Element *> shared_planars;

   /// Shared objects in each group.
   Table group_svert;
   Table group_sedge;
   Table group_stria;  // contains shared triangle indices
   Table group_squad;  // contains shared quadrilateral indices
-   Table group_stetr;
-   //   Table group_splan;

   /// Shared to local index mapping.
   Array<int> svert_lvert;
   Array<int> sedge_ledge;
-   Array<int> splan_lplan;
   // sface ids: all triangles first, then all quads
-   // in 4D, just all tetrahedra
   Array<int> sface_lface;

   /// Table that maps from face neighbor element number, to the face numbers of
@@ -144,18 +122,6 @@ protected:
   bool DecodeFaceSplittings(HashTable<Hashed2> &v_to_v, const int *v,
                             const Array<unsigned> &codes, int &pos);

-   void GetFaceSplittings4D(const Vert4_tag &f, const HashTable<Hashed2> &v_to_v,
-                            const DSTable &edges, Array<unsigned> &codes);
-
-   bool DecodeFaceSplittings4D(HashTable<Hashed2> &v_to_v, const Vert4_tag &v,
-                               const Array<unsigned> &codes, int &pos);
-
-   void GetFaceSplittings4D_old(const Vert4_tag &f, const HashTable<Hashed2> &v_to_v,
-                                Array<unsigned> &codes);
-
-   bool DecodeFaceSplittings4D_old(HashTable<Hashed2> &v_to_v, const Vert4_tag &v,
-                                   const Array<unsigned> &codes, int &pos);
-
   // Given a completed FacesTable and SharedFacesTable, construct a table that
   // maps from face neighbor element number, to the set of faces of that
   // element. Store the resulting data in the member variable
@@ -200,9 +166,6 @@ protected:
   /// Update the groups after tetrahedron refinement
   void RefineGroups(int old_nv, const HashTable<Hashed2> &v_to_v);

-   void RefineGroups4D(int old_nv, const HashTable<Hashed2> &v_to_v);
-   void UniformRefineGroups4D_Freudenthal(int old_nv, const HashTable<Hashed2> &v_to_v);
-
   void UniformRefineGroups2D(int old_nv);

   // f2qf can be NULL if all faces are quads or there are no quad faces
@@ -263,9 +226,6 @@ protected:
                        Array<int>& face_group,
                        ListOfIntegerSets& groups);

-   int FindSharedPlanars(const Mesh &mesh, const int* partition,
-                         Table* &plan_element, ListOfIntegerSets &groups);
-
   int FindSharedEdges(const Mesh &mesh, const int* partition,
                       Table* &edge_element, ListOfIntegerSets& groups);

@@ -276,13 +236,6 @@ protected:
                       const Array<int>& face_group,
                       int &nstria, int &nsquad);

-   void BuildFaceGroup4D(int ngroups, const Mesh &mesh,
-                         const Array<int>& face_group,
-                         int &nstetr, int &nshexa);
-
-   void BuildPlanarGroup(int ngroups, const Mesh &mesh,const Table& plan_element,
-                         int &nstria, int &nsquad);
-
   void BuildEdgeGroup(int ngroups, const Table& edge_element);

   void BuildVertexGroup(int ngroups, const Table& vert_element);
@@ -293,17 +246,6 @@ protected:
                             const Array<int> &face_group,
                             const Array<int> &vert_global_local);

-   void BuildSharedFaceElems4D(int ntet_faces, int nhex_faces,
-                               const Mesh &mesh, int *partitioning,
-                               const STable4D *faces_tbl_4d,
-                               const Array<int> &face_group,
-                               const Array<int> &vert_global_local,
-                               const std::map<int,char> &vert_to_type);
-
-   void BuildSharedPlanarElems(int ntri_planars, int nquad_planars,
-                               const Mesh &mesh, const Array<int>& vert_global_local,
-                               const STable3D *planar_tbl, const Table* plan_element);
-
   void BuildSharedEdgeElems(int nedges, Mesh &mesh,
                             const Array<int> &vert_global_local,
                             const Table *edge_element);
@@ -505,17 +447,12 @@ public:
   int GroupNEdges(int group) const { return group_sedge.RowSize(group-1); }
   int GroupNTriangles(int group) const { return group_stria.RowSize(group-1); }
   int GroupNQuadrilaterals(int group) const { return group_squad.RowSize(group-1); }
-   // int GroupNPlanars(int group) const { return group_splan.RowSize(group-1); }
-   int GroupNTetrahedra(int group) const { return group_stetr.RowSize(group-1); }

   int GroupVertex(int group, int i) const
   { return svert_lvert[group_svert.GetRow(group-1)[i]]; }
-
   void GroupEdge(int group, int i, int &edge, int &o) const;
   void GroupTriangle(int group, int i, int &face, int &o) const;
   void GroupQuadrilateral(int group, int i, int &face, int &o) const;
-   void GroupTetrahedron(int group, int i, int &face, int &o) const;
-
   ///@}

   /**
@@ -819,7 +819,7 @@ ParPumiMesh::ParPumiMesh(MPI_Comm comm, apf::Mesh2* apf_mesh,
         apf::Downward verts;
         apf_mesh->getDownward(ent,0,verts);

-         int *v = nullptr, nv = 0;
+         int *v, nv = 0;
         apf::Mesh::Type ftype = apf_mesh->getType(ent);
         if (ftype == apf::Mesh::TRIANGLE)
         {
@@ -890,9 +890,9 @@ GridFunctionPumi::GridFunctionPumi(Mesh* m, apf::Mesh2* PumiM,
 {
   int spDim = m->SpaceDimension();
   // Note: default BasisType for 'fec' is GaussLobatto.
-   fec_owned = new H1_FECollection(mesh_order, m->Dimension());
+   fec = new H1_FECollection(mesh_order, m->Dimension());
   int ordering = Ordering::byVDIM; // x1y1z1/x2y2z2/...
-   fes = new FiniteElementSpace(m, fec_owned, spDim, ordering);
+   fes = new FiniteElementSpace(m, fec, spDim, ordering);
   int data_size = fes->GetVSize();

   // Read PUMI mesh data
@@ -1,116 +0,0 @@
-// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
-// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
-// reserved. See file COPYRIGHT for details.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability see http://mfem.googlecode.com.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the GNU Lesser General Public License (as published by the Free
-// Software Foundation) version 2.1 dated February 1999.
-
-
-#include "mesh_headers.hpp"
-
-namespace mfem
-{
-
-const int Tesseract::edges[32][2] =
-{
-   {0, 1}, {1, 2}, {3, 2}, {0, 3},
-   {4, 5}, {5, 6}, {7, 6}, {4, 7},
-   {0, 4}, {1, 5}, {2, 6}, {3, 7},
-   {8, 9}, {9, 10}, {11, 10}, {8, 11},
-   {12, 13}, {13, 14}, {15, 14}, {12, 15},
-   {8, 12}, {9, 13}, {10, 14}, {11, 15},
-   {0, 8}, {1, 9}, {2, 10}, {3, 11},
-   {4, 12}, {5, 13}, {6, 14}, {7, 15}
-};
-
-// same as Mesh::hex_faces
-const int Tesseract::faces[8][8] =
-{
-   // {8,11,12,15,0,3,4,7},   //x bottom
-   // {1,2,6,5,9,10,14,13},   //x top
-   // {0,1,5,4,8,9,13,12},    //y bottom
-   // {2,3,7,6,10,11,15,14},  //y top
-   // {8,9,10,11,0,1,2,3},    // z bottom
-   // {4,5,6,7,12,13,14,15},  //z top
-   // {0,1,2,3,4,5,6,7},      //t botom
-   // {12,13,14,15,8,9,10,11} //t top
-   {8,11,15,12,0,3,7,4},   //x bottom
-   {1,2,6,5,9,10,14,13},   //x top
-   {0,1,5,4,8,9,13,12},    //y bottom
-   {2,3,7,6,10,11,15,14},  //y top
-   {8,9,10,11,0,1,2,3},    // z bottom
-   {4,5,6,7,12,13,14,15},  //z top
-   {0,1,2,3,4,5,6,7},      //t botom
-   {12,13,14,15,8,9,10,11} //t top
-};
-
-
-Tesseract::Tesseract(const int *ind, int attr)
-   : Element(Geometry::TESSERACT)
-{
-   attribute = attr;
-   for (int i = 0; i < 16; i++)
-   {
-      indices[i] = ind[i];
-   }
-}
-
-Tesseract::Tesseract(int ind1, int ind2, int ind3, int ind4,
-                     int ind5, int ind6, int ind7, int ind8,
-                     int ind9, int ind10, int ind11, int ind12,
-                     int ind13, int ind14, int ind15, int ind16,
-                     int attr) : Element(Geometry::TESSERACT)
-{
-   attribute  = attr;
-   indices[0] = ind1;
-   indices[1] = ind2;
-   indices[2] = ind3;
-   indices[3] = ind4;
-   indices[4] = ind5;
-   indices[5] = ind6;
-   indices[6] = ind7;
-   indices[7] = ind8;
-   indices[8] = ind9;
-   indices[9] = ind10;
-   indices[10] = ind11;
-   indices[11] = ind12;
-   indices[12] = ind13;
-   indices[13] = ind14;
-   indices[14] = ind15;
-   indices[15] = ind16;
-}
-
-// Cancelled and added new version at the end of the file (2025 November)
-/*void Tesseract::GetVertices(Array<int> &v) const
-{
-   v.SetSize(16);
-   for (int i = 0; i < 16; i++)
-   {
-      v[i] = indices[i];
-   }
-}*/
-
-void Tesseract::GetVertices(Array<int> &v) const
-{
-   v.SetSize(16);
-   std::copy(indices, indices + 16, v.begin());
-}
-
-void Tesseract::SetVertices(const Array<int> &v)
-{
-   MFEM_ASSERT(v.Size() == 16, "!");
-   std::copy(v.begin(), v.end(), indices);
-}
-
-void Tesseract::SetVertices(const int *ind)
-{
-   std::copy(ind, ind + 16, indices);
-}
-
-QuadLinear4DFiniteElement TesseractFE;
-
-}
@@ -1,90 +0,0 @@
-// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
-// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
-// reserved. See file COPYRIGHT for details.
-//
-// This file is part of the MFEM library. For more information and source code
-// availability see http://mfem.googlecode.com.
-//
-// MFEM is free software; you can redistribute it and/or modify it under the
-// terms of the GNU Lesser General Public License (as published by the Free
-// Software Foundation) version 2.1 dated February 1999.
-
-#ifndef MFEM_TESSERACT
-#define MFEM_TESSERACT
-
-#include "../config/config.hpp"
-#include "element.hpp"
-
-namespace mfem
-{
-
-/// Data type tesseract element
-class Tesseract : public Element
-{
-protected:
-   int indices[16];
-
-public:
-   static const int edges[32][2];
-   static const int faces[8][8];  // same as Mesh::tes_faces
-
-   Tesseract() : Element(Geometry::TESSERACT) { }
-
-   /// Constructs hexahedron by specifying the indices and the attribute.
-   Tesseract(const int *ind, int attr = 1);
-
-   /// Constructs hexahedron by specifying the indices and the attribute.
-   Tesseract(int ind1, int ind2, int ind3, int ind4,
-             int ind5, int ind6, int ind7, int ind8,
-             int ind9, int ind10, int ind11, int ind12,
-             int ind13, int ind14, int ind15, int ind16, int attr = 1);
-
-   /// Return element's type
-   Type GetType() const { return Element::TESSERACT; }
-
-   // Cancelled and added new version at the end of the file (2025 November)
-   // /// Returns the indices of the element's vertices.
-   // virtual void GetVertices(Array<int> &v) const;
-   //
-   // virtual int *GetVertices() { return indices; }
-
-   virtual int GetNVertices() const { return 16; }
-
-   virtual int GetNEdges() const { return 32; }
-
-   virtual int GetNFaces() const { return 8; }
-
-   virtual int GetNFaceVertices(int fi) const { return 8; }
-
-   virtual const int *GetEdgeVertices(int ei) const
-   { return edges[ei]; }
-
-   virtual int GetNFaces(int &nFaceVertices) const
-   { nFaceVertices = 8; return 8; }
-
-   virtual const int *GetFaceVertices(int fi) const
-   { return faces[fi]; }
-
-   virtual Element *Duplicate(Mesh *m) const
-   { return new Tesseract(indices, attribute); }
-
-   /// Get the indices defining the vertices.
-   void GetVertices(Array<int> &v) const override;
-
-   /// Set the indices defining the vertices.
-   void SetVertices(const Array<int> &v) override;
-
-   /// @note The returned array should NOT be deleted by the caller.
-   int * GetVertices () override { return indices; }
-
-   /// Set the indices defining the vertices.
-   void SetVertices(const int *ind) override;
-
-   virtual ~Tesseract() { }
-};
-
-extern QuadLinear4DFiniteElement TesseractFE;
-
-}
-
-#endif
@@ -22,18 +22,17 @@ namespace mfem
 class Vertex
 {
 protected:
-   real_t coord[4];
+   real_t coord[3];

 public:
   Vertex() = default;

   // Trivial copy constructor and trivial copy assignment operator
+
   Vertex(real_t *xx, int dim);
-   Vertex(real_t x, real_t y) { coord[0] = x; coord[1] = y; coord[2] = 0.; coord[3] = 0.;}
+   Vertex(real_t x, real_t y) { coord[0] = x; coord[1] = y; coord[2] = 0.; }
   Vertex(real_t x, real_t y, real_t z)
-   { coord[0] = x; coord[1] = y; coord[2] = z; coord[3] = 0.;}
-   Vertex(real_t x, real_t y, real_t z, real_t t)
-   { coord[0] = x; coord[1] = y; coord[2] = z; coord[3] = t;}
+   { coord[0] = x; coord[1] = y; coord[2] = z; }

   /// Returns pointer to the coordinates of the vertex.
   inline real_t * operator() () const { return (real_t*)coord; }
@@ -46,8 +45,8 @@ public:

   /// (DEPRECATED) Set the coordinates of the Vertex.
   /** @deprecated This old version of SetCoords is not always memory safe. */
-   MFEM_DEPRECATED void SetCoords(const double *p)
-   { coord[0] = p[0]; coord[1] = p[1]; coord[2] = p[2]; coord[3] = p[3]; }
+   MFEM_DEPRECATED void SetCoords(const real_t *p)
+   { coord[0] = p[0]; coord[1] = p[1]; coord[2] = p[2]; }

   /// Sets vertex location based on given point p
   void SetCoords(int dim, const real_t *p)
@@ -206,7 +206,7 @@ int main (int argc, char *argv[])
   solver.SetMaxIter(200);
   solver.SetRelTol(1e-10);
   solver.SetAbsTol(0.0);
-   solver.SetAdaptiveSurfaceFittingScalingFactor(10);
+   solver.EnableAdaptiveSurfaceFitting();
   solver.SetTerminationWithMaxSurfaceFittingError(1e-3);

   // Solve.
@@ -34,22 +34,6 @@ real_t circle_level_set(const Vector &x)
   }
 }

-real_t squircle_level_set(const Vector &x)
-{
-   const int dim = x.Size();
-   if (dim == 2)
-   {
-      const real_t xc = x(0) - 0.5, yc = x(1) - 0.5;
-      return std::pow(xc, 4.0) + std::pow(yc, 4.0) - std::pow(0.24, 4.0);
-   }
-   else
-   {
-      const real_t xc = x(0) - 0.5, yc = x(1) - 0.5, zc = x(2) - 0.5;
-      return std::pow(xc, 4.0) + std::pow(yc, 4.0) +
-             std::pow(zc, 4.0) - std::pow(0.24, 4.0);
-   }
-}
-
 real_t in_circle(const Vector &x, const Vector &x_center, real_t radius)
 {
   Vector x_current = x;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Socratis Petrides	896e78972c	empty part fix	2024-05-28 14:36:24 -07:00
Socratis Petrides	8bdcf168a2	style	2024-05-27 20:16:17 -07:00
Socratis Petrides	2fb0e6fe48	minor edits	2024-05-27 20:08:07 -07:00
Socratis Petrides	28bb675053	minor edits	2024-05-20 17:41:27 -07:00
Socratis Petrides	787942b114	adding block prec with exact inverese. Adding complex operator convention and sign scaling	2024-05-20 14:06:16 -07:00
Socratis Petrides	66cc54e680	maxwell driver to test block-diag AMS	2024-05-20 12:56:04 -07:00