From 01a2ab5fc0a21bdd45beb54e2f64e7df1ddd37c7 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Thu, 21 Nov 2024 20:34:35 -0700
Subject: [PATCH 01/14] Add device macros to fix eospac builds on HIP and also
 fix evaluate for tables on CUDA

---
 singularity-eos/eos/eos_base.hpp    | 12 +++-
 singularity-eos/eos/eos_eospac.hpp  | 95 ++++++++++++++++++++++++-----
 singularity-eos/eos/eos_variant.hpp |  9 ++-
 3 files changed, 98 insertions(+), 18 deletions(-)

diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index daa55bbdb3..cb19ea6d3b 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -147,11 +147,19 @@ class EosBase {
       : std::is_same<std::remove_reference_t<std::remove_cv_t<T>>, R *> {};
 
   // Generic evaluator
+#if defined(__CUDACC__) || defined(__HIPCC__)
   template <typename Functor_t>
-  constexpr void Evaluate(Functor_t &f) const {
-    CRTP copy = *(static_cast<CRTP const *>(this));
+  PORTABLE_INLINE_FUNCTION void Evaluate(Functor_t &f) const {
+    const CRTP copy = *(static_cast<CRTP const *>(this));
+    f(copy);
+  }
+#else
+  template <typename Functor_t>
+  void Evaluate(Functor_t &f) const {
+    const CRTP copy = *(static_cast<CRTP const *>(this));
     f(copy);
   }
+#endif // ON _DEVICE
 
   // EOS builder helpers
   // Checks if an EOS can be modified
diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 1be7404958..ada14c7587 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -1274,31 +1274,38 @@ inline std::size_t EOSPAC::SetDynamicMemory(char *src, const SharedMemSettings &
 }
 inline std::size_t EOSPAC::SharedMemorySizeInBytes() const { return shared_size_; }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, E[1] = {sieToSesame(sie)}, T[1], dTdr[1], dTde[1];
   EOS_INTEGER nxypairs = 1;
   EOS_INTEGER table = TofRE_table_;
   eosSafeInterpolate(&table, nxypairs, R, E, T, dTdr, dTde, "TofRE", Verbosity::Quiet);
   return Real(temperatureFromSesame(T[0]));
+#endif // ON_DEVICE
 }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, P[1], T[1] = {temperatureToSesame(temp)}, dPdr[1], dPdT[1];
   EOS_INTEGER nxypairs = 1;
   EOS_INTEGER table = PofRT_table_;
   eosSafeInterpolate(&table, nxypairs, R, T, P, dPdr, dPdT, "PofRT", Verbosity::Quiet);
   return Real(pressureFromSesame(P[0]));
+#endif // ON DEVICE
 }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityTemperature(
     const Real rho, const Real temperature, Indexer_t &&lambda) const {
@@ -1306,11 +1313,13 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityTemperature(
   return 1.0;
 }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void
 EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press, Real &cv, Real &bmod,
                 const unsigned long output, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+#else
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temp)};
   EOS_REAL E[1] = {sieToSesame(sie)}, P[1] = {pressureToSesame(press)};
@@ -1388,42 +1397,61 @@ EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press, Real &cv, Real &b
     }
     bmod = bulkModulusFromSesame(std::max(BMOD, 0.0));
   }
+#endif // ON DEVICE
 }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
   const unsigned long output = thermalqs::specific_internal_energy;
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return sie;
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
   const unsigned long output = thermalqs::bulk_modulus;
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return bmod;
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
   const unsigned long output = thermalqs::specific_heat;
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return cv;
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   EOS_INTEGER options[]{EOS_Y_CONVERT, EOS_F_CONVERT};
   EOS_REAL values[]{sieFromSesame(1.0), pressureFromSesame(1.0)};
@@ -1435,11 +1463,16 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
                      options, values, nopts);
 
   return Real(P[0]);
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real
 EOSPAC::MinInternalEnergyFromDensity(const Real rho, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   EOS_INTEGER options[]{EOS_F_CONVERT};
   EOS_REAL values[]{sieFromSesame(1.0)};
@@ -1451,36 +1484,55 @@ EOSPAC::MinInternalEnergyFromDensity(const Real rho, Indexer_t &&lambda) const {
                      options, values, nopts);
 
   return Real(S[0]);
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   const Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return EntropyFromDensityTemperature(rho, temp, lambda);
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return SpecificHeatFromDensityTemperature(rho, temp, lambda);
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return BulkModulusFromDensityTemperature(rho, temp, lambda);
+#endif // ON DEVICE
 }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
     const Real rho, const Real temperature, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temperature)};
   EOS_REAL E[1], P[1], dx[1], dy[1];
@@ -1494,19 +1546,28 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
   DPDT = dy[0];
   DPDE = DPDT / DEDT;
   return robust::ratio(pressureFromSesame(sieToSesame(DPDE)), rho);
+#endif // ON DEVICE
 }
-SG_PIF_NOWARN
+
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+  return 0; // compiler happy
+#else
   Real temperature = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return GruneisenParamFromDensityTemperature(rho, temperature, lambda);
+#endif // ON DEVICE
 }
 
 SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(
     const Real press, const Real temp, Indexer_t &&lambda, Real &rho, Real &sie) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+#else
   using namespace EospacWrapper;
   EOS_REAL P[1] = {pressureToSesame(press)};
   EOS_REAL T[1] = {temperatureToSesame(temp)};
@@ -1521,14 +1582,17 @@ PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(
   table = EofRT_table_;
   eosSafeInterpolate(&table, nxypairs, R, T, E, dx, dy, "EofPRT", Verbosity::Quiet);
   sie = sieFromSesame(E[0]);
+#endif // ON DEVICE
 }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void
 EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Real &cv,
                                Real &bmod, Real &dpde, Real &dvdt,
                                Indexer_t &&lambda) const {
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  EOS_ERROR("EOSPAC calls not supported on device\n");
+#else
   using namespace EospacWrapper;
   rho = rho_ref_;
   temp = temp_ref_;
@@ -1538,6 +1602,7 @@ EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Re
   bmod = bmod_ref_;
   dpde = dpde_ref_;
   dvdt = dvdt_ref_;
+#endif // ON DEVICE
 }
 
 } // namespace singularity
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index 938bb1da40..7024e67661 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -80,10 +80,17 @@ class Variant {
     return mpark::visit([](auto &eos) { return eos.CheckParams(); }, eos_);
   }
 
+#if defined(__CUDACC__) || defined(__HIPCC__)
   template <typename Functor_t>
-  constexpr void Evaluate(Functor_t &f) const {
+  PORTABLE_INLINE_FUNCTION void Evaluate(Functor_t &f) const {
     return mpark::visit([&f](const auto &eos) { return eos.Evaluate(f); }, eos_);
   }
+#else
+  template <typename Functor_t>
+  void Evaluate(Functor_t &f) const {
+    return mpark::visit([&f](const auto &eos) { return eos.Evaluate(f); }, eos_);
+  }
+#endif
 
   // EOS modifier object-oriented API
   template <template <class> typename Mod>

From e56041e6659aeab6b23abc8f5b34b7f3d9782b5b Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Thu, 21 Nov 2024 20:42:36 -0700
Subject: [PATCH 02/14] changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2606e2e566..4cc15acee6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,7 @@ Release is in preparation for JOSS publication.
 - [[PR330]](https://github.com/lanl/singularity-eos/pull/330) Piecewise grids for Spiner EOS.
 
 ### Fixed (Repair bugs, etc)
+- [[PR434]](https://github.com/lanl/singularity-eos/pull/434) Fix failure of eospac to build on HIP and segfaults with Evalaute
 - [[PR424]](https://github.com/lanl/singularity-eos/pull/424) Fix for variant patch: point to correct patch file
 - [[PR420]](https://github.com/lanl/singularity-eos/pull/420) Fix broken test_get_sg_eos
 - [[PR417]](https://github.com/lanl/singularity-eos/pull/417) Bugs in shared memory related to eospac resolved

From a5b1aa504ed7fe85328a58c1ba022ee08d091650 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Thu, 21 Nov 2024 21:05:21 -0700
Subject: [PATCH 03/14] how did these get through previous tests

---
 sesame2spiner/generate_files.cpp | 2 +-
 test/test_closure_pte.cpp        | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/sesame2spiner/generate_files.cpp b/sesame2spiner/generate_files.cpp
index f561fa0c06..3966a9dc90 100644
--- a/sesame2spiner/generate_files.cpp
+++ b/sesame2spiner/generate_files.cpp
@@ -177,7 +177,7 @@ herr_t saveAllMaterials(const std::string &savename,
   H5LTset_attribute_string(file, "/", "singularity_version", SINGULARITY_VERSION);
   // log type. 0 for true, 1 for NQT1, 2 for NQT2, -1 for single precision true
   int log_type = singularity::FastMath::Settings::log_type;
-  H5LTset_attribute_int(file, "/", SP5::LogType, &log_type, 1);
+  H5LTset_attribute_int(file, "/", SP5::logType, &log_type, 1);
 
   std::cout << "Processing " << matids.size() << " materials..." << std::endl;
 
diff --git a/test/test_closure_pte.cpp b/test/test_closure_pte.cpp
index a9c734a3e4..fce46ac9ca 100644
--- a/test/test_closure_pte.cpp
+++ b/test/test_closure_pte.cpp
@@ -40,12 +40,12 @@ using singularity::DavisProducts;
 using singularity::DavisReactants;
 using singularity::IdealGas;
 using singularity::MAX_NUM_LAMBDAS;
+using singularity::MixParams;
 using singularity::PTESolverRhoT;
 using singularity::PTESolverRhoTRequiredScratch;
 using singularity::ShiftedEOS;
 using singularity::SpinerEOSDependsRhoT;
 using singularity::mix_impl::CacheAccessor;
-using singularity::mix_params::pte_rel_tolerance_e;
 using singularity::robust::ratio;
 
 using EOS = singularity::Variant<IdealGas, ShiftedEOS<DavisProducts>, DavisProducts,
@@ -189,6 +189,7 @@ SCENARIO("Density-Temperature PTE Solver", "[PTE]") {
     constexpr Real Q = 4.115 * MJ_per_kg;
     EOS davis_p_eos = DavisProducts(a, b, k, n, vc, pc, Cv).Modify<ShiftedEOS>(-Q);
 
+    const MixParams params;
     GIVEN("A difficult three-material state") {
       // Define the state
       constexpr Real spvol_bulk = 6.256037280402093e-01;
@@ -211,7 +212,7 @@ SCENARIO("Density-Temperature PTE Solver", "[PTE]") {
           const Real u_scale = std::abs(u_bulk);
           const Real u_bulk_scale = ratio(u_bulk, u_scale);
           const Real residual = std::abs(u_bulk_scale - ratio(u_bulk_out, u_scale));
-          CHECK(residual < pte_rel_tolerance_e);
+          CHECK(residual < params.pte_rel_tolerance_e);
         }
         // Free EOS copies on device
         PORTABLE_FREE(v_EOS);
@@ -233,6 +234,7 @@ SCENARIO("Density-Temperature PTE Solver", "[PTE]") {
         Real u_bulk_out = std::numeric_limits<Real>::max();
         const bool pte_converged = run_PTE_from_state(num_pte, v_EOS, spvol_bulk,
                                                       sie_bulk, mass_frac, u_bulk_out);
+        const MixParams params;
         // CHECK(pte_converged);
         // AND_THEN("The solution satisfies the bulk internal energy constraint") {
         //   // NOTE(@pdmullen): The following fails prior to PR401
@@ -240,7 +242,7 @@ SCENARIO("Density-Temperature PTE Solver", "[PTE]") {
         //   const Real u_scale = std::abs(u_bulk);
         //   const Real u_bulk_scale = ratio(u_bulk, u_scale);
         //   const Real residual = std::abs(u_bulk_scale - ratio(u_bulk_out, u_scale));
-        //   CHECK(residual < pte_rel_tolerance_e);
+        //   CHECK(residual < params.pte_rel_tolerance_e);
         // }
         // Free EOS copies on device
         PORTABLE_FREE(v_EOS);

From 53c36326893066599b73886458b3a1a17b4486aa Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Thu, 21 Nov 2024 21:52:20 -0700
Subject: [PATCH 04/14] Split evaluate

---
 doc/sphinx/src/using-eos.rst        | 50 +++++++++++++++++------------
 singularity-eos/eos/eos_base.hpp    |  7 ++--
 singularity-eos/eos/eos_variant.hpp | 12 +++----
 test/test_eos_ideal.cpp             |  2 +-
 test/test_eos_modifiers.cpp         |  1 -
 5 files changed, 37 insertions(+), 35 deletions(-)

diff --git a/doc/sphinx/src/using-eos.rst b/doc/sphinx/src/using-eos.rst
index c2fcc8c3e3..ca5bb4380c 100644
--- a/doc/sphinx/src/using-eos.rst
+++ b/doc/sphinx/src/using-eos.rst
@@ -36,9 +36,10 @@ conditions. The type of parallelism used depends on how
 ``singularity-eos`` is compiled. If the ``Kokkos`` backend is used,
 any parallel dispatch supported by ``Kokkos`` is supported.
 
-A more generic version of the vector calls exists in the ``Evaluate``
-method, which allows the user to specify arbitrary parallel dispatch
-models by writing their own loops. See the relevant section below.
+A more generic version of the vector calls exists in the
+``EvaluateHost`` and ``EvaluateDevice`` methods, which allows the user
+to specify arbitrary parallel dispatch models by writing their own
+loops. See the relevant section below.
 
 Serialization and shared memory
 --------------------------------
@@ -494,19 +495,26 @@ available member function.
    eos.TemperatureFromDensityInternalEnergy(density.data(), energy.data(), temperature.data(),
                                             scratch.data(), density.size());
 
-The Evaluate Method
-~~~~~~~~~~~~~~~~~~~
+The Evaluate Methods
+~~~~~~~~~~~~~~~~~~~~~~
 
-A special call related to the vector calls is the ``Evaluate``
-method. The ``Evaluate`` method requests the EOS object to evaluate
-almost arbitrary code, but in a way where the type of the underlying
-EOS object is resolved *before* this arbitrary code is evaluated. This
-means the code required to resolve the type of the variant is only
-executed *once* per ``Evaluate`` call. This can enable composite EOS
-calls, non-standard vector calls, and vector calls with non-standard
-loop structure.
+A pair of special call related to the vector calls are the
+``EvaluateHost`` and ``EvaluateDevice`` methods. These methods request
+the EOS object to evaluate almost arbitrary code, but in a way where
+the type of the underlying EOS object is resolved *before* this
+arbitrary code is evaluated. This means the code required to resolve
+the type of the variant is only executed *once* per ``Evaluate``
+call. This can enable composite EOS calls, non-standard vector calls,
+and vector calls with non-standard loop structure.
 
-The ``Evaluate`` call has the signature
+The ``EvaluateHost`` call has the signature
+
+.. code-block:: cpp
+
+  template<typename Functor_t>
+  void Evaluate(Functor_t f);
+
+and the ``EvaluateDevice`` method has the signature
 
 .. code-block:: cpp
 
@@ -514,11 +522,11 @@ The ``Evaluate`` call has the signature
   PORTABLE_INLINE_FUNCTION
   void Evaluate(Functor_t f);
 
+
 where a ``Functor_t`` is a class that *must* provide a ``void
-operator() const`` method templated on EOS type. ``Evaluate`` is
-decorated so that it may be evaluated on either host or device,
-depending on desired use-case. Alternatively, you may use an anonymous
-function with an `auto` argument as the input, e.g.,
+operator() const`` method templated on EOS type. Alternatively, you
+may use an anonymous function with an `auto` argument as the input,
+e.g.,
 
 .. code-block:: cpp
 
@@ -583,17 +591,17 @@ is summed using the ``Kokkos::parallel_reduce`` functionality in the
   CheckPofRE my_op(P, rho, sie, N);
 
   // Here we call the evaluate function
-  eos.Evaluate(my_op);
+  eos.EvaluateHost(my_op);
 
   // The above two lines could have been called "in-one" with:
-  // eos.Evaluate(CheckPofRE(P, rho, sie, N));
+  // eos.EvaluateHost(CheckPofRE(P, rho, sie, N));
 
 Alternatively, you could eliminate the functor and use an anonymous
 function with:
 
 .. code-block:: cpp
 
-  eos.Evaluate([=](auto eos) {
+  eos.EvaluateHost([=](auto eos) {
     Real tot_diff;
     Kokkos::parallel_reduce(
         "MyCheckPofRE", N_,
diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index cb19ea6d3b..1af4ff4dad 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -147,19 +147,16 @@ class EosBase {
       : std::is_same<std::remove_reference_t<std::remove_cv_t<T>>, R *> {};
 
   // Generic evaluator
-#if defined(__CUDACC__) || defined(__HIPCC__)
   template <typename Functor_t>
-  PORTABLE_INLINE_FUNCTION void Evaluate(Functor_t &f) const {
+  PORTABLE_INLINE_FUNCTION void EvaluateDevice(Functor_t &f) const {
     const CRTP copy = *(static_cast<CRTP const *>(this));
     f(copy);
   }
-#else
   template <typename Functor_t>
-  void Evaluate(Functor_t &f) const {
+  void EvaluateHost(Functor_t &f) const {
     const CRTP copy = *(static_cast<CRTP const *>(this));
     f(copy);
   }
-#endif // ON _DEVICE
 
   // EOS builder helpers
   // Checks if an EOS can be modified
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index 7024e67661..c149bce304 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -80,17 +80,15 @@ class Variant {
     return mpark::visit([](auto &eos) { return eos.CheckParams(); }, eos_);
   }
 
-#if defined(__CUDACC__) || defined(__HIPCC__)
   template <typename Functor_t>
-  PORTABLE_INLINE_FUNCTION void Evaluate(Functor_t &f) const {
-    return mpark::visit([&f](const auto &eos) { return eos.Evaluate(f); }, eos_);
+  PORTABLE_INLINE_FUNCTION void EvaluateDevice(Functor_t &f) const {
+    return mpark::visit([&f](const auto &eos) { return eos.EvaluateDevice(f); }, eos_);
   }
-#else
+
   template <typename Functor_t>
-  void Evaluate(Functor_t &f) const {
-    return mpark::visit([&f](const auto &eos) { return eos.Evaluate(f); }, eos_);
+  void EvaluateHost(Functor_t &f) const {
+    return mpark::visit([&f](const auto &eos) { return eos.EvaluateHost(f); }, eos_);
   }
-#endif
 
   // EOS modifier object-oriented API
   template <template <class> typename Mod>
diff --git a/test/test_eos_ideal.cpp b/test/test_eos_ideal.cpp
index b97f3de4de..9e52c81769 100644
--- a/test/test_eos_ideal.cpp
+++ b/test/test_eos_ideal.cpp
@@ -136,7 +136,7 @@ SCENARIO("Ideal gas vector Evaluate call", "[IdealGas][Evaluate]") {
           });
       THEN("The vector Evaluate API can be used to compare") {
         CheckPofRE my_op(P, rho, sie, N);
-        eos_device.Evaluate(my_op);
+        eos_device.EvaluateHost(my_op);
         REQUIRE(my_op.nwrong == 0);
       }
     }
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index b75bfca16e..631d906ba9 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -62,7 +62,6 @@ using variadic_utils::transform_variadic_list;
 static constexpr const auto full_eos_list = tl<IdealGas>{};
 static constexpr const auto relativistic_eos_list = tl<IdealGas>{};
 static constexpr const auto unit_system_eos_list = tl<IdealGas>{};
-static constexpr const auto apply_to_all = al<ScaledEOS, ShiftedEOS>{};
 static constexpr const auto unit_system =
     transform_variadic_list(unit_system_eos_list, al<UnitSystem>{});
 // variadic list of eos's with shifted or scaled modifiers

From 14ed09643760b49d65ae0cbad2717d9be64ad348 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Thu, 21 Nov 2024 21:57:23 -0700
Subject: [PATCH 05/14] const for device-side var. Pass by reference allowed
 for host side, if user is cautious.

---
 singularity-eos/eos/eos_base.hpp    | 2 +-
 singularity-eos/eos/eos_variant.hpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index 1af4ff4dad..6e838d108d 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -148,7 +148,7 @@ class EosBase {
 
   // Generic evaluator
   template <typename Functor_t>
-  PORTABLE_INLINE_FUNCTION void EvaluateDevice(Functor_t &f) const {
+  PORTABLE_INLINE_FUNCTION void EvaluateDevice(const Functor_t f) const {
     const CRTP copy = *(static_cast<CRTP const *>(this));
     f(copy);
   }
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index c149bce304..36711df58f 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -81,7 +81,7 @@ class Variant {
   }
 
   template <typename Functor_t>
-  PORTABLE_INLINE_FUNCTION void EvaluateDevice(Functor_t &f) const {
+  PORTABLE_INLINE_FUNCTION void EvaluateDevice(const Functor_t f) const {
     return mpark::visit([&f](const auto &eos) { return eos.EvaluateDevice(f); }, eos_);
   }
 

From 86c24999e547f8d02a83ce95e5b2a591794f6f7b Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Thu, 21 Nov 2024 21:58:47 -0700
Subject: [PATCH 06/14] const correctness

---
 doc/sphinx/src/using-eos.rst | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/sphinx/src/using-eos.rst b/doc/sphinx/src/using-eos.rst
index ca5bb4380c..092e4a63a7 100644
--- a/doc/sphinx/src/using-eos.rst
+++ b/doc/sphinx/src/using-eos.rst
@@ -539,7 +539,9 @@ e.g.,
   with GPUs it can produce very unintuitive behaviour. We recommend
   you only make the ``operator()`` non-const if you really know what
   you're doing. And in the anonymous function case, we recommend you
-  capture by value, not reference.
+  capture by value, not reference. ``EvaluateDevice`` does not support
+  side effects at all and you must pass your functors in by value in
+  that case.
 
 To see the utlity of the ``Evaluate`` function, it's probably just
 easiest to provide an example. The following code evaluates the EOS on

From d15f43f6fa877c21d2398d057adf7d5b7d5fe282 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Fri, 22 Nov 2024 19:54:16 -0700
Subject: [PATCH 07/14] timestamp

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 512060bf5f..56178b2fba 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,6 +32,7 @@ list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
 set(SINGULARITY_GOLDFILES_VERSION "goldfiles-1.8.0")
 set(SINGULARITY_GOLDFILE_HASH
     249772f3314c4b6b9386aa08895280698ae905ef188f4383b819f28c1484603b)
+set(DOWNLOAD_EXTRACT_TIMESTAMP ON)
 
 # ------------------------------------------------------------------------------#
 # Options

From bec2cf5903e90c2ac4ee83aad224f1992a7a8db2 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Mon, 25 Nov 2024 10:45:36 -0700
Subject: [PATCH 08/14] fixing EOSPAC preprocessor macros

---
 singularity-eos/eos/eos_eospac.hpp | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index ada14c7587..ae36f006e4 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -1277,7 +1277,7 @@ inline std::size_t EOSPAC::SharedMemorySizeInBytes() const { return shared_size_
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1293,7 +1293,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1317,7 +1317,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void
 EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press, Real &cv, Real &bmod,
                 const unsigned long output, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
@@ -1403,7 +1403,7 @@ EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press, Real &cv, Real &b
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1418,7 +1418,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1433,7 +1433,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1448,7 +1448,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1469,7 +1469,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real
 EOSPAC::MinInternalEnergyFromDensity(const Real rho, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1490,7 +1490,7 @@ EOSPAC::MinInternalEnergyFromDensity(const Real rho, Indexer_t &&lambda) const {
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1503,7 +1503,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1516,7 +1516,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1529,7 +1529,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
     const Real rho, const Real temperature, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1552,7 +1552,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1565,7 +1565,7 @@ SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(
     const Real press, const Real temp, Indexer_t &&lambda, Real &rho, Real &sie) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
@@ -1590,7 +1590,7 @@ PORTABLE_INLINE_FUNCTION void
 EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Real &cv,
                                Real &bmod, Real &dpde, Real &dvdt,
                                Indexer_t &&lambda) const {
-#if defined(__CUDACC__) || defined(__HIPCC__)
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
   EOS_ERROR("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;

From 7b7d971e56e1012ea08f4d7f8315f0c84036351a Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Mon, 25 Nov 2024 11:48:38 -0700
Subject: [PATCH 09/14] danl fixes. fix CI issue

---
 singularity-eos/eos/eos_eospac.hpp | 46 ++++++++++++++----------------
 test/test_closure_pte.cpp          |  2 +-
 2 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index ae36f006e4..2f7ce6888e 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -43,16 +43,12 @@ using namespace EospacWrapper;
 // Only really works in serial
 // Not really supported on device
 
-// SG_PIF_NOWARN
-// this pragma disables host-device warnings when cuda enabled
-#if defined(__CUDACC__)
-#define SG_PIF_NOWARN #pragma nv_exec_check_disable
-#endif // __CUDACC__
-
-// force this macro to be defined regardless of complexity of logic above
-#ifndef SG_PIF_NOWARN
-#define SG_PIF_NOWARN
-#endif // !defind SG_PIF_NOWARN
+// TODO(JMM): Move this into ports of call or base if needed elsehwere.
+#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#define SINGULARITY_ON_DEVICE 1
+#else
+#define SINGULARITY_ON_DEVICE 0
+#endif // ON DEVICE
 
 namespace impl_eospac {
 
@@ -1277,7 +1273,7 @@ inline std::size_t EOSPAC::SharedMemorySizeInBytes() const { return shared_size_
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1293,7 +1289,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1317,7 +1313,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void
 EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press, Real &cv, Real &bmod,
                 const unsigned long output, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
@@ -1403,7 +1399,7 @@ EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press, Real &cv, Real &b
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1418,7 +1414,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1433,7 +1429,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1448,7 +1444,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1469,7 +1465,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real
 EOSPAC::MinInternalEnergyFromDensity(const Real rho, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1490,7 +1486,7 @@ EOSPAC::MinInternalEnergyFromDensity(const Real rho, Indexer_t &&lambda) const {
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1503,7 +1499,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1516,7 +1512,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1529,7 +1525,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
     const Real rho, const Real temperature, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1552,7 +1548,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
@@ -1565,7 +1561,7 @@ SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(
     const Real press, const Real temp, Indexer_t &&lambda, Real &rho, Real &sie) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
@@ -1590,7 +1586,7 @@ PORTABLE_INLINE_FUNCTION void
 EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Real &cv,
                                Real &bmod, Real &dpde, Real &dvdt,
                                Indexer_t &&lambda) const {
-#if defined(__CUDA_ARCH__) || __HIP_DEVICE_COMPILE__
+#if SINGULARITY_ON_DEVICE
   EOS_ERROR("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
diff --git a/test/test_closure_pte.cpp b/test/test_closure_pte.cpp
index 978fccc083..fce46ac9ca 100644
--- a/test/test_closure_pte.cpp
+++ b/test/test_closure_pte.cpp
@@ -212,7 +212,7 @@ SCENARIO("Density-Temperature PTE Solver", "[PTE]") {
           const Real u_scale = std::abs(u_bulk);
           const Real u_bulk_scale = ratio(u_bulk, u_scale);
           const Real residual = std::abs(u_bulk_scale - ratio(u_bulk_out, u_scale));
-          CHECK(residual < default_PTE_params.pte_rel_tolerance_e);
+          CHECK(residual < params.pte_rel_tolerance_e);
         }
         // Free EOS copies on device
         PORTABLE_FREE(v_EOS);

From 46ab3a2395a25a02c28119fd56706bf423b51a80 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonah.maxwell.miller@gmail.com>
Date: Mon, 25 Nov 2024 15:55:44 -0700
Subject: [PATCH 10/14] Update doc/sphinx/src/using-eos.rst

Co-authored-by: Jeff Peterson <83598606+jhp-lanl@users.noreply.github.com>
---
 doc/sphinx/src/using-eos.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/sphinx/src/using-eos.rst b/doc/sphinx/src/using-eos.rst
index 092e4a63a7..8810914adb 100644
--- a/doc/sphinx/src/using-eos.rst
+++ b/doc/sphinx/src/using-eos.rst
@@ -37,7 +37,7 @@ conditions. The type of parallelism used depends on how
 any parallel dispatch supported by ``Kokkos`` is supported.
 
 A more generic version of the vector calls exists in the
-``EvaluateHost`` and ``EvaluateDevice`` methods, which allows the user
+``EvaluateHost`` and ``EvaluateDevice`` methods, which allow the user
 to specify arbitrary parallel dispatch models by writing their own
 loops. See the relevant section below.
 

From 6a0ec4874e6a90b8bb831d43c73bb8d685a6cef8 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Tue, 26 Nov 2024 12:16:52 -0700
Subject: [PATCH 11/14] remove all SG_PIF_NOWARNS

---
 singularity-eos/eos/eos_eospac.hpp | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 2f7ce6888e..b1db16b889 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -150,82 +150,66 @@ class EOSPAC : public EosBase<EOSPAC> {
   std::size_t SharedMemorySizeInBytes() const;
   constexpr bool AllDynamicMemoryIsShareable() const { return false; }
 
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real TemperatureFromDensityInternalEnergy(
       const Real rho, const Real sie,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real InternalEnergyFromDensityTemperature(
       const Real rho, const Real temperature,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real
   PressureFromDensityTemperature(const Real rho, const Real temperature,
                                  Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real PressureFromDensityInternalEnergy(
       const Real rho, const Real sie,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real MinInternalEnergyFromDensity(
       const Real rho, Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real
   EntropyFromDensityTemperature(const Real rho, const Real temperature,
                                 Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real EntropyFromDensityInternalEnergy(
       const Real rho, const Real sie,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityTemperature(
       const Real rho, const Real temperature,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityInternalEnergy(
       const Real rho, const Real sie,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityTemperature(
       const Real rho, const Real temperature,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityInternalEnergy(
       const Real rho, const Real sie,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityTemperature(
       const Real rho, const Real temperature,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityInternalEnergy(
       const Real rho, const Real sie,
       Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION void
   FillEos(Real &rho, Real &temp, Real &energy, Real &press, Real &cv, Real &bmod,
           const unsigned long output,
           Indexer_t &&lambda = static_cast<Real *>(nullptr)) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION void
   DensityEnergyFromPressureTemperature(const Real press, const Real temp,
                                        Indexer_t &&lambda, Real &rho, Real &sie) const;
-  SG_PIF_NOWARN
   template <typename Indexer_t = Real *>
   PORTABLE_INLINE_FUNCTION void
   ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Real &cv,
@@ -1557,7 +1541,6 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
 #endif // ON DEVICE
 }
 
-SG_PIF_NOWARN
 template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(
     const Real press, const Real temp, Indexer_t &&lambda, Real &rho, Real &sie) const {

From e95f74fb9b1e05ec079b9b02de47351c224779b9 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Tue, 26 Nov 2024 12:19:40 -0700
Subject: [PATCH 12/14] portable always abort

---
 singularity-eos/eos/eos_eospac.hpp | 31 +++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index b1db16b889..1f08a65873 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -25,6 +25,7 @@
 #include <eos_Interface.h>
 // ports-of-call
 #include <ports-of-call/portability.hpp>
+#include <ports-of-call/portable_errors.hpp>
 
 #include <eospac-wrapper/eospac_wrapper.hpp>
 #include <singularity-eos/base/constants.hpp>
@@ -1258,7 +1259,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1274,7 +1275,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1298,7 +1299,7 @@ PORTABLE_INLINE_FUNCTION void
 EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press, Real &cv, Real &bmod,
                 const unsigned long output, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temp)};
@@ -1384,7 +1385,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1399,7 +1400,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1414,7 +1415,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
     const Real rho, const Real temp, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1429,7 +1430,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1450,7 +1451,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real
 EOSPAC::MinInternalEnergyFromDensity(const Real rho, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1471,7 +1472,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1484,7 +1485,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1497,7 +1498,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1510,7 +1511,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
     const Real rho, const Real temperature, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   using namespace EospacWrapper;
@@ -1533,7 +1534,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
     const Real rho, const Real sie, Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
   return 0; // compiler happy
 #else
   Real temperature = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
@@ -1545,7 +1546,7 @@ template <typename Indexer_t>
 PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(
     const Real press, const Real temp, Indexer_t &&lambda, Real &rho, Real &sie) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
   EOS_REAL P[1] = {pressureToSesame(press)};
@@ -1570,7 +1571,7 @@ EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Re
                                Real &bmod, Real &dpde, Real &dvdt,
                                Indexer_t &&lambda) const {
 #if SINGULARITY_ON_DEVICE
-  EOS_ERROR("EOSPAC calls not supported on device\n");
+  PORTABLE_ALWAYS_ABORT("EOSPAC calls not supported on device\n");
 #else
   using namespace EospacWrapper;
   rho = rho_ref_;

From cbd251268da648af659e3029f7a44ff4d0afaeba Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Tue, 26 Nov 2024 12:24:04 -0700
Subject: [PATCH 13/14] add include guard for kokkos kernels in find

---
 cmake/singularity-eos/kokkos.cmake | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/cmake/singularity-eos/kokkos.cmake b/cmake/singularity-eos/kokkos.cmake
index 832d9d190e..22e5e9c732 100644
--- a/cmake/singularity-eos/kokkos.cmake
+++ b/cmake/singularity-eos/kokkos.cmake
@@ -107,7 +107,9 @@ macro(singularity_import_kokkoskernels)
 endmacro()
 
 macro(singularity_find_kokkoskernels)
-  find_package(KokkosKernels REQUIRED)
+  if(NOT TARGET Kokkos::kokkoskernels)
+    find_package(KokkosKernels REQUIRED)
+  endif()
 endmacro()
 
 macro(singularity_enable_kokkoskernels target)

From 2f7b1dfbbed8d9b91da9119263b01c5d34455d7e Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Tue, 26 Nov 2024 14:41:47 -0700
Subject: [PATCH 14/14] add more time for eos tabulated tests

---
 test/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 747cbf5c57..e01d0a01e1 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -93,7 +93,7 @@ endif()
 include(Catch)
 catch_discover_tests(eos_analytic_unit_tests PROPERTIES TIMEOUT 60)
 catch_discover_tests(eos_infrastructure_tests PROPERTIES TIMEOUT 60)
-catch_discover_tests(eos_tabulated_unit_tests PROPERTIES TIMEOUT 60)
+catch_discover_tests(eos_tabulated_unit_tests PROPERTIES TIMEOUT 120)
 if (plugin_tests)
   catch_discover_tests(eos_plugin_tests PROPERTIES TIMEOUT 60)
 endif()