From 289f39c43b298fae5899c05c604e734a45259c92 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Thu, 23 Mar 2023 14:49:37 -0600
Subject: [PATCH 01/45] Initial commit on splitting out get_sg_eos to a
 separate compilation unit. This is the first step to moving that code out of
 sg-eos.

---
 singularity-eos/CMakeLists.txt          |   6 +-
 singularity-eos/eos/eos.hpp             |   2 +-
 singularity-eos/eos/eos_eospac.hpp      |   2 +-
 singularity-eos/eos/get_sg_eos.cpp      | 599 ++++++++++++++++++++++++
 singularity-eos/eos/singularity_eos.cpp | 590 +----------------------
 5 files changed, 608 insertions(+), 591 deletions(-)
 create mode 100644 singularity-eos/eos/get_sg_eos.cpp

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index cff8cba22b..4d7b801055 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -41,12 +41,14 @@ set(EOS_SRCS
 )
 
 if (SINGULARITY_BUILD_CLOSURE)
-  list(APPEND EOS_SRCS eos/singularity_eos.cpp)
-  list(APPEND EOS_HEADERS eos/singularity_eos.hpp closure/mixed_cell_models.hpp)
+  list(APPEND EOS_SRCS eos/get_sg_eos.cpp)
+  list(APPEND EOS_HEADERS closure/mixed_cell_models.hpp)
 endif()
 
 if (SINGULARITY_USE_FORTRAN)
   list(APPEND EOS_SRCS eos/singularity_eos.f90)
+  list(APPEND EOS_SRCS eos/singularity_eos.cpp)
+  list(APPEND EOS_HEADERS eos/singularity_eos.hpp)
   # would rather handle this more robustly, being sloppy for now
   list(APPEND EOS_MODS singularity_eos.mod singularity_eos_types.mod)
 endif()
diff --git a/singularity-eos/eos/eos.hpp b/singularity-eos/eos/eos.hpp
index bd6b2ff206..db4a6924d1 100644
--- a/singularity-eos/eos/eos.hpp
+++ b/singularity-eos/eos/eos.hpp
@@ -54,7 +54,7 @@ namespace singularity {
 template <typename... Ts>
 using tl = singularity::detail::type_list<Ts...>;
 
-template <template <typename> typename... Ts>
+template <template <typename> class... Ts>
 using al = singularity::detail::adapt_list<Ts...>;
 
 // transform variadic list: applies modifiers to eos's
diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index c629a033ac..314c5ea185 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -175,7 +175,7 @@ class EOSPAC : public EosBase<EOSPAC> {
   inline void Finalize() {}
   static std::string EosType() { return std::string("EOSPAC"); }
   static std::string EosPyType() { return EosType(); }
-  inline void PrintParams() const { printf("EOSPAC parameters:\nmatid = %s\n", matid_); }
+  inline void PrintParams() const { printf("EOSPAC parameters:\nmatid = %i\n", matid_); }
   PORTABLE_FORCEINLINE_FUNCTION Real MinimumDensity() const { return rho_min_; }
   PORTABLE_FORCEINLINE_FUNCTION Real MinimumTemperature() const { return temp_min_; }
 
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
new file mode 100644
index 0000000000..0769e6668a
--- /dev/null
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -0,0 +1,599 @@
+//------------------------------------------------------------------------------
+// © 2021-2022. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <map>
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/eos/singularity_eos.hpp>
+
+using namespace singularity;
+
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+using Lrgt = Kokkos::LayoutRight;
+using Llft = Kokkos::LayoutLeft;
+template <typename T>
+using ScratchV = Kokkos::View<T **, Lrgt>;
+#endif // PORTABILITY_STRATEGY_KOKKOS
+
+// mapping from EAP integer to
+static const std::map<const int, const unsigned long> EAPInputToBD = {
+    {-3, thermalqs::temperature | thermalqs::density},
+    {-2, thermalqs::density | thermalqs::pressure},
+    {-1, thermalqs::pressure | thermalqs::temperature},
+    {0, thermalqs::specific_internal_energy | thermalqs::density},
+    {1, thermalqs::specific_internal_energy | thermalqs::density},
+};
+
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+namespace singularity {
+struct EOSAccessor_ {
+  PORTABLE_INLINE_FUNCTION
+  EOSAccessor_(const Kokkos::View<EOS *, Llft> &eos_v, int *mats)
+      : eos_v_(eos_v), mats_(mats) {}
+  PORTABLE_INLINE_FUNCTION
+  EOS &operator[](const int m) const { return eos_v_(mats_[m]); }
+  Kokkos::View<EOS *, Llft> eos_v_;
+  int *mats_;
+};
+} // namespace singularity
+#endif // PORTABILITY_STRATEGY_KOKKOS
+// EAP centric arguments and function signature
+
+int get_sg_eos( // sizing information
+    int nmat, int ncell, int cell_dim,
+    // Input parameters
+    int input_int,
+    // eos index offsets
+    int *eos_offsets,
+    // equation of state array
+    EOS *eos,
+    // index offsets
+    int *offsets,
+    // per cell quantities
+    double *press, double *pmax, double *vol, double *spvol, double *sie, double *temp,
+    double *bmod, double *dpde, double *cv,
+    // per material quantities
+    double *frac_mass, double *frac_vol, double *frac_ie,
+    // optional per material quantities
+    double *frac_bmod, double *frac_dpde, double *frac_cv) {
+  // printBacktrace();
+  // kernel return value will be the number of failures
+  int ret{0};
+  // handle optionals
+  bool do_frac_bmod{true};
+  if (frac_bmod == NULL || frac_bmod == nullptr) do_frac_bmod = false;
+  bool do_frac_dpde{true};
+  if (frac_dpde == NULL || frac_dpde == nullptr) do_frac_dpde = false;
+  bool do_frac_cv{true};
+  if (frac_dpde == NULL || frac_dpde == nullptr) do_frac_cv = false;
+  // get inputs
+  enum class input_condition {
+    RHO_T_INPUT = -3,
+    RHO_P_INPUT = -2,
+    P_T_INPUT = -1,
+    NORM_RHO_E_INPUT = 0,
+    RHO_E_INPUT = 1
+  };
+  const auto input{EAPInputToBD.at(input_int)};
+  const auto output = thermalqs::all_values - input;
+  const bool p_is_inp{static_cast<bool>(input & thermalqs::pressure)};
+  const bool r_is_inp{static_cast<bool>(input & thermalqs::density)};
+  const bool t_is_inp{static_cast<bool>(input & thermalqs::temperature)};
+  const bool s_is_inp{static_cast<bool>(input & thermalqs::specific_internal_energy)};
+  constexpr const Real min_guess_density{1.e-20};
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+  // convenience aliases
+  using Unmgd = Kokkos::MemoryUnmanaged;
+  using HS = Kokkos::HostSpace;
+  using Kokkos::create_mirror_view_and_copy;
+  using host_v = Kokkos::View<double *, Llft, HS, Unmgd>;
+  using dev_v = Kokkos::View<double *, Llft>;
+  using host_frac_v = Kokkos::View<double **, Llft, HS, Unmgd>;
+  using dev_frac_v = Kokkos::View<double **, Llft>;
+  using DES = Kokkos::DefaultExecutionSpace;
+  using DMS = DES::memory_space;
+  using Kokkos::MemoryTraits;
+  constexpr const unsigned int ra{0 | Kokkos::RandomAccess};
+  // constexpr const unsigned int ra_u{Kokkos::Unmanaged | Kokkos::RandomAccess};
+  using VAWI = Kokkos::ViewAllocateWithoutInitializing;
+  using Kokkos::deep_copy;
+  static constexpr const double ev2k = 1.160451930280894026e4;
+  // convert pointers to host side views
+  Kokkos::View<int *, Llft, HS, Unmgd> eos_offsets_hv(eos_offsets, nmat);
+  Kokkos::View<int *, Llft, HS, Unmgd> offsets_hv(offsets, ncell);
+  host_v press_hv(press, cell_dim);
+  host_v pmax_hv(pmax, cell_dim);
+  host_v vol_hv(vol, cell_dim);
+  host_v spvol_hv(spvol, cell_dim);
+  host_v sie_hv(sie, cell_dim);
+  host_v temp_hv(temp, cell_dim);
+  host_v bmod_hv(bmod, cell_dim);
+  host_v dpde_hv(dpde, cell_dim);
+  host_v cv_hv(cv, cell_dim);
+  host_frac_v frac_mass_hv(frac_mass, cell_dim, nmat);
+  host_frac_v frac_vol_hv(frac_vol, cell_dim, nmat);
+  host_frac_v frac_ie_hv(frac_ie, cell_dim, nmat);
+  host_frac_v frac_bmod_hv, frac_dpde_hv, frac_cv_hv;
+  if (do_frac_bmod) frac_bmod_hv = host_frac_v(frac_bmod, cell_dim, nmat);
+  if (do_frac_dpde) frac_dpde_hv = host_frac_v(frac_dpde, cell_dim, nmat);
+  if (do_frac_cv) frac_cv_hv = host_frac_v(frac_cv, cell_dim, nmat);
+
+  // get device views if necessary
+  Kokkos::View<const int *, Llft, MemoryTraits<ra>> offsets_v{
+      create_mirror_view_and_copy(DMS(), offsets_hv)};
+  Kokkos::View<const int *, Llft, MemoryTraits<ra>> eos_offsets_v{
+      create_mirror_view_and_copy(DMS(), eos_offsets_hv)};
+  dev_v press_v{create_mirror_view_and_copy(DMS(), press_hv)};
+  dev_v pmax_v{create_mirror_view_and_copy(DMS(), pmax_hv)};
+  dev_v spvol_v{create_mirror_view_and_copy(DMS(), spvol_hv)};
+  dev_v vol_v{create_mirror_view_and_copy(DMS(), vol_hv)};
+  dev_v sie_v{create_mirror_view_and_copy(DMS(), sie_hv)};
+  dev_v temp_v{create_mirror_view_and_copy(DMS(), temp_hv)};
+  dev_v bmod_v{create_mirror_view_and_copy(DMS(), bmod_hv)};
+  dev_v dpde_v{create_mirror_view_and_copy(DMS(), dpde_hv)};
+  dev_v cv_v{create_mirror_view_and_copy(DMS(), cv_hv)};
+  dev_frac_v frac_mass_v{create_mirror_view_and_copy(DMS(), frac_mass_hv)};
+  dev_frac_v frac_vol_v{create_mirror_view_and_copy(DMS(), frac_vol_hv)};
+  dev_frac_v frac_ie_v{create_mirror_view_and_copy(DMS(), frac_ie_hv)};
+  dev_frac_v frac_bmod_v, frac_dpde_v, frac_cv_v;
+  if (do_frac_bmod) frac_bmod_v = create_mirror_view_and_copy(DMS(), frac_bmod_hv);
+  if (do_frac_dpde) frac_dpde_v = create_mirror_view_and_copy(DMS(), frac_dpde_hv);
+  if (do_frac_cv) frac_cv_v = create_mirror_view_and_copy(DMS(), frac_cv_hv);
+  // array of eos's
+  const auto eos_nmat{*std::max_element(eos_offsets, eos_offsets + nmat)};
+  Kokkos::View<EOS *, Llft, HS, Unmgd> eos_hv(eos, eos_nmat);
+  Kokkos::View<EOS *, Llft> eos_v{create_mirror_view_and_copy(DMS(), eos_hv)};
+  // TODO: make this a scatter view
+  constexpr auto at_int_full{0 | Kokkos::Atomic};
+#ifdef KOKKOS_ENABLE_SERIAL
+  constexpr auto at_int{std::is_same<DES, Kokkos::Serial>::value ? 0 : at_int_full};
+#else  // KOKKOS_ENABLE_SERIAL
+  // assume atomics are required for correctness if serial not even enabled
+  constexpr auto at_int{at_int_full};
+#endif // KOKKOS_ENABLE_SERIAL
+  // set up scratch arrays
+  constexpr auto KGlobal = Kokkos::Experimental::UniqueTokenScope::Global;
+  Kokkos::Experimental::UniqueToken<DES, KGlobal> tokens{};
+  using VAWI = Kokkos::ViewAllocateWithoutInitializing;
+
+  const bool small_loop{tokens.size() > ncell};
+  const decltype(tokens)::size_type scratch_size{std::min(tokens.size(), ncell)};
+  ScratchV<int> pte_mats(VAWI("PTE::scratch mats"), scratch_size, nmat);
+  ScratchV<int> pte_idxs(VAWI("PTE::scratch idxs"), scratch_size, nmat);
+  ScratchV<double> mass_pte(VAWI("PTE::scratch mass"), scratch_size, nmat);
+  ScratchV<double> sie_pte(VAWI("PTE::scratch sie"), scratch_size, nmat);
+  ScratchV<double> vfrac_pte(VAWI("PTE::scratch vfrac"), scratch_size, nmat);
+  ScratchV<double> temp_pte(VAWI("PTE::scratch temp"), scratch_size, nmat);
+  ScratchV<double> press_pte(VAWI("PTE::scratch press"), scratch_size, nmat);
+  ScratchV<double> rho_pte(VAWI("PTE::scratch rho"), scratch_size, nmat);
+  // declare solver scratch, allocate in the case statement
+  int pte_solver_scratch_size{};
+  ScratchV<double> solver_scratch;
+
+  // create helper lambdas to reduce code duplication
+  const auto init_lambda =
+      PORTABLE_LAMBDA(const int i, const int tid, double &mass_sum, int &npte,
+                      const Real t_mult, const Real s_mult, const Real p_mult) {
+    // normalize mass fractions
+    // first find the mass sum
+    // also set idxs as the decrement of the eos offsets
+    // to take into account 1 based indexing in fortran
+    for (int m = 0; m < nmat; ++m) {
+      mass_sum += frac_mass_v(i, m);
+      pte_idxs(tid, m) = eos_offsets_v(m) - 1;
+      frac_vol_v(i, m) = 0.0;
+    }
+    for (int m = 0; m < nmat; ++m) {
+      frac_mass_v(i, m) /= mass_sum;
+    }
+    // set inputs
+    npte = 0;
+    for (int m = 0; m < nmat; ++m) {
+      if (frac_mass_v(i, m) > 1.e-12) {
+        pte_idxs(tid, npte) = eos_offsets_v(m) - 1;
+        pte_mats(tid, npte) = m;
+        npte += 1;
+      }
+      vfrac_pte(tid, m) = 0.0;
+      sie_pte(tid, m) = 0.0;
+      temp_pte(tid, m) = 0.0;
+      press_pte(tid, m) = 0.0;
+    }
+    for (int mp = 0; mp < npte; ++mp) {
+      const int m = pte_mats(tid, mp);
+      rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m);
+      vfrac_pte(tid, mp) = 1.0 / npte;
+      temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult;
+      press_pte(tid, mp) = press_v(i) * p_mult;
+      sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult;
+    }
+  };
+  const auto final_lambda = PORTABLE_LAMBDA(
+      const int i, const int tid, const int npte, const Real mass_sum, const Real t_mult,
+      const Real s_mult, const Real p_mult, singularity::mix_impl::CacheAccessor &cache) {
+    // initialize averaged quantities to 0
+    const bool do_t = t_mult == 1.0;
+    const bool do_s = s_mult == 1.0;
+    const bool do_p = p_mult == 1.0;
+    if (do_t) {
+      temp_v(i) = 0.0;
+    }
+    if (do_p) {
+      press_v(i) = 0.0;
+    }
+    if (do_s) {
+      sie_v(i) = 0.0;
+    }
+    bmod_v(i) = 0.0;
+    cv_v(i) = 0.0;
+    dpde_v(i) = 0.0;
+    // material loop for averaging and assigning per mat quantities
+    for (int mp = 0; mp < npte; ++mp) {
+      const int m = pte_mats(tid, mp);
+      // pressure contribution from material m
+      press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult;
+      // temperature contribution from material m
+      temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult;
+      const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum;
+      // sie contribution from material m
+      sie_v(i) += ie_m * s_mult;
+      // assign per material specific internal energy
+      frac_ie_v(i, m) = ie_m;
+      // assign volume fraction based on pte calculation
+      frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i);
+      // calculate bulk modulus for material m
+      const Real bmod_m = eos_v(pte_idxs(tid, mp))
+                              .BulkModulusFromDensityTemperature(
+                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
+      // add bmod contribution from material m
+      bmod_v(i) += bmod_m * vfrac_pte(tid, mp);
+      // calculate specific heat for material m
+      const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp))
+                                   .SpecificHeatFromDensityTemperature(
+                                       rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
+      // add mass weighted contribution specific heat for material m
+      cv_v(i) += cv_m * frac_mass_v(i, m);
+      // calculate gruneisen parameter for material m
+      const Real dpde_m = eos_v(pte_idxs(tid, mp))
+                              .GruneisenParamFromDensityTemperature(
+                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
+      // add gruneisen param contribution from material m
+      dpde_v(i) += dpde_m * vfrac_pte(tid, mp);
+      // optionally assign per material quantities to per material arrays
+      if (do_frac_bmod) {
+        frac_bmod_v(i, m) = bmod_m;
+      }
+      if (do_frac_cv) {
+        frac_cv_v(i, m) = cv_m;
+      }
+      if (do_frac_dpde) {
+        frac_dpde_v(i, m) = dpde_m;
+      }
+    }
+    if (do_t) {
+      temp_v(i) /= ev2k;
+    }
+    if (do_s) {
+      sie_v(i) /= mass_sum;
+    }
+    // reset mass fractions to original values if not normalized to 1
+    for (int m = 0; m < nmat; ++m) {
+      frac_mass_v(i, m) *= mass_sum;
+    }
+  };
+  Kokkos::View<int, MemoryTraits<at_int>> res("PTE::num fails");
+  Kokkos::View<int, MemoryTraits<at_int>> n_solves("PTE::num solves");
+  const std::string perf_nums =
+      "[" + std::to_string(nmat) + "," + std::to_string(ncell) + "]";
+  auto input_int_enum = static_cast<input_condition>(input_int);
+  switch (input_int_enum) {
+  case input_condition::RHO_T_INPUT: {
+    // T-rho input
+    // set frac_vol = 1/nmat
+    // set rho_i = nmat / spvol * frac_mass_i
+    // iterate PTE solver to obtain internal energies
+    // that results in the input T
+    pte_solver_scratch_size = PTESolverFixedTRequiredScratch(nmat);
+    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
+                                      pte_solver_scratch_size);
+    const std::string rt_name = "PTE::solve (rho,T) input" + perf_nums;
+    portableFor(
+        rt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+          // cell offset
+          const int i{offsets_v(iloop) - 1};
+          // get "thread-id" like thing with optimization
+          // for small loops
+          const int32_t token{tokens.acquire()};
+          const int32_t tid{small_loop ? iloop : token};
+          double mass_sum{0.0};
+          int npte{0};
+          // initialize values for solver / lookup
+          init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
+          // calculate pte condition (lookup for 1 mat cell)
+          Real sie_tot_true{0.0};
+          const int neq = npte;
+          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+                                                     neq * (neq + 4) + 2 * npte);
+          if (npte > 1) {
+            // create solver lambda
+            // eos accessor
+            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+            PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
+                npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
+                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+                &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
+            const bool res_{PTESolver(method)};
+            // calculate total internal energy
+            for (int mp = 0; mp < npte; ++mp) {
+              const int m = pte_mats(tid, mp);
+              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+            }
+          } else {
+            // pure cell (nmat = 1)
+            // calculate sie from single eos
+            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+                                  .InternalEnergyFromDensityTemperature(
+                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+            // set total sie to material 0 value
+            sie_tot_true = sie_pte(tid, 0);
+            // set pressure
+            press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+                                    .PressureFromDensityTemperature(
+                                        rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+          }
+          // total sie is known
+          sie_v(i) = sie_tot_true;
+          // assign quantities
+          final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
+          // assign max pressure
+          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+          // release the token used for scratch arrays
+          tokens.release(token);
+        });
+    break;
+  }
+  case input_condition::RHO_P_INPUT: {
+    // rho-P input
+    // set frac_vol = 1/nmat
+    // set rho_i = nmat / spvol * frac_mass_i
+    // iterate PTE solver to obtain internal energies
+    // that results in the input P
+    pte_solver_scratch_size = PTESolverRhoTRequiredScratch(nmat);
+    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
+                                      pte_solver_scratch_size);
+    const std::string rp_name = "PTE::solve (rho,P) input" + perf_nums;
+    portableFor(
+        rp_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+          // cell offset
+          const int i{offsets_v(iloop) - 1};
+          // get "thread-id" like thing with optimization
+          // for small loops
+          const int32_t token{tokens.acquire()};
+          const int32_t tid{small_loop ? iloop : token};
+          double mass_sum{0.0};
+          int npte{0};
+          // initialize values for solver / lookup
+          init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
+          Real sie_tot_true{0.0};
+          const int neq = npte + 1;
+          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+                                                     neq * (neq + 4) + 2 * npte);
+          if (npte > 1) {
+            // create solver lambda
+            // eos accessor
+            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+            PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
+                npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
+                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+                &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
+            const bool res_{PTESolver(method)};
+            // calculate total sie
+            for (int mp = 0; mp < npte; ++mp) {
+              const int m = pte_mats(tid, mp);
+              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+            }
+          } else {
+            // pure cell (nmat = 1)
+            // calculate sie from single eos
+            auto p_from_t = [&](const Real &t_i) {
+              return eos_v(pte_idxs(tid, 0))
+                  .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
+            };
+            // calculate sie root bounds
+            Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
+            Real r_dpde{}, r_dvdt{};
+            eos_v(pte_idxs(tid, 0))
+                .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
+                                        r_dpde, r_dvdt);
+            RootFinding1D::RootCounts co{};
+            Real temp_i;
+            RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
+                                    1.e10 * r_temp, 1.e-12, 1.e-12, temp_i, co);
+            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+                                  .InternalEnergyFromDensityTemperature(rho_pte(tid, 0),
+                                                                        temp_i, cache[0]);
+            sie_tot_true = sie_pte(tid, 0);
+            // set temperature
+            temp_pte(tid, 0) = temp_i;
+          }
+          // sie calculate explicitly already
+          sie_v(i) = sie_tot_true;
+          // assign remaining outputs
+          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
+          // assign max pressure
+          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+          // release the token used for scratch arrays
+          tokens.release(token);
+        });
+    break;
+  }
+  case input_condition::P_T_INPUT: {
+    // P-T input
+    const int pte_solver_scratch_size = nmat * MAX_NUM_LAMBDAS;
+    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
+                                      pte_solver_scratch_size);
+    const std::string pt_name = "PTE::solve (P,T) input" + perf_nums;
+    portableFor(
+        pt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+          // cell offset
+          const int i{offsets_v(iloop) - 1};
+          // get "thread-id" like thing with optimization
+          // for small loops
+          const int32_t token{tokens.acquire()};
+          const int32_t tid{small_loop ? iloop : token};
+          // caching mechanism
+          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
+          double mass_sum{0.0};
+          // normalize mass fractions
+          // first find the mass sum
+          // also set idxs as the decrement of the eos offsets
+          // to take into account 1 based indexing in fortran
+          for (int m = 0; m < nmat; ++m) {
+            mass_sum += frac_mass_v(i, m);
+            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
+            pte_mats(tid, m) = m;
+            temp_pte(tid, m) = temp_v(i) * ev2k;
+            press_pte(tid, m) = press_v(i);
+          }
+          for (int m = 0; m < nmat; ++m) {
+            frac_mass_v(i, m) /= mass_sum;
+          }
+          // do r-e of pt for each mat
+          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+          Real vfrac_tot{0.0};
+          Real sie_tot{0.0};
+          for (int m = 0; m < nmat; ++m) {
+            // obtain rho and sie from P-T
+            eos_inx[m].DensityEnergyFromPressureTemperature(
+                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
+                sie_pte(tid, m));
+            // assign volume fractions
+            // this is a physical volume
+            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
+            vfrac_tot += vfrac_pte(tid, m);
+            // add internal energy component
+            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
+          }
+          // assign volume, etc.
+          // total sie is known
+          sie_v(i) = sie_tot;
+          vol_v(i) = vfrac_tot;
+          spvol_v(i) = vol_v(i) / mass_sum;
+          for (int m = 0; m < nmat; ++m) {
+            vfrac_pte(tid, m) /= vfrac_tot;
+          }
+          // assign remaining outputs
+          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
+          // assign max pressure
+          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+          // release the token used for scratch arrays
+          tokens.release(token);
+        });
+    break;
+  }
+  case input_condition::NORM_RHO_E_INPUT:
+    // rho-sie input
+    // no break so fallthrough to case 1
+  case input_condition::RHO_E_INPUT: {
+    // rho-sie input
+    pte_solver_scratch_size = PTESolverRhoTRequiredScratch(nmat);
+    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
+                                      pte_solver_scratch_size);
+    const std::string re_name = "PTE::solve (rho,e) input" + perf_nums;
+    portableFor(
+        re_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+          // cell offset
+          const int i{offsets_v(iloop) - 1};
+          // get "thread-id" like thing with optimization
+          // for small loops
+          const int32_t token{tokens.acquire()};
+          const int32_t tid{small_loop ? iloop : token};
+          double mass_sum{0.0};
+          int npte{0};
+          // initialize values for solver / lookup
+          init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
+          // get cache from offsets into scratch
+          const int neq = npte + 1;
+          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+                                                     neq * (neq + 4) + 2 * npte);
+          if (npte > 1) {
+            // create solver lambda
+            // eos accessor
+            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+            // reset inputs
+            PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
+                npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
+                &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
+                &solver_scratch(tid, 0));
+            const bool res_{PTESolver(method)};
+          } else {
+            // pure cell (nmat = 1)
+            // calculate sie from single eos
+            Real dpdr_m, dtdr_m, dpde_m, dtde_m;
+            eos_v(pte_idxs(tid, 0))
+                .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
+                        temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
+          }
+          // assign outputs
+          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
+          // assign max pressure
+          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+          // release the token used for scratch arrays
+          tokens.release(token);
+        });
+    break;
+  }
+  }
+
+  Kokkos::fence();
+  // copy results back into local values
+  // there is lots of room for performance optimization
+  // in terms of when to copy and when not necessary
+  // this is the return value (number of solve failures)
+  deep_copy(ret, res);
+  // copy pressure, this is not needed in all cases
+  deep_copy(press_hv, press_v);
+  // return max pressure, this may be needed
+  deep_copy(pmax_hv, pmax_v);
+  // I don't think the volume is necessary
+  deep_copy(vol_hv, vol_v);
+  // specific volume, copy-back not needed in all cases
+  deep_copy(spvol_hv, spvol_v);
+  // internal energy, copy-back not needed in all cases
+  deep_copy(sie_hv, sie_v);
+  // temperature, copy-back not needed in all cases
+  deep_copy(temp_hv, temp_v);
+  // bulk modulus, alwasy copy-back
+  deep_copy(bmod_hv, bmod_v);
+  // dpde, always copy-back
+  deep_copy(dpde_hv, dpde_v);
+  // specific heat, always copy-back
+  deep_copy(cv_hv, cv_v);
+  // volume fractions, always copy-back (maybe not for pure cells)
+  deep_copy(frac_vol_hv, frac_vol_v);
+  // component internal energies, always copy-back (maybe not for pure cells)
+  deep_copy(frac_ie_hv, frac_ie_v);
+  // optionally copy-back the component bmod, dpde, and cv
+  if (do_frac_bmod) {
+    deep_copy(frac_bmod_hv, frac_bmod_v);
+  }
+  if (do_frac_dpde) {
+    deep_copy(frac_dpde_hv, frac_dpde_v);
+  }
+  if (do_frac_cv) {
+    deep_copy(frac_cv_hv, frac_cv_v);
+  }
+#endif // PORTABILITY_STRATEGY_KOKKOS
+  return ret;
+}
diff --git a/singularity-eos/eos/singularity_eos.cpp b/singularity-eos/eos/singularity_eos.cpp
index e4aab54e83..a8a958658a 100644
--- a/singularity-eos/eos/singularity_eos.cpp
+++ b/singularity-eos/eos/singularity_eos.cpp
@@ -12,20 +12,14 @@
 // publicly and display publicly, and to permit others to do so.
 //------------------------------------------------------------------------------
 
-#include <algorithm>
 #include <cassert>
-#include <map>
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/eos_builder.hpp>
 #include <singularity-eos/eos/singularity_eos.hpp>
 
 using namespace singularity;
 
-template <typename T,
-          typename = typename std::enable_if<std::is_floating_point<T>::value>::type>
-constexpr bool isfinite(const T &a) {
-  return (a == a) && ((a == 0) || (a != 2 * a));
-}
-
 int init_sg_eos(const int nmat, EOS *&eos) {
 #ifdef PORTABILITY_STRATEGY_KOKKOS
   if (!Kokkos::is_initialized()) Kokkos::initialize();
@@ -215,585 +209,6 @@ int init_sg_eospac(const int matindex, EOS *eos, const int id) {
 
 #undef SGAPPLYMOD
 
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-using Lrgt = Kokkos::LayoutRight;
-using Llft = Kokkos::LayoutLeft;
-template <typename T>
-using ScratchV = Kokkos::View<T **, Lrgt>;
-#endif // PORTABILITY_STRATEGY_KOKKOS
-
-// mapping from EAP integer to
-static const std::map<const int, const unsigned long> EAPInputToBD = {
-    {-3, thermalqs::temperature | thermalqs::density},
-    {-2, thermalqs::density | thermalqs::pressure},
-    {-1, thermalqs::pressure | thermalqs::temperature},
-    {0, thermalqs::specific_internal_energy | thermalqs::density},
-    {1, thermalqs::specific_internal_energy | thermalqs::density},
-};
-
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-namespace singularity {
-struct EOSAccessor_ {
-  PORTABLE_INLINE_FUNCTION
-  EOSAccessor_(const Kokkos::View<EOS *, Llft> &eos_v, int *mats)
-      : eos_v_(eos_v), mats_(mats) {}
-  PORTABLE_INLINE_FUNCTION
-  EOS &operator[](const int m) const { return eos_v_(mats_[m]); }
-  Kokkos::View<EOS *, Llft> eos_v_;
-  int *mats_;
-};
-} // namespace singularity
-#endif // PORTABILITY_STRATEGY_KOKKOS
-// EAP centric arguments and function signature
-
-int get_sg_eos( // sizing information
-    int nmat, int ncell, int cell_dim,
-    // Input parameters
-    int input_int,
-    // eos index offsets
-    int *eos_offsets,
-    // equation of state array
-    EOS *eos,
-    // index offsets
-    int *offsets,
-    // per cell quantities
-    double *press, double *pmax, double *vol, double *spvol, double *sie, double *temp,
-    double *bmod, double *dpde, double *cv,
-    // per material quantities
-    double *frac_mass, double *frac_vol, double *frac_ie,
-    // optional per material quantities
-    double *frac_bmod, double *frac_dpde, double *frac_cv) {
-  // printBacktrace();
-  // kernel return value will be the number of failures
-  int ret{0};
-  // handle optionals
-  bool do_frac_bmod{true};
-  if (frac_bmod == NULL || frac_bmod == nullptr) do_frac_bmod = false;
-  bool do_frac_dpde{true};
-  if (frac_dpde == NULL || frac_dpde == nullptr) do_frac_dpde = false;
-  bool do_frac_cv{true};
-  if (frac_dpde == NULL || frac_dpde == nullptr) do_frac_cv = false;
-  // get inputs
-  enum class input_condition {
-    RHO_T_INPUT = -3,
-    RHO_P_INPUT = -2,
-    P_T_INPUT = -1,
-    NORM_RHO_E_INPUT = 0,
-    RHO_E_INPUT = 1
-  };
-  const auto input{EAPInputToBD.at(input_int)};
-  const auto output = thermalqs::all_values - input;
-  const bool p_is_inp{static_cast<bool>(input & thermalqs::pressure)};
-  const bool r_is_inp{static_cast<bool>(input & thermalqs::density)};
-  const bool t_is_inp{static_cast<bool>(input & thermalqs::temperature)};
-  const bool s_is_inp{static_cast<bool>(input & thermalqs::specific_internal_energy)};
-  constexpr const Real min_guess_density{1.e-20};
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-  // convenience aliases
-  using Unmgd = Kokkos::MemoryUnmanaged;
-  using HS = Kokkos::HostSpace;
-  using Kokkos::create_mirror_view_and_copy;
-  using host_v = Kokkos::View<double *, Llft, HS, Unmgd>;
-  using dev_v = Kokkos::View<double *, Llft>;
-  using host_frac_v = Kokkos::View<double **, Llft, HS, Unmgd>;
-  using dev_frac_v = Kokkos::View<double **, Llft>;
-  using DES = Kokkos::DefaultExecutionSpace;
-  using DMS = DES::memory_space;
-  using Kokkos::MemoryTraits;
-  constexpr const unsigned int ra{0 | Kokkos::RandomAccess};
-  // constexpr const unsigned int ra_u{Kokkos::Unmanaged | Kokkos::RandomAccess};
-  using VAWI = Kokkos::ViewAllocateWithoutInitializing;
-  using Kokkos::deep_copy;
-  static constexpr const double ev2k = 1.160451930280894026e4;
-  // convert pointers to host side views
-  Kokkos::View<int *, Llft, HS, Unmgd> eos_offsets_hv(eos_offsets, nmat);
-  Kokkos::View<int *, Llft, HS, Unmgd> offsets_hv(offsets, ncell);
-  host_v press_hv(press, cell_dim);
-  host_v pmax_hv(pmax, cell_dim);
-  host_v vol_hv(vol, cell_dim);
-  host_v spvol_hv(spvol, cell_dim);
-  host_v sie_hv(sie, cell_dim);
-  host_v temp_hv(temp, cell_dim);
-  host_v bmod_hv(bmod, cell_dim);
-  host_v dpde_hv(dpde, cell_dim);
-  host_v cv_hv(cv, cell_dim);
-  host_frac_v frac_mass_hv(frac_mass, cell_dim, nmat);
-  host_frac_v frac_vol_hv(frac_vol, cell_dim, nmat);
-  host_frac_v frac_ie_hv(frac_ie, cell_dim, nmat);
-  host_frac_v frac_bmod_hv, frac_dpde_hv, frac_cv_hv;
-  if (do_frac_bmod) frac_bmod_hv = host_frac_v(frac_bmod, cell_dim, nmat);
-  if (do_frac_dpde) frac_dpde_hv = host_frac_v(frac_dpde, cell_dim, nmat);
-  if (do_frac_cv) frac_cv_hv = host_frac_v(frac_cv, cell_dim, nmat);
-
-  // get device views if necessary
-  Kokkos::View<const int *, Llft, MemoryTraits<ra>> offsets_v{
-      create_mirror_view_and_copy(DMS(), offsets_hv)};
-  Kokkos::View<const int *, Llft, MemoryTraits<ra>> eos_offsets_v{
-      create_mirror_view_and_copy(DMS(), eos_offsets_hv)};
-  dev_v press_v{create_mirror_view_and_copy(DMS(), press_hv)};
-  dev_v pmax_v{create_mirror_view_and_copy(DMS(), pmax_hv)};
-  dev_v spvol_v{create_mirror_view_and_copy(DMS(), spvol_hv)};
-  dev_v vol_v{create_mirror_view_and_copy(DMS(), vol_hv)};
-  dev_v sie_v{create_mirror_view_and_copy(DMS(), sie_hv)};
-  dev_v temp_v{create_mirror_view_and_copy(DMS(), temp_hv)};
-  dev_v bmod_v{create_mirror_view_and_copy(DMS(), bmod_hv)};
-  dev_v dpde_v{create_mirror_view_and_copy(DMS(), dpde_hv)};
-  dev_v cv_v{create_mirror_view_and_copy(DMS(), cv_hv)};
-  dev_frac_v frac_mass_v{create_mirror_view_and_copy(DMS(), frac_mass_hv)};
-  dev_frac_v frac_vol_v{create_mirror_view_and_copy(DMS(), frac_vol_hv)};
-  dev_frac_v frac_ie_v{create_mirror_view_and_copy(DMS(), frac_ie_hv)};
-  dev_frac_v frac_bmod_v, frac_dpde_v, frac_cv_v;
-  if (do_frac_bmod) frac_bmod_v = create_mirror_view_and_copy(DMS(), frac_bmod_hv);
-  if (do_frac_dpde) frac_dpde_v = create_mirror_view_and_copy(DMS(), frac_dpde_hv);
-  if (do_frac_cv) frac_cv_v = create_mirror_view_and_copy(DMS(), frac_cv_hv);
-  // array of eos's
-  const auto eos_nmat{*std::max_element(eos_offsets, eos_offsets + nmat)};
-  Kokkos::View<EOS *, Llft, HS, Unmgd> eos_hv(eos, eos_nmat);
-  Kokkos::View<EOS *, Llft> eos_v{create_mirror_view_and_copy(DMS(), eos_hv)};
-  // TODO: make this a scatter view
-  constexpr auto at_int_full{0 | Kokkos::Atomic};
-#ifdef KOKKOS_ENABLE_SERIAL
-  constexpr auto at_int{std::is_same<DES, Kokkos::Serial>::value ? 0 : at_int_full};
-#else  // KOKKOS_ENABLE_SERIAL
-  // assume atomics are required for correctness if serial not even enabled
-  constexpr auto at_int{at_int_full};
-#endif // KOKKOS_ENABLE_SERIAL
-  // set up scratch arrays
-  constexpr auto KGlobal = Kokkos::Experimental::UniqueTokenScope::Global;
-  Kokkos::Experimental::UniqueToken<DES, KGlobal> tokens{};
-  using VAWI = Kokkos::ViewAllocateWithoutInitializing;
-
-  const bool small_loop{tokens.size() > ncell};
-  const decltype(tokens)::size_type scratch_size{std::min(tokens.size(), ncell)};
-  ScratchV<int> pte_mats(VAWI("PTE::scratch mats"), scratch_size, nmat);
-  ScratchV<int> pte_idxs(VAWI("PTE::scratch idxs"), scratch_size, nmat);
-  ScratchV<double> mass_pte(VAWI("PTE::scratch mass"), scratch_size, nmat);
-  ScratchV<double> sie_pte(VAWI("PTE::scratch sie"), scratch_size, nmat);
-  ScratchV<double> vfrac_pte(VAWI("PTE::scratch vfrac"), scratch_size, nmat);
-  ScratchV<double> temp_pte(VAWI("PTE::scratch temp"), scratch_size, nmat);
-  ScratchV<double> press_pte(VAWI("PTE::scratch press"), scratch_size, nmat);
-  ScratchV<double> rho_pte(VAWI("PTE::scratch rho"), scratch_size, nmat);
-  // declare solver scratch, allocate in the case statement
-  int pte_solver_scratch_size{};
-  ScratchV<double> solver_scratch;
-
-  // create helper lambdas to reduce code duplication
-  const auto init_lambda =
-      PORTABLE_LAMBDA(const int i, const int tid, double &mass_sum, int &npte,
-                      const Real t_mult, const Real s_mult, const Real p_mult) {
-    // normalize mass fractions
-    // first find the mass sum
-    // also set idxs as the decrement of the eos offsets
-    // to take into account 1 based indexing in fortran
-    for (int m = 0; m < nmat; ++m) {
-      mass_sum += frac_mass_v(i, m);
-      pte_idxs(tid, m) = eos_offsets_v(m) - 1;
-      frac_vol_v(i, m) = 0.0;
-    }
-    for (int m = 0; m < nmat; ++m) {
-      frac_mass_v(i, m) /= mass_sum;
-    }
-    // set inputs
-    npte = 0;
-    for (int m = 0; m < nmat; ++m) {
-      if (frac_mass_v(i, m) > 1.e-12) {
-        pte_idxs(tid, npte) = eos_offsets_v(m) - 1;
-        pte_mats(tid, npte) = m;
-        npte += 1;
-      }
-      vfrac_pte(tid, m) = 0.0;
-      sie_pte(tid, m) = 0.0;
-      temp_pte(tid, m) = 0.0;
-      press_pte(tid, m) = 0.0;
-    }
-    for (int mp = 0; mp < npte; ++mp) {
-      const int m = pte_mats(tid, mp);
-      rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m);
-      vfrac_pte(tid, mp) = 1.0 / npte;
-      temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult;
-      press_pte(tid, mp) = press_v(i) * p_mult;
-      sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult;
-    }
-  };
-  const auto final_lambda = PORTABLE_LAMBDA(
-      const int i, const int tid, const int npte, const Real mass_sum, const Real t_mult,
-      const Real s_mult, const Real p_mult, singularity::mix_impl::CacheAccessor &cache) {
-    // initialize averaged quantities to 0
-    const bool do_t = t_mult == 1.0;
-    const bool do_s = s_mult == 1.0;
-    const bool do_p = p_mult == 1.0;
-    if (do_t) {
-      temp_v(i) = 0.0;
-    }
-    if (do_p) {
-      press_v(i) = 0.0;
-    }
-    if (do_s) {
-      sie_v(i) = 0.0;
-    }
-    bmod_v(i) = 0.0;
-    cv_v(i) = 0.0;
-    dpde_v(i) = 0.0;
-    // material loop for averaging and assigning per mat quantities
-    for (int mp = 0; mp < npte; ++mp) {
-      const int m = pte_mats(tid, mp);
-      // pressure contribution from material m
-      press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult;
-      // temperature contribution from material m
-      temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult;
-      const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum;
-      // sie contribution from material m
-      sie_v(i) += ie_m * s_mult;
-      // assign per material specific internal energy
-      frac_ie_v(i, m) = ie_m;
-      // assign volume fraction based on pte calculation
-      frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i);
-      // calculate bulk modulus for material m
-      const Real bmod_m = eos_v(pte_idxs(tid, mp))
-                              .BulkModulusFromDensityTemperature(
-                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
-      // add bmod contribution from material m
-      bmod_v(i) += bmod_m * vfrac_pte(tid, mp);
-      // calculate specific heat for material m
-      const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp))
-                                   .SpecificHeatFromDensityTemperature(
-                                       rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
-      // add mass weighted contribution specific heat for material m
-      cv_v(i) += cv_m * frac_mass_v(i, m);
-      // calculate gruneisen parameter for material m
-      const Real dpde_m = eos_v(pte_idxs(tid, mp))
-                              .GruneisenParamFromDensityTemperature(
-                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
-      // add gruneisen param contribution from material m
-      dpde_v(i) += dpde_m * vfrac_pte(tid, mp);
-      // optionally assign per material quantities to per material arrays
-      if (do_frac_bmod) {
-        frac_bmod_v(i, m) = bmod_m;
-      }
-      if (do_frac_cv) {
-        frac_cv_v(i, m) = cv_m;
-      }
-      if (do_frac_dpde) {
-        frac_dpde_v(i, m) = dpde_m;
-      }
-    }
-    if (do_t) {
-      temp_v(i) /= ev2k;
-    }
-    if (do_s) {
-      sie_v(i) /= mass_sum;
-    }
-    // reset mass fractions to original values if not normalized to 1
-    for (int m = 0; m < nmat; ++m) {
-      frac_mass_v(i, m) *= mass_sum;
-    }
-  };
-  Kokkos::View<int, MemoryTraits<at_int>> res("PTE::num fails");
-  Kokkos::View<int, MemoryTraits<at_int>> n_solves("PTE::num solves");
-  const std::string perf_nums =
-      "[" + std::to_string(nmat) + "," + std::to_string(ncell) + "]";
-  auto input_int_enum = static_cast<input_condition>(input_int);
-  switch (input_int_enum) {
-  case input_condition::RHO_T_INPUT: {
-    // T-rho input
-    // set frac_vol = 1/nmat
-    // set rho_i = nmat / spvol * frac_mass_i
-    // iterate PTE solver to obtain internal energies
-    // that results in the input T
-    pte_solver_scratch_size = PTESolverFixedTRequiredScratch(nmat);
-    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
-                                      pte_solver_scratch_size);
-    const std::string rt_name = "PTE::solve (rho,T) input" + perf_nums;
-    portableFor(
-        rt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          double mass_sum{0.0};
-          int npte{0};
-          // initialize values for solver / lookup
-          init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
-          // calculate pte condition (lookup for 1 mat cell)
-          Real sie_tot_true{0.0};
-          const int neq = npte;
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-                                                     neq * (neq + 4) + 2 * npte);
-          if (npte > 1) {
-            // create solver lambda
-            // eos accessor
-            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-            PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
-                npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
-                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-                &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
-            const bool res_{PTESolver(method)};
-            // calculate total internal energy
-            for (int mp = 0; mp < npte; ++mp) {
-              const int m = pte_mats(tid, mp);
-              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-            }
-          } else {
-            // pure cell (nmat = 1)
-            // calculate sie from single eos
-            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-                                  .InternalEnergyFromDensityTemperature(
-                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
-            // set total sie to material 0 value
-            sie_tot_true = sie_pte(tid, 0);
-            // set pressure
-            press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-                                    .PressureFromDensityTemperature(
-                                        rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
-          }
-          // total sie is known
-          sie_v(i) = sie_tot_true;
-          // assign quantities
-          final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
-    break;
-  }
-  case input_condition::RHO_P_INPUT: {
-    // rho-P input
-    // set frac_vol = 1/nmat
-    // set rho_i = nmat / spvol * frac_mass_i
-    // iterate PTE solver to obtain internal energies
-    // that results in the input P
-    pte_solver_scratch_size = PTESolverRhoTRequiredScratch(nmat);
-    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
-                                      pte_solver_scratch_size);
-    const std::string rp_name = "PTE::solve (rho,P) input" + perf_nums;
-    portableFor(
-        rp_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          double mass_sum{0.0};
-          int npte{0};
-          // initialize values for solver / lookup
-          init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
-          Real sie_tot_true{0.0};
-          const int neq = npte + 1;
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-                                                     neq * (neq + 4) + 2 * npte);
-          if (npte > 1) {
-            // create solver lambda
-            // eos accessor
-            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-            PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
-                npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
-                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-                &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
-            const bool res_{PTESolver(method)};
-            // calculate total sie
-            for (int mp = 0; mp < npte; ++mp) {
-              const int m = pte_mats(tid, mp);
-              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-            }
-          } else {
-            // pure cell (nmat = 1)
-            // calculate sie from single eos
-            auto p_from_t = [&](const Real &t_i) {
-              return eos_v(pte_idxs(tid, 0))
-                  .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
-            };
-            // calculate sie root bounds
-            Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
-            Real r_dpde{}, r_dvdt{};
-            eos_v(pte_idxs(tid, 0))
-                .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
-                                        r_dpde, r_dvdt);
-            RootFinding1D::RootCounts co{};
-            Real temp_i;
-            RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
-                                    1.e10 * r_temp, 1.e-12, 1.e-12, temp_i, co);
-            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-                                  .InternalEnergyFromDensityTemperature(rho_pte(tid, 0),
-                                                                        temp_i, cache[0]);
-            sie_tot_true = sie_pte(tid, 0);
-            // set temperature
-            temp_pte(tid, 0) = temp_i;
-          }
-          // sie calculate explicitly already
-          sie_v(i) = sie_tot_true;
-          // assign remaining outputs
-          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
-    break;
-  }
-  case input_condition::P_T_INPUT: {
-    // P-T input
-    const int pte_solver_scratch_size = nmat * MAX_NUM_LAMBDAS;
-    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
-                                      pte_solver_scratch_size);
-    const std::string pt_name = "PTE::solve (P,T) input" + perf_nums;
-    portableFor(
-        pt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          // caching mechanism
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
-          double mass_sum{0.0};
-          // normalize mass fractions
-          // first find the mass sum
-          // also set idxs as the decrement of the eos offsets
-          // to take into account 1 based indexing in fortran
-          for (int m = 0; m < nmat; ++m) {
-            mass_sum += frac_mass_v(i, m);
-            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
-            pte_mats(tid, m) = m;
-            temp_pte(tid, m) = temp_v(i) * ev2k;
-            press_pte(tid, m) = press_v(i);
-          }
-          for (int m = 0; m < nmat; ++m) {
-            frac_mass_v(i, m) /= mass_sum;
-          }
-          // do r-e of pt for each mat
-          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-          Real vfrac_tot{0.0};
-          Real sie_tot{0.0};
-          for (int m = 0; m < nmat; ++m) {
-            // obtain rho and sie from P-T
-            eos_inx[m].DensityEnergyFromPressureTemperature(
-                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
-                sie_pte(tid, m));
-            // assign volume fractions
-            // this is a physical volume
-            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
-            vfrac_tot += vfrac_pte(tid, m);
-            // add internal energy component
-            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
-          }
-          // assign volume, etc.
-          // total sie is known
-          sie_v(i) = sie_tot;
-          vol_v(i) = vfrac_tot;
-          spvol_v(i) = vol_v(i) / mass_sum;
-          for (int m = 0; m < nmat; ++m) {
-            vfrac_pte(tid, m) /= vfrac_tot;
-          }
-          // assign remaining outputs
-          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
-    break;
-  }
-  case input_condition::NORM_RHO_E_INPUT:
-    // rho-sie input
-    // no break so fallthrough to case 1
-  case input_condition::RHO_E_INPUT: {
-    // rho-sie input
-    pte_solver_scratch_size = PTESolverRhoTRequiredScratch(nmat);
-    solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
-                                      pte_solver_scratch_size);
-    const std::string re_name = "PTE::solve (rho,e) input" + perf_nums;
-    portableFor(
-        re_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          double mass_sum{0.0};
-          int npte{0};
-          // initialize values for solver / lookup
-          init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
-          // get cache from offsets into scratch
-          const int neq = npte + 1;
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-                                                     neq * (neq + 4) + 2 * npte);
-          if (npte > 1) {
-            // create solver lambda
-            // eos accessor
-            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-            // reset inputs
-            PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
-                npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
-                &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
-                &solver_scratch(tid, 0));
-            const bool res_{PTESolver(method)};
-          } else {
-            // pure cell (nmat = 1)
-            // calculate sie from single eos
-            Real dpdr_m, dtdr_m, dpde_m, dtde_m;
-            eos_v(pte_idxs(tid, 0))
-                .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
-                        temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
-          }
-          // assign outputs
-          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
-    break;
-  }
-  }
-
-  Kokkos::fence();
-  // copy results back into local values
-  // there is lots of room for performance optimization
-  // in terms of when to copy and when not necessary
-  // this is the return value (number of solve failures)
-  deep_copy(ret, res);
-  // copy pressure, this is not needed in all cases
-  deep_copy(press_hv, press_v);
-  // return max pressure, this may be needed
-  deep_copy(pmax_hv, pmax_v);
-  // I don't think the volume is necessary
-  deep_copy(vol_hv, vol_v);
-  // specific volume, copy-back not needed in all cases
-  deep_copy(spvol_hv, spvol_v);
-  // internal energy, copy-back not needed in all cases
-  deep_copy(sie_hv, sie_v);
-  // temperature, copy-back not needed in all cases
-  deep_copy(temp_hv, temp_v);
-  // bulk modulus, alwasy copy-back
-  deep_copy(bmod_hv, bmod_v);
-  // dpde, always copy-back
-  deep_copy(dpde_hv, dpde_v);
-  // specific heat, always copy-back
-  deep_copy(cv_hv, cv_v);
-  // volume fractions, always copy-back (maybe not for pure cells)
-  deep_copy(frac_vol_hv, frac_vol_v);
-  // component internal energies, always copy-back (maybe not for pure cells)
-  deep_copy(frac_ie_hv, frac_ie_v);
-  // optionally copy-back the component bmod, dpde, and cv
-  if (do_frac_bmod) {
-    deep_copy(frac_bmod_hv, frac_bmod_v);
-  }
-  if (do_frac_dpde) {
-    deep_copy(frac_dpde_hv, frac_dpde_v);
-  }
-  if (do_frac_cv) {
-    deep_copy(frac_cv_hv, frac_cv_v);
-  }
-#endif // PORTABILITY_STRATEGY_KOKKOS
-  return ret;
-}
-
 int finalize_sg_eos(const int nmat, EOS *&eos, const int own_kokkos) {
   {
     for (int i = 0; i < nmat; ++i)
@@ -809,3 +224,4 @@ int finalize_sg_eos(const int nmat, EOS *&eos, const int own_kokkos) {
 #endif
   return 0;
 }
+

From 4c948da7775e835b3962b60b8c5a10c213be062b Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 27 Mar 2023 13:04:39 -0600
Subject: [PATCH 02/45] format.

---
 singularity-eos/eos/singularity_eos.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/singularity-eos/eos/singularity_eos.cpp b/singularity-eos/eos/singularity_eos.cpp
index ad832f4664..50ecf6d1a6 100644
--- a/singularity-eos/eos/singularity_eos.cpp
+++ b/singularity-eos/eos/singularity_eos.cpp
@@ -224,4 +224,3 @@ int finalize_sg_eos(const int nmat, EOS *&eos, const int own_kokkos) {
 #endif
   return 0;
 }
-

From 8ba8a2ab06127317bfd777437fed7f41e4762dd0 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 27 Mar 2023 13:19:15 -0600
Subject: [PATCH 03/45] Included file locations moved to correct place, mixed
 cell models only needed in the new file.

---
 singularity-eos/CMakeLists.txt          | 1 -
 singularity-eos/eos/get_sg_eos.cpp      | 1 +
 singularity-eos/eos/singularity_eos.hpp | 1 -
 3 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index d7f74883a3..8a8ff4132b 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -13,7 +13,6 @@
 #------------------------------------------------------------------------------#
 
 set(EOS_HEADERS
-    closure/mixed_cell_models.hpp
     base/fast-math/logs.hpp
     base/robust_utils.hpp
     base/root-finding-1d/root_finding.hpp
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 0769e6668a..337df0ae57 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -16,6 +16,7 @@
 #include <ports-of-call/portability.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/singularity_eos.hpp>
+#include <singularity-eos/closure/mixed_cell_models.hpp>
 
 using namespace singularity;
 
diff --git a/singularity-eos/eos/singularity_eos.hpp b/singularity-eos/eos/singularity_eos.hpp
index b20a06d350..aea7fbe4d1 100644
--- a/singularity-eos/eos/singularity_eos.hpp
+++ b/singularity-eos/eos/singularity_eos.hpp
@@ -15,7 +15,6 @@
 #ifndef _SINGULARITY_EOS_EOS_SINGULARITY_EOS_HPP_
 #define _SINGULARITY_EOS_EOS_SINGULARITY_EOS_HPP_
 
-#include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 
 using singularity::EOS;

From ef62d5933e1086768fb03a78e9e9198204b7036f Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 27 Mar 2023 13:21:59 -0600
Subject: [PATCH 04/45] format

---
 singularity-eos/eos/get_sg_eos.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 337df0ae57..ffc2719948 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -14,9 +14,9 @@
 
 #include <map>
 #include <ports-of-call/portability.hpp>
+#include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/singularity_eos.hpp>
-#include <singularity-eos/closure/mixed_cell_models.hpp>
 
 using namespace singularity;
 

From fffa84cc424dd163bb6d9ae71200d02cbcb8b67a Mon Sep 17 00:00:00 2001
From: Daniel Holladay <danl@rzansel61.coral.llnl.gov>
Date: Tue, 25 Apr 2023 10:11:37 -0700
Subject: [PATCH 05/45] Split get sg eos into several compilation units to
 reduce compile times. Add no warn to eospac on gpus to reduce known and not
 useful warnings.

---
 singularity-eos/CMakeLists.txt             |  12 +-
 singularity-eos/eos/eos_eospac.hpp         |  70 +--
 singularity-eos/eos/get_sg_eos.cpp         | 623 +++++++++------------
 singularity-eos/eos/get_sg_eos.hpp         | 192 +++++++
 singularity-eos/eos/get_sg_eos_lambdas.hpp | 143 +++++
 singularity-eos/eos/get_sg_eos_p_t.cpp     | 111 ++++
 singularity-eos/eos/get_sg_eos_rho_e.cpp   |  97 ++++
 singularity-eos/eos/get_sg_eos_rho_p.cpp   | 118 ++++
 singularity-eos/eos/get_sg_eos_rho_t.cpp   | 109 ++++
 9 files changed, 1074 insertions(+), 401 deletions(-)
 create mode 100644 singularity-eos/eos/get_sg_eos.hpp
 create mode 100644 singularity-eos/eos/get_sg_eos_lambdas.hpp
 create mode 100644 singularity-eos/eos/get_sg_eos_p_t.cpp
 create mode 100644 singularity-eos/eos/get_sg_eos_rho_e.cpp
 create mode 100644 singularity-eos/eos/get_sg_eos_rho_p.cpp
 create mode 100644 singularity-eos/eos/get_sg_eos_rho_t.cpp

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 8a8ff4132b..7b3d3a257a 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -46,8 +46,16 @@ set(EOS_SRCS
 )
 
 if (SINGULARITY_BUILD_CLOSURE)
-  list(APPEND EOS_SRCS eos/get_sg_eos.cpp)
-  list(APPEND EOS_HEADERS closure/mixed_cell_models.hpp)
+  list(APPEND EOS_SRCS 
+       eos/get_sg_eos_p_t.cpp
+       eos/get_sg_eos_rho_t.cpp
+       eos/get_sg_eos_rho_p.cpp
+       eos/get_sg_eos_rho_e.cpp
+       eos/get_sg_eos.cpp)
+  list(APPEND EOS_HEADERS
+       closure/mixed_cell_models.hpp
+       eos/get_sg_eos.hpp
+       eos/get_sg_eos_lambdas.hpp)
 endif()
 
 if (SINGULARITY_USE_FORTRAN)
diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index a4b75724b8..532d427c04 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -41,42 +41,46 @@ using namespace eos_base;
 
 // Only really works in serial
 // Not really supported on device
+#define SG_PIF_NOWARN \
+#pragma nv_exec_check_disable \
+PORTABLE_INLINE_FUNCTION
+
 class EOSPAC : public EosBase<EOSPAC> {
  public:
   inline EOSPAC() = default;
   inline EOSPAC(int matid, bool invert_at_setup = false);
   inline EOSPAC GetOnDevice() { return *this; }
-  PORTABLE_INLINE_FUNCTION Real TemperatureFromDensityInternalEnergy(
+  SG_PIF_NOWARN Real TemperatureFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real InternalEnergyFromDensityTemperature(
+  SG_PIF_NOWARN Real InternalEnergyFromDensityTemperature(
       const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real PressureFromDensityTemperature(
+  SG_PIF_NOWARN Real PressureFromDensityTemperature(
       const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real PressureFromDensityInternalEnergy(
+  SG_PIF_NOWARN Real PressureFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityTemperature(
+  SG_PIF_NOWARN Real EntropyFromDensityTemperature(
       const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityInternalEnergy(
+  SG_PIF_NOWARN Real EntropyFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityTemperature(
+  SG_PIF_NOWARN Real SpecificHeatFromDensityTemperature(
       const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityInternalEnergy(
+  SG_PIF_NOWARN Real SpecificHeatFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityTemperature(
+  SG_PIF_NOWARN Real BulkModulusFromDensityTemperature(
       const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityInternalEnergy(
+  SG_PIF_NOWARN Real BulkModulusFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityTemperature(
+  SG_PIF_NOWARN Real GruneisenParamFromDensityTemperature(
       const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityInternalEnergy(
+  SG_PIF_NOWARN Real GruneisenParamFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION void FillEos(Real &rho, Real &temp, Real &energy, Real &press,
+  SG_PIF_NOWARN void FillEos(Real &rho, Real &temp, Real &energy, Real &press,
                                         Real &cv, Real &bmod, const unsigned long output,
                                         Real *lambda = nullptr) const;
-  PORTABLE_INLINE_FUNCTION
+  SG_PIF_NOWARN
   void DensityEnergyFromPressureTemperature(const Real press, const Real temp,
                                             Real *lambda, Real &rho, Real &sie) const;
-  PORTABLE_INLINE_FUNCTION void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
+  SG_PIF_NOWARN void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
                                                        Real &press, Real &cv, Real &bmod,
                                                        Real &dpde, Real &dvdt,
                                                        Real *lambda = nullptr) const;
@@ -661,7 +665,7 @@ class EOSPAC : public EosBase<EOSPAC> {
         });
   }
 
-  PORTABLE_INLINE_FUNCTION
+  SG_PIF_NOWARN
   void PTofRE(Real &rho, Real &sie, Real *lambda, Real &press, Real &temp, Real &dpdr,
               Real &dpde, Real &dtdr, Real &dtde) const {
 
@@ -698,11 +702,11 @@ class EOSPAC : public EosBase<EOSPAC> {
   }
 
   static constexpr unsigned long PreferredInput() { return _preferred_input; }
-  PORTABLE_INLINE_FUNCTION int nlambda() const noexcept { return 0; }
+  SG_PIF_NOWARN int nlambda() const noexcept { return 0; }
   inline void Finalize() {}
   static std::string EosType() { return std::string("EOSPAC"); }
   static std::string EosPyType() { return EosType(); }
-  inline void PrintParams() const { printf("EOSPAC parameters:\nmatid = %i\n", matid_); }
+  SG_PIF_NOWARN void PrintParams() const { printf("EOSPAC parameters:\nmatid = %i\n", matid_); }
   PORTABLE_FORCEINLINE_FUNCTION Real MinimumDensity() const { return rho_min_; }
   PORTABLE_FORCEINLINE_FUNCTION Real MinimumTemperature() const { return temp_min_; }
 
@@ -796,7 +800,7 @@ inline EOSPAC::EOSPAC(const int matid, bool invert_at_setup) : matid_(matid) {
       robust::ratio(dpde_ref_ * cv_ref_, rho_ref_ * rho_ref_ * pressureFromSesame(DPDR));
 }
 
-PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
+SG_PIF_NOWARN Real EOSPAC::TemperatureFromDensityInternalEnergy(
     const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, E[1] = {sieToSesame(sie)}, T[1], dTdr[1], dTde[1];
@@ -806,7 +810,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
   return Real(temperatureFromSesame(T[0]));
 }
 
-PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(const Real rho,
+SG_PIF_NOWARN Real EOSPAC::PressureFromDensityTemperature(const Real rho,
                                                                      const Real temp,
                                                                      Real *lambda) const {
   using namespace EospacWrapper;
@@ -817,13 +821,13 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(const Real
   return Real(pressureFromSesame(P[0]));
 }
 
-PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityTemperature(
+SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityTemperature(
     const Real rho, const Real temperature, Real *lambda) const {
   EntropyIsNotEnabled("EOSPAC");
   return 1.0;
 }
 
-PORTABLE_INLINE_FUNCTION void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
+SG_PIF_NOWARN void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
                                               Real &press, Real &cv, Real &bmod,
                                               const unsigned long output,
                                               Real *lambda) const {
@@ -906,7 +910,7 @@ PORTABLE_INLINE_FUNCTION void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
   }
 }
 
-PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
+SG_PIF_NOWARN Real EOSPAC::InternalEnergyFromDensityTemperature(
     const Real rho, const Real temp, Real *lambda) const {
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
@@ -914,7 +918,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return sie;
 }
-PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
+SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityTemperature(
     const Real rho, const Real temp, Real *lambda) const {
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
@@ -922,7 +926,7 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return bmod;
 }
-PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
+SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityTemperature(
     const Real rho, const Real temp, Real *lambda) const {
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
@@ -930,32 +934,32 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return cv;
 }
-PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
+SG_PIF_NOWARN Real EOSPAC::PressureFromDensityInternalEnergy(
     const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return PressureFromDensityTemperature(rho, temp, lambda);
 }
-PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
+SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityInternalEnergy(
     const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   const Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return EntropyFromDensityTemperature(rho, temp, lambda);
 }
-PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
+SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
     const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return SpecificHeatFromDensityTemperature(rho, temp, lambda);
 }
-PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
+SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityInternalEnergy(
     const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return BulkModulusFromDensityTemperature(rho, temp, lambda);
 }
 
-PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
+SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityTemperature(
     const Real rho, const Real temperature, Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temperature)};
@@ -971,13 +975,13 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
   DPDE = DPDT / DEDT;
   return robust::ratio(pressureFromSesame(sieToSesame(DPDE)), rho);
 }
-PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
+SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
     const Real rho, const Real sie, Real *lambda) const {
   Real temperature = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return GruneisenParamFromDensityTemperature(rho, temperature, lambda);
 }
 
-PORTABLE_INLINE_FUNCTION
+SG_PIF_NOWARN
 void EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real temp,
                                                   Real *lambda, Real &rho,
                                                   Real &sie) const {
@@ -998,7 +1002,7 @@ void EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real t
   sie = sieFromSesame(E[0]);
 }
 
-PORTABLE_INLINE_FUNCTION void
+SG_PIF_NOWARN void
 EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Real &cv,
                                Real &bmod, Real &dpde, Real &dvdt, Real *lambda) const {
   using namespace EospacWrapper;
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index ffc2719948..561a19758a 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
-// © 2021-2022. Triad National Security, LLC. All rights reserved.  This
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
 // program was produced under U.S. Government contract 89233218CNA000001
 // for Los Alamos National Laboratory (LANL), which is operated by Triad
 // National Security, LLC for the U.S.  Department of Energy/National
@@ -17,16 +17,11 @@
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/singularity_eos.hpp>
+#include <singularity-eos/eos/get_sg_eos.hpp>
+#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 using namespace singularity;
 
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-using Lrgt = Kokkos::LayoutRight;
-using Llft = Kokkos::LayoutLeft;
-template <typename T>
-using ScratchV = Kokkos::View<T **, Lrgt>;
-#endif // PORTABILITY_STRATEGY_KOKKOS
-
 // mapping from EAP integer to
 static const std::map<const int, const unsigned long> EAPInputToBD = {
     {-3, thermalqs::temperature | thermalqs::density},
@@ -36,21 +31,7 @@ static const std::map<const int, const unsigned long> EAPInputToBD = {
     {1, thermalqs::specific_internal_energy | thermalqs::density},
 };
 
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-namespace singularity {
-struct EOSAccessor_ {
-  PORTABLE_INLINE_FUNCTION
-  EOSAccessor_(const Kokkos::View<EOS *, Llft> &eos_v, int *mats)
-      : eos_v_(eos_v), mats_(mats) {}
-  PORTABLE_INLINE_FUNCTION
-  EOS &operator[](const int m) const { return eos_v_(mats_[m]); }
-  Kokkos::View<EOS *, Llft> eos_v_;
-  int *mats_;
-};
-} // namespace singularity
-#endif // PORTABILITY_STRATEGY_KOKKOS
 // EAP centric arguments and function signature
-
 int get_sg_eos( // sizing information
     int nmat, int ncell, int cell_dim,
     // Input parameters
@@ -93,23 +74,7 @@ int get_sg_eos( // sizing information
   const bool t_is_inp{static_cast<bool>(input & thermalqs::temperature)};
   const bool s_is_inp{static_cast<bool>(input & thermalqs::specific_internal_energy)};
   constexpr const Real min_guess_density{1.e-20};
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-  // convenience aliases
-  using Unmgd = Kokkos::MemoryUnmanaged;
-  using HS = Kokkos::HostSpace;
-  using Kokkos::create_mirror_view_and_copy;
-  using host_v = Kokkos::View<double *, Llft, HS, Unmgd>;
-  using dev_v = Kokkos::View<double *, Llft>;
-  using host_frac_v = Kokkos::View<double **, Llft, HS, Unmgd>;
-  using dev_frac_v = Kokkos::View<double **, Llft>;
-  using DES = Kokkos::DefaultExecutionSpace;
-  using DMS = DES::memory_space;
-  using Kokkos::MemoryTraits;
-  constexpr const unsigned int ra{0 | Kokkos::RandomAccess};
-  // constexpr const unsigned int ra_u{Kokkos::Unmanaged | Kokkos::RandomAccess};
-  using VAWI = Kokkos::ViewAllocateWithoutInitializing;
-  using Kokkos::deep_copy;
-  static constexpr const double ev2k = 1.160451930280894026e4;
+  #ifdef PORTABILITY_STRATEGY_KOKKOS
   // convert pointers to host side views
   Kokkos::View<int *, Llft, HS, Unmgd> eos_offsets_hv(eos_offsets, nmat);
   Kokkos::View<int *, Llft, HS, Unmgd> offsets_hv(offsets, ncell);
@@ -131,10 +96,9 @@ int get_sg_eos( // sizing information
   if (do_frac_cv) frac_cv_hv = host_frac_v(frac_cv, cell_dim, nmat);
 
   // get device views if necessary
-  Kokkos::View<const int *, Llft, MemoryTraits<ra>> offsets_v{
-      create_mirror_view_and_copy(DMS(), offsets_hv)};
-  Kokkos::View<const int *, Llft, MemoryTraits<ra>> eos_offsets_v{
-      create_mirror_view_and_copy(DMS(), eos_offsets_hv)};
+  indirection_v offsets_v{create_mirror_view_and_copy(DMS(), offsets_hv)};
+  indirection_v eos_offsets_v{create_mirror_view_and_copy(DMS(),
+                                                          eos_offsets_hv)};
   dev_v press_v{create_mirror_view_and_copy(DMS(), press_hv)};
   dev_v pmax_v{create_mirror_view_and_copy(DMS(), pmax_hv)};
   dev_v spvol_v{create_mirror_view_and_copy(DMS(), spvol_hv)};
@@ -183,116 +147,8 @@ int get_sg_eos( // sizing information
   ScratchV<double> solver_scratch;
 
   // create helper lambdas to reduce code duplication
-  const auto init_lambda =
-      PORTABLE_LAMBDA(const int i, const int tid, double &mass_sum, int &npte,
-                      const Real t_mult, const Real s_mult, const Real p_mult) {
-    // normalize mass fractions
-    // first find the mass sum
-    // also set idxs as the decrement of the eos offsets
-    // to take into account 1 based indexing in fortran
-    for (int m = 0; m < nmat; ++m) {
-      mass_sum += frac_mass_v(i, m);
-      pte_idxs(tid, m) = eos_offsets_v(m) - 1;
-      frac_vol_v(i, m) = 0.0;
-    }
-    for (int m = 0; m < nmat; ++m) {
-      frac_mass_v(i, m) /= mass_sum;
-    }
-    // set inputs
-    npte = 0;
-    for (int m = 0; m < nmat; ++m) {
-      if (frac_mass_v(i, m) > 1.e-12) {
-        pte_idxs(tid, npte) = eos_offsets_v(m) - 1;
-        pte_mats(tid, npte) = m;
-        npte += 1;
-      }
-      vfrac_pte(tid, m) = 0.0;
-      sie_pte(tid, m) = 0.0;
-      temp_pte(tid, m) = 0.0;
-      press_pte(tid, m) = 0.0;
-    }
-    for (int mp = 0; mp < npte; ++mp) {
-      const int m = pte_mats(tid, mp);
-      rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m);
-      vfrac_pte(tid, mp) = 1.0 / npte;
-      temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult;
-      press_pte(tid, mp) = press_v(i) * p_mult;
-      sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult;
-    }
-  };
-  const auto final_lambda = PORTABLE_LAMBDA(
-      const int i, const int tid, const int npte, const Real mass_sum, const Real t_mult,
-      const Real s_mult, const Real p_mult, singularity::mix_impl::CacheAccessor &cache) {
-    // initialize averaged quantities to 0
-    const bool do_t = t_mult == 1.0;
-    const bool do_s = s_mult == 1.0;
-    const bool do_p = p_mult == 1.0;
-    if (do_t) {
-      temp_v(i) = 0.0;
-    }
-    if (do_p) {
-      press_v(i) = 0.0;
-    }
-    if (do_s) {
-      sie_v(i) = 0.0;
-    }
-    bmod_v(i) = 0.0;
-    cv_v(i) = 0.0;
-    dpde_v(i) = 0.0;
-    // material loop for averaging and assigning per mat quantities
-    for (int mp = 0; mp < npte; ++mp) {
-      const int m = pte_mats(tid, mp);
-      // pressure contribution from material m
-      press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult;
-      // temperature contribution from material m
-      temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult;
-      const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum;
-      // sie contribution from material m
-      sie_v(i) += ie_m * s_mult;
-      // assign per material specific internal energy
-      frac_ie_v(i, m) = ie_m;
-      // assign volume fraction based on pte calculation
-      frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i);
-      // calculate bulk modulus for material m
-      const Real bmod_m = eos_v(pte_idxs(tid, mp))
-                              .BulkModulusFromDensityTemperature(
-                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
-      // add bmod contribution from material m
-      bmod_v(i) += bmod_m * vfrac_pte(tid, mp);
-      // calculate specific heat for material m
-      const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp))
-                                   .SpecificHeatFromDensityTemperature(
-                                       rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
-      // add mass weighted contribution specific heat for material m
-      cv_v(i) += cv_m * frac_mass_v(i, m);
-      // calculate gruneisen parameter for material m
-      const Real dpde_m = eos_v(pte_idxs(tid, mp))
-                              .GruneisenParamFromDensityTemperature(
-                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
-      // add gruneisen param contribution from material m
-      dpde_v(i) += dpde_m * vfrac_pte(tid, mp);
-      // optionally assign per material quantities to per material arrays
-      if (do_frac_bmod) {
-        frac_bmod_v(i, m) = bmod_m;
-      }
-      if (do_frac_cv) {
-        frac_cv_v(i, m) = cv_m;
-      }
-      if (do_frac_dpde) {
-        frac_dpde_v(i, m) = dpde_m;
-      }
-    }
-    if (do_t) {
-      temp_v(i) /= ev2k;
-    }
-    if (do_s) {
-      sie_v(i) /= mass_sum;
-    }
-    // reset mass fractions to original values if not normalized to 1
-    for (int m = 0; m < nmat; ++m) {
-      frac_mass_v(i, m) *= mass_sum;
-    }
-  };
+  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
+  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   Kokkos::View<int, MemoryTraits<at_int>> res("PTE::num fails");
   Kokkos::View<int, MemoryTraits<at_int>> n_solves("PTE::num solves");
   const std::string perf_nums =
@@ -309,59 +165,68 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string rt_name = "PTE::solve (rho,T) input" + perf_nums;
-    portableFor(
-        rt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          double mass_sum{0.0};
-          int npte{0};
-          // initialize values for solver / lookup
-          init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
-          // calculate pte condition (lookup for 1 mat cell)
-          Real sie_tot_true{0.0};
-          const int neq = npte;
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-                                                     neq * (neq + 4) + 2 * npte);
-          if (npte > 1) {
-            // create solver lambda
-            // eos accessor
-            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-            PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
-                npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
-                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-                &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
-            const bool res_{PTESolver(method)};
-            // calculate total internal energy
-            for (int mp = 0; mp < npte; ++mp) {
-              const int m = pte_mats(tid, mp);
-              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-            }
-          } else {
-            // pure cell (nmat = 1)
-            // calculate sie from single eos
-            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-                                  .InternalEnergyFromDensityTemperature(
-                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
-            // set total sie to material 0 value
-            sie_tot_true = sie_pte(tid, 0);
-            // set pressure
-            press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-                                    .PressureFromDensityTemperature(
-                                        rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
-          }
-          // total sie is known
-          sie_v(i) = sie_tot_true;
-          // assign quantities
-          final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
+    singularity::get_sg_eos_rho_t(rt_name.c_str(), ncell, nmat, offsets_v,
+                                  eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
+                                  spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
+                                  frac_mass_v, frac_vol_v, frac_ie_v,
+                                  frac_bmod_v, frac_dpde_v, frac_cv_v, 
+                                  pte_idxs, pte_mats, press_pte, vfrac_pte,
+                                  rho_pte, sie_pte, temp_pte, solver_scratch,
+                                  tokens, small_loop, do_frac_bmod,
+                                  do_frac_dpde, do_frac_cv);
+//    portableFor(
+//        rt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+//          // cell offset
+//          const int i{offsets_v(iloop) - 1};
+//          // get "thread-id" like thing with optimization
+//          // for small loops
+//          const int32_t token{tokens.acquire()};
+//          const int32_t tid{small_loop ? iloop : token};
+//          double mass_sum{0.0};
+//          int npte{0};
+//          // initialize values for solver / lookup
+//          init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
+//          // calculate pte condition (lookup for 1 mat cell)
+//          Real sie_tot_true{0.0};
+//          const int neq = npte;
+//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+//                                                     neq * (neq + 4) + 2 * npte);
+//          if (npte > 1) {
+//            // create solver lambda
+//            // eos accessor
+//            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+//            PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
+//                npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
+//                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+//                &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
+//            const bool res_{PTESolver(method)};
+//            // calculate total internal energy
+//            for (int mp = 0; mp < npte; ++mp) {
+//              const int m = pte_mats(tid, mp);
+//              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+//            }
+//          } else {
+//            // pure cell (nmat = 1)
+//            // calculate sie from single eos
+//            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+//                                  .InternalEnergyFromDensityTemperature(
+//                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+//            // set total sie to material 0 value
+//            sie_tot_true = sie_pte(tid, 0);
+//            // set pressure
+//            press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+//                                    .PressureFromDensityTemperature(
+//                                        rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+//          }
+//          // total sie is known
+//          sie_v(i) = sie_tot_true;
+//          // assign quantities
+//          final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
+//          // assign max pressure
+//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+//          // release the token used for scratch arrays
+//          tokens.release(token);
+//        });
     break;
   }
   case input_condition::RHO_P_INPUT: {
@@ -374,69 +239,77 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string rp_name = "PTE::solve (rho,P) input" + perf_nums;
-    portableFor(
-        rp_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          double mass_sum{0.0};
-          int npte{0};
-          // initialize values for solver / lookup
-          init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
-          Real sie_tot_true{0.0};
-          const int neq = npte + 1;
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-                                                     neq * (neq + 4) + 2 * npte);
-          if (npte > 1) {
-            // create solver lambda
-            // eos accessor
-            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-            PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
-                npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
-                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-                &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
-            const bool res_{PTESolver(method)};
-            // calculate total sie
-            for (int mp = 0; mp < npte; ++mp) {
-              const int m = pte_mats(tid, mp);
-              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-            }
-          } else {
-            // pure cell (nmat = 1)
-            // calculate sie from single eos
-            auto p_from_t = [&](const Real &t_i) {
-              return eos_v(pte_idxs(tid, 0))
-                  .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
-            };
-            // calculate sie root bounds
-            Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
-            Real r_dpde{}, r_dvdt{};
-            eos_v(pte_idxs(tid, 0))
-                .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
-                                        r_dpde, r_dvdt);
-            RootFinding1D::RootCounts co{};
-            Real temp_i;
-            RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
-                                    1.e10 * r_temp, 1.e-12, 1.e-12, temp_i, co);
-            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-                                  .InternalEnergyFromDensityTemperature(rho_pte(tid, 0),
-                                                                        temp_i, cache[0]);
-            sie_tot_true = sie_pte(tid, 0);
-            // set temperature
-            temp_pte(tid, 0) = temp_i;
-          }
-          // sie calculate explicitly already
-          sie_v(i) = sie_tot_true;
-          // assign remaining outputs
-          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
+    singularity::get_sg_eos_rho_p(rp_name.c_str(), ncell, nmat, offsets_v,
+                                  eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
+                                  spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
+                                  frac_mass_v, frac_vol_v, frac_ie_v,
+                                  frac_bmod_v, frac_dpde_v, frac_cv_v, 
+                                  pte_idxs, pte_mats, press_pte, vfrac_pte,
+                                  rho_pte, sie_pte, temp_pte, solver_scratch,
+                                  tokens, small_loop, do_frac_bmod,
+                                  do_frac_dpde, do_frac_cv);
+//    portableFor(
+//        rp_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+//          // cell offset
+//          const int i{offsets_v(iloop) - 1};
+//          // get "thread-id" like thing with optimization
+//          // for small loops
+//          const int32_t token{tokens.acquire()};
+//          const int32_t tid{small_loop ? iloop : token};
+//          double mass_sum{0.0};
+//          int npte{0};
+//          // initialize values for solver / lookup
+//          init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
+//          Real sie_tot_true{0.0};
+//          const int neq = npte + 1;
+//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+//                                                     neq * (neq + 4) + 2 * npte);
+//          if (npte > 1) {
+//            // create solver lambda
+//            // eos accessor
+//            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+//            PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
+//                npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
+//                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+//                &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
+//            const bool res_{PTESolver(method)};
+//            // calculate total sie
+//            for (int mp = 0; mp < npte; ++mp) {
+//              const int m = pte_mats(tid, mp);
+//              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+//            }
+//          } else {
+//            // pure cell (nmat = 1)
+//            // calculate sie from single eos
+//            auto p_from_t = [&](const Real &t_i) {
+//              return eos_v(pte_idxs(tid, 0))
+//                  .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
+//            };
+//            // calculate sie root bounds
+//            Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
+//            Real r_dpde{}, r_dvdt{};
+//            eos_v(pte_idxs(tid, 0))
+//                .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
+//                                        r_dpde, r_dvdt);
+//            Real temp_i;
+//            RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
+//                                    1.e10 * r_temp, 1.e-12, 1.e-12, temp_i);
+//            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+//                                  .InternalEnergyFromDensityTemperature(rho_pte(tid, 0),
+//                                                                        temp_i, cache[0]);
+//            sie_tot_true = sie_pte(tid, 0);
+//            // set temperature
+//            temp_pte(tid, 0) = temp_i;
+//          }
+//          // sie calculate explicitly already
+//          sie_v(i) = sie_tot_true;
+//          // assign remaining outputs
+//          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
+//          // assign max pressure
+//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+//          // release the token used for scratch arrays
+//          tokens.release(token);
+//        });
     break;
   }
   case input_condition::P_T_INPUT: {
@@ -445,62 +318,71 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string pt_name = "PTE::solve (P,T) input" + perf_nums;
-    portableFor(
-        pt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          // caching mechanism
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
-          double mass_sum{0.0};
-          // normalize mass fractions
-          // first find the mass sum
-          // also set idxs as the decrement of the eos offsets
-          // to take into account 1 based indexing in fortran
-          for (int m = 0; m < nmat; ++m) {
-            mass_sum += frac_mass_v(i, m);
-            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
-            pte_mats(tid, m) = m;
-            temp_pte(tid, m) = temp_v(i) * ev2k;
-            press_pte(tid, m) = press_v(i);
-          }
-          for (int m = 0; m < nmat; ++m) {
-            frac_mass_v(i, m) /= mass_sum;
-          }
-          // do r-e of pt for each mat
-          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-          Real vfrac_tot{0.0};
-          Real sie_tot{0.0};
-          for (int m = 0; m < nmat; ++m) {
-            // obtain rho and sie from P-T
-            eos_inx[m].DensityEnergyFromPressureTemperature(
-                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
-                sie_pte(tid, m));
-            // assign volume fractions
-            // this is a physical volume
-            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
-            vfrac_tot += vfrac_pte(tid, m);
-            // add internal energy component
-            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
-          }
-          // assign volume, etc.
-          // total sie is known
-          sie_v(i) = sie_tot;
-          vol_v(i) = vfrac_tot;
-          spvol_v(i) = vol_v(i) / mass_sum;
-          for (int m = 0; m < nmat; ++m) {
-            vfrac_pte(tid, m) /= vfrac_tot;
-          }
-          // assign remaining outputs
-          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
+    singularity::get_sg_eos_p_t(pt_name.c_str(), ncell, nmat, offsets_v,
+                                eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
+                                spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
+                                frac_mass_v, frac_vol_v, frac_ie_v,
+                                frac_bmod_v, frac_dpde_v, frac_cv_v, 
+                                pte_idxs, pte_mats, press_pte, vfrac_pte,
+                                rho_pte, sie_pte, temp_pte, solver_scratch,
+                                tokens, small_loop, do_frac_bmod,
+                                do_frac_dpde, do_frac_cv);    
+//    portableFor(
+//        pt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+//          // cell offset
+//          const int i{offsets_v(iloop) - 1};
+//          // get "thread-id" like thing with optimization
+//          // for small loops
+//          const int32_t token{tokens.acquire()};
+//          const int32_t tid{small_loop ? iloop : token};
+//          // caching mechanism
+//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
+//          double mass_sum{0.0};
+//          // normalize mass fractions
+//          // first find the mass sum
+//          // also set idxs as the decrement of the eos offsets
+//          // to take into account 1 based indexing in fortran
+//          for (int m = 0; m < nmat; ++m) {
+//            mass_sum += frac_mass_v(i, m);
+//            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
+//            pte_mats(tid, m) = m;
+//            temp_pte(tid, m) = temp_v(i) * ev2k;
+//            press_pte(tid, m) = press_v(i);
+//          }
+//          for (int m = 0; m < nmat; ++m) {
+//            frac_mass_v(i, m) /= mass_sum;
+//          }
+//          // do r-e of pt for each mat
+//          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+//          Real vfrac_tot{0.0};
+//          Real sie_tot{0.0};
+//          for (int m = 0; m < nmat; ++m) {
+//            // obtain rho and sie from P-T
+//            eos_inx[m].DensityEnergyFromPressureTemperature(
+//                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
+//                sie_pte(tid, m));
+//            // assign volume fractions
+//            // this is a physical volume
+//            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
+//            vfrac_tot += vfrac_pte(tid, m);
+//            // add internal energy component
+//            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
+//          }
+//          // assign volume, etc.
+//          // total sie is known
+//          sie_v(i) = sie_tot;
+//          vol_v(i) = vfrac_tot;
+//          spvol_v(i) = vol_v(i) / mass_sum;
+//          for (int m = 0; m < nmat; ++m) {
+//            vfrac_pte(tid, m) /= vfrac_tot;
+//          }
+//          // assign remaining outputs
+//          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
+//          // assign max pressure
+//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+//          // release the token used for scratch arrays
+//          tokens.release(token);
+//        });
     break;
   }
   case input_condition::NORM_RHO_E_INPUT:
@@ -512,47 +394,56 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string re_name = "PTE::solve (rho,e) input" + perf_nums;
-    portableFor(
-        re_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          double mass_sum{0.0};
-          int npte{0};
-          // initialize values for solver / lookup
-          init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
-          // get cache from offsets into scratch
-          const int neq = npte + 1;
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-                                                     neq * (neq + 4) + 2 * npte);
-          if (npte > 1) {
-            // create solver lambda
-            // eos accessor
-            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-            // reset inputs
-            PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
-                npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
-                &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
-                &solver_scratch(tid, 0));
-            const bool res_{PTESolver(method)};
-          } else {
-            // pure cell (nmat = 1)
-            // calculate sie from single eos
-            Real dpdr_m, dtdr_m, dpde_m, dtde_m;
-            eos_v(pte_idxs(tid, 0))
-                .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
-                        temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
-          }
-          // assign outputs
-          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
+    singularity::get_sg_eos_rho_p(re_name.c_str(), ncell, nmat, offsets_v,
+                                  eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
+                                  spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
+                                  frac_mass_v, frac_vol_v, frac_ie_v,
+                                  frac_bmod_v, frac_dpde_v, frac_cv_v, 
+                                  pte_idxs, pte_mats, press_pte, vfrac_pte,
+                                  rho_pte, sie_pte, temp_pte, solver_scratch,
+                                  tokens, small_loop, do_frac_bmod,
+                                  do_frac_dpde, do_frac_cv);    
+//    portableFor(
+//        re_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+//          // cell offset
+//          const int i{offsets_v(iloop) - 1};
+//          // get "thread-id" like thing with optimization
+//          // for small loops
+//          const int32_t token{tokens.acquire()};
+//          const int32_t tid{small_loop ? iloop : token};
+//          double mass_sum{0.0};
+//          int npte{0};
+//          // initialize values for solver / lookup
+//          init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
+//          // get cache from offsets into scratch
+//          const int neq = npte + 1;
+//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+//                                                     neq * (neq + 4) + 2 * npte);
+//          if (npte > 1) {
+//            // create solver lambda
+//            // eos accessor
+//            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+//            // reset inputs
+//            PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
+//                npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
+//                &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
+//                &solver_scratch(tid, 0));
+//            const bool res_{PTESolver(method)};
+//          } else {
+//            // pure cell (nmat = 1)
+//            // calculate sie from single eos
+//            Real dpdr_m, dtdr_m, dpde_m, dtde_m;
+//            eos_v(pte_idxs(tid, 0))
+//                .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
+//                        temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
+//          }
+//          // assign outputs
+//          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
+//          // assign max pressure
+//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+//          // release the token used for scratch arrays
+//          tokens.release(token);
+//        });
     break;
   }
   }
diff --git a/singularity-eos/eos/get_sg_eos.hpp b/singularity-eos/eos/get_sg_eos.hpp
new file mode 100644
index 0000000000..e86a85f249
--- /dev/null
+++ b/singularity-eos/eos/get_sg_eos.hpp
@@ -0,0 +1,192 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#ifndef _SINGULARITY_EOS_EOS_GET_SG_EOS_HPP_
+#define _SINGULARITY_EOS_EOS_GET_SG_EOS_HPP_
+
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/eos.hpp>
+
+using namespace singularity;
+
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+using Lrgt = Kokkos::LayoutRight;
+using Llft = Kokkos::LayoutLeft;
+template <typename T>
+using ScratchV = Kokkos::View<T **, Lrgt>;
+#endif // PORTABILITY_STRATEGY_KOKKOS
+
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+namespace singularity {
+struct EOSAccessor_ {
+  PORTABLE_INLINE_FUNCTION
+  EOSAccessor_(const Kokkos::View<EOS *, Llft> &eos_v, int *mats)
+      : eos_v_(eos_v), mats_(mats) {}
+  PORTABLE_INLINE_FUNCTION
+  EOS &operator[](const int m) const { return eos_v_(mats_[m]); }
+  Kokkos::View<EOS *, Llft> eos_v_;
+  int *mats_;
+};
+} // namespace singularity
+#endif // PORTABILITY_STRATEGY_KOKKOS
+
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+// convenience aliases
+using Unmgd = Kokkos::MemoryUnmanaged;
+using HS = Kokkos::HostSpace;
+using Kokkos::create_mirror_view_and_copy;
+using host_v = Kokkos::View<double *, Llft, HS, Unmgd>;
+using dev_v = Kokkos::View<double *, Llft>;
+using host_frac_v = Kokkos::View<double **, Llft, HS, Unmgd>;
+using dev_frac_v = Kokkos::View<double **, Llft>;
+using DES = Kokkos::DefaultExecutionSpace;
+using DMS = DES::memory_space;
+using Kokkos::MemoryTraits;
+constexpr const unsigned int ra{0 | Kokkos::RandomAccess};
+// constexpr const unsigned int ra_u{Kokkos::Unmanaged | Kokkos::RandomAccess};
+using indirection_v = Kokkos::View<const int *, Llft, MemoryTraits<ra>>;
+using VAWI = Kokkos::ViewAllocateWithoutInitializing;
+using Kokkos::deep_copy;
+constexpr auto KGlobal = Kokkos::Experimental::UniqueTokenScope::Global;
+static constexpr const double ev2k = 1.160451930280894026e4;
+#endif // PORTABILITY_STRATEGY_KOKKOS
+
+namespace singularity {
+// rho t input
+void get_sg_eos_rho_t(const char* name, int ncell, int nmat, 
+                      indirection_v& offsets_v,
+		      indirection_v& eos_offsets_v,
+		      Kokkos::View<EOS *, Llft>& eos_v,
+                      dev_v& press_v,
+                      dev_v& pmax_v,
+                      dev_v& vol_v,
+                      dev_v& spvol_v,
+                      dev_v& sie_v,
+                      dev_v& temp_v,
+                      dev_v& bmod_v,
+                      dev_v& dpde_v,
+                      dev_v& cv_v,
+                      dev_frac_v& frac_mass_v,
+                      dev_frac_v& frac_vol_v,
+                      dev_frac_v& frac_ie_v,
+                      dev_frac_v& frac_bmod_v,
+                      dev_frac_v& frac_dpde_v,
+                      dev_frac_v& frac_cv_v,
+                      ScratchV<int>& pte_idxs,
+                      ScratchV<int>& pte_mats,
+                      ScratchV<double>& press_pte,
+                      ScratchV<double>& vfrac_pte,
+                      ScratchV<double>& rho_pte,
+                      ScratchV<double>& sie_pte,
+                      ScratchV<double>& temp_pte,
+                      ScratchV<double>& solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		      bool small_loop,
+                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+// rho P input
+void get_sg_eos_rho_p(const char* name, int ncell, int nmat, 
+                      indirection_v& offsets_v,
+		      indirection_v& eos_offsets_v,
+		      Kokkos::View<EOS *, Llft>& eos_v,
+                      dev_v& press_v,
+                      dev_v& pmax_v,
+                      dev_v& vol_v,
+                      dev_v& spvol_v,
+                      dev_v& sie_v,
+                      dev_v& temp_v,
+                      dev_v& bmod_v,
+                      dev_v& dpde_v,
+                      dev_v& cv_v,
+                      dev_frac_v& frac_mass_v,
+                      dev_frac_v& frac_vol_v,
+                      dev_frac_v& frac_ie_v,
+                      dev_frac_v& frac_bmod_v,
+                      dev_frac_v& frac_dpde_v,
+                      dev_frac_v& frac_cv_v,
+                      ScratchV<int>& pte_idxs,
+                      ScratchV<int>& pte_mats,
+                      ScratchV<double>& press_pte,
+                      ScratchV<double>& vfrac_pte,
+                      ScratchV<double>& rho_pte,
+                      ScratchV<double>& sie_pte,
+                      ScratchV<double>& temp_pte,
+                      ScratchV<double>& solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		      bool small_loop,
+                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+// PT input
+void get_sg_eos_p_t(const char* name, int ncell, int nmat, 
+                    indirection_v& offsets_v,
+		    indirection_v& eos_offsets_v,
+		    Kokkos::View<EOS *, Llft>& eos_v,
+                    dev_v& press_v,
+                    dev_v& pmax_v,
+                    dev_v& vol_v,
+                    dev_v& spvol_v,
+                    dev_v& sie_v,
+                    dev_v& temp_v,
+                    dev_v& bmod_v,
+                    dev_v& dpde_v,
+                    dev_v& cv_v,
+                    dev_frac_v& frac_mass_v,
+                    dev_frac_v& frac_vol_v,
+                    dev_frac_v& frac_ie_v,
+                    dev_frac_v& frac_bmod_v,
+                    dev_frac_v& frac_dpde_v,
+                    dev_frac_v& frac_cv_v,
+                    ScratchV<int>& pte_idxs,
+                    ScratchV<int>& pte_mats,
+                    ScratchV<double>& press_pte,
+                    ScratchV<double>& vfrac_pte,
+                    ScratchV<double>& rho_pte,
+                    ScratchV<double>& sie_pte,
+                    ScratchV<double>& temp_pte,
+                    ScratchV<double>& solver_scratch,
+                    Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		    bool small_loop,
+                    bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+// rho e input
+void get_sg_eos_rho_e(const char* name, int ncell, int nmat, 
+                      indirection_v& offsets_v,
+		      indirection_v& eos_offsets_v,
+		      Kokkos::View<EOS *, Llft>& eos_v,
+                      dev_v& press_v,
+                      dev_v& pmax_v,
+                      dev_v& vol_v,
+                      dev_v& spvol_v,
+                      dev_v& sie_v,
+                      dev_v& temp_v,
+                      dev_v& bmod_v,
+                      dev_v& dpde_v,
+                      dev_v& cv_v,
+                      dev_frac_v& frac_mass_v,
+                      dev_frac_v& frac_vol_v,
+                      dev_frac_v& frac_ie_v,
+                      dev_frac_v& frac_bmod_v,
+                      dev_frac_v& frac_dpde_v,
+                      dev_frac_v& frac_cv_v,
+                      ScratchV<int>& pte_idxs,
+                      ScratchV<int>& pte_mats,
+                      ScratchV<double>& press_pte,
+                      ScratchV<double>& vfrac_pte,
+                      ScratchV<double>& rho_pte,
+                      ScratchV<double>& sie_pte,
+                      ScratchV<double>& temp_pte,
+                      ScratchV<double>& solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		      bool small_loop,
+                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+} // namespace singularity
+
+#endif // _SINGULARITY_EOS_EOS_GET_SG_EOS_HPP_
diff --git a/singularity-eos/eos/get_sg_eos_lambdas.hpp b/singularity-eos/eos/get_sg_eos_lambdas.hpp
new file mode 100644
index 0000000000..24ed62fddd
--- /dev/null
+++ b/singularity-eos/eos/get_sg_eos_lambdas.hpp
@@ -0,0 +1,143 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#ifndef _SINGULARITY_EOS_EOS_GET_SG_EOS_LAMBDAS_HPP_
+#define _SINGULARITY_EOS_EOS_GET_SG_EOS_LAMBDAS_HPP_
+
+#include <ports-of-call/portability.hpp>
+
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+
+#define SG_GET_SG_EOS_INIT_LAMBDA_DECL \
+PORTABLE_LAMBDA(const int i, const int tid, double &mass_sum, int &npte, \
+                const Real t_mult, const Real s_mult, const Real p_mult) { \
+  /* normalize mass fractions */ \
+  /* first find the mass sum */ \
+  /* also set idxs as the decrement of the eos offsets */ \
+  /* to take into account 1 based indexing in fortran */ \
+  for (int m = 0; m < nmat; ++m) { \
+    mass_sum += frac_mass_v(i, m); \
+    pte_idxs(tid, m) = eos_offsets_v(m) - 1; \
+    frac_vol_v(i, m) = 0.0; \
+  } \
+  for (int m = 0; m < nmat; ++m) { \
+    frac_mass_v(i, m) /= mass_sum; \
+  } \
+  /* set inputs */ \
+  npte = 0; \
+  for (int m = 0; m < nmat; ++m) { \
+    if (frac_mass_v(i, m) > 1.e-12) { \
+      pte_idxs(tid, npte) = eos_offsets_v(m) - 1; \
+      pte_mats(tid, npte) = m; \
+      npte += 1; \
+    } \
+    vfrac_pte(tid, m) = 0.0; \
+    sie_pte(tid, m) = 0.0; \
+    temp_pte(tid, m) = 0.0; \
+    press_pte(tid, m) = 0.0; \
+  } \
+  for (int mp = 0; mp < npte; ++mp) { \
+    const int m = pte_mats(tid, mp); \
+    rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m); \
+    vfrac_pte(tid, mp) = 1.0 / npte; \
+    temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult; \
+    press_pte(tid, mp) = press_v(i) * p_mult; \
+    sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult; \
+  } \
+}
+
+#define SG_GET_SG_EOS_FINAL_LAMBDA_DECL \
+PORTABLE_LAMBDA(const int i, const int tid, const int npte, \
+                const Real mass_sum, const Real t_mult, const Real s_mult, \
+		const Real p_mult, \
+                singularity::mix_impl::CacheAccessor &cache) { \
+  /* initialize averaged quantities to 0 */ \
+  const bool do_t = t_mult == 1.0; \
+  const bool do_s = s_mult == 1.0; \
+  const bool do_p = p_mult == 1.0; \
+  if (do_t) { \
+    temp_v(i) = 0.0; \
+  } \
+  if (do_p) { \
+    press_v(i) = 0.0; \
+  } \
+  if (do_s) { \
+    sie_v(i) = 0.0; \
+  } \
+  bmod_v(i) = 0.0; \
+  cv_v(i) = 0.0; \
+  dpde_v(i) = 0.0; \
+  /* material loop for averaging and assigning per mat quantities */ \
+  for (int mp = 0; mp < npte; ++mp) { \
+    const int m = pte_mats(tid, mp); \
+    /* pressure contribution from material m */ \
+    press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult; \
+    /* temperature contribution from material m */ \
+    temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult; \
+    const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum; \
+    /* sie contribution from material m */ \
+    sie_v(i) += ie_m * s_mult; \
+    /* assign per material specific internal energy */ \
+    frac_ie_v(i, m) = ie_m; \
+    /* assign volume fraction based on pte calculation */ \
+    frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i); \
+    /* calculate bulk modulus for material m */ \
+    const Real bmod_m = eos_v(pte_idxs(tid, mp)) \
+                            .BulkModulusFromDensityTemperature( \
+                                rho_pte(tid, mp), \
+                                temp_pte(tid, mp), \
+                                cache[mp]); \
+    /* add bmod contribution from material m */ \
+    bmod_v(i) += bmod_m * vfrac_pte(tid, mp); \
+    /* calculate specific heat for material m */ \
+    const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp)) \
+                                 .SpecificHeatFromDensityTemperature( \
+                                     rho_pte(tid, mp), \
+                                     temp_pte(tid, mp), \
+                                     cache[mp]); \
+    /* add mass weighted contribution specific heat for material m */ \
+    cv_v(i) += cv_m * frac_mass_v(i, m); \
+    /* calculate gruneisen parameter for material m */ \
+    const Real dpde_m = eos_v(pte_idxs(tid, mp)) \
+                            .GruneisenParamFromDensityTemperature( \
+                                rho_pte(tid, mp), \
+                                temp_pte(tid, mp), \
+                                cache[mp]);\
+    /* add gruneisen param contribution from material m */ \
+    dpde_v(i) += dpde_m * vfrac_pte(tid, mp); \
+    /* optionally assign per material quantities to per material arrays */ \
+    if (do_frac_bmod) { \
+      frac_bmod_v(i, m) = bmod_m; \
+    } \
+    if (do_frac_cv) { \
+      frac_cv_v(i, m) = cv_m; \
+    } \
+    if (do_frac_dpde) { \
+      frac_dpde_v(i, m) = dpde_m; \
+    } \
+  } \
+  if (do_t) { \
+    temp_v(i) /= ev2k; \
+  } \
+  if (do_s) { \
+    sie_v(i) /= mass_sum; \
+  } \
+  /* reset mass fractions to original values if not normalized to 1 */ \
+  for (int m = 0; m < nmat; ++m) { \
+    frac_mass_v(i, m) *= mass_sum; \
+  } \
+}
+#endif // PORTABILITY_STRATEGY_KOKKOS
+
+#endif // _SINGULARITY_EOS_EOS_GET_SG_EOS_LAMBDAS_HPP_
diff --git a/singularity-eos/eos/get_sg_eos_p_t.cpp b/singularity-eos/eos/get_sg_eos_p_t.cpp
new file mode 100644
index 0000000000..40bdf6990a
--- /dev/null
+++ b/singularity-eos/eos/get_sg_eos_p_t.cpp
@@ -0,0 +1,111 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/get_sg_eos.hpp>
+#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+
+namespace singularity {
+void get_sg_eos_p_t(const char* name, int ncell, int nmat, 
+                    indirection_v& offsets_v,
+		    indirection_v& eos_offsets_v,
+		    Kokkos::View<EOS *, Llft>& eos_v,
+                    dev_v& press_v,
+                    dev_v& pmax_v,
+                    dev_v& vol_v,
+                    dev_v& spvol_v,
+                    dev_v& sie_v,
+                    dev_v& temp_v,
+                    dev_v& bmod_v,
+                    dev_v& dpde_v,
+                    dev_v& cv_v,
+                    dev_frac_v& frac_mass_v,
+                    dev_frac_v& frac_vol_v,
+                    dev_frac_v& frac_ie_v,
+                    dev_frac_v& frac_bmod_v,
+                    dev_frac_v& frac_dpde_v,
+                    dev_frac_v& frac_cv_v,
+                    ScratchV<int>& pte_idxs,
+                    ScratchV<int>& pte_mats,
+                    ScratchV<double>& press_pte,
+                    ScratchV<double>& vfrac_pte,
+                    ScratchV<double>& rho_pte,
+                    ScratchV<double>& sie_pte,
+                    ScratchV<double>& temp_pte,
+                    ScratchV<double>& solver_scratch,
+                    Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		    bool small_loop,
+                    bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+  portableFor(
+      name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+          // cell offset
+          const int i{offsets_v(iloop) - 1};
+          // get "thread-id" like thing with optimization
+          // for small loops
+          const int32_t token{tokens.acquire()};
+          const int32_t tid{small_loop ? iloop : token};
+          // caching mechanism
+          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
+          double mass_sum{0.0};
+          // normalize mass fractions
+          // first find the mass sum
+          // also set idxs as the decrement of the eos offsets
+          // to take into account 1 based indexing in fortran
+          for (int m = 0; m < nmat; ++m) {
+            mass_sum += frac_mass_v(i, m);
+            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
+            pte_mats(tid, m) = m;
+            temp_pte(tid, m) = temp_v(i) * ev2k;
+            press_pte(tid, m) = press_v(i);
+          }
+          for (int m = 0; m < nmat; ++m) {
+            frac_mass_v(i, m) /= mass_sum;
+          }
+          // do r-e of pt for each mat
+          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+          Real vfrac_tot{0.0};
+          Real sie_tot{0.0};
+          for (int m = 0; m < nmat; ++m) {
+            // obtain rho and sie from P-T
+            eos_inx[m].DensityEnergyFromPressureTemperature(
+                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
+                sie_pte(tid, m));
+            // assign volume fractions
+            // this is a physical volume
+            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
+            vfrac_tot += vfrac_pte(tid, m);
+            // add internal energy component
+            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
+          }
+          // assign volume, etc.
+          // total sie is known
+          sie_v(i) = sie_tot;
+          vol_v(i) = vfrac_tot;
+          spvol_v(i) = vol_v(i) / mass_sum;
+          for (int m = 0; m < nmat; ++m) {
+            vfrac_pte(tid, m) /= vfrac_tot;
+          }
+          // assign remaining outputs
+          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
+          // assign max pressure
+          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+          // release the token used for scratch arrays
+          tokens.release(token);
+        });
+  return;
+}
+} // namespace singularity
diff --git a/singularity-eos/eos/get_sg_eos_rho_e.cpp b/singularity-eos/eos/get_sg_eos_rho_e.cpp
new file mode 100644
index 0000000000..fcff919e24
--- /dev/null
+++ b/singularity-eos/eos/get_sg_eos_rho_e.cpp
@@ -0,0 +1,97 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/get_sg_eos.hpp>
+#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+
+namespace singularity {
+void get_sg_eos_rho_e(const char* name, int ncell, int nmat, 
+                      indirection_v& offsets_v,
+		      indirection_v& eos_offsets_v,
+		      Kokkos::View<EOS *, Llft>& eos_v,
+                      dev_v& press_v,
+                      dev_v& pmax_v,
+                      dev_v& vol_v,
+                      dev_v& spvol_v,
+                      dev_v& sie_v,
+                      dev_v& temp_v,
+                      dev_v& bmod_v,
+                      dev_v& dpde_v,
+                      dev_v& cv_v,
+                      dev_frac_v& frac_mass_v,
+                      dev_frac_v& frac_vol_v,
+                      dev_frac_v& frac_ie_v,
+                      dev_frac_v& frac_bmod_v,
+                      dev_frac_v& frac_dpde_v,
+                      dev_frac_v& frac_cv_v,
+                      ScratchV<int>& pte_idxs,
+                      ScratchV<int>& pte_mats,
+                      ScratchV<double>& press_pte,
+                      ScratchV<double>& vfrac_pte,
+                      ScratchV<double>& rho_pte,
+                      ScratchV<double>& sie_pte,
+                      ScratchV<double>& temp_pte,
+                      ScratchV<double>& solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		      bool small_loop,
+                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
+  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+  portableFor(
+    name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+      // cell offset
+      const int i{offsets_v(iloop) - 1};
+      // get "thread-id" like thing with optimization
+      // for small loops
+      const int32_t token{tokens.acquire()};
+      const int32_t tid{small_loop ? iloop : token};
+      double mass_sum{0.0};
+      int npte{0};
+      // initialize values for solver / lookup
+      init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
+      // get cache from offsets into scratch
+      const int neq = npte + 1;
+      singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+                                                 neq * (neq + 4) + 2 * npte);
+      if (npte > 1) {
+        // create solver lambda
+        // eos accessor
+        singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+        // reset inputs
+        PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
+            npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
+            &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
+            &solver_scratch(tid, 0));
+        const bool res_{PTESolver(method)};
+      } else {
+        // pure cell (nmat = 1)
+        // calculate sie from single eos
+        Real dpdr_m, dtdr_m, dpde_m, dtde_m;
+        eos_v(pte_idxs(tid, 0))
+            .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
+                    temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
+      }
+      // assign outputs
+      final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
+      // assign max pressure
+      pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+      // release the token used for scratch arrays
+      tokens.release(token);
+    });
+  return;
+}
+} // namespace singularity
diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
new file mode 100644
index 0000000000..580d360b79
--- /dev/null
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -0,0 +1,118 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/get_sg_eos.hpp>
+#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+
+namespace singularity {
+void get_sg_eos_rho_p(const char* name, int ncell, int nmat, 
+                      indirection_v& offsets_v,
+		      indirection_v& eos_offsets_v,
+		      Kokkos::View<EOS *, Llft>& eos_v,
+                      dev_v& press_v,
+                      dev_v& pmax_v,
+                      dev_v& vol_v,
+                      dev_v& spvol_v,
+                      dev_v& sie_v,
+                      dev_v& temp_v,
+                      dev_v& bmod_v,
+                      dev_v& dpde_v,
+                      dev_v& cv_v,
+                      dev_frac_v& frac_mass_v,
+                      dev_frac_v& frac_vol_v,
+                      dev_frac_v& frac_ie_v,
+                      dev_frac_v& frac_bmod_v,
+                      dev_frac_v& frac_dpde_v,
+                      dev_frac_v& frac_cv_v,
+                      ScratchV<int>& pte_idxs,
+                      ScratchV<int>& pte_mats,
+                      ScratchV<double>& press_pte,
+                      ScratchV<double>& vfrac_pte,
+                      ScratchV<double>& rho_pte,
+                      ScratchV<double>& sie_pte,
+                      ScratchV<double>& temp_pte,
+                      ScratchV<double>& solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		      bool small_loop,
+                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
+  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+  portableFor(
+      name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+        // cell offset
+        const int i{offsets_v(iloop) - 1};
+        // get "thread-id" like thing with optimization
+        // for small loops
+        const int32_t token{tokens.acquire()};
+        const int32_t tid{small_loop ? iloop : token};
+        double mass_sum{0.0};
+        int npte{0};
+        // initialize values for solver / lookup
+        init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
+        Real sie_tot_true{0.0};
+        const int neq = npte + 1;
+        singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+                                                   neq * (neq + 4) + 2 * npte);
+        if (npte > 1) {
+          // create solver lambda
+          // eos accessor
+          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+          PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
+              npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
+              &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+              &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
+          const bool res_{PTESolver(method)};
+          // calculate total sie
+          for (int mp = 0; mp < npte; ++mp) {
+            const int m = pte_mats(tid, mp);
+            sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+          }
+        } else {
+          // pure cell (nmat = 1)
+          // calculate sie from single eos
+          auto p_from_t = [&](const Real &t_i) {
+            return eos_v(pte_idxs(tid, 0))
+                .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
+          };
+          // calculate sie root bounds
+          Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
+          Real r_dpde{}, r_dvdt{};
+          eos_v(pte_idxs(tid, 0))
+              .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
+                                      r_dpde, r_dvdt);
+          Real temp_i;
+          RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
+                                  1.e10 * r_temp, 1.e-12, 1.e-12, temp_i);
+          sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+                                .InternalEnergyFromDensityTemperature(rho_pte(tid, 0),
+                                                                      temp_i, cache[0]);
+          sie_tot_true = sie_pte(tid, 0);
+          // set temperature
+          temp_pte(tid, 0) = temp_i;
+        }
+        // sie calculate explicitly already
+        sie_v(i) = sie_tot_true;
+        // assign remaining outputs
+        final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
+        // assign max pressure
+        pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+        // release the token used for scratch arrays
+        tokens.release(token);
+      });
+  return;
+}
+} // namespace singularity
diff --git a/singularity-eos/eos/get_sg_eos_rho_t.cpp b/singularity-eos/eos/get_sg_eos_rho_t.cpp
new file mode 100644
index 0000000000..9a9b4d37b5
--- /dev/null
+++ b/singularity-eos/eos/get_sg_eos_rho_t.cpp
@@ -0,0 +1,109 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/get_sg_eos.hpp>
+#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+
+namespace singularity {
+void get_sg_eos_rho_t(const char* name, int ncell, int nmat, 
+                      indirection_v& offsets_v,
+		      indirection_v& eos_offsets_v,
+		      Kokkos::View<EOS *, Llft>& eos_v,
+                      dev_v& press_v,
+                      dev_v& pmax_v,
+                      dev_v& vol_v,
+                      dev_v& spvol_v,
+                      dev_v& sie_v,
+                      dev_v& temp_v,
+                      dev_v& bmod_v,
+                      dev_v& dpde_v,
+                      dev_v& cv_v,
+                      dev_frac_v& frac_mass_v,
+                      dev_frac_v& frac_vol_v,
+                      dev_frac_v& frac_ie_v,
+                      dev_frac_v& frac_bmod_v,
+                      dev_frac_v& frac_dpde_v,
+                      dev_frac_v& frac_cv_v,
+                      ScratchV<int>& pte_idxs,
+                      ScratchV<int>& pte_mats,
+                      ScratchV<double>& press_pte,
+                      ScratchV<double>& vfrac_pte,
+                      ScratchV<double>& rho_pte,
+                      ScratchV<double>& sie_pte,
+                      ScratchV<double>& temp_pte,
+                      ScratchV<double>& solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
+		      bool small_loop,
+                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
+  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+  portableFor(
+      name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+        // cell offset
+        const int i{offsets_v(iloop) - 1};
+        // get "thread-id" like thing with optimization
+        // for small loops
+        const int32_t token{tokens.acquire()};
+        const int32_t tid{small_loop ? iloop : token};
+        double mass_sum{0.0};
+        int npte{0};
+        // initialize values for solver / lookup
+        init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
+        // calculate pte condition (lookup for 1 mat cell)
+        Real sie_tot_true{0.0};
+        const int neq = npte;
+        singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+                                                   neq * (neq + 4) + 2 * npte);
+        if (npte > 1) {
+          // create solver lambda
+          // eos accessor
+          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+          PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
+              npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
+              &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+              &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
+          const bool res_{PTESolver(method)};
+          // calculate total internal energy
+          for (int mp = 0; mp < npte; ++mp) {
+            const int m = pte_mats(tid, mp);
+            sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+          }
+        } else {
+          // pure cell (nmat = 1)
+          // calculate sie from single eos
+          sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))\
+                                .InternalEnergyFromDensityTemperature(
+                                    rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+          // set total sie to material 0 value
+          sie_tot_true = sie_pte(tid, 0);
+          // set pressure
+          press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))\
+                                  .PressureFromDensityTemperature(
+                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+        }
+        // total sie is known
+        sie_v(i) = sie_tot_true;
+        // assign quantities
+        final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
+        // assign max pressure
+        pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+        // release the token used for scratch arrays
+        tokens.release(token);
+      });
+  return;
+}
+} // namespace singularity

From 98ad54ccae58faf8e2a23f7df2648949296c7429 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 14:27:22 -0600
Subject: [PATCH 06/45] Fixing non-kokkos build issues.

---
 singularity-eos/CMakeLists.txt     | 11 +++++++----
 singularity-eos/eos/get_sg_eos.hpp |  2 ++
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 7b3d3a257a..c479c3e323 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -47,11 +47,14 @@ set(EOS_SRCS
 
 if (SINGULARITY_BUILD_CLOSURE)
   list(APPEND EOS_SRCS 
-       eos/get_sg_eos_p_t.cpp
-       eos/get_sg_eos_rho_t.cpp
-       eos/get_sg_eos_rho_p.cpp
-       eos/get_sg_eos_rho_e.cpp
        eos/get_sg_eos.cpp)
+  if (SINGULARITY_USE_KOKKOS)
+    list(APPEND EOS_SRCS 
+         eos/get_sg_eos_p_t.cpp
+         eos/get_sg_eos_rho_t.cpp
+         eos/get_sg_eos_rho_p.cpp
+         eos/get_sg_eos_rho_e.cpp)
+  endif()
   list(APPEND EOS_HEADERS
        closure/mixed_cell_models.hpp
        eos/get_sg_eos.hpp
diff --git a/singularity-eos/eos/get_sg_eos.hpp b/singularity-eos/eos/get_sg_eos.hpp
index e86a85f249..e4ec79f0c2 100644
--- a/singularity-eos/eos/get_sg_eos.hpp
+++ b/singularity-eos/eos/get_sg_eos.hpp
@@ -62,6 +62,7 @@ constexpr auto KGlobal = Kokkos::Experimental::UniqueTokenScope::Global;
 static constexpr const double ev2k = 1.160451930280894026e4;
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
+#ifdef PORTABILITY_STRATEGY_KOKKOS
 namespace singularity {
 // rho t input
 void get_sg_eos_rho_t(const char* name, int ncell, int nmat, 
@@ -188,5 +189,6 @@ void get_sg_eos_rho_e(const char* name, int ncell, int nmat,
 		      bool small_loop,
                       bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
 } // namespace singularity
+#endif // PORTABILITY_STRATEGY_KOKKOS
 
 #endif // _SINGULARITY_EOS_EOS_GET_SG_EOS_HPP_

From 4d35a16d1c18cdbacebcdaef0e75b844b9c58867 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 14:32:51 -0600
Subject: [PATCH 07/45] Formatting.

---
 singularity-eos/eos/eos_eospac.hpp         | 144 +++---
 singularity-eos/eos/get_sg_eos.cpp         | 495 ++++++++++-----------
 singularity-eos/eos/get_sg_eos.hpp         | 176 +++-----
 singularity-eos/eos/get_sg_eos_lambdas.hpp | 229 +++++-----
 singularity-eos/eos/get_sg_eos_p_t.cpp     | 154 +++----
 singularity-eos/eos/get_sg_eos_rho_e.cpp   | 126 +++---
 singularity-eos/eos/get_sg_eos_rho_p.cpp   |  56 +--
 singularity-eos/eos/get_sg_eos_rho_t.cpp   |  56 +--
 8 files changed, 653 insertions(+), 783 deletions(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 532d427c04..8d0ea0b7ef 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -41,49 +41,51 @@ using namespace eos_base;
 
 // Only really works in serial
 // Not really supported on device
-#define SG_PIF_NOWARN \
-#pragma nv_exec_check_disable \
-PORTABLE_INLINE_FUNCTION
+#define SG_PIF_NOWARN #pragma nv_exec_check_disable PORTABLE_INLINE_FUNCTION
 
 class EOSPAC : public EosBase<EOSPAC> {
  public:
   inline EOSPAC() = default;
   inline EOSPAC(int matid, bool invert_at_setup = false);
   inline EOSPAC GetOnDevice() { return *this; }
-  SG_PIF_NOWARN Real TemperatureFromDensityInternalEnergy(
-      const Real rho, const Real sie, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real InternalEnergyFromDensityTemperature(
-      const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real PressureFromDensityTemperature(
-      const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real PressureFromDensityInternalEnergy(
-      const Real rho, const Real sie, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real EntropyFromDensityTemperature(
-      const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real EntropyFromDensityInternalEnergy(
-      const Real rho, const Real sie, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real SpecificHeatFromDensityTemperature(
-      const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real SpecificHeatFromDensityInternalEnergy(
-      const Real rho, const Real sie, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real BulkModulusFromDensityTemperature(
-      const Real rho, const Real temperature, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real BulkModulusFromDensityInternalEnergy(
-      const Real rho, const Real sie, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real GruneisenParamFromDensityTemperature(
-      const Real rho, const Real temperature, Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real TemperatureFromDensityInternalEnergy(const Real rho, const Real sie,
+                                                          Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real InternalEnergyFromDensityTemperature(const Real rho,
+                                                          const Real temperature,
+                                                          Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real PressureFromDensityTemperature(const Real rho,
+                                                    const Real temperature,
+                                                    Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real PressureFromDensityInternalEnergy(const Real rho, const Real sie,
+                                                       Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real EntropyFromDensityTemperature(const Real rho, const Real temperature,
+                                                   Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real EntropyFromDensityInternalEnergy(const Real rho, const Real sie,
+                                                      Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real SpecificHeatFromDensityTemperature(const Real rho,
+                                                        const Real temperature,
+                                                        Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real SpecificHeatFromDensityInternalEnergy(const Real rho, const Real sie,
+                                                           Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real BulkModulusFromDensityTemperature(const Real rho,
+                                                       const Real temperature,
+                                                       Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real BulkModulusFromDensityInternalEnergy(const Real rho, const Real sie,
+                                                          Real *lambda = nullptr) const;
+  SG_PIF_NOWARN Real GruneisenParamFromDensityTemperature(const Real rho,
+                                                          const Real temperature,
+                                                          Real *lambda = nullptr) const;
   SG_PIF_NOWARN Real GruneisenParamFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN void FillEos(Real &rho, Real &temp, Real &energy, Real &press,
-                                        Real &cv, Real &bmod, const unsigned long output,
-                                        Real *lambda = nullptr) const;
+  SG_PIF_NOWARN void FillEos(Real &rho, Real &temp, Real &energy, Real &press, Real &cv,
+                             Real &bmod, const unsigned long output,
+                             Real *lambda = nullptr) const;
   SG_PIF_NOWARN
   void DensityEnergyFromPressureTemperature(const Real press, const Real temp,
                                             Real *lambda, Real &rho, Real &sie) const;
-  SG_PIF_NOWARN void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
-                                                       Real &press, Real &cv, Real &bmod,
-                                                       Real &dpde, Real &dvdt,
-                                                       Real *lambda = nullptr) const;
+  SG_PIF_NOWARN void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press,
+                                            Real &cv, Real &bmod, Real &dpde, Real &dvdt,
+                                            Real *lambda = nullptr) const;
 
   // Generic (Scalar)
   using EosBase<EOSPAC>::TemperatureFromDensityInternalEnergy;
@@ -706,7 +708,9 @@ class EOSPAC : public EosBase<EOSPAC> {
   inline void Finalize() {}
   static std::string EosType() { return std::string("EOSPAC"); }
   static std::string EosPyType() { return EosType(); }
-  SG_PIF_NOWARN void PrintParams() const { printf("EOSPAC parameters:\nmatid = %i\n", matid_); }
+  SG_PIF_NOWARN void PrintParams() const {
+    printf("EOSPAC parameters:\nmatid = %i\n", matid_);
+  }
   PORTABLE_FORCEINLINE_FUNCTION Real MinimumDensity() const { return rho_min_; }
   PORTABLE_FORCEINLINE_FUNCTION Real MinimumTemperature() const { return temp_min_; }
 
@@ -800,8 +804,9 @@ inline EOSPAC::EOSPAC(const int matid, bool invert_at_setup) : matid_(matid) {
       robust::ratio(dpde_ref_ * cv_ref_, rho_ref_ * rho_ref_ * pressureFromSesame(DPDR));
 }
 
-SG_PIF_NOWARN Real EOSPAC::TemperatureFromDensityInternalEnergy(
-    const Real rho, const Real sie, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::TemperatureFromDensityInternalEnergy(const Real rho,
+                                                                const Real sie,
+                                                                Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, E[1] = {sieToSesame(sie)}, T[1], dTdr[1], dTde[1];
   EOS_INTEGER nxypairs = 1;
@@ -810,9 +815,8 @@ SG_PIF_NOWARN Real EOSPAC::TemperatureFromDensityInternalEnergy(
   return Real(temperatureFromSesame(T[0]));
 }
 
-SG_PIF_NOWARN Real EOSPAC::PressureFromDensityTemperature(const Real rho,
-                                                                     const Real temp,
-                                                                     Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::PressureFromDensityTemperature(const Real rho, const Real temp,
+                                                          Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, P[1], T[1] = {temperatureToSesame(temp)}, dPdr[1], dPdT[1];
   EOS_INTEGER nxypairs = 1;
@@ -821,16 +825,16 @@ SG_PIF_NOWARN Real EOSPAC::PressureFromDensityTemperature(const Real rho,
   return Real(pressureFromSesame(P[0]));
 }
 
-SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityTemperature(
-    const Real rho, const Real temperature, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityTemperature(const Real rho,
+                                                         const Real temperature,
+                                                         Real *lambda) const {
   EntropyIsNotEnabled("EOSPAC");
   return 1.0;
 }
 
-SG_PIF_NOWARN void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
-                                              Real &press, Real &cv, Real &bmod,
-                                              const unsigned long output,
-                                              Real *lambda) const {
+SG_PIF_NOWARN void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press,
+                                   Real &cv, Real &bmod, const unsigned long output,
+                                   Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temp)};
   EOS_REAL E[1] = {sie}, P[1] = {pressureToSesame(press)};
@@ -910,57 +914,65 @@ SG_PIF_NOWARN void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
   }
 }
 
-SG_PIF_NOWARN Real EOSPAC::InternalEnergyFromDensityTemperature(
-    const Real rho, const Real temp, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::InternalEnergyFromDensityTemperature(const Real rho,
+                                                                const Real temp,
+                                                                Real *lambda) const {
   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;
 }
-SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityTemperature(
-    const Real rho, const Real temp, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityTemperature(const Real rho,
+                                                             const Real temp,
+                                                             Real *lambda) const {
   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;
 }
-SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityTemperature(
-    const Real rho, const Real temp, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityTemperature(const Real rho,
+                                                              const Real temp,
+                                                              Real *lambda) const {
   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;
 }
-SG_PIF_NOWARN Real EOSPAC::PressureFromDensityInternalEnergy(
-    const Real rho, const Real sie, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::PressureFromDensityInternalEnergy(const Real rho,
+                                                             const Real sie,
+                                                             Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return PressureFromDensityTemperature(rho, temp, lambda);
 }
-SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityInternalEnergy(
-    const Real rho, const Real sie, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityInternalEnergy(const Real rho,
+                                                            const Real sie,
+                                                            Real *lambda) const {
   using namespace EospacWrapper;
   const Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return EntropyFromDensityTemperature(rho, temp, lambda);
 }
-SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
-    const Real rho, const Real sie, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityInternalEnergy(const Real rho,
+                                                                 const Real sie,
+                                                                 Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return SpecificHeatFromDensityTemperature(rho, temp, lambda);
 }
-SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityInternalEnergy(
-    const Real rho, const Real sie, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityInternalEnergy(const Real rho,
+                                                                const Real sie,
+                                                                Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return BulkModulusFromDensityTemperature(rho, temp, lambda);
 }
 
-SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityTemperature(
-    const Real rho, const Real temperature, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityTemperature(const Real rho,
+                                                                const Real temperature,
+                                                                Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temperature)};
   EOS_REAL E[1], P[1], dx[1], dy[1];
@@ -975,8 +987,9 @@ SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityTemperature(
   DPDE = DPDT / DEDT;
   return robust::ratio(pressureFromSesame(sieToSesame(DPDE)), rho);
 }
-SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
-    const Real rho, const Real sie, Real *lambda) const {
+SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityInternalEnergy(const Real rho,
+                                                                   const Real sie,
+                                                                   Real *lambda) const {
   Real temperature = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return GruneisenParamFromDensityTemperature(rho, temperature, lambda);
 }
@@ -1002,9 +1015,10 @@ void EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real t
   sie = sieFromSesame(E[0]);
 }
 
-SG_PIF_NOWARN void
-EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Real &cv,
-                               Real &bmod, Real &dpde, Real &dvdt, Real *lambda) const {
+SG_PIF_NOWARN void EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
+                                                  Real &press, Real &cv, Real &bmod,
+                                                  Real &dpde, Real &dvdt,
+                                                  Real *lambda) const {
   using namespace EospacWrapper;
   rho = rho_ref_;
   temp = temp_ref_;
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 561a19758a..5c2b39603a 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -16,9 +16,9 @@
 #include <ports-of-call/portability.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
-#include <singularity-eos/eos/singularity_eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+#include <singularity-eos/eos/singularity_eos.hpp>
 
 using namespace singularity;
 
@@ -74,7 +74,7 @@ int get_sg_eos( // sizing information
   const bool t_is_inp{static_cast<bool>(input & thermalqs::temperature)};
   const bool s_is_inp{static_cast<bool>(input & thermalqs::specific_internal_energy)};
   constexpr const Real min_guess_density{1.e-20};
-  #ifdef PORTABILITY_STRATEGY_KOKKOS
+#ifdef PORTABILITY_STRATEGY_KOKKOS
   // convert pointers to host side views
   Kokkos::View<int *, Llft, HS, Unmgd> eos_offsets_hv(eos_offsets, nmat);
   Kokkos::View<int *, Llft, HS, Unmgd> offsets_hv(offsets, ncell);
@@ -97,8 +97,7 @@ int get_sg_eos( // sizing information
 
   // get device views if necessary
   indirection_v offsets_v{create_mirror_view_and_copy(DMS(), offsets_hv)};
-  indirection_v eos_offsets_v{create_mirror_view_and_copy(DMS(),
-                                                          eos_offsets_hv)};
+  indirection_v eos_offsets_v{create_mirror_view_and_copy(DMS(), eos_offsets_hv)};
   dev_v press_v{create_mirror_view_and_copy(DMS(), press_hv)};
   dev_v pmax_v{create_mirror_view_and_copy(DMS(), pmax_hv)};
   dev_v spvol_v{create_mirror_view_and_copy(DMS(), spvol_hv)};
@@ -165,68 +164,66 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string rt_name = "PTE::solve (rho,T) input" + perf_nums;
-    singularity::get_sg_eos_rho_t(rt_name.c_str(), ncell, nmat, offsets_v,
-                                  eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
-                                  spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
-                                  frac_mass_v, frac_vol_v, frac_ie_v,
-                                  frac_bmod_v, frac_dpde_v, frac_cv_v, 
-                                  pte_idxs, pte_mats, press_pte, vfrac_pte,
-                                  rho_pte, sie_pte, temp_pte, solver_scratch,
-                                  tokens, small_loop, do_frac_bmod,
-                                  do_frac_dpde, do_frac_cv);
-//    portableFor(
-//        rt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-//          // cell offset
-//          const int i{offsets_v(iloop) - 1};
-//          // get "thread-id" like thing with optimization
-//          // for small loops
-//          const int32_t token{tokens.acquire()};
-//          const int32_t tid{small_loop ? iloop : token};
-//          double mass_sum{0.0};
-//          int npte{0};
-//          // initialize values for solver / lookup
-//          init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
-//          // calculate pte condition (lookup for 1 mat cell)
-//          Real sie_tot_true{0.0};
-//          const int neq = npte;
-//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-//                                                     neq * (neq + 4) + 2 * npte);
-//          if (npte > 1) {
-//            // create solver lambda
-//            // eos accessor
-//            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-//            PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
-//                npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
-//                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-//                &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
-//            const bool res_{PTESolver(method)};
-//            // calculate total internal energy
-//            for (int mp = 0; mp < npte; ++mp) {
-//              const int m = pte_mats(tid, mp);
-//              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-//            }
-//          } else {
-//            // pure cell (nmat = 1)
-//            // calculate sie from single eos
-//            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-//                                  .InternalEnergyFromDensityTemperature(
-//                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
-//            // set total sie to material 0 value
-//            sie_tot_true = sie_pte(tid, 0);
-//            // set pressure
-//            press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-//                                    .PressureFromDensityTemperature(
-//                                        rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
-//          }
-//          // total sie is known
-//          sie_v(i) = sie_tot_true;
-//          // assign quantities
-//          final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
-//          // assign max pressure
-//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-//          // release the token used for scratch arrays
-//          tokens.release(token);
-//        });
+    singularity::get_sg_eos_rho_t(
+        rt_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
+        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
+        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
+        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
+        do_frac_bmod, do_frac_dpde, do_frac_cv);
+    //    portableFor(
+    //        rt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+    //          // cell offset
+    //          const int i{offsets_v(iloop) - 1};
+    //          // get "thread-id" like thing with optimization
+    //          // for small loops
+    //          const int32_t token{tokens.acquire()};
+    //          const int32_t tid{small_loop ? iloop : token};
+    //          double mass_sum{0.0};
+    //          int npte{0};
+    //          // initialize values for solver / lookup
+    //          init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
+    //          // calculate pte condition (lookup for 1 mat cell)
+    //          Real sie_tot_true{0.0};
+    //          const int neq = npte;
+    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+    //                                                     neq * (neq + 4) + 2 * npte);
+    //          if (npte > 1) {
+    //            // create solver lambda
+    //            // eos accessor
+    //            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+    //            PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
+    //                npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
+    //                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+    //                &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
+    //            const bool res_{PTESolver(method)};
+    //            // calculate total internal energy
+    //            for (int mp = 0; mp < npte; ++mp) {
+    //              const int m = pte_mats(tid, mp);
+    //              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+    //            }
+    //          } else {
+    //            // pure cell (nmat = 1)
+    //            // calculate sie from single eos
+    //            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+    //                                  .InternalEnergyFromDensityTemperature(
+    //                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+    //            // set total sie to material 0 value
+    //            sie_tot_true = sie_pte(tid, 0);
+    //            // set pressure
+    //            press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+    //                                    .PressureFromDensityTemperature(
+    //                                        rho_pte(tid, 0), temp_pte(tid, 0),
+    //                                        cache[0]);
+    //          }
+    //          // total sie is known
+    //          sie_v(i) = sie_tot_true;
+    //          // assign quantities
+    //          final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
+    //          // assign max pressure
+    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+    //          // release the token used for scratch arrays
+    //          tokens.release(token);
+    //        });
     break;
   }
   case input_condition::RHO_P_INPUT: {
@@ -239,77 +236,76 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string rp_name = "PTE::solve (rho,P) input" + perf_nums;
-    singularity::get_sg_eos_rho_p(rp_name.c_str(), ncell, nmat, offsets_v,
-                                  eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
-                                  spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
-                                  frac_mass_v, frac_vol_v, frac_ie_v,
-                                  frac_bmod_v, frac_dpde_v, frac_cv_v, 
-                                  pte_idxs, pte_mats, press_pte, vfrac_pte,
-                                  rho_pte, sie_pte, temp_pte, solver_scratch,
-                                  tokens, small_loop, do_frac_bmod,
-                                  do_frac_dpde, do_frac_cv);
-//    portableFor(
-//        rp_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-//          // cell offset
-//          const int i{offsets_v(iloop) - 1};
-//          // get "thread-id" like thing with optimization
-//          // for small loops
-//          const int32_t token{tokens.acquire()};
-//          const int32_t tid{small_loop ? iloop : token};
-//          double mass_sum{0.0};
-//          int npte{0};
-//          // initialize values for solver / lookup
-//          init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
-//          Real sie_tot_true{0.0};
-//          const int neq = npte + 1;
-//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-//                                                     neq * (neq + 4) + 2 * npte);
-//          if (npte > 1) {
-//            // create solver lambda
-//            // eos accessor
-//            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-//            PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
-//                npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
-//                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-//                &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
-//            const bool res_{PTESolver(method)};
-//            // calculate total sie
-//            for (int mp = 0; mp < npte; ++mp) {
-//              const int m = pte_mats(tid, mp);
-//              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-//            }
-//          } else {
-//            // pure cell (nmat = 1)
-//            // calculate sie from single eos
-//            auto p_from_t = [&](const Real &t_i) {
-//              return eos_v(pte_idxs(tid, 0))
-//                  .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
-//            };
-//            // calculate sie root bounds
-//            Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
-//            Real r_dpde{}, r_dvdt{};
-//            eos_v(pte_idxs(tid, 0))
-//                .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
-//                                        r_dpde, r_dvdt);
-//            Real temp_i;
-//            RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
-//                                    1.e10 * r_temp, 1.e-12, 1.e-12, temp_i);
-//            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-//                                  .InternalEnergyFromDensityTemperature(rho_pte(tid, 0),
-//                                                                        temp_i, cache[0]);
-//            sie_tot_true = sie_pte(tid, 0);
-//            // set temperature
-//            temp_pte(tid, 0) = temp_i;
-//          }
-//          // sie calculate explicitly already
-//          sie_v(i) = sie_tot_true;
-//          // assign remaining outputs
-//          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
-//          // assign max pressure
-//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-//          // release the token used for scratch arrays
-//          tokens.release(token);
-//        });
+    singularity::get_sg_eos_rho_p(
+        rp_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
+        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
+        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
+        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
+        do_frac_bmod, do_frac_dpde, do_frac_cv);
+    //    portableFor(
+    //        rp_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+    //          // cell offset
+    //          const int i{offsets_v(iloop) - 1};
+    //          // get "thread-id" like thing with optimization
+    //          // for small loops
+    //          const int32_t token{tokens.acquire()};
+    //          const int32_t tid{small_loop ? iloop : token};
+    //          double mass_sum{0.0};
+    //          int npte{0};
+    //          // initialize values for solver / lookup
+    //          init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
+    //          Real sie_tot_true{0.0};
+    //          const int neq = npte + 1;
+    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+    //                                                     neq * (neq + 4) + 2 * npte);
+    //          if (npte > 1) {
+    //            // create solver lambda
+    //            // eos accessor
+    //            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+    //            PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
+    //                npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
+    //                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
+    //                &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
+    //            const bool res_{PTESolver(method)};
+    //            // calculate total sie
+    //            for (int mp = 0; mp < npte; ++mp) {
+    //              const int m = pte_mats(tid, mp);
+    //              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
+    //            }
+    //          } else {
+    //            // pure cell (nmat = 1)
+    //            // calculate sie from single eos
+    //            auto p_from_t = [&](const Real &t_i) {
+    //              return eos_v(pte_idxs(tid, 0))
+    //                  .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
+    //            };
+    //            // calculate sie root bounds
+    //            Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
+    //            Real r_dpde{}, r_dvdt{};
+    //            eos_v(pte_idxs(tid, 0))
+    //                .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
+    //                                        r_dpde, r_dvdt);
+    //            Real temp_i;
+    //            RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
+    //                                    1.e10 * r_temp, 1.e-12, 1.e-12, temp_i);
+    //            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+    //                                  .InternalEnergyFromDensityTemperature(rho_pte(tid,
+    //                                  0),
+    //                                                                        temp_i,
+    //                                                                        cache[0]);
+    //            sie_tot_true = sie_pte(tid, 0);
+    //            // set temperature
+    //            temp_pte(tid, 0) = temp_i;
+    //          }
+    //          // sie calculate explicitly already
+    //          sie_v(i) = sie_tot_true;
+    //          // assign remaining outputs
+    //          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
+    //          // assign max pressure
+    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+    //          // release the token used for scratch arrays
+    //          tokens.release(token);
+    //        });
     break;
   }
   case input_condition::P_T_INPUT: {
@@ -318,71 +314,68 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string pt_name = "PTE::solve (P,T) input" + perf_nums;
-    singularity::get_sg_eos_p_t(pt_name.c_str(), ncell, nmat, offsets_v,
-                                eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
-                                spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
-                                frac_mass_v, frac_vol_v, frac_ie_v,
-                                frac_bmod_v, frac_dpde_v, frac_cv_v, 
-                                pte_idxs, pte_mats, press_pte, vfrac_pte,
-                                rho_pte, sie_pte, temp_pte, solver_scratch,
-                                tokens, small_loop, do_frac_bmod,
-                                do_frac_dpde, do_frac_cv);    
-//    portableFor(
-//        pt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-//          // cell offset
-//          const int i{offsets_v(iloop) - 1};
-//          // get "thread-id" like thing with optimization
-//          // for small loops
-//          const int32_t token{tokens.acquire()};
-//          const int32_t tid{small_loop ? iloop : token};
-//          // caching mechanism
-//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
-//          double mass_sum{0.0};
-//          // normalize mass fractions
-//          // first find the mass sum
-//          // also set idxs as the decrement of the eos offsets
-//          // to take into account 1 based indexing in fortran
-//          for (int m = 0; m < nmat; ++m) {
-//            mass_sum += frac_mass_v(i, m);
-//            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
-//            pte_mats(tid, m) = m;
-//            temp_pte(tid, m) = temp_v(i) * ev2k;
-//            press_pte(tid, m) = press_v(i);
-//          }
-//          for (int m = 0; m < nmat; ++m) {
-//            frac_mass_v(i, m) /= mass_sum;
-//          }
-//          // do r-e of pt for each mat
-//          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-//          Real vfrac_tot{0.0};
-//          Real sie_tot{0.0};
-//          for (int m = 0; m < nmat; ++m) {
-//            // obtain rho and sie from P-T
-//            eos_inx[m].DensityEnergyFromPressureTemperature(
-//                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
-//                sie_pte(tid, m));
-//            // assign volume fractions
-//            // this is a physical volume
-//            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
-//            vfrac_tot += vfrac_pte(tid, m);
-//            // add internal energy component
-//            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
-//          }
-//          // assign volume, etc.
-//          // total sie is known
-//          sie_v(i) = sie_tot;
-//          vol_v(i) = vfrac_tot;
-//          spvol_v(i) = vol_v(i) / mass_sum;
-//          for (int m = 0; m < nmat; ++m) {
-//            vfrac_pte(tid, m) /= vfrac_tot;
-//          }
-//          // assign remaining outputs
-//          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
-//          // assign max pressure
-//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-//          // release the token used for scratch arrays
-//          tokens.release(token);
-//        });
+    singularity::get_sg_eos_p_t(
+        pt_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
+        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
+        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
+        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
+        do_frac_bmod, do_frac_dpde, do_frac_cv);
+    //    portableFor(
+    //        pt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+    //          // cell offset
+    //          const int i{offsets_v(iloop) - 1};
+    //          // get "thread-id" like thing with optimization
+    //          // for small loops
+    //          const int32_t token{tokens.acquire()};
+    //          const int32_t tid{small_loop ? iloop : token};
+    //          // caching mechanism
+    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
+    //          double mass_sum{0.0};
+    //          // normalize mass fractions
+    //          // first find the mass sum
+    //          // also set idxs as the decrement of the eos offsets
+    //          // to take into account 1 based indexing in fortran
+    //          for (int m = 0; m < nmat; ++m) {
+    //            mass_sum += frac_mass_v(i, m);
+    //            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
+    //            pte_mats(tid, m) = m;
+    //            temp_pte(tid, m) = temp_v(i) * ev2k;
+    //            press_pte(tid, m) = press_v(i);
+    //          }
+    //          for (int m = 0; m < nmat; ++m) {
+    //            frac_mass_v(i, m) /= mass_sum;
+    //          }
+    //          // do r-e of pt for each mat
+    //          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+    //          Real vfrac_tot{0.0};
+    //          Real sie_tot{0.0};
+    //          for (int m = 0; m < nmat; ++m) {
+    //            // obtain rho and sie from P-T
+    //            eos_inx[m].DensityEnergyFromPressureTemperature(
+    //                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
+    //                sie_pte(tid, m));
+    //            // assign volume fractions
+    //            // this is a physical volume
+    //            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
+    //            vfrac_tot += vfrac_pte(tid, m);
+    //            // add internal energy component
+    //            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
+    //          }
+    //          // assign volume, etc.
+    //          // total sie is known
+    //          sie_v(i) = sie_tot;
+    //          vol_v(i) = vfrac_tot;
+    //          spvol_v(i) = vol_v(i) / mass_sum;
+    //          for (int m = 0; m < nmat; ++m) {
+    //            vfrac_pte(tid, m) /= vfrac_tot;
+    //          }
+    //          // assign remaining outputs
+    //          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
+    //          // assign max pressure
+    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+    //          // release the token used for scratch arrays
+    //          tokens.release(token);
+    //        });
     break;
   }
   case input_condition::NORM_RHO_E_INPUT:
@@ -394,56 +387,54 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string re_name = "PTE::solve (rho,e) input" + perf_nums;
-    singularity::get_sg_eos_rho_p(re_name.c_str(), ncell, nmat, offsets_v,
-                                  eos_offsets_v, eos_v, press_v, pmax_v, vol_v,
-                                  spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v,
-                                  frac_mass_v, frac_vol_v, frac_ie_v,
-                                  frac_bmod_v, frac_dpde_v, frac_cv_v, 
-                                  pte_idxs, pte_mats, press_pte, vfrac_pte,
-                                  rho_pte, sie_pte, temp_pte, solver_scratch,
-                                  tokens, small_loop, do_frac_bmod,
-                                  do_frac_dpde, do_frac_cv);    
-//    portableFor(
-//        re_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-//          // cell offset
-//          const int i{offsets_v(iloop) - 1};
-//          // get "thread-id" like thing with optimization
-//          // for small loops
-//          const int32_t token{tokens.acquire()};
-//          const int32_t tid{small_loop ? iloop : token};
-//          double mass_sum{0.0};
-//          int npte{0};
-//          // initialize values for solver / lookup
-//          init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
-//          // get cache from offsets into scratch
-//          const int neq = npte + 1;
-//          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-//                                                     neq * (neq + 4) + 2 * npte);
-//          if (npte > 1) {
-//            // create solver lambda
-//            // eos accessor
-//            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-//            // reset inputs
-//            PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
-//                npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
-//                &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
-//                &solver_scratch(tid, 0));
-//            const bool res_{PTESolver(method)};
-//          } else {
-//            // pure cell (nmat = 1)
-//            // calculate sie from single eos
-//            Real dpdr_m, dtdr_m, dpde_m, dtde_m;
-//            eos_v(pte_idxs(tid, 0))
-//                .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
-//                        temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
-//          }
-//          // assign outputs
-//          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
-//          // assign max pressure
-//          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-//          // release the token used for scratch arrays
-//          tokens.release(token);
-//        });
+    singularity::get_sg_eos_rho_p(
+        re_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
+        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
+        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
+        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
+        do_frac_bmod, do_frac_dpde, do_frac_cv);
+    //    portableFor(
+    //        re_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+    //          // cell offset
+    //          const int i{offsets_v(iloop) - 1};
+    //          // get "thread-id" like thing with optimization
+    //          // for small loops
+    //          const int32_t token{tokens.acquire()};
+    //          const int32_t tid{small_loop ? iloop : token};
+    //          double mass_sum{0.0};
+    //          int npte{0};
+    //          // initialize values for solver / lookup
+    //          init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
+    //          // get cache from offsets into scratch
+    //          const int neq = npte + 1;
+    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+    //                                                     neq * (neq + 4) + 2 * npte);
+    //          if (npte > 1) {
+    //            // create solver lambda
+    //            // eos accessor
+    //            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+    //            // reset inputs
+    //            PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
+    //                npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
+    //                &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
+    //                &solver_scratch(tid, 0));
+    //            const bool res_{PTESolver(method)};
+    //          } else {
+    //            // pure cell (nmat = 1)
+    //            // calculate sie from single eos
+    //            Real dpdr_m, dtdr_m, dpde_m, dtde_m;
+    //            eos_v(pte_idxs(tid, 0))
+    //                .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid,
+    //                0),
+    //                        temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
+    //          }
+    //          // assign outputs
+    //          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
+    //          // assign max pressure
+    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+    //          // release the token used for scratch arrays
+    //          tokens.release(token);
+    //        });
     break;
   }
   }
diff --git a/singularity-eos/eos/get_sg_eos.hpp b/singularity-eos/eos/get_sg_eos.hpp
index e4ec79f0c2..144e250d13 100644
--- a/singularity-eos/eos/get_sg_eos.hpp
+++ b/singularity-eos/eos/get_sg_eos.hpp
@@ -65,129 +65,65 @@ static constexpr const double ev2k = 1.160451930280894026e4;
 #ifdef PORTABILITY_STRATEGY_KOKKOS
 namespace singularity {
 // rho t input
-void get_sg_eos_rho_t(const char* name, int ncell, int nmat, 
-                      indirection_v& offsets_v,
-		      indirection_v& eos_offsets_v,
-		      Kokkos::View<EOS *, Llft>& eos_v,
-                      dev_v& press_v,
-                      dev_v& pmax_v,
-                      dev_v& vol_v,
-                      dev_v& spvol_v,
-                      dev_v& sie_v,
-                      dev_v& temp_v,
-                      dev_v& bmod_v,
-                      dev_v& dpde_v,
-                      dev_v& cv_v,
-                      dev_frac_v& frac_mass_v,
-                      dev_frac_v& frac_vol_v,
-                      dev_frac_v& frac_ie_v,
-                      dev_frac_v& frac_bmod_v,
-                      dev_frac_v& frac_dpde_v,
-                      dev_frac_v& frac_cv_v,
-                      ScratchV<int>& pte_idxs,
-                      ScratchV<int>& pte_mats,
-                      ScratchV<double>& press_pte,
-                      ScratchV<double>& vfrac_pte,
-                      ScratchV<double>& rho_pte,
-                      ScratchV<double>& sie_pte,
-                      ScratchV<double>& temp_pte,
-                      ScratchV<double>& solver_scratch,
-                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		      bool small_loop,
-                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                      bool do_frac_cv);
 // rho P input
-void get_sg_eos_rho_p(const char* name, int ncell, int nmat, 
-                      indirection_v& offsets_v,
-		      indirection_v& eos_offsets_v,
-		      Kokkos::View<EOS *, Llft>& eos_v,
-                      dev_v& press_v,
-                      dev_v& pmax_v,
-                      dev_v& vol_v,
-                      dev_v& spvol_v,
-                      dev_v& sie_v,
-                      dev_v& temp_v,
-                      dev_v& bmod_v,
-                      dev_v& dpde_v,
-                      dev_v& cv_v,
-                      dev_frac_v& frac_mass_v,
-                      dev_frac_v& frac_vol_v,
-                      dev_frac_v& frac_ie_v,
-                      dev_frac_v& frac_bmod_v,
-                      dev_frac_v& frac_dpde_v,
-                      dev_frac_v& frac_cv_v,
-                      ScratchV<int>& pte_idxs,
-                      ScratchV<int>& pte_mats,
-                      ScratchV<double>& press_pte,
-                      ScratchV<double>& vfrac_pte,
-                      ScratchV<double>& rho_pte,
-                      ScratchV<double>& sie_pte,
-                      ScratchV<double>& temp_pte,
-                      ScratchV<double>& solver_scratch,
-                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		      bool small_loop,
-                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                      bool do_frac_cv);
 // PT input
-void get_sg_eos_p_t(const char* name, int ncell, int nmat, 
-                    indirection_v& offsets_v,
-		    indirection_v& eos_offsets_v,
-		    Kokkos::View<EOS *, Llft>& eos_v,
-                    dev_v& press_v,
-                    dev_v& pmax_v,
-                    dev_v& vol_v,
-                    dev_v& spvol_v,
-                    dev_v& sie_v,
-                    dev_v& temp_v,
-                    dev_v& bmod_v,
-                    dev_v& dpde_v,
-                    dev_v& cv_v,
-                    dev_frac_v& frac_mass_v,
-                    dev_frac_v& frac_vol_v,
-                    dev_frac_v& frac_ie_v,
-                    dev_frac_v& frac_bmod_v,
-                    dev_frac_v& frac_dpde_v,
-                    dev_frac_v& frac_cv_v,
-                    ScratchV<int>& pte_idxs,
-                    ScratchV<int>& pte_mats,
-                    ScratchV<double>& press_pte,
-                    ScratchV<double>& vfrac_pte,
-                    ScratchV<double>& rho_pte,
-                    ScratchV<double>& sie_pte,
-                    ScratchV<double>& temp_pte,
-                    ScratchV<double>& solver_scratch,
-                    Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		    bool small_loop,
-                    bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                    indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                    dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                    dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                    dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                    dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                    dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                    ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                    ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                    ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                    ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                    Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                    bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                    bool do_frac_cv);
 // rho e input
-void get_sg_eos_rho_e(const char* name, int ncell, int nmat, 
-                      indirection_v& offsets_v,
-		      indirection_v& eos_offsets_v,
-		      Kokkos::View<EOS *, Llft>& eos_v,
-                      dev_v& press_v,
-                      dev_v& pmax_v,
-                      dev_v& vol_v,
-                      dev_v& spvol_v,
-                      dev_v& sie_v,
-                      dev_v& temp_v,
-                      dev_v& bmod_v,
-                      dev_v& dpde_v,
-                      dev_v& cv_v,
-                      dev_frac_v& frac_mass_v,
-                      dev_frac_v& frac_vol_v,
-                      dev_frac_v& frac_ie_v,
-                      dev_frac_v& frac_bmod_v,
-                      dev_frac_v& frac_dpde_v,
-                      dev_frac_v& frac_cv_v,
-                      ScratchV<int>& pte_idxs,
-                      ScratchV<int>& pte_mats,
-                      ScratchV<double>& press_pte,
-                      ScratchV<double>& vfrac_pte,
-                      ScratchV<double>& rho_pte,
-                      ScratchV<double>& sie_pte,
-                      ScratchV<double>& temp_pte,
-                      ScratchV<double>& solver_scratch,
-                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		      bool small_loop,
-                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv);
+void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                      bool do_frac_cv);
 } // namespace singularity
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
diff --git a/singularity-eos/eos/get_sg_eos_lambdas.hpp b/singularity-eos/eos/get_sg_eos_lambdas.hpp
index 24ed62fddd..0f0bf1b910 100644
--- a/singularity-eos/eos/get_sg_eos_lambdas.hpp
+++ b/singularity-eos/eos/get_sg_eos_lambdas.hpp
@@ -19,125 +19,118 @@
 
 #ifdef PORTABILITY_STRATEGY_KOKKOS
 
-#define SG_GET_SG_EOS_INIT_LAMBDA_DECL \
-PORTABLE_LAMBDA(const int i, const int tid, double &mass_sum, int &npte, \
-                const Real t_mult, const Real s_mult, const Real p_mult) { \
-  /* normalize mass fractions */ \
-  /* first find the mass sum */ \
-  /* also set idxs as the decrement of the eos offsets */ \
-  /* to take into account 1 based indexing in fortran */ \
-  for (int m = 0; m < nmat; ++m) { \
-    mass_sum += frac_mass_v(i, m); \
-    pte_idxs(tid, m) = eos_offsets_v(m) - 1; \
-    frac_vol_v(i, m) = 0.0; \
-  } \
-  for (int m = 0; m < nmat; ++m) { \
-    frac_mass_v(i, m) /= mass_sum; \
-  } \
-  /* set inputs */ \
-  npte = 0; \
-  for (int m = 0; m < nmat; ++m) { \
-    if (frac_mass_v(i, m) > 1.e-12) { \
-      pte_idxs(tid, npte) = eos_offsets_v(m) - 1; \
-      pte_mats(tid, npte) = m; \
-      npte += 1; \
-    } \
-    vfrac_pte(tid, m) = 0.0; \
-    sie_pte(tid, m) = 0.0; \
-    temp_pte(tid, m) = 0.0; \
-    press_pte(tid, m) = 0.0; \
-  } \
-  for (int mp = 0; mp < npte; ++mp) { \
-    const int m = pte_mats(tid, mp); \
-    rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m); \
-    vfrac_pte(tid, mp) = 1.0 / npte; \
-    temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult; \
-    press_pte(tid, mp) = press_v(i) * p_mult; \
-    sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult; \
-  } \
-}
+#define SG_GET_SG_EOS_INIT_LAMBDA_DECL                                                   \
+  PORTABLE_LAMBDA(const int i, const int tid, double &mass_sum, int &npte,               \
+                  const Real t_mult, const Real s_mult, const Real p_mult) {             \
+    /* normalize mass fractions */                                                       \
+    /* first find the mass sum */                                                        \
+    /* also set idxs as the decrement of the eos offsets */                              \
+    /* to take into account 1 based indexing in fortran */                               \
+    for (int m = 0; m < nmat; ++m) {                                                     \
+      mass_sum += frac_mass_v(i, m);                                                     \
+      pte_idxs(tid, m) = eos_offsets_v(m) - 1;                                           \
+      frac_vol_v(i, m) = 0.0;                                                            \
+    }                                                                                    \
+    for (int m = 0; m < nmat; ++m) {                                                     \
+      frac_mass_v(i, m) /= mass_sum;                                                     \
+    }                                                                                    \
+    /* set inputs */                                                                     \
+    npte = 0;                                                                            \
+    for (int m = 0; m < nmat; ++m) {                                                     \
+      if (frac_mass_v(i, m) > 1.e-12) {                                                  \
+        pte_idxs(tid, npte) = eos_offsets_v(m) - 1;                                      \
+        pte_mats(tid, npte) = m;                                                         \
+        npte += 1;                                                                       \
+      }                                                                                  \
+      vfrac_pte(tid, m) = 0.0;                                                           \
+      sie_pte(tid, m) = 0.0;                                                             \
+      temp_pte(tid, m) = 0.0;                                                            \
+      press_pte(tid, m) = 0.0;                                                           \
+    }                                                                                    \
+    for (int mp = 0; mp < npte; ++mp) {                                                  \
+      const int m = pte_mats(tid, mp);                                                   \
+      rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m);                          \
+      vfrac_pte(tid, mp) = 1.0 / npte;                                                   \
+      temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult;                                     \
+      press_pte(tid, mp) = press_v(i) * p_mult;                                          \
+      sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult;                          \
+    }                                                                                    \
+  }
 
-#define SG_GET_SG_EOS_FINAL_LAMBDA_DECL \
-PORTABLE_LAMBDA(const int i, const int tid, const int npte, \
-                const Real mass_sum, const Real t_mult, const Real s_mult, \
-		const Real p_mult, \
-                singularity::mix_impl::CacheAccessor &cache) { \
-  /* initialize averaged quantities to 0 */ \
-  const bool do_t = t_mult == 1.0; \
-  const bool do_s = s_mult == 1.0; \
-  const bool do_p = p_mult == 1.0; \
-  if (do_t) { \
-    temp_v(i) = 0.0; \
-  } \
-  if (do_p) { \
-    press_v(i) = 0.0; \
-  } \
-  if (do_s) { \
-    sie_v(i) = 0.0; \
-  } \
-  bmod_v(i) = 0.0; \
-  cv_v(i) = 0.0; \
-  dpde_v(i) = 0.0; \
-  /* material loop for averaging and assigning per mat quantities */ \
-  for (int mp = 0; mp < npte; ++mp) { \
-    const int m = pte_mats(tid, mp); \
-    /* pressure contribution from material m */ \
-    press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult; \
-    /* temperature contribution from material m */ \
-    temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult; \
-    const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum; \
-    /* sie contribution from material m */ \
-    sie_v(i) += ie_m * s_mult; \
-    /* assign per material specific internal energy */ \
-    frac_ie_v(i, m) = ie_m; \
-    /* assign volume fraction based on pte calculation */ \
-    frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i); \
-    /* calculate bulk modulus for material m */ \
-    const Real bmod_m = eos_v(pte_idxs(tid, mp)) \
-                            .BulkModulusFromDensityTemperature( \
-                                rho_pte(tid, mp), \
-                                temp_pte(tid, mp), \
-                                cache[mp]); \
-    /* add bmod contribution from material m */ \
-    bmod_v(i) += bmod_m * vfrac_pte(tid, mp); \
-    /* calculate specific heat for material m */ \
-    const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp)) \
-                                 .SpecificHeatFromDensityTemperature( \
-                                     rho_pte(tid, mp), \
-                                     temp_pte(tid, mp), \
-                                     cache[mp]); \
-    /* add mass weighted contribution specific heat for material m */ \
-    cv_v(i) += cv_m * frac_mass_v(i, m); \
-    /* calculate gruneisen parameter for material m */ \
-    const Real dpde_m = eos_v(pte_idxs(tid, mp)) \
-                            .GruneisenParamFromDensityTemperature( \
-                                rho_pte(tid, mp), \
-                                temp_pte(tid, mp), \
-                                cache[mp]);\
-    /* add gruneisen param contribution from material m */ \
-    dpde_v(i) += dpde_m * vfrac_pte(tid, mp); \
-    /* optionally assign per material quantities to per material arrays */ \
-    if (do_frac_bmod) { \
-      frac_bmod_v(i, m) = bmod_m; \
-    } \
-    if (do_frac_cv) { \
-      frac_cv_v(i, m) = cv_m; \
-    } \
-    if (do_frac_dpde) { \
-      frac_dpde_v(i, m) = dpde_m; \
-    } \
-  } \
-  if (do_t) { \
-    temp_v(i) /= ev2k; \
-  } \
-  if (do_s) { \
-    sie_v(i) /= mass_sum; \
-  } \
-  /* reset mass fractions to original values if not normalized to 1 */ \
-  for (int m = 0; m < nmat; ++m) { \
-    frac_mass_v(i, m) *= mass_sum; \
-  } \
-}
+#define SG_GET_SG_EOS_FINAL_LAMBDA_DECL                                                  \
+  PORTABLE_LAMBDA(const int i, const int tid, const int npte, const Real mass_sum,       \
+                  const Real t_mult, const Real s_mult, const Real p_mult,               \
+                  singularity::mix_impl::CacheAccessor &cache) {                         \
+    /* initialize averaged quantities to 0 */                                            \
+    const bool do_t = t_mult == 1.0;                                                     \
+    const bool do_s = s_mult == 1.0;                                                     \
+    const bool do_p = p_mult == 1.0;                                                     \
+    if (do_t) {                                                                          \
+      temp_v(i) = 0.0;                                                                   \
+    }                                                                                    \
+    if (do_p) {                                                                          \
+      press_v(i) = 0.0;                                                                  \
+    }                                                                                    \
+    if (do_s) {                                                                          \
+      sie_v(i) = 0.0;                                                                    \
+    }                                                                                    \
+    bmod_v(i) = 0.0;                                                                     \
+    cv_v(i) = 0.0;                                                                       \
+    dpde_v(i) = 0.0;                                                                     \
+    /* material loop for averaging and assigning per mat quantities */                   \
+    for (int mp = 0; mp < npte; ++mp) {                                                  \
+      const int m = pte_mats(tid, mp);                                                   \
+      /* pressure contribution from material m */                                        \
+      press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult;                    \
+      /* temperature contribution from material m */                                     \
+      temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult;                      \
+      const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum;                 \
+      /* sie contribution from material m */                                             \
+      sie_v(i) += ie_m * s_mult;                                                         \
+      /* assign per material specific internal energy */                                 \
+      frac_ie_v(i, m) = ie_m;                                                            \
+      /* assign volume fraction based on pte calculation */                              \
+      frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i);                                  \
+      /* calculate bulk modulus for material m */                                        \
+      const Real bmod_m = eos_v(pte_idxs(tid, mp))                                       \
+                              .BulkModulusFromDensityTemperature(                        \
+                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);       \
+      /* add bmod contribution from material m */                                        \
+      bmod_v(i) += bmod_m * vfrac_pte(tid, mp);                                          \
+      /* calculate specific heat for material m */                                       \
+      const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp))                                  \
+                                   .SpecificHeatFromDensityTemperature(                  \
+                                       rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);  \
+      /* add mass weighted contribution specific heat for material m */                  \
+      cv_v(i) += cv_m * frac_mass_v(i, m);                                               \
+      /* calculate gruneisen parameter for material m */                                 \
+      const Real dpde_m = eos_v(pte_idxs(tid, mp))                                       \
+                              .GruneisenParamFromDensityTemperature(                     \
+                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);       \
+      /* add gruneisen param contribution from material m */                             \
+      dpde_v(i) += dpde_m * vfrac_pte(tid, mp);                                          \
+      /* optionally assign per material quantities to per material arrays */             \
+      if (do_frac_bmod) {                                                                \
+        frac_bmod_v(i, m) = bmod_m;                                                      \
+      }                                                                                  \
+      if (do_frac_cv) {                                                                  \
+        frac_cv_v(i, m) = cv_m;                                                          \
+      }                                                                                  \
+      if (do_frac_dpde) {                                                                \
+        frac_dpde_v(i, m) = dpde_m;                                                      \
+      }                                                                                  \
+    }                                                                                    \
+    if (do_t) {                                                                          \
+      temp_v(i) /= ev2k;                                                                 \
+    }                                                                                    \
+    if (do_s) {                                                                          \
+      sie_v(i) /= mass_sum;                                                              \
+    }                                                                                    \
+    /* reset mass fractions to original values if not normalized to 1 */                 \
+    for (int m = 0; m < nmat; ++m) {                                                     \
+      frac_mass_v(i, m) *= mass_sum;                                                     \
+    }                                                                                    \
+  }
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
 #endif // _SINGULARITY_EOS_EOS_GET_SG_EOS_LAMBDAS_HPP_
diff --git a/singularity-eos/eos/get_sg_eos_p_t.cpp b/singularity-eos/eos/get_sg_eos_p_t.cpp
index 40bdf6990a..b472cec2df 100644
--- a/singularity-eos/eos/get_sg_eos_p_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_p_t.cpp
@@ -13,99 +13,83 @@
 //------------------------------------------------------------------------------
 
 #include <ports-of-call/portability.hpp>
-#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 namespace singularity {
-void get_sg_eos_p_t(const char* name, int ncell, int nmat, 
-                    indirection_v& offsets_v,
-		    indirection_v& eos_offsets_v,
-		    Kokkos::View<EOS *, Llft>& eos_v,
-                    dev_v& press_v,
-                    dev_v& pmax_v,
-                    dev_v& vol_v,
-                    dev_v& spvol_v,
-                    dev_v& sie_v,
-                    dev_v& temp_v,
-                    dev_v& bmod_v,
-                    dev_v& dpde_v,
-                    dev_v& cv_v,
-                    dev_frac_v& frac_mass_v,
-                    dev_frac_v& frac_vol_v,
-                    dev_frac_v& frac_ie_v,
-                    dev_frac_v& frac_bmod_v,
-                    dev_frac_v& frac_dpde_v,
-                    dev_frac_v& frac_cv_v,
-                    ScratchV<int>& pte_idxs,
-                    ScratchV<int>& pte_mats,
-                    ScratchV<double>& press_pte,
-                    ScratchV<double>& vfrac_pte,
-                    ScratchV<double>& rho_pte,
-                    ScratchV<double>& sie_pte,
-                    ScratchV<double>& temp_pte,
-                    ScratchV<double>& solver_scratch,
-                    Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		    bool small_loop,
-                    bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                    indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                    dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                    dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                    dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                    dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                    dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                    ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                    ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                    ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                    ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                    Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                    bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                    bool do_frac_cv) {
   const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-          // cell offset
-          const int i{offsets_v(iloop) - 1};
-          // get "thread-id" like thing with optimization
-          // for small loops
-          const int32_t token{tokens.acquire()};
-          const int32_t tid{small_loop ? iloop : token};
-          // caching mechanism
-          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
-          double mass_sum{0.0};
-          // normalize mass fractions
-          // first find the mass sum
-          // also set idxs as the decrement of the eos offsets
-          // to take into account 1 based indexing in fortran
-          for (int m = 0; m < nmat; ++m) {
-            mass_sum += frac_mass_v(i, m);
-            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
-            pte_mats(tid, m) = m;
-            temp_pte(tid, m) = temp_v(i) * ev2k;
-            press_pte(tid, m) = press_v(i);
-          }
-          for (int m = 0; m < nmat; ++m) {
-            frac_mass_v(i, m) /= mass_sum;
-          }
-          // do r-e of pt for each mat
-          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-          Real vfrac_tot{0.0};
-          Real sie_tot{0.0};
-          for (int m = 0; m < nmat; ++m) {
-            // obtain rho and sie from P-T
-            eos_inx[m].DensityEnergyFromPressureTemperature(
-                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
-                sie_pte(tid, m));
-            // assign volume fractions
-            // this is a physical volume
-            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
-            vfrac_tot += vfrac_pte(tid, m);
-            // add internal energy component
-            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
-          }
-          // assign volume, etc.
-          // total sie is known
-          sie_v(i) = sie_tot;
-          vol_v(i) = vfrac_tot;
-          spvol_v(i) = vol_v(i) / mass_sum;
-          for (int m = 0; m < nmat; ++m) {
-            vfrac_pte(tid, m) /= vfrac_tot;
-          }
-          // assign remaining outputs
-          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
-          // assign max pressure
-          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-          // release the token used for scratch arrays
-          tokens.release(token);
-        });
+        // cell offset
+        const int i{offsets_v(iloop) - 1};
+        // get "thread-id" like thing with optimization
+        // for small loops
+        const int32_t token{tokens.acquire()};
+        const int32_t tid{small_loop ? iloop : token};
+        // caching mechanism
+        singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
+        double mass_sum{0.0};
+        // normalize mass fractions
+        // first find the mass sum
+        // also set idxs as the decrement of the eos offsets
+        // to take into account 1 based indexing in fortran
+        for (int m = 0; m < nmat; ++m) {
+          mass_sum += frac_mass_v(i, m);
+          pte_idxs(tid, m) = eos_offsets_v(m) - 1;
+          pte_mats(tid, m) = m;
+          temp_pte(tid, m) = temp_v(i) * ev2k;
+          press_pte(tid, m) = press_v(i);
+        }
+        for (int m = 0; m < nmat; ++m) {
+          frac_mass_v(i, m) /= mass_sum;
+        }
+        // do r-e of pt for each mat
+        singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+        Real vfrac_tot{0.0};
+        Real sie_tot{0.0};
+        for (int m = 0; m < nmat; ++m) {
+          // obtain rho and sie from P-T
+          eos_inx[m].DensityEnergyFromPressureTemperature(
+              press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
+              sie_pte(tid, m));
+          // assign volume fractions
+          // this is a physical volume
+          vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
+          vfrac_tot += vfrac_pte(tid, m);
+          // add internal energy component
+          sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
+        }
+        // assign volume, etc.
+        // total sie is known
+        sie_v(i) = sie_tot;
+        vol_v(i) = vfrac_tot;
+        spvol_v(i) = vol_v(i) / mass_sum;
+        for (int m = 0; m < nmat; ++m) {
+          vfrac_pte(tid, m) /= vfrac_tot;
+        }
+        // assign remaining outputs
+        final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
+        // assign max pressure
+        pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+        // release the token used for scratch arrays
+        tokens.release(token);
+      });
   return;
 }
 } // namespace singularity
diff --git a/singularity-eos/eos/get_sg_eos_rho_e.cpp b/singularity-eos/eos/get_sg_eos_rho_e.cpp
index fcff919e24..69d340675e 100644
--- a/singularity-eos/eos/get_sg_eos_rho_e.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_e.cpp
@@ -13,85 +13,69 @@
 //------------------------------------------------------------------------------
 
 #include <ports-of-call/portability.hpp>
-#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 namespace singularity {
-void get_sg_eos_rho_e(const char* name, int ncell, int nmat, 
-                      indirection_v& offsets_v,
-		      indirection_v& eos_offsets_v,
-		      Kokkos::View<EOS *, Llft>& eos_v,
-                      dev_v& press_v,
-                      dev_v& pmax_v,
-                      dev_v& vol_v,
-                      dev_v& spvol_v,
-                      dev_v& sie_v,
-                      dev_v& temp_v,
-                      dev_v& bmod_v,
-                      dev_v& dpde_v,
-                      dev_v& cv_v,
-                      dev_frac_v& frac_mass_v,
-                      dev_frac_v& frac_vol_v,
-                      dev_frac_v& frac_ie_v,
-                      dev_frac_v& frac_bmod_v,
-                      dev_frac_v& frac_dpde_v,
-                      dev_frac_v& frac_cv_v,
-                      ScratchV<int>& pte_idxs,
-                      ScratchV<int>& pte_mats,
-                      ScratchV<double>& press_pte,
-                      ScratchV<double>& vfrac_pte,
-                      ScratchV<double>& rho_pte,
-                      ScratchV<double>& sie_pte,
-                      ScratchV<double>& temp_pte,
-                      ScratchV<double>& solver_scratch,
-                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		      bool small_loop,
-                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                      bool do_frac_cv) {
   const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
   const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   portableFor(
-    name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-      // cell offset
-      const int i{offsets_v(iloop) - 1};
-      // get "thread-id" like thing with optimization
-      // for small loops
-      const int32_t token{tokens.acquire()};
-      const int32_t tid{small_loop ? iloop : token};
-      double mass_sum{0.0};
-      int npte{0};
-      // initialize values for solver / lookup
-      init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
-      // get cache from offsets into scratch
-      const int neq = npte + 1;
-      singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-                                                 neq * (neq + 4) + 2 * npte);
-      if (npte > 1) {
-        // create solver lambda
-        // eos accessor
-        singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-        // reset inputs
-        PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
-            npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
-            &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
-            &solver_scratch(tid, 0));
-        const bool res_{PTESolver(method)};
-      } else {
-        // pure cell (nmat = 1)
-        // calculate sie from single eos
-        Real dpdr_m, dtdr_m, dpde_m, dtde_m;
-        eos_v(pte_idxs(tid, 0))
-            .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
-                    temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
-      }
-      // assign outputs
-      final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
-      // assign max pressure
-      pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-      // release the token used for scratch arrays
-      tokens.release(token);
-    });
+      name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
+        // cell offset
+        const int i{offsets_v(iloop) - 1};
+        // get "thread-id" like thing with optimization
+        // for small loops
+        const int32_t token{tokens.acquire()};
+        const int32_t tid{small_loop ? iloop : token};
+        double mass_sum{0.0};
+        int npte{0};
+        // initialize values for solver / lookup
+        init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
+        // get cache from offsets into scratch
+        const int neq = npte + 1;
+        singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
+                                                   neq * (neq + 4) + 2 * npte);
+        if (npte > 1) {
+          // create solver lambda
+          // eos accessor
+          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
+          // reset inputs
+          PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
+              npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
+              &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
+              &solver_scratch(tid, 0));
+          const bool res_{PTESolver(method)};
+        } else {
+          // pure cell (nmat = 1)
+          // calculate sie from single eos
+          Real dpdr_m, dtdr_m, dpde_m, dtde_m;
+          eos_v(pte_idxs(tid, 0))
+              .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
+                      temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
+        }
+        // assign outputs
+        final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
+        // assign max pressure
+        pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
+        // release the token used for scratch arrays
+        tokens.release(token);
+      });
   return;
 }
 } // namespace singularity
diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
index 580d360b79..a3990d7ede 100644
--- a/singularity-eos/eos/get_sg_eos_rho_p.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -13,42 +13,26 @@
 //------------------------------------------------------------------------------
 
 #include <ports-of-call/portability.hpp>
-#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 namespace singularity {
-void get_sg_eos_rho_p(const char* name, int ncell, int nmat, 
-                      indirection_v& offsets_v,
-		      indirection_v& eos_offsets_v,
-		      Kokkos::View<EOS *, Llft>& eos_v,
-                      dev_v& press_v,
-                      dev_v& pmax_v,
-                      dev_v& vol_v,
-                      dev_v& spvol_v,
-                      dev_v& sie_v,
-                      dev_v& temp_v,
-                      dev_v& bmod_v,
-                      dev_v& dpde_v,
-                      dev_v& cv_v,
-                      dev_frac_v& frac_mass_v,
-                      dev_frac_v& frac_vol_v,
-                      dev_frac_v& frac_ie_v,
-                      dev_frac_v& frac_bmod_v,
-                      dev_frac_v& frac_dpde_v,
-                      dev_frac_v& frac_cv_v,
-                      ScratchV<int>& pte_idxs,
-                      ScratchV<int>& pte_mats,
-                      ScratchV<double>& press_pte,
-                      ScratchV<double>& vfrac_pte,
-                      ScratchV<double>& rho_pte,
-                      ScratchV<double>& sie_pte,
-                      ScratchV<double>& temp_pte,
-                      ScratchV<double>& solver_scratch,
-                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		      bool small_loop,
-                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                      bool do_frac_cv) {
   const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
   const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   portableFor(
@@ -72,9 +56,9 @@ void get_sg_eos_rho_p(const char* name, int ncell, int nmat,
           // eos accessor
           singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
           PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
-              npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
-              &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-              &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
+              npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
+              &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache[0],
+              &solver_scratch(tid, 0));
           const bool res_{PTESolver(method)};
           // calculate total sie
           for (int mp = 0; mp < npte; ++mp) {
@@ -92,8 +76,8 @@ void get_sg_eos_rho_p(const char* name, int ncell, int nmat,
           Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
           Real r_dpde{}, r_dvdt{};
           eos_v(pte_idxs(tid, 0))
-              .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
-                                      r_dpde, r_dvdt);
+              .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod, r_dpde,
+                                      r_dvdt);
           Real temp_i;
           RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
                                   1.e10 * r_temp, 1.e-12, 1.e-12, temp_i);
diff --git a/singularity-eos/eos/get_sg_eos_rho_t.cpp b/singularity-eos/eos/get_sg_eos_rho_t.cpp
index 9a9b4d37b5..b557b631e3 100644
--- a/singularity-eos/eos/get_sg_eos_rho_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_t.cpp
@@ -13,42 +13,26 @@
 //------------------------------------------------------------------------------
 
 #include <ports-of-call/portability.hpp>
-#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 namespace singularity {
-void get_sg_eos_rho_t(const char* name, int ncell, int nmat, 
-                      indirection_v& offsets_v,
-		      indirection_v& eos_offsets_v,
-		      Kokkos::View<EOS *, Llft>& eos_v,
-                      dev_v& press_v,
-                      dev_v& pmax_v,
-                      dev_v& vol_v,
-                      dev_v& spvol_v,
-                      dev_v& sie_v,
-                      dev_v& temp_v,
-                      dev_v& bmod_v,
-                      dev_v& dpde_v,
-                      dev_v& cv_v,
-                      dev_frac_v& frac_mass_v,
-                      dev_frac_v& frac_vol_v,
-                      dev_frac_v& frac_ie_v,
-                      dev_frac_v& frac_bmod_v,
-                      dev_frac_v& frac_dpde_v,
-                      dev_frac_v& frac_cv_v,
-                      ScratchV<int>& pte_idxs,
-                      ScratchV<int>& pte_mats,
-                      ScratchV<double>& press_pte,
-                      ScratchV<double>& vfrac_pte,
-                      ScratchV<double>& rho_pte,
-                      ScratchV<double>& sie_pte,
-                      ScratchV<double>& temp_pte,
-                      ScratchV<double>& solver_scratch,
-                      Kokkos::Experimental::UniqueToken<DES, KGlobal>& tokens,
-		      bool small_loop,
-                      bool do_frac_bmod, bool do_frac_dpde, bool do_frac_cv) {
+void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
+                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
+                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
+                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
+                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
+                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
+                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
+                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
+                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
+                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
+                      bool do_frac_cv) {
   const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
   const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   portableFor(
@@ -73,9 +57,9 @@ void get_sg_eos_rho_t(const char* name, int ncell, int nmat,
           // eos accessor
           singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
           PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
-              npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
-              &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-              &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
+              npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
+              &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
+              &solver_scratch(tid, 0));
           const bool res_{PTESolver(method)};
           // calculate total internal energy
           for (int mp = 0; mp < npte; ++mp) {
@@ -85,13 +69,13 @@ void get_sg_eos_rho_t(const char* name, int ncell, int nmat,
         } else {
           // pure cell (nmat = 1)
           // calculate sie from single eos
-          sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))\
+          sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
                                 .InternalEnergyFromDensityTemperature(
                                     rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
           // set total sie to material 0 value
           sie_tot_true = sie_pte(tid, 0);
           // set pressure
-          press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))\
+          press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
                                   .PressureFromDensityTemperature(
                                       rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
         }

From da798cc4c6c934072b8216d5f4f9d6c3fe6d860b Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 15:07:26 -0600
Subject: [PATCH 08/45] guard the nowarn.

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

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 8d0ea0b7ef..f92cbefb67 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -41,7 +41,11 @@ using namespace eos_base;
 
 // Only really works in serial
 // Not really supported on device
+#ifdef __CUDACC__
 #define SG_PIF_NOWARN #pragma nv_exec_check_disable PORTABLE_INLINE_FUNCTION
+#else
+#define SG_PIF_NOWARN #pragma PORTABLE_INLINE_FUNCTION
+#endif
 
 class EOSPAC : public EosBase<EOSPAC> {
  public:

From c5df26b7c1d05851378b23dbdb0aa65cee699f12 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 15:19:55 -0600
Subject: [PATCH 09/45] remove erroneous pragma from copy-paste.

---
 singularity-eos/eos/eos_eospac.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index f92cbefb67..31f498fae2 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -44,7 +44,7 @@ using namespace eos_base;
 #ifdef __CUDACC__
 #define SG_PIF_NOWARN #pragma nv_exec_check_disable PORTABLE_INLINE_FUNCTION
 #else
-#define SG_PIF_NOWARN #pragma PORTABLE_INLINE_FUNCTION
+#define SG_PIF_NOWARN PORTABLE_INLINE_FUNCTION
 #endif
 
 class EOSPAC : public EosBase<EOSPAC> {

From acd33494b62d384785d9a4df4c86640b6174e74b Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 17:12:39 -0600
Subject: [PATCH 10/45] Added missing portable function.

---
 singularity-eos/eos/modifiers/scaled_eos.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/singularity-eos/eos/modifiers/scaled_eos.hpp b/singularity-eos/eos/modifiers/scaled_eos.hpp
index c62b4c633a..9f5605302d 100644
--- a/singularity-eos/eos/modifiers/scaled_eos.hpp
+++ b/singularity-eos/eos/modifiers/scaled_eos.hpp
@@ -92,6 +92,7 @@ class ScaledEOS : public EosBase<ScaledEOS<T>> {
                                          Real *lambda = nullptr) const {
     return t_.PressureFromDensityInternalEnergy(scale_ * rho, inv_scale_ * sie, lambda);
   }
+  PORTABLE_FUNCTION
   Real EntropyFromDensityInternalEnergy(const Real rho, const Real sie,
                                         Real *lambda = nullptr) const {
     return scale_ *

From 1fbcfacceab1006eb1614eb11282b68ebb07f53d Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 18:06:41 -0600
Subject: [PATCH 11/45] More missing function decorators.

---
 singularity-eos/eos/modifiers/eos_unitsystem.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/singularity-eos/eos/modifiers/eos_unitsystem.hpp b/singularity-eos/eos/modifiers/eos_unitsystem.hpp
index 5e7f6b033a..df998a161e 100644
--- a/singularity-eos/eos/modifiers/eos_unitsystem.hpp
+++ b/singularity-eos/eos/modifiers/eos_unitsystem.hpp
@@ -166,6 +166,7 @@ class UnitSystem : public EosBase<UnitSystem<T>> {
         t_.PressureFromDensityTemperature(rho * rho_unit_, temp * temp_unit_, lambda);
     return inv_press_unit_ * P;
   }
+  PORTABLE_FUNCTION
   Real EntropyFromDensityTemperature(const Real rho, const Real temp,
                                      Real *lambda = nullptr) const {
     const Real S =

From 54dfeecb7ed18ffaa70671d85b42a75531956c89 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 18:12:52 -0600
Subject: [PATCH 12/45] Minor syntax change to preprocessor logic.

---
 singularity-eos/eos/eos_eospac.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 31f498fae2..10887f569a 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -41,7 +41,7 @@ using namespace eos_base;
 
 // Only really works in serial
 // Not really supported on device
-#ifdef __CUDACC__
+#if defined(__CUDACC__)
 #define SG_PIF_NOWARN #pragma nv_exec_check_disable PORTABLE_INLINE_FUNCTION
 #else
 #define SG_PIF_NOWARN PORTABLE_INLINE_FUNCTION

From de35b08632cba9c07bc95656b9a32f45540896e6 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 25 Apr 2023 18:39:50 -0600
Subject: [PATCH 13/45] Make macro on new line.

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

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 10887f569a..3514de20ad 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -42,7 +42,9 @@ using namespace eos_base;
 // Only really works in serial
 // Not really supported on device
 #if defined(__CUDACC__)
-#define SG_PIF_NOWARN #pragma nv_exec_check_disable PORTABLE_INLINE_FUNCTION
+#define SG_PIF_NOWARN \
+#pragma nv_exec_check_disable \
+PORTABLE_INLINE_FUNCTION
 #else
 #define SG_PIF_NOWARN PORTABLE_INLINE_FUNCTION
 #endif

From 7f1997abd5e14fa1855b7a13f2865b6fc1451465 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Wed, 26 Apr 2023 09:35:28 -0600
Subject: [PATCH 14/45] The macro I created won't work b/c the pragma needs a
 new line and newlines cannot be generated by macros.

---
 singularity-eos/eos/eos_eospac.hpp | 100 ++++++++++++++++++-----------
 1 file changed, 63 insertions(+), 37 deletions(-)

diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 3514de20ad..3c09944709 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -42,11 +42,9 @@ using namespace eos_base;
 // Only really works in serial
 // Not really supported on device
 #if defined(__CUDACC__)
-#define SG_PIF_NOWARN \
-#pragma nv_exec_check_disable \
-PORTABLE_INLINE_FUNCTION
+#define SG_PIF_NOWARN #pragma nv_exec_check_disable
 #else
-#define SG_PIF_NOWARN PORTABLE_INLINE_FUNCTION
+#define SG_PIF_NOWARN
 #endif
 
 class EOSPAC : public EosBase<EOSPAC> {
@@ -54,42 +52,56 @@ class EOSPAC : public EosBase<EOSPAC> {
   inline EOSPAC() = default;
   inline EOSPAC(int matid, bool invert_at_setup = false);
   inline EOSPAC GetOnDevice() { return *this; }
-  SG_PIF_NOWARN Real TemperatureFromDensityInternalEnergy(const Real rho, const Real sie,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real TemperatureFromDensityInternalEnergy(const Real rho, const Real sie,
                                                           Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real InternalEnergyFromDensityTemperature(const Real rho,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real InternalEnergyFromDensityTemperature(const Real rho,
                                                           const Real temperature,
                                                           Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real PressureFromDensityTemperature(const Real rho,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real PressureFromDensityTemperature(const Real rho,
                                                     const Real temperature,
                                                     Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real PressureFromDensityInternalEnergy(const Real rho, const Real sie,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real PressureFromDensityInternalEnergy(const Real rho, const Real sie,
                                                        Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real EntropyFromDensityTemperature(const Real rho, const Real temperature,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityTemperature(const Real rho, const Real temperature,
                                                    Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real EntropyFromDensityInternalEnergy(const Real rho, const Real sie,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityInternalEnergy(const Real rho, const Real sie,
                                                       Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real SpecificHeatFromDensityTemperature(const Real rho,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityTemperature(const Real rho,
                                                         const Real temperature,
                                                         Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real SpecificHeatFromDensityInternalEnergy(const Real rho, const Real sie,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityInternalEnergy(const Real rho, const Real sie,
                                                            Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real BulkModulusFromDensityTemperature(const Real rho,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityTemperature(const Real rho,
                                                        const Real temperature,
                                                        Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real BulkModulusFromDensityInternalEnergy(const Real rho, const Real sie,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityInternalEnergy(const Real rho, const Real sie,
                                                           Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real GruneisenParamFromDensityTemperature(const Real rho,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityTemperature(const Real rho,
                                                           const Real temperature,
                                                           Real *lambda = nullptr) const;
-  SG_PIF_NOWARN Real GruneisenParamFromDensityInternalEnergy(
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
-  SG_PIF_NOWARN void FillEos(Real &rho, Real &temp, Real &energy, Real &press, Real &cv,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION void FillEos(Real &rho, Real &temp, Real &energy, Real &press, Real &cv,
                              Real &bmod, const unsigned long output,
                              Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  void DensityEnergyFromPressureTemperature(const Real press, const Real temp,
+  PORTABLE_INLINE_FUNCTION void DensityEnergyFromPressureTemperature(const Real press, const Real temp,
                                             Real *lambda, Real &rho, Real &sie) const;
-  SG_PIF_NOWARN void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press,
+  SG_PIF_NOWARN
+  PORTABLE_INLINE_FUNCTION void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press,
                                             Real &cv, Real &bmod, Real &dpde, Real &dvdt,
                                             Real *lambda = nullptr) const;
 
@@ -674,7 +686,7 @@ class EOSPAC : public EosBase<EOSPAC> {
   }
 
   SG_PIF_NOWARN
-  void PTofRE(Real &rho, Real &sie, Real *lambda, Real &press, Real &temp, Real &dpdr,
+  PORTABLE_INLINE_FUNCTION void PTofRE(Real &rho, Real &sie, Real *lambda, Real &press, Real &temp, Real &dpdr,
               Real &dpde, Real &dtdr, Real &dtde) const {
 
     press = PressureFromDensityInternalEnergy(rho, sie, lambda);
@@ -710,11 +722,11 @@ class EOSPAC : public EosBase<EOSPAC> {
   }
 
   static constexpr unsigned long PreferredInput() { return _preferred_input; }
-  SG_PIF_NOWARN int nlambda() const noexcept { return 0; }
+  PORTABLE_INLINE_FUNCTION int nlambda() const noexcept { return 0; }
   inline void Finalize() {}
   static std::string EosType() { return std::string("EOSPAC"); }
   static std::string EosPyType() { return EosType(); }
-  SG_PIF_NOWARN void PrintParams() const {
+  PORTABLE_INLINE_FUNCTION void PrintParams() const {
     printf("EOSPAC parameters:\nmatid = %i\n", matid_);
   }
   PORTABLE_FORCEINLINE_FUNCTION Real MinimumDensity() const { return rho_min_; }
@@ -810,7 +822,8 @@ inline EOSPAC::EOSPAC(const int matid, bool invert_at_setup) : matid_(matid) {
       robust::ratio(dpde_ref_ * cv_ref_, rho_ref_ * rho_ref_ * pressureFromSesame(DPDR));
 }
 
-SG_PIF_NOWARN Real EOSPAC::TemperatureFromDensityInternalEnergy(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(const Real rho,
                                                                 const Real sie,
                                                                 Real *lambda) const {
   using namespace EospacWrapper;
@@ -821,7 +834,8 @@ SG_PIF_NOWARN Real EOSPAC::TemperatureFromDensityInternalEnergy(const Real rho,
   return Real(temperatureFromSesame(T[0]));
 }
 
-SG_PIF_NOWARN Real EOSPAC::PressureFromDensityTemperature(const Real rho, const Real temp,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(const Real rho, const Real temp,
                                                           Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, P[1], T[1] = {temperatureToSesame(temp)}, dPdr[1], dPdT[1];
@@ -831,14 +845,16 @@ SG_PIF_NOWARN Real EOSPAC::PressureFromDensityTemperature(const Real rho, const
   return Real(pressureFromSesame(P[0]));
 }
 
-SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityTemperature(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityTemperature(const Real rho,
                                                          const Real temperature,
                                                          Real *lambda) const {
   EntropyIsNotEnabled("EOSPAC");
   return 1.0;
 }
 
-SG_PIF_NOWARN void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press,
                                    Real &cv, Real &bmod, const unsigned long output,
                                    Real *lambda) const {
   using namespace EospacWrapper;
@@ -920,7 +936,8 @@ SG_PIF_NOWARN void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press
   }
 }
 
-SG_PIF_NOWARN Real EOSPAC::InternalEnergyFromDensityTemperature(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(const Real rho,
                                                                 const Real temp,
                                                                 Real *lambda) const {
   using namespace EospacWrapper;
@@ -929,7 +946,8 @@ SG_PIF_NOWARN Real EOSPAC::InternalEnergyFromDensityTemperature(const Real rho,
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return sie;
 }
-SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityTemperature(const Real rho,
+SG_PIF_NOWARN 
+PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(const Real rho,
                                                              const Real temp,
                                                              Real *lambda) const {
   using namespace EospacWrapper;
@@ -938,7 +956,8 @@ SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityTemperature(const Real rho,
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return bmod;
 }
-SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityTemperature(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(const Real rho,
                                                               const Real temp,
                                                               Real *lambda) const {
   using namespace EospacWrapper;
@@ -947,28 +966,32 @@ SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityTemperature(const Real rho,
   FillEos(RHO, TEMP, sie, press, cv, bmod, output, lambda);
   return cv;
 }
-SG_PIF_NOWARN Real EOSPAC::PressureFromDensityInternalEnergy(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(const Real rho,
                                                              const Real sie,
                                                              Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return PressureFromDensityTemperature(rho, temp, lambda);
 }
-SG_PIF_NOWARN Real EOSPAC::EntropyFromDensityInternalEnergy(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(const Real rho,
                                                             const Real sie,
                                                             Real *lambda) const {
   using namespace EospacWrapper;
   const Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return EntropyFromDensityTemperature(rho, temp, lambda);
 }
-SG_PIF_NOWARN Real EOSPAC::SpecificHeatFromDensityInternalEnergy(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(const Real rho,
                                                                  const Real sie,
                                                                  Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return SpecificHeatFromDensityTemperature(rho, temp, lambda);
 }
-SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityInternalEnergy(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(const Real rho,
                                                                 const Real sie,
                                                                 Real *lambda) const {
   using namespace EospacWrapper;
@@ -976,7 +999,8 @@ SG_PIF_NOWARN Real EOSPAC::BulkModulusFromDensityInternalEnergy(const Real rho,
   return BulkModulusFromDensityTemperature(rho, temp, lambda);
 }
 
-SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityTemperature(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(const Real rho,
                                                                 const Real temperature,
                                                                 Real *lambda) const {
   using namespace EospacWrapper;
@@ -993,7 +1017,8 @@ SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityTemperature(const Real rho,
   DPDE = DPDT / DEDT;
   return robust::ratio(pressureFromSesame(sieToSesame(DPDE)), rho);
 }
-SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityInternalEnergy(const Real rho,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(const Real rho,
                                                                    const Real sie,
                                                                    Real *lambda) const {
   Real temperature = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
@@ -1001,7 +1026,7 @@ SG_PIF_NOWARN Real EOSPAC::GruneisenParamFromDensityInternalEnergy(const Real rh
 }
 
 SG_PIF_NOWARN
-void EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real temp,
+PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real temp,
                                                   Real *lambda, Real &rho,
                                                   Real &sie) const {
   using namespace EospacWrapper;
@@ -1021,7 +1046,8 @@ void EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real t
   sie = sieFromSesame(E[0]);
 }
 
-SG_PIF_NOWARN void EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION void EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
                                                   Real &press, Real &cv, Real &bmod,
                                                   Real &dpde, Real &dvdt,
                                                   Real *lambda) const {

From 30de7d39c8cad87a543b4e27fbd79ba7705fe3dc Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Wed, 26 Apr 2023 15:58:20 -0600
Subject: [PATCH 15/45] Removed commented out code, get rid of warnings, try to
 improve compile time.

---
 singularity-eos/closure/mixed_cell_models.hpp |  12 +-
 singularity-eos/eos/eos_eospac.hpp            |   4 +-
 singularity-eos/eos/get_sg_eos.cpp            | 238 ++----------------
 singularity-eos/eos/get_sg_eos_rho_p.cpp      |   2 +-
 4 files changed, 23 insertions(+), 233 deletions(-)

diff --git a/singularity-eos/closure/mixed_cell_models.hpp b/singularity-eos/closure/mixed_cell_models.hpp
index e9c2b8d210..142873a6b0 100644
--- a/singularity-eos/closure/mixed_cell_models.hpp
+++ b/singularity-eos/closure/mixed_cell_models.hpp
@@ -206,7 +206,7 @@ class PTESolverBase {
     Cache = CacheAccessor(AssignIncrement(scratch, nmat * MAX_NUM_LAMBDAS));
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
+  PORTABLE_INLINE_FUNCTION
   void InitRhoBarandRho() {
     // rhobar is a fixed quantity: the average density of
     // material m averaged over the full PTE volume
@@ -217,7 +217,7 @@ class PTESolverBase {
     }
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
+  PORTABLE_INLINE_FUNCTION
   void SetVfracFromT(const Real T) {
     Real vsum = 0.0;
     // set volume fractions
@@ -233,7 +233,7 @@ class PTESolverBase {
     }
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
+  PORTABLE_INLINE_FUNCTION
   Real GetTguess() {
     // guess some non-zero temperature to start
     // If a guess was passed in, it's saved in Tnorm
@@ -272,9 +272,9 @@ class PTESolverBase {
     return Tguess;
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
-  static Real GetPressureFromPreferred(const EOS &eos, const Real rho, const Real T,
-                                       Real sie, Real *lambda, const bool do_e_lookup) {
+  PORTABLE_INLINE_FUNCTION
+  Real GetPressureFromPreferred(const EOS &eos, const Real rho, const Real T,
+                                       Real sie, Real *lambda, const bool do_e_lookup) const {
     Real P{};
     if (eos.PreferredInput() ==
         (thermalqs::density | thermalqs::specific_internal_energy)) {
diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index 3c09944709..cc8e04ebdd 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -862,7 +862,7 @@ PORTABLE_INLINE_FUNCTION void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
   EOS_REAL E[1] = {sie}, P[1] = {pressureToSesame(press)};
   EOS_REAL dx[1], dy[1];
   EOS_INTEGER nxypairs = 1;
-  Real CV, BMOD_T, BMOD, SIE, PRESS, DPDE, DPDT, DPDR, DEDT, DEDR;
+  Real /*CV,*/ BMOD_T, BMOD, SIE, PRESS, DPDE, DPDT, DPDR, DEDT, DEDR;
   const unsigned long input = ~output;
   if (output == thermalqs::none) {
     UNDEFINED_ERROR;
@@ -1034,7 +1034,7 @@ PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(const
   EOS_REAL T[1] = {temperatureToSesame(temp)};
   EOS_REAL dx[1], dy[1], R[1], E[1];
   EOS_INTEGER nxypairs = 1;
-  EOS_INTEGER errorCode;
+  //EOS_INTEGER errorCode;
   EOS_INTEGER table;
 
   table = RofPT_table_;
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 5c2b39603a..2e2f03b44e 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -68,12 +68,10 @@ int get_sg_eos( // sizing information
     RHO_E_INPUT = 1
   };
   const auto input{EAPInputToBD.at(input_int)};
-  const auto output = thermalqs::all_values - input;
   const bool p_is_inp{static_cast<bool>(input & thermalqs::pressure)};
   const bool r_is_inp{static_cast<bool>(input & thermalqs::density)};
   const bool t_is_inp{static_cast<bool>(input & thermalqs::temperature)};
   const bool s_is_inp{static_cast<bool>(input & thermalqs::specific_internal_energy)};
-  constexpr const Real min_guess_density{1.e-20};
 #ifdef PORTABILITY_STRATEGY_KOKKOS
   // convert pointers to host side views
   Kokkos::View<int *, Llft, HS, Unmgd> eos_offsets_hv(eos_offsets, nmat);
@@ -146,8 +144,8 @@ int get_sg_eos( // sizing information
   ScratchV<double> solver_scratch;
 
   // create helper lambdas to reduce code duplication
-  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
-  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+  //const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
+  //const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   Kokkos::View<int, MemoryTraits<at_int>> res("PTE::num fails");
   Kokkos::View<int, MemoryTraits<at_int>> n_solves("PTE::num solves");
   const std::string perf_nums =
@@ -170,60 +168,6 @@ int get_sg_eos( // sizing information
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
         do_frac_bmod, do_frac_dpde, do_frac_cv);
-    //    portableFor(
-    //        rt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-    //          // cell offset
-    //          const int i{offsets_v(iloop) - 1};
-    //          // get "thread-id" like thing with optimization
-    //          // for small loops
-    //          const int32_t token{tokens.acquire()};
-    //          const int32_t tid{small_loop ? iloop : token};
-    //          double mass_sum{0.0};
-    //          int npte{0};
-    //          // initialize values for solver / lookup
-    //          init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
-    //          // calculate pte condition (lookup for 1 mat cell)
-    //          Real sie_tot_true{0.0};
-    //          const int neq = npte;
-    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-    //                                                     neq * (neq + 4) + 2 * npte);
-    //          if (npte > 1) {
-    //            // create solver lambda
-    //            // eos accessor
-    //            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-    //            PTESolverFixedT<singularity::EOSAccessor_, Real *, Real **> method(
-    //                npte, eos_inx, 1.0, temp_pte(tid, 0), &rho_pte(tid, 0),
-    //                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-    //                &press_pte(tid, 0), cache, &solver_scratch(tid, 0));
-    //            const bool res_{PTESolver(method)};
-    //            // calculate total internal energy
-    //            for (int mp = 0; mp < npte; ++mp) {
-    //              const int m = pte_mats(tid, mp);
-    //              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-    //            }
-    //          } else {
-    //            // pure cell (nmat = 1)
-    //            // calculate sie from single eos
-    //            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-    //                                  .InternalEnergyFromDensityTemperature(
-    //                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
-    //            // set total sie to material 0 value
-    //            sie_tot_true = sie_pte(tid, 0);
-    //            // set pressure
-    //            press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-    //                                    .PressureFromDensityTemperature(
-    //                                        rho_pte(tid, 0), temp_pte(tid, 0),
-    //                                        cache[0]);
-    //          }
-    //          // total sie is known
-    //          sie_v(i) = sie_tot_true;
-    //          // assign quantities
-    //          final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
-    //          // assign max pressure
-    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-    //          // release the token used for scratch arrays
-    //          tokens.release(token);
-    //        });
     break;
   }
   case input_condition::RHO_P_INPUT: {
@@ -242,70 +186,6 @@ int get_sg_eos( // sizing information
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
         do_frac_bmod, do_frac_dpde, do_frac_cv);
-    //    portableFor(
-    //        rp_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-    //          // cell offset
-    //          const int i{offsets_v(iloop) - 1};
-    //          // get "thread-id" like thing with optimization
-    //          // for small loops
-    //          const int32_t token{tokens.acquire()};
-    //          const int32_t tid{small_loop ? iloop : token};
-    //          double mass_sum{0.0};
-    //          int npte{0};
-    //          // initialize values for solver / lookup
-    //          init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
-    //          Real sie_tot_true{0.0};
-    //          const int neq = npte + 1;
-    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-    //                                                     neq * (neq + 4) + 2 * npte);
-    //          if (npte > 1) {
-    //            // create solver lambda
-    //            // eos accessor
-    //            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-    //            PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
-    //                npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0),
-    //                &vfrac_pte(tid, 0), &sie_pte(tid, 0), &temp_pte(tid, 0),
-    //                &press_pte(tid, 0), cache[0], &solver_scratch(tid, 0));
-    //            const bool res_{PTESolver(method)};
-    //            // calculate total sie
-    //            for (int mp = 0; mp < npte; ++mp) {
-    //              const int m = pte_mats(tid, mp);
-    //              sie_tot_true += sie_pte(tid, mp) * frac_mass_v(i, m);
-    //            }
-    //          } else {
-    //            // pure cell (nmat = 1)
-    //            // calculate sie from single eos
-    //            auto p_from_t = [&](const Real &t_i) {
-    //              return eos_v(pte_idxs(tid, 0))
-    //                  .PressureFromDensityTemperature(rho_pte(tid, 0), t_i, cache[0]);
-    //            };
-    //            // calculate sie root bounds
-    //            Real r_rho{}, r_temp{}, r_sie{}, r_press{}, r_cv{}, r_bmod{};
-    //            Real r_dpde{}, r_dvdt{};
-    //            eos_v(pte_idxs(tid, 0))
-    //                .ValuesAtReferenceState(r_rho, r_temp, r_sie, r_press, r_cv, r_bmod,
-    //                                        r_dpde, r_dvdt);
-    //            Real temp_i;
-    //            RootFinding1D::findRoot(p_from_t, press_v(i), r_temp, 1.e-10 * r_temp,
-    //                                    1.e10 * r_temp, 1.e-12, 1.e-12, temp_i);
-    //            sie_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-    //                                  .InternalEnergyFromDensityTemperature(rho_pte(tid,
-    //                                  0),
-    //                                                                        temp_i,
-    //                                                                        cache[0]);
-    //            sie_tot_true = sie_pte(tid, 0);
-    //            // set temperature
-    //            temp_pte(tid, 0) = temp_i;
-    //          }
-    //          // sie calculate explicitly already
-    //          sie_v(i) = sie_tot_true;
-    //          // assign remaining outputs
-    //          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
-    //          // assign max pressure
-    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-    //          // release the token used for scratch arrays
-    //          tokens.release(token);
-    //        });
     break;
   }
   case input_condition::P_T_INPUT: {
@@ -320,62 +200,6 @@ int get_sg_eos( // sizing information
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
         do_frac_bmod, do_frac_dpde, do_frac_cv);
-    //    portableFor(
-    //        pt_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-    //          // cell offset
-    //          const int i{offsets_v(iloop) - 1};
-    //          // get "thread-id" like thing with optimization
-    //          // for small loops
-    //          const int32_t token{tokens.acquire()};
-    //          const int32_t tid{small_loop ? iloop : token};
-    //          // caching mechanism
-    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0));
-    //          double mass_sum{0.0};
-    //          // normalize mass fractions
-    //          // first find the mass sum
-    //          // also set idxs as the decrement of the eos offsets
-    //          // to take into account 1 based indexing in fortran
-    //          for (int m = 0; m < nmat; ++m) {
-    //            mass_sum += frac_mass_v(i, m);
-    //            pte_idxs(tid, m) = eos_offsets_v(m) - 1;
-    //            pte_mats(tid, m) = m;
-    //            temp_pte(tid, m) = temp_v(i) * ev2k;
-    //            press_pte(tid, m) = press_v(i);
-    //          }
-    //          for (int m = 0; m < nmat; ++m) {
-    //            frac_mass_v(i, m) /= mass_sum;
-    //          }
-    //          // do r-e of pt for each mat
-    //          singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-    //          Real vfrac_tot{0.0};
-    //          Real sie_tot{0.0};
-    //          for (int m = 0; m < nmat; ++m) {
-    //            // obtain rho and sie from P-T
-    //            eos_inx[m].DensityEnergyFromPressureTemperature(
-    //                press_pte(tid, m), temp_pte(tid, m), cache[m], rho_pte(tid, m),
-    //                sie_pte(tid, m));
-    //            // assign volume fractions
-    //            // this is a physical volume
-    //            vfrac_pte(tid, m) = frac_mass_v(i, m) / rho_pte(tid, m) * mass_sum;
-    //            vfrac_tot += vfrac_pte(tid, m);
-    //            // add internal energy component
-    //            sie_tot += sie_pte(tid, m) * frac_mass_v(i, m);
-    //          }
-    //          // assign volume, etc.
-    //          // total sie is known
-    //          sie_v(i) = sie_tot;
-    //          vol_v(i) = vfrac_tot;
-    //          spvol_v(i) = vol_v(i) / mass_sum;
-    //          for (int m = 0; m < nmat; ++m) {
-    //            vfrac_pte(tid, m) /= vfrac_tot;
-    //          }
-    //          // assign remaining outputs
-    //          final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
-    //          // assign max pressure
-    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-    //          // release the token used for scratch arrays
-    //          tokens.release(token);
-    //        });
     break;
   }
   case input_condition::NORM_RHO_E_INPUT:
@@ -393,48 +217,6 @@ int get_sg_eos( // sizing information
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
         do_frac_bmod, do_frac_dpde, do_frac_cv);
-    //    portableFor(
-    //        re_name.c_str(), 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
-    //          // cell offset
-    //          const int i{offsets_v(iloop) - 1};
-    //          // get "thread-id" like thing with optimization
-    //          // for small loops
-    //          const int32_t token{tokens.acquire()};
-    //          const int32_t tid{small_loop ? iloop : token};
-    //          double mass_sum{0.0};
-    //          int npte{0};
-    //          // initialize values for solver / lookup
-    //          init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
-    //          // get cache from offsets into scratch
-    //          const int neq = npte + 1;
-    //          singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
-    //                                                     neq * (neq + 4) + 2 * npte);
-    //          if (npte > 1) {
-    //            // create solver lambda
-    //            // eos accessor
-    //            singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-    //            // reset inputs
-    //            PTESolverRhoT<singularity::EOSAccessor_, Real *, Real **> method(
-    //                npte, eos_inx, 1.0, sie_v(i), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
-    //                &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache,
-    //                &solver_scratch(tid, 0));
-    //            const bool res_{PTESolver(method)};
-    //          } else {
-    //            // pure cell (nmat = 1)
-    //            // calculate sie from single eos
-    //            Real dpdr_m, dtdr_m, dpde_m, dtde_m;
-    //            eos_v(pte_idxs(tid, 0))
-    //                .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid,
-    //                0),
-    //                        temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
-    //          }
-    //          // assign outputs
-    //          final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
-    //          // assign max pressure
-    //          pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
-    //          // release the token used for scratch arrays
-    //          tokens.release(token);
-    //        });
     break;
   }
   }
@@ -446,17 +228,25 @@ int get_sg_eos( // sizing information
   // this is the return value (number of solve failures)
   deep_copy(ret, res);
   // copy pressure, this is not needed in all cases
-  deep_copy(press_hv, press_v);
+  if (!p_is_inp) {
+    deep_copy(press_hv, press_v);
+  }
   // return max pressure, this may be needed
   deep_copy(pmax_hv, pmax_v);
   // I don't think the volume is necessary
   deep_copy(vol_hv, vol_v);
   // specific volume, copy-back not needed in all cases
-  deep_copy(spvol_hv, spvol_v);
+  if (!r_is_inp) {
+    deep_copy(spvol_hv, spvol_v);
+  }
   // internal energy, copy-back not needed in all cases
-  deep_copy(sie_hv, sie_v);
+  if (!s_is_inp) {
+    deep_copy(sie_hv, sie_v);
+  }
   // temperature, copy-back not needed in all cases
-  deep_copy(temp_hv, temp_v);
+  if (!t_is_inp) {
+    deep_copy(temp_hv, temp_v);
+  }
   // bulk modulus, alwasy copy-back
   deep_copy(bmod_hv, bmod_v);
   // dpde, always copy-back
diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
index a3990d7ede..12c0dc023d 100644
--- a/singularity-eos/eos/get_sg_eos_rho_p.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -55,7 +55,7 @@ void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offs
           // create solver lambda
           // eos accessor
           singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-          PTESolverFixedP<singularity::EOSAccessor_, Real *, Real **> method(
+          PTESolverFixedP<singularity::EOSAccessor_, Real *, Real *, decltype(cache)> method(
               npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
               &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache[0],
               &solver_scratch(tid, 0));

From 53ef4db46286244f5ae81698d9eee424a6d58929 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 13:28:29 -0600
Subject: [PATCH 16/45] Remove rdc references in spackages and cmake files.

---
 cmake/submodule_configs.cmake                  | 1 -
 spack-repo/packages/singularity-eos/package.py | 2 +-
 spack-repo/packages/spiner/package.py          | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/cmake/submodule_configs.cmake b/cmake/submodule_configs.cmake
index 303df4414b..64d4502b71 100644
--- a/cmake/submodule_configs.cmake
+++ b/cmake/submodule_configs.cmake
@@ -23,7 +23,6 @@ macro(singularity_cmake_config pkg)
     if(SINGULARITY_USE_CUDA)
       set(Kokkos_ENABLE_CUDA ON CACHE BOOL "" FORCE)
       set(Kokkos_ENABLE_CUDA_LAMBDA ON CACHE BOOL "" FORCE)
-      set(Kokkos_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE ON CACHE BOOL "" FORCE)
     endif()
   elseif(${pkg} STREQUAL "KokkosKernels")
     # Disable TPLs
diff --git a/spack-repo/packages/singularity-eos/package.py b/spack-repo/packages/singularity-eos/package.py
index d8045c1f96..27c398fcd1 100644
--- a/spack-repo/packages/singularity-eos/package.py
+++ b/spack-repo/packages/singularity-eos/package.py
@@ -84,7 +84,7 @@ class SingularityEos(CMakePackage, CudaPackage):
         depends_on("spiner" + _flag, when="+kokkos" + _flag)
 
     # specfic specs when using GPU/cuda offloading
-    depends_on("kokkos +wrapper+cuda_lambda+cuda_relocatable_device_code", when="+cuda+kokkos")
+    depends_on("kokkos +wrapper+cuda_lambda", when="+cuda+kokkos")
 
     # fix for older spacks
     if spack.version.Version(spack.spack_version) >= spack.version.Version("0.17"):
diff --git a/spack-repo/packages/spiner/package.py b/spack-repo/packages/spiner/package.py
index 783d0e1b87..69574745bf 100644
--- a/spack-repo/packages/spiner/package.py
+++ b/spack-repo/packages/spiner/package.py
@@ -43,7 +43,7 @@ class Spiner(CMakePackage, CudaPackage):
         depends_on("kokkos@3.3.00: cuda_arch=" + _flag, when="+cuda+kokkos cuda_arch=" + _flag)
     for _flag in ("~cuda", "+cuda", "~openmp", "+openmp"):
         depends_on("kokkos@3.3.00: " + _flag, when="+kokkos" + _flag)
-    depends_on("kokkos@3.3.00: ~shared+wrapper+cuda_lambda+cuda_constexpr+cuda_relocatable_device_code", when="+cuda+kokkos")
+    depends_on("kokkos@3.3.00: ~shared+wrapper+cuda_lambda+cuda_constexpr", when="+cuda+kokkos")
 
     depends_on("hdf5+hl~mpi", when="+hdf5~mpi")
     depends_on("hdf5+hl+mpi", when="+hdf5+mpi")

From cf23fd5c5043146cbfa41145a4411fb2d5836eac Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 13:34:26 -0600
Subject: [PATCH 17/45] Make modifier checking/modification functionality
 inline constexpr to remove warnings.

---
 singularity-eos/eos/eos_base.hpp                 | 16 +++++++++-------
 singularity-eos/eos/eos_variant.hpp              | 11 +++++------
 singularity-eos/eos/modifiers/eos_unitsystem.hpp | 11 +++++------
 singularity-eos/eos/modifiers/ramps_eos.hpp      | 11 +++++------
 .../eos/modifiers/relativistic_eos.hpp           | 11 +++++------
 singularity-eos/eos/modifiers/scaled_eos.hpp     | 11 +++++------
 singularity-eos/eos/modifiers/shifted_eos.hpp    | 11 +++++------
 7 files changed, 39 insertions(+), 43 deletions(-)

diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index 72b9eda1b2..28be264955 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -80,7 +80,10 @@ char *StrCat(char *destination, const char *source) {
   using EosBase<EOSDERIVED>::FillEos;                                                    \
   using EosBase<EOSDERIVED>::EntropyFromDensityTemperature;                              \
   using EosBase<EOSDERIVED>::EntropyFromDensityInternalEnergy;                           \
-  using EosBase<EOSDERIVED>::EntropyIsNotEnabled;
+  using EosBase<EOSDERIVED>::EntropyIsNotEnabled;                                        \
+  using EosBase<EOSDERIVED>::IsModified;                                                 \
+  using EosBase<EOSDERIVED>::UnmodifyOnce;                                               \
+  using EosBase<EOSDERIVED>::GetUnmodifiedObject;
 
 /*
 This is a CRTP that allows for static inheritance so that default behavior for
@@ -426,12 +429,11 @@ class EosBase {
   }
 
   // Tooling for modifiers
-  PORTABLE_FORCEINLINE_FUNCTION
-  bool IsModified() const { return false; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  auto UnmodifyOnce() { return *static_cast<CRTP *>(this); }
-  PORTABLE_FORCEINLINE_FUNCTION
-  auto GetUnmodifiedObject() { return *static_cast<CRTP *>(this); }
+  inline constexpr bool IsModified() const { return false; }
+
+  inline constexpr decltype(auto) UnmodifyOnce() { return *static_cast<CRTP *>(this); }
+
+  inline constexpr decltype(auto) GetUnmodifiedObject() { return *static_cast<CRTP *>(this); }
 };
 } // namespace eos_base
 } // namespace singularity
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index 2d8eeedfa8..0f1ae014cf 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -841,17 +841,16 @@ class Variant {
   }
 
   // Tooling for modifiers
-  PORTABLE_FORCEINLINE_FUNCTION
-  bool IsModified() const {
+  inline constexpr bool IsModified() const {
     return mpark::visit([](const auto &eos) { return eos.IsModified(); }, eos_);
   }
-  PORTABLE_FORCEINLINE_FUNCTION
-  Variant UnmodifyOnce() {
+
+  inline constexpr Variant UnmodifyOnce() {
     return mpark::visit(
         [](auto &eos) { return eos_variant<EOSs...>(eos.UnmodifyOnce()); }, eos_);
   }
-  PORTABLE_FORCEINLINE_FUNCTION
-  Variant GetUnmodifiedObject() {
+
+  inline constexpr Variant GetUnmodifiedObject() {
     return mpark::visit(
         [](auto &eos) { return eos_variant<EOSs...>(eos.GetUnmodifiedObject()); }, eos_);
   }
diff --git a/singularity-eos/eos/modifiers/eos_unitsystem.hpp b/singularity-eos/eos/modifiers/eos_unitsystem.hpp
index df998a161e..d10277362b 100644
--- a/singularity-eos/eos/modifiers/eos_unitsystem.hpp
+++ b/singularity-eos/eos/modifiers/eos_unitsystem.hpp
@@ -270,12 +270,11 @@ class UnitSystem : public EosBase<UnitSystem<T>> {
     printf("Units = %e %e %e %e\n", rho_unit_, sie_unit_, temp_unit_, press_unit_);
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
-  bool IsModified() const { return true; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  T UnmodifyOnce() { return t_; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  auto GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr bool IsModified() const { return true; }
+
+  inline constexpr T UnmodifyOnce() { return t_; }
+
+  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/ramps_eos.hpp b/singularity-eos/eos/modifiers/ramps_eos.hpp
index 973f819bf2..fd6ce3309d 100644
--- a/singularity-eos/eos/modifiers/ramps_eos.hpp
+++ b/singularity-eos/eos/modifiers/ramps_eos.hpp
@@ -258,12 +258,11 @@ class BilinearRampEOS : public EosBase<BilinearRampEOS<T>> {
   // Vector functions that overload the scalar versions declared here.
   SG_ADD_BASE_CLASS_USINGS(BilinearRampEOS<T>)
 
-  PORTABLE_FORCEINLINE_FUNCTION
-  bool IsModified() const { return true; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  T UnmodifyOnce() { return t_; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  auto GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr bool IsModified() const { return true; }
+
+  inline constexpr T UnmodifyOnce() { return t_; }
+
+  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/relativistic_eos.hpp b/singularity-eos/eos/modifiers/relativistic_eos.hpp
index e1fe0b5fa7..0365696d27 100644
--- a/singularity-eos/eos/modifiers/relativistic_eos.hpp
+++ b/singularity-eos/eos/modifiers/relativistic_eos.hpp
@@ -185,12 +185,11 @@ class RelativisticEOS : public EosBase<RelativisticEOS<T>> {
     t_.ValuesAtReferenceState(rho, temp, sie, press, cv, bmod, dpde, dvdt, lambda);
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
-  bool IsModified() const { return true; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  T UnmodifyOnce() { return t_; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  auto GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr bool IsModified() const { return true; }
+
+  inline constexpr T UnmodifyOnce() { return t_; }
+
+  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/scaled_eos.hpp b/singularity-eos/eos/modifiers/scaled_eos.hpp
index 9f5605302d..5f1f2077e5 100644
--- a/singularity-eos/eos/modifiers/scaled_eos.hpp
+++ b/singularity-eos/eos/modifiers/scaled_eos.hpp
@@ -202,12 +202,11 @@ class ScaledEOS : public EosBase<ScaledEOS<T>> {
     return t_.MinimumTemperature();
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
-  bool IsModified() const { return true; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  T UnmodifyOnce() { return t_; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  auto GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr bool IsModified() const { return true; }
+
+  inline constexpr T UnmodifyOnce() { return t_; }
+
+  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/shifted_eos.hpp b/singularity-eos/eos/modifiers/shifted_eos.hpp
index 822f1d260c..ac0d3af05f 100644
--- a/singularity-eos/eos/modifiers/shifted_eos.hpp
+++ b/singularity-eos/eos/modifiers/shifted_eos.hpp
@@ -192,12 +192,11 @@ class ShiftedEOS : public EosBase<ShiftedEOS<T>> {
     return t_.MinimumTemperature();
   }
 
-  PORTABLE_FORCEINLINE_FUNCTION
-  bool IsModified() const { return true; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  T UnmodifyOnce() { return t_; }
-  PORTABLE_FORCEINLINE_FUNCTION
-  auto GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr bool IsModified() const { return true; }
+
+  inline constexpr T UnmodifyOnce() { return t_; }
+
+  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
 
  private:
   T t_;

From e196b553e93ec16b6c443fd2b6a2e400662f6ef7 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 14:03:42 -0600
Subject: [PATCH 18/45] Reverting template parameters, this change was an
 incorrect change.

---
 singularity-eos/eos/get_sg_eos_rho_p.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
index 12c0dc023d..6c9239d657 100644
--- a/singularity-eos/eos/get_sg_eos_rho_p.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -55,7 +55,7 @@ void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offs
           // create solver lambda
           // eos accessor
           singularity::EOSAccessor_ eos_inx(eos_v, &pte_idxs(tid, 0));
-          PTESolverFixedP<singularity::EOSAccessor_, Real *, Real *, decltype(cache)> method(
+          PTESolverFixedP<singularity::EOSAccessor_, Real *, Real *> method(
               npte, eos_inx, 1.0, press_pte(tid, 0), &rho_pte(tid, 0), &vfrac_pte(tid, 0),
               &sie_pte(tid, 0), &temp_pte(tid, 0), &press_pte(tid, 0), cache[0],
               &solver_scratch(tid, 0));

From be1268d7d2c21508dbd76a4f92e2ba6c9d99087c Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 14:14:35 -0600
Subject: [PATCH 19/45] Using execution space arguments for deep copies. This
 may not improve performance in this case, but it demonstrates correct usage
 and paves the way for future streams usaged via kokkos partition space.

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

diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 2e2f03b44e..daf7f38e5d 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -226,46 +226,46 @@ int get_sg_eos( // sizing information
   // there is lots of room for performance optimization
   // in terms of when to copy and when not necessary
   // this is the return value (number of solve failures)
-  deep_copy(ret, res);
+  //deep_copy(ret, res);
   // copy pressure, this is not needed in all cases
   if (!p_is_inp) {
-    deep_copy(press_hv, press_v);
+    deep_copy(DES(), press_hv, press_v);
   }
   // return max pressure, this may be needed
-  deep_copy(pmax_hv, pmax_v);
+  deep_copy(DES(), pmax_hv, pmax_v);
   // I don't think the volume is necessary
-  deep_copy(vol_hv, vol_v);
+  deep_copy(DES(), vol_hv, vol_v);
   // specific volume, copy-back not needed in all cases
   if (!r_is_inp) {
-    deep_copy(spvol_hv, spvol_v);
+    deep_copy(DES(), spvol_hv, spvol_v);
   }
   // internal energy, copy-back not needed in all cases
   if (!s_is_inp) {
-    deep_copy(sie_hv, sie_v);
+    deep_copy(DES(), sie_hv, sie_v);
   }
   // temperature, copy-back not needed in all cases
   if (!t_is_inp) {
-    deep_copy(temp_hv, temp_v);
+    deep_copy(DES(), temp_hv, temp_v);
   }
   // bulk modulus, alwasy copy-back
-  deep_copy(bmod_hv, bmod_v);
+  deep_copy(DES(), bmod_hv, bmod_v);
   // dpde, always copy-back
-  deep_copy(dpde_hv, dpde_v);
+  deep_copy(DES(), dpde_hv, dpde_v);
   // specific heat, always copy-back
-  deep_copy(cv_hv, cv_v);
+  deep_copy(DES(), cv_hv, cv_v);
   // volume fractions, always copy-back (maybe not for pure cells)
-  deep_copy(frac_vol_hv, frac_vol_v);
+  deep_copy(DES(), frac_vol_hv, frac_vol_v);
   // component internal energies, always copy-back (maybe not for pure cells)
-  deep_copy(frac_ie_hv, frac_ie_v);
+  deep_copy(DES(), frac_ie_hv, frac_ie_v);
   // optionally copy-back the component bmod, dpde, and cv
   if (do_frac_bmod) {
-    deep_copy(frac_bmod_hv, frac_bmod_v);
+    deep_copy(DES(), frac_bmod_hv, frac_bmod_v);
   }
   if (do_frac_dpde) {
-    deep_copy(frac_dpde_hv, frac_dpde_v);
+    deep_copy(DES(), frac_dpde_hv, frac_dpde_v);
   }
   if (do_frac_cv) {
-    deep_copy(frac_cv_hv, frac_cv_v);
+    deep_copy(DES(), frac_cv_hv, frac_cv_v);
   }
 #endif // PORTABILITY_STRATEGY_KOKKOS
   return ret;

From ecff45972dcdbd609b53bae8b791409954b33d82 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 14:23:14 -0600
Subject: [PATCH 20/45] Format

---
 singularity-eos/closure/mixed_cell_models.hpp |   4 +-
 singularity-eos/eos/eos_base.hpp              |   4 +-
 singularity-eos/eos/eos_eospac.hpp            | 156 ++++++++----------
 singularity-eos/eos/get_sg_eos.cpp            |   6 +-
 .../eos/modifiers/eos_unitsystem.hpp          |   4 +-
 singularity-eos/eos/modifiers/ramps_eos.hpp   |   4 +-
 .../eos/modifiers/relativistic_eos.hpp        |   4 +-
 singularity-eos/eos/modifiers/scaled_eos.hpp  |   4 +-
 singularity-eos/eos/modifiers/shifted_eos.hpp |   4 +-
 9 files changed, 95 insertions(+), 95 deletions(-)

diff --git a/singularity-eos/closure/mixed_cell_models.hpp b/singularity-eos/closure/mixed_cell_models.hpp
index 142873a6b0..4717273d0d 100644
--- a/singularity-eos/closure/mixed_cell_models.hpp
+++ b/singularity-eos/closure/mixed_cell_models.hpp
@@ -273,8 +273,8 @@ class PTESolverBase {
   }
 
   PORTABLE_INLINE_FUNCTION
-  Real GetPressureFromPreferred(const EOS &eos, const Real rho, const Real T,
-                                       Real sie, Real *lambda, const bool do_e_lookup) const {
+  Real GetPressureFromPreferred(const EOS &eos, const Real rho, const Real T, Real sie,
+                                Real *lambda, const bool do_e_lookup) const {
     Real P{};
     if (eos.PreferredInput() ==
         (thermalqs::density | thermalqs::specific_internal_energy)) {
diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index 28be264955..9cddb04c69 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -433,7 +433,9 @@ class EosBase {
 
   inline constexpr decltype(auto) UnmodifyOnce() { return *static_cast<CRTP *>(this); }
 
-  inline constexpr decltype(auto) GetUnmodifiedObject() { return *static_cast<CRTP *>(this); }
+  inline constexpr decltype(auto) GetUnmodifiedObject() {
+    return *static_cast<CRTP *>(this);
+  }
 };
 } // namespace eos_base
 } // namespace singularity
diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index a901c673d8..bea57cfdd6 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -53,57 +53,54 @@ class EOSPAC : public EosBase<EOSPAC> {
   inline EOSPAC(int matid, bool invert_at_setup = false);
   inline EOSPAC GetOnDevice() { return *this; }
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real TemperatureFromDensityInternalEnergy(const Real rho, const Real sie,
-                                                          Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real TemperatureFromDensityInternalEnergy(
+      const Real rho, const Real sie, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real InternalEnergyFromDensityTemperature(const Real rho,
-                                                          const Real temperature,
-                                                          Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real InternalEnergyFromDensityTemperature(
+      const Real rho, const Real temperature, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real PressureFromDensityTemperature(const Real rho,
-                                                    const Real temperature,
-                                                    Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real PressureFromDensityTemperature(
+      const Real rho, const Real temperature, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real PressureFromDensityInternalEnergy(const Real rho, const Real sie,
-                                                       Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real PressureFromDensityInternalEnergy(
+      const Real rho, const Real sie, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityTemperature(const Real rho, const Real temperature,
-                                                   Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityTemperature(
+      const Real rho, const Real temperature, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityInternalEnergy(const Real rho, const Real sie,
-                                                      Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real EntropyFromDensityInternalEnergy(
+      const Real rho, const Real sie, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityTemperature(const Real rho,
-                                                        const Real temperature,
-                                                        Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityTemperature(
+      const Real rho, const Real temperature, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityInternalEnergy(const Real rho, const Real sie,
-                                                           Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real SpecificHeatFromDensityInternalEnergy(
+      const Real rho, const Real sie, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityTemperature(const Real rho,
-                                                       const Real temperature,
-                                                       Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityTemperature(
+      const Real rho, const Real temperature, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityInternalEnergy(const Real rho, const Real sie,
-                                                          Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real BulkModulusFromDensityInternalEnergy(
+      const Real rho, const Real sie, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityTemperature(const Real rho,
-                                                          const Real temperature,
-                                                          Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityTemperature(
+      const Real rho, const Real temperature, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
   PORTABLE_INLINE_FUNCTION Real GruneisenParamFromDensityInternalEnergy(
       const Real rho, const Real sie, Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION void FillEos(Real &rho, Real &temp, Real &energy, Real &press, Real &cv,
-                             Real &bmod, const unsigned long output,
-                             Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION void FillEos(Real &rho, Real &temp, Real &energy, Real &press,
+                                        Real &cv, Real &bmod, const unsigned long output,
+                                        Real *lambda = nullptr) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION void DensityEnergyFromPressureTemperature(const Real press, const Real temp,
-                                            Real *lambda, Real &rho, Real &sie) const;
+  PORTABLE_INLINE_FUNCTION void
+  DensityEnergyFromPressureTemperature(const Real press, const Real temp, Real *lambda,
+                                       Real &rho, Real &sie) const;
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press,
-                                            Real &cv, Real &bmod, Real &dpde, Real &dvdt,
-                                            Real *lambda = nullptr) const;
+  PORTABLE_INLINE_FUNCTION void ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
+                                                       Real &press, Real &cv, Real &bmod,
+                                                       Real &dpde, Real &dvdt,
+                                                       Real *lambda = nullptr) const;
 
   // Generic (Scalar)
   template <typename RealIndexer, typename ConstRealIndexer, typename LambdaIndexer>
@@ -896,8 +893,9 @@ class EOSPAC : public EosBase<EOSPAC> {
   }
 
   SG_PIF_NOWARN
-  PORTABLE_INLINE_FUNCTION void PTofRE(Real &rho, Real &sie, Real *lambda, Real &press, Real &temp, Real &dpdr,
-              Real &dpde, Real &dtdr, Real &dtde) const {
+  PORTABLE_INLINE_FUNCTION void PTofRE(Real &rho, Real &sie, Real *lambda, Real &press,
+                                       Real &temp, Real &dpdr, Real &dpde, Real &dtdr,
+                                       Real &dtde) const {
 
     press = PressureFromDensityInternalEnergy(rho, sie, lambda);
     temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
@@ -1033,9 +1031,8 @@ inline EOSPAC::EOSPAC(const int matid, bool invert_at_setup) : matid_(matid) {
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(const Real rho,
-                                                                const Real sie,
-                                                                Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(
+    const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, E[1] = {sieToSesame(sie)}, T[1], dTdr[1], dTde[1];
   EOS_INTEGER nxypairs = 1;
@@ -1045,8 +1042,9 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::TemperatureFromDensityInternalEnergy(const
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(const Real rho, const Real temp,
-                                                          Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(const Real rho,
+                                                                     const Real temp,
+                                                                     Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, P[1], T[1] = {temperatureToSesame(temp)}, dPdr[1], dPdT[1];
   EOS_INTEGER nxypairs = 1;
@@ -1056,17 +1054,17 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityTemperature(const Real
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityTemperature(const Real rho,
-                                                         const Real temperature,
-                                                         Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityTemperature(
+    const Real rho, const Real temperature, Real *lambda) const {
   EntropyIsNotEnabled("EOSPAC");
   return 1.0;
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie, Real &press,
-                                   Real &cv, Real &bmod, const unsigned long output,
-                                   Real *lambda) const {
+PORTABLE_INLINE_FUNCTION void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
+                                              Real &press, Real &cv, Real &bmod,
+                                              const unsigned long output,
+                                              Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temp)};
   EOS_REAL E[1] = {sie}, P[1] = {pressureToSesame(press)};
@@ -1147,19 +1145,17 @@ PORTABLE_INLINE_FUNCTION void EOSPAC::FillEos(Real &rho, Real &temp, Real &sie,
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(const Real rho,
-                                                                const Real temp,
-                                                                Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::InternalEnergyFromDensityTemperature(
+    const Real rho, const Real temp, Real *lambda) const {
   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;
 }
-SG_PIF_NOWARN 
-PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(const Real rho,
-                                                             const Real temp,
-                                                             Real *lambda) const {
+SG_PIF_NOWARN
+PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(
+    const Real rho, const Real temp, Real *lambda) const {
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
   const unsigned long output = thermalqs::bulk_modulus;
@@ -1167,9 +1163,8 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityTemperature(const Re
   return bmod;
 }
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(const Real rho,
-                                                              const Real temp,
-                                                              Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(
+    const Real rho, const Real temp, Real *lambda) const {
   using namespace EospacWrapper;
   Real RHO = rho, TEMP = temp, sie, press, cv, bmod;
   const unsigned long output = thermalqs::specific_heat;
@@ -1177,42 +1172,37 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityTemperature(const R
   return cv;
 }
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(const Real rho,
-                                                             const Real sie,
-                                                             Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::PressureFromDensityInternalEnergy(
+    const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return PressureFromDensityTemperature(rho, temp, lambda);
 }
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(const Real rho,
-                                                            const Real sie,
-                                                            Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::EntropyFromDensityInternalEnergy(
+    const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   const Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return EntropyFromDensityTemperature(rho, temp, lambda);
 }
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(const Real rho,
-                                                                 const Real sie,
-                                                                 Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::SpecificHeatFromDensityInternalEnergy(
+    const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return SpecificHeatFromDensityTemperature(rho, temp, lambda);
 }
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(const Real rho,
-                                                                const Real sie,
-                                                                Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::BulkModulusFromDensityInternalEnergy(
+    const Real rho, const Real sie, Real *lambda) const {
   using namespace EospacWrapper;
   Real temp = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return BulkModulusFromDensityTemperature(rho, temp, lambda);
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(const Real rho,
-                                                                const Real temperature,
-                                                                Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(
+    const Real rho, const Real temperature, Real *lambda) const {
   using namespace EospacWrapper;
   EOS_REAL R[1] = {rho}, T[1] = {temperatureToSesame(temperature)};
   EOS_REAL E[1], P[1], dx[1], dy[1];
@@ -1228,23 +1218,22 @@ PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityTemperature(const
   return robust::ratio(pressureFromSesame(sieToSesame(DPDE)), rho);
 }
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(const Real rho,
-                                                                   const Real sie,
-                                                                   Real *lambda) const {
+PORTABLE_INLINE_FUNCTION Real EOSPAC::GruneisenParamFromDensityInternalEnergy(
+    const Real rho, const Real sie, Real *lambda) const {
   Real temperature = TemperatureFromDensityInternalEnergy(rho, sie, lambda);
   return GruneisenParamFromDensityTemperature(rho, temperature, lambda);
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real temp,
-                                                  Real *lambda, Real &rho,
-                                                  Real &sie) const {
+PORTABLE_INLINE_FUNCTION void
+EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real temp,
+                                             Real *lambda, Real &rho, Real &sie) const {
   using namespace EospacWrapper;
   EOS_REAL P[1] = {pressureToSesame(press)};
   EOS_REAL T[1] = {temperatureToSesame(temp)};
   EOS_REAL dx[1], dy[1], R[1], E[1];
   EOS_INTEGER nxypairs = 1;
-  //EOS_INTEGER errorCode;
+  // EOS_INTEGER errorCode;
   EOS_INTEGER table;
 
   table = RofPT_table_;
@@ -1257,10 +1246,9 @@ PORTABLE_INLINE_FUNCTION void EOSPAC::DensityEnergyFromPressureTemperature(const
 }
 
 SG_PIF_NOWARN
-PORTABLE_INLINE_FUNCTION void EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie,
-                                                  Real &press, Real &cv, Real &bmod,
-                                                  Real &dpde, Real &dvdt,
-                                                  Real *lambda) const {
+PORTABLE_INLINE_FUNCTION void
+EOSPAC::ValuesAtReferenceState(Real &rho, Real &temp, Real &sie, Real &press, Real &cv,
+                               Real &bmod, Real &dpde, Real &dvdt, Real *lambda) const {
   using namespace EospacWrapper;
   rho = rho_ref_;
   temp = temp_ref_;
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index daf7f38e5d..42fe201f7e 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -144,8 +144,8 @@ int get_sg_eos( // sizing information
   ScratchV<double> solver_scratch;
 
   // create helper lambdas to reduce code duplication
-  //const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
-  //const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+  // const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
+  // const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   Kokkos::View<int, MemoryTraits<at_int>> res("PTE::num fails");
   Kokkos::View<int, MemoryTraits<at_int>> n_solves("PTE::num solves");
   const std::string perf_nums =
@@ -226,7 +226,7 @@ int get_sg_eos( // sizing information
   // there is lots of room for performance optimization
   // in terms of when to copy and when not necessary
   // this is the return value (number of solve failures)
-  //deep_copy(ret, res);
+  // deep_copy(ret, res);
   // copy pressure, this is not needed in all cases
   if (!p_is_inp) {
     deep_copy(DES(), press_hv, press_v);
diff --git a/singularity-eos/eos/modifiers/eos_unitsystem.hpp b/singularity-eos/eos/modifiers/eos_unitsystem.hpp
index d10277362b..a01fdf599b 100644
--- a/singularity-eos/eos/modifiers/eos_unitsystem.hpp
+++ b/singularity-eos/eos/modifiers/eos_unitsystem.hpp
@@ -274,7 +274,9 @@ class UnitSystem : public EosBase<UnitSystem<T>> {
 
   inline constexpr T UnmodifyOnce() { return t_; }
 
-  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr decltype(auto) GetUnmodifiedObject() {
+    return t_.GetUnmodifiedObject();
+  }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/ramps_eos.hpp b/singularity-eos/eos/modifiers/ramps_eos.hpp
index fd6ce3309d..3fcf743d49 100644
--- a/singularity-eos/eos/modifiers/ramps_eos.hpp
+++ b/singularity-eos/eos/modifiers/ramps_eos.hpp
@@ -262,7 +262,9 @@ class BilinearRampEOS : public EosBase<BilinearRampEOS<T>> {
 
   inline constexpr T UnmodifyOnce() { return t_; }
 
-  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr decltype(auto) GetUnmodifiedObject() {
+    return t_.GetUnmodifiedObject();
+  }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/relativistic_eos.hpp b/singularity-eos/eos/modifiers/relativistic_eos.hpp
index 0365696d27..174349f5fd 100644
--- a/singularity-eos/eos/modifiers/relativistic_eos.hpp
+++ b/singularity-eos/eos/modifiers/relativistic_eos.hpp
@@ -189,7 +189,9 @@ class RelativisticEOS : public EosBase<RelativisticEOS<T>> {
 
   inline constexpr T UnmodifyOnce() { return t_; }
 
-  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr decltype(auto) GetUnmodifiedObject() {
+    return t_.GetUnmodifiedObject();
+  }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/scaled_eos.hpp b/singularity-eos/eos/modifiers/scaled_eos.hpp
index 5f1f2077e5..61d3995b55 100644
--- a/singularity-eos/eos/modifiers/scaled_eos.hpp
+++ b/singularity-eos/eos/modifiers/scaled_eos.hpp
@@ -206,7 +206,9 @@ class ScaledEOS : public EosBase<ScaledEOS<T>> {
 
   inline constexpr T UnmodifyOnce() { return t_; }
 
-  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr decltype(auto) GetUnmodifiedObject() {
+    return t_.GetUnmodifiedObject();
+  }
 
  private:
   T t_;
diff --git a/singularity-eos/eos/modifiers/shifted_eos.hpp b/singularity-eos/eos/modifiers/shifted_eos.hpp
index ac0d3af05f..8a33d97310 100644
--- a/singularity-eos/eos/modifiers/shifted_eos.hpp
+++ b/singularity-eos/eos/modifiers/shifted_eos.hpp
@@ -196,7 +196,9 @@ class ShiftedEOS : public EosBase<ShiftedEOS<T>> {
 
   inline constexpr T UnmodifyOnce() { return t_; }
 
-  inline constexpr decltype(auto) GetUnmodifiedObject() { return t_.GetUnmodifiedObject(); }
+  inline constexpr decltype(auto) GetUnmodifiedObject() {
+    return t_.GetUnmodifiedObject();
+  }
 
  private:
   T t_;

From 52dc1c980be01f86a0ff3eb59079672cfd3c0d02 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 17:56:47 -0600
Subject: [PATCH 21/45] Make cuda builds release and everything else the
 default value of relwithdebinfo

---
 .gitlab-ci.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 0baf9269d4..1e7081dedc 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -121,17 +121,20 @@ before_script:
     - spack add ${SINGULARITY_EOS_SPACK_SPEC}
     - spack install -j $(nproc) --show-log-on-error --no-checksum --yes-to-all -u cmake
     - echo -e "\e[0Ksection_end:`date +%s`:spack_env\r\e[0K"
+    - export SINGULARITY_BUILD_TYPE="RelWithDebInfo"
     - |
       if [[ -n ${SINGULARITY_USE_CUDA} ]];
       then
         export SINGULARITY_NVCC_WRAPPER="$(which nvcc_wrapper)";
         export SINGULARITY_CMAKE_CXX_COMPILER_FLAG="-DCMAKE_CXX_COMPILER=${SINGULARITY_NVCC_WRAPPER}";
         echo "passing '${SINGULARITY_CMAKE_CXX_COMPILER_FLAG}' to cmake"
+        export SINGULARITY_BUILD_TYPE="Release"
       fi
     - mkdir -p build
     - cd build
     - |
       cmake -DCMAKE_INSTALL_PREFIX=${CI_PROJECT_DIR}/install ${SINGULARITY_CMAKE_CXX_COMPILER_FLAG} \
+            -DCMAKE_BUILD_TYPE=${SINGULARITY_BUILD_TYPE}
             -DSINGULARITY_USE_EOSPAC=ON \
             -DSINGULARITY_USE_HDF5=ON \
             -DSINGULARITY_BUILD_SESAME2SPINER=ON \

From 9151751c38ba87cd7b872420344064dcd95f4639 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 18:06:56 -0600
Subject: [PATCH 22/45] fix mistakes in gitlab changes.

---
 .gitlab-ci.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 1e7081dedc..356d098c66 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -128,13 +128,13 @@ before_script:
         export SINGULARITY_NVCC_WRAPPER="$(which nvcc_wrapper)";
         export SINGULARITY_CMAKE_CXX_COMPILER_FLAG="-DCMAKE_CXX_COMPILER=${SINGULARITY_NVCC_WRAPPER}";
         echo "passing '${SINGULARITY_CMAKE_CXX_COMPILER_FLAG}' to cmake"
-        export SINGULARITY_BUILD_TYPE="Release"
+        export SINGULARITY_BUILD_TYPE="Release";
       fi
     - mkdir -p build
     - cd build
     - |
       cmake -DCMAKE_INSTALL_PREFIX=${CI_PROJECT_DIR}/install ${SINGULARITY_CMAKE_CXX_COMPILER_FLAG} \
-            -DCMAKE_BUILD_TYPE=${SINGULARITY_BUILD_TYPE}
+            -DCMAKE_BUILD_TYPE=${SINGULARITY_BUILD_TYPE} \
             -DSINGULARITY_USE_EOSPAC=ON \
             -DSINGULARITY_USE_HDF5=ON \
             -DSINGULARITY_BUILD_SESAME2SPINER=ON \

From 3f2cbf95d5d3f9fd4d2e9fd25849723f8d2954ef Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 22 May 2023 18:47:34 -0600
Subject: [PATCH 23/45] Updating the cuda compatibility patch to make more
 usage of constexpr, less hostdevice, and more warning suppression.

---
 utils/cuda_compatibility.patch | 134 +++++++++++++++++++++++++++------
 1 file changed, 110 insertions(+), 24 deletions(-)

diff --git a/utils/cuda_compatibility.patch b/utils/cuda_compatibility.patch
index 3852721321..7c415277ff 100644
--- a/utils/cuda_compatibility.patch
+++ b/utils/cuda_compatibility.patch
@@ -1,7 +1,16 @@
 diff --git a/include/mpark/variant.hpp b/include/mpark/variant.hpp
-index 2fb2ac549..aeef9dcdd 100644
+index 2fb2ac549..76f58530a 100644
 --- a/include/mpark/variant.hpp
 +++ b/include/mpark/variant.hpp
+@@ -245,7 +245,7 @@ namespace mpark {
+   };
+ 
+   [[noreturn]] inline void throw_bad_variant_access() {
+-#ifdef MPARK_EXCEPTIONS
++#if defined(MPARK_EXCEPTIONS) && !defined(__CUDACC__)
+     throw bad_variant_access{};
+ #else
+     std::terminate();
 @@ -1021,9 +1021,15 @@ namespace mpark {
      friend struct access::recursive_union;                                 \
    }
@@ -19,7 +28,13 @@ index 2fb2ac549..aeef9dcdd 100644
                                    ~recursive_union() {});
      MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
                                    ~recursive_union() = delete;);
-@@ -1133,9 +1139,9 @@ namespace mpark {
+@@ -1128,14 +1134,14 @@ namespace mpark {
+     MPARK_VARIANT_DESTRUCTOR(
+         Trait::TriviallyAvailable,
+         ~destructor() = default;,
+-        inline void destroy() noexcept {
++        inline constexpr void destroy() noexcept {
+           this->index_ = static_cast<index_t<Ts...>>(-1);
          });
  
      MPARK_VARIANT_DESTRUCTOR(
@@ -57,20 +72,15 @@ index 2fb2ac549..aeef9dcdd 100644
              lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
              : move_constructor(valueless_t{}) {
            this->generic_construct(*this, lib::move(that));
-@@ -1256,11 +1262,11 @@ namespace mpark {
-   }
- 
-     MPARK_VARIANT_COPY_CONSTRUCTOR(
--        Trait::TriviallyAvailable,
-+        Trait::TriviallyAvailable,
-         copy_constructor(const copy_constructor &that) = default;);
+@@ -1261,7 +1267,7 @@ namespace mpark {
  
      MPARK_VARIANT_COPY_CONSTRUCTOR(
--        Trait::Available,
-+        Trait::Available,V_GPU_FUNCTION
-         copy_constructor(const copy_constructor &that)
+         Trait::Available,
+-        copy_constructor(const copy_constructor &that)
++        constexpr copy_constructor(const copy_constructor &that)
              : copy_constructor(valueless_t{}) {
            this->generic_construct(*this, that);
+         });
 @@ -1281,7 +1287,7 @@ namespace mpark {
        using super::operator=;
  
@@ -98,20 +108,15 @@ index 2fb2ac549..aeef9dcdd 100644
          if (this->valueless_by_exception() && that.valueless_by_exception()) {
            // do nothing.
          } else if (that.valueless_by_exception()) {
-@@ -1376,11 +1382,11 @@ namespace mpark {
-   }
- 
-     MPARK_VARIANT_MOVE_ASSIGNMENT(
--        Trait::TriviallyAvailable,
-+        Trait::TriviallyAvailable,
-         move_assignment &operator=(move_assignment &&that) = default;);
+@@ -1381,7 +1387,7 @@ namespace mpark {
  
      MPARK_VARIANT_MOVE_ASSIGNMENT(
--        Trait::Available,
-+        Trait::Available,V_GPU_FUNCTION
-         move_assignment &
+         Trait::Available,
+-        move_assignment &
++        constexpr move_assignment &
          operator=(move_assignment &&that) noexcept(
              lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
+                       std::is_nothrow_move_assignable<Ts>::value)...>::value) {
 @@ -1394,6 +1400,7 @@ namespace mpark {
          move_assignment &operator=(move_assignment &&) = delete;);
  
@@ -129,14 +134,95 @@ index 2fb2ac549..aeef9dcdd 100644
            this->generic_assign(that);
            return *this;
          });
+@@ -1447,7 +1454,7 @@ namespace mpark {
+       impl &operator=(impl &&) = default;
+ 
+       template <std::size_t I, typename Arg>
+-      inline void assign(Arg &&arg) {
++      inline constexpr void assign(Arg &&arg) {
+         this->assign_alt(access::base::get_alt<I>(*this),
+                          lib::forward<Arg>(arg));
+       }
+@@ -1499,7 +1506,7 @@ namespace mpark {
+ #ifndef MPARK_GENERIC_LAMBDAS
+       struct swapper {
+         template <typename ThisAlt, typename ThatAlt>
+-        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
++        inline constexpr void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
+           using std::swap;
+           swap(this_alt.value, that_alt.value);
+         }
 @@ -1694,8 +1701,8 @@ namespace mpark {
  
      ~variant() = default;
  
 -    variant &operator=(const variant &) = default;
 -    variant &operator=(variant &&) = default;
-+    /*V_GPU_FUNCTION*/constexpr variant &operator=(const variant &) = default;
-+    /*V_GPU_FUNCTION*/constexpr variant &operator=(variant &&) = default;
++    constexpr variant &operator=(const variant &) = default;
++    constexpr variant &operator=(variant &&) = default;
  
      template <typename Arg,
                lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
+@@ -1705,7 +1712,7 @@ namespace mpark {
+               lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
+                                 std::is_constructible<T, Arg>::value),
+                                int> = 0>
+-    inline variant &operator=(Arg &&arg) noexcept(
++    inline constexpr variant &operator=(Arg &&arg) noexcept(
+         (std::is_nothrow_assignable<T &, Arg>::value &&
+          std::is_nothrow_constructible<T, Arg>::value)) {
+       impl_.template assign<I>(lib::forward<Arg>(arg));
+@@ -1717,7 +1724,7 @@ namespace mpark {
+         typename... Args,
+         typename T = lib::type_pack_element_t<I, Ts...>,
+         lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+-    inline T &emplace(Args &&... args) {
++    inline constexpr T &emplace(Args &&... args) {
+       return impl_.template emplace<I>(lib::forward<Args>(args)...);
+     }
+ 
+@@ -1730,7 +1737,7 @@ namespace mpark {
+                                                std::initializer_list<Up> &,
+                                                Args...>::value,
+                          int> = 0>
+-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
++    inline constexpr T &emplace(std::initializer_list<Up> il, Args &&... args) {
+       return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+     }
+ 
+@@ -1739,7 +1746,7 @@ namespace mpark {
+         typename... Args,
+         std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+         lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+-    inline T &emplace(Args &&... args) {
++    inline constexpr T &emplace(Args &&... args) {
+       return impl_.template emplace<I>(lib::forward<Args>(args)...);
+     }
+ 
+@@ -1752,7 +1759,7 @@ namespace mpark {
+                                                std::initializer_list<Up> &,
+                                                Args...>::value,
+                          int> = 0>
+-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
++    inline constexpr T &emplace(std::initializer_list<Up> il, Args &&... args) {
+       return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+     }
+ 
+@@ -1772,7 +1779,7 @@ namespace mpark {
+                             lib::dependent_type<lib::is_swappable<Ts>,
+                                                 Dummy>::value)...>::value,
+                   int> = 0>
+-    inline void swap(variant &that) noexcept(
++    inline constexpr void swap(variant &that) noexcept(
+         lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
+                   lib::is_nothrow_swappable<Ts>::value)...>::value) {
+       impl_.swap(that.impl_);
+@@ -2093,7 +2100,7 @@ namespace mpark {
+ #endif
+ 
+   template <typename... Ts>
+-  inline auto swap(variant<Ts...> &lhs,
++  inline constexpr auto swap(variant<Ts...> &lhs,
+                    variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
+       -> decltype(lhs.swap(rhs)) {
+     lhs.swap(rhs);

From ea59f83360f0775ce44b093ef1ca26c2a6afd232 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 23 May 2023 08:30:40 -0600
Subject: [PATCH 24/45] Moving to earlier cuda versions that passed tests.

---
 .gitlab-ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 356d098c66..50b0a44ed3 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -9,7 +9,7 @@ variables:
   GIT_SUBMODULE_STRATEGY: recursive
   SINGULARITY_EOS_GCC_VERSION: "9.3.0"
   SINGULARITY_EOS_OPENMPI_VERSION: "4.1.3"
-  SINGULARITY_EOS_CUDA_VERSION: "11.6.0"
+  SINGULARITY_EOS_CUDA_VERSION: "11.4.2"
   SINGULARITY_EOS_SPACK_SPEC: "singularity-eos@main+mpi+python+tests%gcc@${SINGULARITY_EOS_GCC_VERSION} ^openmpi@${SINGULARITY_EOS_OPENMPI_VERSION}"
   COLOR_CYAN: '\033[1;36m'
   COLOR_PLAIN: '\033[0m'

From 1c284b2e4d63bd44b8b8dd2c0a1069986e9127ee Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 23 May 2023 10:50:02 -0600
Subject: [PATCH 25/45] Adding fences to see if asynchrony was source of
 issues.

---
 test/test_eos_unit.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/test_eos_unit.cpp b/test/test_eos_unit.cpp
index 1ed9499c2f..403ec9776d 100644
--- a/test/test_eos_unit.cpp
+++ b/test/test_eos_unit.cpp
@@ -1030,6 +1030,7 @@ SCENARIO("SpinerEOS depends on rho and sie", "[SpinerEOS],[DependsRhoSie]") {
 
       int nw_ie2{0}, nw_te2{0};
 #ifdef PORTABILITY_STRATEGY_KOKKOS
+      Kokkos::fence();
       using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
       Kokkos::View<int, atomic_view> n_wrong_ie("wrong_ie");
       Kokkos::View<int, atomic_view> n_wrong_te("wrong_te");
@@ -1045,6 +1046,7 @@ SCENARIO("SpinerEOS depends on rho and sie", "[SpinerEOS],[DependsRhoSie]") {
             if (!isClose(te, 75594.6)) n_wrong_te() += 1;
           });
 #ifdef PORTABILITY_STRATEGY_KOKKOS
+      Kokkos::fence()
       Kokkos::deep_copy(nw_ie2, n_wrong_ie);
       Kokkos::deep_copy(nw_te2, n_wrong_te);
 #endif

From 946720c8d3bc7018d6d93678fc4e1f29ca119b8a Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Fri, 26 May 2023 00:17:49 -0600
Subject: [PATCH 26/45] Fixing test failure from setting mutable member in a
 GPU kernel which resulted in errors, adding fences in test.

---
 singularity-eos/eos/eos_spiner.hpp | 40 +++++++++++++++++-------------
 test/test_eos_unit.cpp             | 20 ++++++++-------
 2 files changed, 34 insertions(+), 26 deletions(-)

diff --git a/singularity-eos/eos/eos_spiner.hpp b/singularity-eos/eos/eos_spiner.hpp
index 1af778e455..044876f12e 100644
--- a/singularity-eos/eos/eos_spiner.hpp
+++ b/singularity-eos/eos/eos_spiner.hpp
@@ -198,23 +198,23 @@ class SpinerEOSDependsRhoT : public EosBase<SpinerEOSDependsRhoT> {
   static PORTABLE_FORCEINLINE_FUNCTION Real fromLog_(const Real lx, const Real offset) {
     return FastMath::pow10(lx) - offset;
   }
-  PORTABLE_INLINE_FUNCTION Real __attribute__((always_inline))
-  lRho_(const Real rho) const noexcept {
+  PORTABLE_FORCEINLINE_FUNCTION
+  Real lRho_(const Real rho) const noexcept {
     Real out = toLog_(rho, lRhoOffset_);
     return out;
     // return out < lRhoMin_ ? lRhoMin_ : out;
   }
-  PORTABLE_INLINE_FUNCTION Real __attribute__((always_inline))
-  lT_(const Real T) const noexcept {
+  PORTABLE_FORCEINLINE_FUNCTION
+  Real lT_(const Real T) const noexcept {
     return toLog_(T, lTOffset_);
   }
-  PORTABLE_INLINE_FUNCTION Real __attribute__((always_inline))
-  rho_(const Real lRho) const noexcept {
+  PORTABLE_FORCEINLINE_FUNCTION
+  Real rho_(const Real lRho) const noexcept {
     Real rho = fromLog_(lRho, lRhoOffset_);
     return rho < 0 ? 0 : rho;
   }
-  PORTABLE_INLINE_FUNCTION Real __attribute__((always_inline))
-  T_(const Real lT) const noexcept {
+  PORTABLE_FORCEINLINE_FUNCTION
+  Real T_(const Real lT) const noexcept {
     return fromLog_(lT, lTOffset_);
   }
 
@@ -1201,7 +1201,7 @@ Real SpinerEOSDependsRhoT::lRhoFromPlT_(const Real P, const Real lT,
                     lRhoMinSearch_, lRhoMax_, ROOT_THRESH, ROOT_THRESH, lRho, pcounts);
   }
   if (status != RootFinding1D::Status::SUCCESS) {
-#if EPINER_EOS_VERBOSE
+#if SPINER_EOS_VERBOSE
     std::stringstream errorMessage;
     errorMessage << "inverting P table for logRho failed\n"
                  << "matid     = " << matid_ << "\n"
@@ -1216,8 +1216,10 @@ Real SpinerEOSDependsRhoT::lRhoFromPlT_(const Real P, const Real lT,
     lambda[Lambda::lRho] = lRho;
     lambda[Lambda::lT] = lT;
   }
-  status_ = status;
-  whereAmI_ = whereAmI;
+  if (memoryStatus_ != DataStatus::OnDevice) {
+    status_ = status;
+    whereAmI_ = whereAmI;
+  }
   return lRho;
 }
 
@@ -1278,8 +1280,8 @@ Real SpinerEOSDependsRhoT::lTFromlRhoSie_(const Real lRho, const Real sie,
   }
   if (memoryStatus_ != DataStatus::OnDevice) {
     status_ = status;
+    whereAmI_ = whereAmI;
   }
-  whereAmI_ = whereAmI;
   return lT;
 }
 
@@ -1336,8 +1338,8 @@ Real SpinerEOSDependsRhoT::lTFromlRhoP_(const Real lRho, const Real press,
   }
   if (memoryStatus_ != DataStatus::OnDevice) {
     status_ = status;
+    whereAmI_ = whereAmI;
   }
-  whereAmI_ = whereAmI;
   return lT;
 }
 
@@ -1411,8 +1413,8 @@ Real SpinerEOSDependsRhoT::bModFromRholRhoTlT_(const Real rho, const Real lRho,
   return bMod > robust::EPS() ? bMod : robust::EPS();
 }
 
-PORTABLE_INLINE_FUNCTION TableStatus
-SpinerEOSDependsRhoT::getLocDependsRhoSie_(const Real lRho, const Real sie) const {
+PORTABLE_INLINE_FUNCTION
+TableStatus SpinerEOSDependsRhoT::getLocDependsRhoSie_(const Real lRho, const Real sie) const {
   TableStatus whereAmI;
   const Real sielTMax = sielTMax_.interpToReal(lRho);
   const Real sieCold = sieCold_.interpToReal(lRho);
@@ -1424,7 +1426,9 @@ SpinerEOSDependsRhoT::getLocDependsRhoSie_(const Real lRho, const Real sie) cons
   } else {
     whereAmI = TableStatus::OnTable;
   }
-  whereAmI_ = whereAmI;
+  if (memoryStatus_ != DataStatus::OnDevice) {
+    whereAmI_ = whereAmI;
+  }
   return whereAmI;
 }
 
@@ -1437,7 +1441,9 @@ SpinerEOSDependsRhoT::getLocDependsRhoT_(const Real lRho, const Real lT) const {
     whereAmI = TableStatus::OffTop;
   else
     whereAmI = TableStatus::OnTable;
-  whereAmI_ = whereAmI;
+  if (memoryStatus_ != DataStatus::OnDevice) {
+    whereAmI_ = whereAmI;
+  }
   return whereAmI;
 }
 
diff --git a/test/test_eos_unit.cpp b/test/test_eos_unit.cpp
index 403ec9776d..cb43b26341 100644
--- a/test/test_eos_unit.cpp
+++ b/test/test_eos_unit.cpp
@@ -892,13 +892,14 @@ SCENARIO("SpinerEOS depends on Rho and T", "[SpinerEOS],[DependsRhoT][EOSPAC]")
 
         int nw_ie{0};
 #ifdef PORTABILITY_STRATEGY_KOKKOS
+	Kokkos::fence();
         using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
         Kokkos::View<int, atomic_view> n_wrong_ie("wrong_ie");
 #else
         PortableMDArray<int> n_wrong_ie(&nw_ie, 1);
 #endif
         portableFor(
-            "calc ie's", 0, 100, PORTABLE_LAMBDA(const int &i) {
+            "calc ie's steel", 0, 100, PORTABLE_LAMBDA(const int &i) {
               const double ie = steelEOS.InternalEnergyFromDensityTemperature(1e0, 1e6);
               if (!isClose(ie, sie_pac)) n_wrong_ie() += 1;
             });
@@ -943,13 +944,14 @@ SCENARIO("SpinerEOS depends on Rho and T", "[SpinerEOS],[DependsRhoT][EOSPAC]")
       REQUIRE(isClose(T, T_pac));
     }
     THEN("Quantities of rho and sie look sane on both host and device") {
-      Real gm1_host = airEOS_host.GruneisenParamFromDensityInternalEnergy(rho, sie);
-      Real T_host = airEOS_host.TemperatureFromDensityInternalEnergy(rho, sie);
-      Real cv_host = airEOS_host.SpecificHeatFromDensityInternalEnergy(rho, sie);
+      const Real gm1_host = airEOS_host.GruneisenParamFromDensityInternalEnergy(rho, sie);
+      const Real T_host = airEOS_host.TemperatureFromDensityInternalEnergy(rho, sie);
+      const Real cv_host = airEOS_host.SpecificHeatFromDensityInternalEnergy(rho, sie);
 
       int nw_gm1{0}, nw_cv{0};
 #ifdef PORTABILITY_STRATEGY_KOKKOS
       using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
+      Kokkos::fence();
       Kokkos::View<int, atomic_view> n_wrong_gm1("wrong_gm1");
       Kokkos::View<int, atomic_view> n_wrong_cv("wrong_cv");
 #else
@@ -958,8 +960,8 @@ SCENARIO("SpinerEOS depends on Rho and T", "[SpinerEOS],[DependsRhoT][EOSPAC]")
 #endif
       portableFor(
           "calc gm1 and cv", 0, 100, PORTABLE_LAMBDA(const int &i) {
-            const double gm1 = airEOS.GruneisenParamFromDensityInternalEnergy(rho, sie);
-            const double cv = airEOS.SpecificHeatFromDensityInternalEnergy(rho, sie);
+            const Real gm1 = airEOS.GruneisenParamFromDensityInternalEnergy(rho, sie);
+            const Real cv = airEOS.SpecificHeatFromDensityInternalEnergy(rho, sie);
             if (!isClose(gm1, gm1_host)) n_wrong_gm1() += 1;
             if (!isClose(cv, cv_host)) n_wrong_cv() += 1;
           });
@@ -1039,14 +1041,13 @@ SCENARIO("SpinerEOS depends on rho and sie", "[SpinerEOS],[DependsRhoSie]") {
       PortableMDArray<int> n_wrong_te(&nw_te2, 1);
 #endif
       portableFor(
-          "calc ie's", 0, 100, PORTABLE_LAMBDA(const int &i) {
+          "calc ie's steel 2", 0, 100, PORTABLE_LAMBDA(const int &i) {
             const Real ie{steelEOS.InternalEnergyFromDensityTemperature(1e0, 1e6)};
             const Real te{steelEOS.TemperatureFromDensityInternalEnergy(1e0, 1e12)};
             if (!isClose(ie, 4.96415e13)) n_wrong_ie() += 1;
             if (!isClose(te, 75594.6)) n_wrong_te() += 1;
           });
 #ifdef PORTABILITY_STRATEGY_KOKKOS
-      Kokkos::fence()
       Kokkos::deep_copy(nw_ie2, n_wrong_ie);
       Kokkos::deep_copy(nw_te2, n_wrong_te);
 #endif
@@ -1084,13 +1085,14 @@ SCENARIO("EOS Builder and SpinerEOS",
         THEN("EOS calls match raw access") {
           int nw_bm{0};
 #ifdef PORTABILITY_STRATEGY_KOKKOS
+	  Kokkos::fence();
           using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
           Kokkos::View<int, atomic_view> n_wrong_bm("wrong_bm");
 #else
           PortableMDArray<int> n_wrong_bm(&nw_bm, 1);
 #endif
           portableFor(
-              "calc ie's", 0, 100, PORTABLE_LAMBDA(const int &i) {
+              "calc ie's steel 3", 0, 100, PORTABLE_LAMBDA(const int &i) {
                 const Real bm{eosDevice.BulkModulusFromDensityTemperature(1e0, 1e6)};
                 if (!isClose(bm, 2.55268e13)) n_wrong_bm() += 1;
               });

From fc077620b1f2c6f3cf481799f2e432beb693d773 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Fri, 26 May 2023 10:04:38 -0600
Subject: [PATCH 27/45] format.

---
 singularity-eos/eos/eos_spiner.hpp | 11 ++++-------
 test/test_eos_unit.cpp             |  4 ++--
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/singularity-eos/eos/eos_spiner.hpp b/singularity-eos/eos/eos_spiner.hpp
index 044876f12e..d6f11b270c 100644
--- a/singularity-eos/eos/eos_spiner.hpp
+++ b/singularity-eos/eos/eos_spiner.hpp
@@ -205,18 +205,14 @@ class SpinerEOSDependsRhoT : public EosBase<SpinerEOSDependsRhoT> {
     // return out < lRhoMin_ ? lRhoMin_ : out;
   }
   PORTABLE_FORCEINLINE_FUNCTION
-  Real lT_(const Real T) const noexcept {
-    return toLog_(T, lTOffset_);
-  }
+  Real lT_(const Real T) const noexcept { return toLog_(T, lTOffset_); }
   PORTABLE_FORCEINLINE_FUNCTION
   Real rho_(const Real lRho) const noexcept {
     Real rho = fromLog_(lRho, lRhoOffset_);
     return rho < 0 ? 0 : rho;
   }
   PORTABLE_FORCEINLINE_FUNCTION
-  Real T_(const Real lT) const noexcept {
-    return fromLog_(lT, lTOffset_);
-  }
+  Real T_(const Real lT) const noexcept { return fromLog_(lT, lTOffset_); }
 
   PORTABLE_INLINE_FUNCTION
   Real lTFromlRhoSie_(const Real lRho, const Real sie, TableStatus &whereAmI,
@@ -1414,7 +1410,8 @@ Real SpinerEOSDependsRhoT::bModFromRholRhoTlT_(const Real rho, const Real lRho,
 }
 
 PORTABLE_INLINE_FUNCTION
-TableStatus SpinerEOSDependsRhoT::getLocDependsRhoSie_(const Real lRho, const Real sie) const {
+TableStatus SpinerEOSDependsRhoT::getLocDependsRhoSie_(const Real lRho,
+                                                       const Real sie) const {
   TableStatus whereAmI;
   const Real sielTMax = sielTMax_.interpToReal(lRho);
   const Real sieCold = sieCold_.interpToReal(lRho);
diff --git a/test/test_eos_unit.cpp b/test/test_eos_unit.cpp
index cb43b26341..fd8d3a30c1 100644
--- a/test/test_eos_unit.cpp
+++ b/test/test_eos_unit.cpp
@@ -892,7 +892,7 @@ SCENARIO("SpinerEOS depends on Rho and T", "[SpinerEOS],[DependsRhoT][EOSPAC]")
 
         int nw_ie{0};
 #ifdef PORTABILITY_STRATEGY_KOKKOS
-	Kokkos::fence();
+        Kokkos::fence();
         using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
         Kokkos::View<int, atomic_view> n_wrong_ie("wrong_ie");
 #else
@@ -1085,7 +1085,7 @@ SCENARIO("EOS Builder and SpinerEOS",
         THEN("EOS calls match raw access") {
           int nw_bm{0};
 #ifdef PORTABILITY_STRATEGY_KOKKOS
-	  Kokkos::fence();
+          Kokkos::fence();
           using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
           Kokkos::View<int, atomic_view> n_wrong_bm("wrong_bm");
 #else

From 9b3bdb08c65f37d1b22f46ee5e6a2db9f271fe14 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Fri, 26 May 2023 14:39:46 -0600
Subject: [PATCH 28/45] Undoing unneccessary changes.

---
 .gitlab-ci.yml                                |  2 +-
 singularity-eos/closure/mixed_cell_models.hpp | 12 ++++++------
 singularity-eos/eos/eos_eospac.hpp            |  4 +++-
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 50b0a44ed3..356d098c66 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -9,7 +9,7 @@ variables:
   GIT_SUBMODULE_STRATEGY: recursive
   SINGULARITY_EOS_GCC_VERSION: "9.3.0"
   SINGULARITY_EOS_OPENMPI_VERSION: "4.1.3"
-  SINGULARITY_EOS_CUDA_VERSION: "11.4.2"
+  SINGULARITY_EOS_CUDA_VERSION: "11.6.0"
   SINGULARITY_EOS_SPACK_SPEC: "singularity-eos@main+mpi+python+tests%gcc@${SINGULARITY_EOS_GCC_VERSION} ^openmpi@${SINGULARITY_EOS_OPENMPI_VERSION}"
   COLOR_CYAN: '\033[1;36m'
   COLOR_PLAIN: '\033[0m'
diff --git a/singularity-eos/closure/mixed_cell_models.hpp b/singularity-eos/closure/mixed_cell_models.hpp
index 4717273d0d..e9c2b8d210 100644
--- a/singularity-eos/closure/mixed_cell_models.hpp
+++ b/singularity-eos/closure/mixed_cell_models.hpp
@@ -206,7 +206,7 @@ class PTESolverBase {
     Cache = CacheAccessor(AssignIncrement(scratch, nmat * MAX_NUM_LAMBDAS));
   }
 
-  PORTABLE_INLINE_FUNCTION
+  PORTABLE_FORCEINLINE_FUNCTION
   void InitRhoBarandRho() {
     // rhobar is a fixed quantity: the average density of
     // material m averaged over the full PTE volume
@@ -217,7 +217,7 @@ class PTESolverBase {
     }
   }
 
-  PORTABLE_INLINE_FUNCTION
+  PORTABLE_FORCEINLINE_FUNCTION
   void SetVfracFromT(const Real T) {
     Real vsum = 0.0;
     // set volume fractions
@@ -233,7 +233,7 @@ class PTESolverBase {
     }
   }
 
-  PORTABLE_INLINE_FUNCTION
+  PORTABLE_FORCEINLINE_FUNCTION
   Real GetTguess() {
     // guess some non-zero temperature to start
     // If a guess was passed in, it's saved in Tnorm
@@ -272,9 +272,9 @@ class PTESolverBase {
     return Tguess;
   }
 
-  PORTABLE_INLINE_FUNCTION
-  Real GetPressureFromPreferred(const EOS &eos, const Real rho, const Real T, Real sie,
-                                Real *lambda, const bool do_e_lookup) const {
+  PORTABLE_FORCEINLINE_FUNCTION
+  static Real GetPressureFromPreferred(const EOS &eos, const Real rho, const Real T,
+                                       Real sie, Real *lambda, const bool do_e_lookup) {
     Real P{};
     if (eos.PreferredInput() ==
         (thermalqs::density | thermalqs::specific_internal_energy)) {
diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index bea57cfdd6..afe2b6c583 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -41,11 +41,13 @@ using namespace eos_base;
 
 // Only really works in serial
 // Not really supported on device
+#ifndef PORTABILITY_STRATEGY_NONE
 #if defined(__CUDACC__)
 #define SG_PIF_NOWARN #pragma nv_exec_check_disable
+#endif // __CUDACC__
 #else
 #define SG_PIF_NOWARN
-#endif
+#endif // PORTABILITY_STRATEGY_NONE
 
 class EOSPAC : public EosBase<EOSPAC> {
  public:

From 7650792bd05c79fce0a100d7771caf56dcee7145 Mon Sep 17 00:00:00 2001
From: "Karen C. Tsai" <ktsai@lanl.gov>
Date: Fri, 26 May 2023 17:48:25 -0600
Subject: [PATCH 29/45] use global var and anchor in gitlab-ci.yml

---
 .gitlab-ci.yml | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 356d098c66..9ffa4d373d 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -10,6 +10,7 @@ variables:
   SINGULARITY_EOS_GCC_VERSION: "9.3.0"
   SINGULARITY_EOS_OPENMPI_VERSION: "4.1.3"
   SINGULARITY_EOS_CUDA_VERSION: "11.6.0"
+  SINGULARITY_EOS_BUILD_TYPE: "RelWithDebInfo"
   SINGULARITY_EOS_SPACK_SPEC: "singularity-eos@main+mpi+python+tests%gcc@${SINGULARITY_EOS_GCC_VERSION} ^openmpi@${SINGULARITY_EOS_OPENMPI_VERSION}"
   COLOR_CYAN: '\033[1;36m'
   COLOR_PLAIN: '\033[0m'
@@ -44,10 +45,13 @@ before_script:
 ##########################
 
 .buildtype_debug: &buildtype_debug
-  BUILD_TYPE: "Debug"
+  SINGULARITY_EOS_BUILD_TYPE: "Debug"
 
 .buildtype_release: &buildtype_release
-  BUILD_TYPE: "Release"
+  SINGULARITY_EOS_BUILD_TYPE: "Release"
+  
+.buildtype_relDebugInfo: &buildtype_relDebugInfo
+  SINGULARITY_EOS_BUILD_TYPE: "RelWithDebInfo"
 
 .gpu: &gpu
   SINGULARITY_USE_CUDA: "true"
@@ -121,20 +125,18 @@ before_script:
     - spack add ${SINGULARITY_EOS_SPACK_SPEC}
     - spack install -j $(nproc) --show-log-on-error --no-checksum --yes-to-all -u cmake
     - echo -e "\e[0Ksection_end:`date +%s`:spack_env\r\e[0K"
-    - export SINGULARITY_BUILD_TYPE="RelWithDebInfo"
     - |
       if [[ -n ${SINGULARITY_USE_CUDA} ]];
       then
         export SINGULARITY_NVCC_WRAPPER="$(which nvcc_wrapper)";
         export SINGULARITY_CMAKE_CXX_COMPILER_FLAG="-DCMAKE_CXX_COMPILER=${SINGULARITY_NVCC_WRAPPER}";
         echo "passing '${SINGULARITY_CMAKE_CXX_COMPILER_FLAG}' to cmake"
-        export SINGULARITY_BUILD_TYPE="Release";
       fi
     - mkdir -p build
     - cd build
     - |
       cmake -DCMAKE_INSTALL_PREFIX=${CI_PROJECT_DIR}/install ${SINGULARITY_CMAKE_CXX_COMPILER_FLAG} \
-            -DCMAKE_BUILD_TYPE=${SINGULARITY_BUILD_TYPE} \
+            -DCMAKE_BUILD_TYPE=${SINGULARITY_EOS_BUILD_TYPE} \
             -DSINGULARITY_USE_EOSPAC=ON \
             -DSINGULARITY_USE_HDF5=ON \
             -DSINGULARITY_BUILD_SESAME2SPINER=ON \
@@ -191,6 +193,7 @@ test_gnu_power9_gpu:
   extends: .test
   variables:    
     <<: *power9
+    <<: *buildtype_release
     <<: *gpu
 
 test_x86_volta_gpu:
@@ -198,6 +201,7 @@ test_x86_volta_gpu:
   extends: .test
   variables:    
     <<: *x86volta
+    <<: *buildtype_release
     <<: *gpu
 
 install_gnu_skylake_fort:

From cc6e5d1616ea6825b1f46ed4ed99da90bcffc6a1 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 27 Jun 2023 18:06:57 -0600
Subject: [PATCH 30/45] First pass at cleaning up unneccessary functionality in
 variadic utils.

---
 singularity-eos/base/variadic_utils.hpp | 22 ++++++----------------
 singularity-eos/eos/eos.hpp             |  2 +-
 2 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/singularity-eos/base/variadic_utils.hpp b/singularity-eos/base/variadic_utils.hpp
index 863fc355a6..40a020511a 100644
--- a/singularity-eos/base/variadic_utils.hpp
+++ b/singularity-eos/base/variadic_utils.hpp
@@ -68,10 +68,6 @@ struct flatten<type_list<Ts...>> {
 };
 
 // filter nested variadic templates
-template <template <typename> class FIRST, template <typename> class... REST>
-constexpr auto remove_first(adapt_list<FIRST, REST...>) {
-  return adapt_list<REST...>{};
-}
 
 // nested specialization filter type
 template <template <typename> class Template, typename T>
@@ -109,18 +105,12 @@ struct filter<ADAPTER, Pred, Variadic, T, Ts...> {
       typename filter<ADAPTER, Pred, Variadic, Ts...>::type>::type;
 };
 
-template <template <typename> class U, typename... Ts>
-constexpr auto filter_nested(type_list<Ts...>) {
-  using f_list = typename filter<U, is_not_duplicate_nested, type_list, Ts...>::type;
-  return f_list{};
-}
-
 template <template <typename> class FIRST, template <typename> class... Us,
           typename... Ts>
 constexpr auto filter_nested_variadic(adapt_list<FIRST, Us...> m, type_list<Ts...> l) {
-  using t1 = type_list<decltype(filter_nested<FIRST>(l))>;
+  using t1 = type_list<typename filter<FIRST, is_not_duplicate_nested, type_list, Ts...>::type>;
   constexpr typename flatten<t1>::type l1{};
-  return filter_nested_variadic(remove_first(m), l1);
+  return filter_nested_variadic(adapt_list<Us...>{}, l1);
 }
 
 template <typename... Ts>
@@ -130,14 +120,14 @@ constexpr auto filter_nested_variadic(adapt_list<>, type_list<Ts...> l) {
 
 // apply class template to typelist
 template <template <typename> class T, typename... Us>
-constexpr auto transform_list(type_list<Us...>) {
-  return type_list<T<Us>...>{};
-}
+struct transform_list_struct {
+  using type = type_list<T<Us>...>;
+};
 
 template <template <typename> class... Ts, typename... Us>
 constexpr auto transform_variadic_list(type_list<Us...> list,
                                        adapt_list<Ts...> mod_list) {
-  using t1 = type_list<decltype(transform_list<Ts>(list))...>;
+  using t1 = type_list<typename transform_list_struct<Ts, Us...>::type...>;
   constexpr typename flatten<t1>::type l1{};
   constexpr auto l2 = filter_nested_variadic(mod_list, l1);
   return l2;
diff --git a/singularity-eos/eos/eos.hpp b/singularity-eos/eos/eos.hpp
index 379246669f..ab1a7feceb 100644
--- a/singularity-eos/eos/eos.hpp
+++ b/singularity-eos/eos/eos.hpp
@@ -110,7 +110,7 @@ static constexpr const auto ramped_all =
     transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
 // final combined list
 static constexpr const auto combined_list = singularity::detail::concat(
-    full_eos_list, shifted, scaled, scaled_of_shifted, unit_or_rel, ramped_all);
+    combined_list_1, ramped_all);
 // a function that returns a Variant from a typelist
 template <typename... Ts>
 struct tl_to_Variant_struct {

From 63456b35fd1371df5613e0c3022e014b3a1ea19a Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Thu, 3 Aug 2023 11:49:25 -0600
Subject: [PATCH 31/45] Only build the get_sg files when closure and (fortran
 or testing), should improve build times for native c++ projects. Remove
 unused variable.

---
 singularity-eos/CMakeLists.txt     | 25 ++++++++++++++-----------
 singularity-eos/eos/eos_eospac.hpp |  1 -
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index c479c3e323..f196ea81f8 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -46,19 +46,22 @@ set(EOS_SRCS
 )
 
 if (SINGULARITY_BUILD_CLOSURE)
-  list(APPEND EOS_SRCS 
-       eos/get_sg_eos.cpp)
-  if (SINGULARITY_USE_KOKKOS)
+  list(APPEND EOS_HEADERS
+       closure/mixed_cell_models.hpp)
+  if (SINGULARITY_USE_FORTRAN OR SINGULARITY_BUILD_TESTS)
     list(APPEND EOS_SRCS 
-         eos/get_sg_eos_p_t.cpp
-         eos/get_sg_eos_rho_t.cpp
-         eos/get_sg_eos_rho_p.cpp
-         eos/get_sg_eos_rho_e.cpp)
+         eos/get_sg_eos.cpp)
+    if (SINGULARITY_USE_KOKKOS)
+      list(APPEND EOS_SRCS 
+           eos/get_sg_eos_p_t.cpp
+           eos/get_sg_eos_rho_t.cpp
+           eos/get_sg_eos_rho_p.cpp
+           eos/get_sg_eos_rho_e.cpp)
+    endif()
+    list(APPEND EOS_HEADERS
+         eos/get_sg_eos.hpp
+         eos/get_sg_eos_lambdas.hpp)
   endif()
-  list(APPEND EOS_HEADERS
-       closure/mixed_cell_models.hpp
-       eos/get_sg_eos.hpp
-       eos/get_sg_eos_lambdas.hpp)
 endif()
 
 if (SINGULARITY_USE_FORTRAN)
diff --git a/singularity-eos/eos/eos_eospac.hpp b/singularity-eos/eos/eos_eospac.hpp
index f3dfa928fa..c8c59de598 100644
--- a/singularity-eos/eos/eos_eospac.hpp
+++ b/singularity-eos/eos/eos_eospac.hpp
@@ -1461,7 +1461,6 @@ EOSPAC::DensityEnergyFromPressureTemperature(const Real press, const Real temp,
   EOS_REAL T[1] = {temperatureToSesame(temp)};
   EOS_REAL dx[1], dy[1], R[1], E[1];
   EOS_INTEGER nxypairs = 1;
-  // EOS_INTEGER errorCode;
   EOS_INTEGER table;
 
   table = RofPT_table_;

From f7736f8a4d4068e0b46f817fc7edd08952143a00 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Thu, 3 Aug 2023 17:43:05 -0600
Subject: [PATCH 32/45] Fix more warnings. Some related to capturing this in
 modifiers, this should get rid of those.

---
 singularity-eos/eos/modifiers/ramps_eos.hpp   | 20 +++++++++----------
 singularity-eos/eos/modifiers/shifted_eos.hpp |  6 ++++--
 test/test_pte.cpp                             | 10 ++++++----
 3 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/singularity-eos/eos/modifiers/ramps_eos.hpp b/singularity-eos/eos/modifiers/ramps_eos.hpp
index 16558594ed..a0111b8ea5 100644
--- a/singularity-eos/eos/modifiers/ramps_eos.hpp
+++ b/singularity-eos/eos/modifiers/ramps_eos.hpp
@@ -246,10 +246,10 @@ class BilinearRampEOS : public EosBase<BilinearRampEOS<T>> {
     static auto const name = singularity::mfuncname::member_func_name(
         typeid(BilinearRampEOS<T>).name(), __func__);
     static auto const cname = name.c_str();
-
+    auto const copy = *this;
     portableFor(
         cname, 0, num, PORTABLE_LAMBDA(const int i) {
-          const Real p_ramp = get_ramp_pressure(rhos[i]);
+          const Real p_ramp = copy.get_ramp_pressure(rhos[i]);
           pressures[i] = std::max(pressures[i], p_ramp);
         });
   }
@@ -265,10 +265,10 @@ class BilinearRampEOS : public EosBase<BilinearRampEOS<T>> {
     static auto const name = singularity::mfuncname::member_func_name(
         typeid(BilinearRampEOS<T>).name(), __func__);
     static auto const cname = name.c_str();
-
+    auto const copy = *this;
     portableFor(
         cname, 0, num, PORTABLE_LAMBDA(const int i) {
-          const Real p_ramp = get_ramp_pressure(rhos[i]);
+          const Real p_ramp = copy.get_ramp_pressure(rhos[i]);
           pressures[i] = std::max(pressures[i], p_ramp);
         });
   }
@@ -305,12 +305,12 @@ class BilinearRampEOS : public EosBase<BilinearRampEOS<T>> {
     static auto const name = singularity::mfuncname::member_func_name(
         typeid(BilinearRampEOS<T>).name(), __func__);
     static auto const cname = name.c_str();
-
+    auto const copy = *this;
     portableFor(
         cname, 0, num, PORTABLE_LAMBDA(const int i) {
-          const Real p_ramp = get_ramp_pressure(rhos[i]);
+          const Real p_ramp = copy.get_ramp_pressure(rhos[i]);
           if (pressures[i] < p_ramp) {
-            bmods[i] = rhos[i] * get_ramp_dpdrho(rhos[i]);
+            bmods[i] = rhos[i] * copy.get_ramp_dpdrho(rhos[i]);
           }
         });
   }
@@ -329,12 +329,12 @@ class BilinearRampEOS : public EosBase<BilinearRampEOS<T>> {
     static auto const name = singularity::mfuncname::member_func_name(
         typeid(BilinearRampEOS<T>).name(), __func__);
     static auto const cname = name.c_str();
-
+    auto const copy = *this;
     portableFor(
         cname, 0, num, PORTABLE_LAMBDA(const int i) {
-          const Real p_ramp = get_ramp_pressure(rhos[i]);
+          const Real p_ramp = copy.get_ramp_pressure(rhos[i]);
           if (pressures[i] < p_ramp) {
-            bmods[i] = rhos[i] * get_ramp_dpdrho(rhos[i]);
+            bmods[i] = rhos[i] * copy.get_ramp_dpdrho(rhos[i]);
           }
         });
   }
diff --git a/singularity-eos/eos/modifiers/shifted_eos.hpp b/singularity-eos/eos/modifiers/shifted_eos.hpp
index 41dd387d33..864039a03a 100644
--- a/singularity-eos/eos/modifiers/shifted_eos.hpp
+++ b/singularity-eos/eos/modifiers/shifted_eos.hpp
@@ -158,16 +158,18 @@ class ShiftedEOS : public EosBase<ShiftedEOS<T>> {
     static auto const name =
         singularity::mfuncname::member_func_name(typeid(ShiftedEOS<T>).name(), __func__);
     static auto const cname = name.c_str();
+    const auto shift_val = shift_;
     portableFor(
-        cname, 0, num, PORTABLE_LAMBDA(const int i) { shifted[i] = sies[i] - shift_; });
+        cname, 0, num, PORTABLE_LAMBDA(const int i) { shifted[i] = sies[i] - shift_val; });
   }
 
   inline void unshift_sies(Real *sies, const int num) const {
     static auto const name =
         singularity::mfuncname::member_func_name(typeid(ShiftedEOS<T>).name(), __func__);
     static auto const cname = name.c_str();
+    const auto shift_val = shift_;
     portableFor(
-        cname, 0, num, PORTABLE_LAMBDA(const int i) { sies[i] += shift_; });
+        cname, 0, num, PORTABLE_LAMBDA(const int i) { sies[i] += shift_val; });
   }
 
   template <typename LambdaIndexer>
diff --git a/test/test_pte.cpp b/test/test_pte.cpp
index 5a8034a4e4..746aedc880 100644
--- a/test/test_pte.cpp
+++ b/test/test_pte.cpp
@@ -63,11 +63,13 @@ class Indexer2D {
 
 template <typename EOSIndexer>
 void set_eos(EOSIndexer &&eos) {
-  eos[0] = Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
-  eos[1] = DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
+  auto gr = Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
+  auto dr = DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
                           0.4265, 0.001074e10);
-  eos[2] =
-      DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
+  auto dp = DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
+  eos[0] = gr.GetOnDevice();
+  eos[1] = dr.GetOnDevice();
+  eos[2] = dp.GetOnDevice();
 }
 
 template <typename RealIndexer, typename EOSIndexer>

From 0aab2536bd8290fe2039846c642951a4528d4b6d Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Fri, 4 Aug 2023 00:50:03 -0600
Subject: [PATCH 33/45] Fix ci warnings + format.

---
 singularity-eos/eos/modifiers/shifted_eos.hpp |  3 ++-
 test/test_pte.cpp                             | 11 ++++++-----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/singularity-eos/eos/modifiers/shifted_eos.hpp b/singularity-eos/eos/modifiers/shifted_eos.hpp
index 864039a03a..45c3ed4d4b 100644
--- a/singularity-eos/eos/modifiers/shifted_eos.hpp
+++ b/singularity-eos/eos/modifiers/shifted_eos.hpp
@@ -160,7 +160,8 @@ class ShiftedEOS : public EosBase<ShiftedEOS<T>> {
     static auto const cname = name.c_str();
     const auto shift_val = shift_;
     portableFor(
-        cname, 0, num, PORTABLE_LAMBDA(const int i) { shifted[i] = sies[i] - shift_val; });
+        cname, 0, num,
+        PORTABLE_LAMBDA(const int i) { shifted[i] = sies[i] - shift_val; });
   }
 
   inline void unshift_sies(Real *sies, const int num) const {
diff --git a/test/test_pte.cpp b/test/test_pte.cpp
index 746aedc880..caa4b46a13 100644
--- a/test/test_pte.cpp
+++ b/test/test_pte.cpp
@@ -61,12 +61,13 @@ class Indexer2D {
   const T &data_;
 };
 
-template <typename EOSIndexer>
-void set_eos(EOSIndexer &&eos) {
+template <typename T>
+void set_eos(T *eos) {
   auto gr = Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
   auto dr = DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
-                          0.4265, 0.001074e10);
-  auto dp = DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
+                           0.4265, 0.001074e10);
+  auto dp =
+      DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
   eos[0] = gr.GetOnDevice();
   eos[1] = dr.GetOnDevice();
   eos[2] = dp.GetOnDevice();
@@ -230,7 +231,7 @@ int main(int argc, char *argv[]) {
 #endif
 
     LinearIndexer<decltype(eos_hv)> eos_h(eos_hv);
-    set_eos(eos_h);
+    set_eos(eos_hv.data());
 
 #ifdef PORTABILITY_STRATEGY_KOKKOS
     Kokkos::deep_copy(eos_v, eos_hv);

From 1f77a510415386145f5f0750a5c769ee91ded263 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Fri, 4 Aug 2023 08:23:26 -0600
Subject: [PATCH 34/45] try to fix warning.

---
 test/test_pte.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/test_pte.cpp b/test/test_pte.cpp
index caa4b46a13..2e095dc6a5 100644
--- a/test/test_pte.cpp
+++ b/test/test_pte.cpp
@@ -63,10 +63,10 @@ class Indexer2D {
 
 template <typename T>
 void set_eos(T *eos) {
-  auto gr = Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
-  auto dr = DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
+  EOS gr = Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
+  EOS dr = DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
                            0.4265, 0.001074e10);
-  auto dp =
+  EOS dp =
       DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
   eos[0] = gr.GetOnDevice();
   eos[1] = dr.GetOnDevice();

From 1d4fc855a5159baafbdd2ea75c004a4615be918f Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Fri, 4 Aug 2023 11:31:44 -0600
Subject: [PATCH 35/45] Remove unused variables.

---
 test/test_eos_stiff.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/test_eos_stiff.cpp b/test/test_eos_stiff.cpp
index 6e6fda2f0f..e5c7ac9ddb 100644
--- a/test/test_eos_stiff.cpp
+++ b/test/test_eos_stiff.cpp
@@ -534,8 +534,6 @@ SCENARIO("Test Stiff Gas Entropy Calls", "[StiffGas][StiffGas5]") {
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
       // Gold standard values for a subset of lookups
-      constexpr std::array<Real, num> pressure_true{2.0265000000000000e+06};
-      constexpr std::array<Real, num> temperature_true{4.0000000000000000e+02};
       constexpr std::array<Real, num> entropy_true{-2.0044437857420778e+08};
 
 #ifdef PORTABILITY_STRATEGY_KOKKOS

From 0dd02680d65a5a468e73872802c8cb807b8db565 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Fri, 4 Aug 2023 12:00:08 -0600
Subject: [PATCH 36/45] format.

---
 test/test_pte.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_pte.cpp b/test/test_pte.cpp
index 2e095dc6a5..8c1808d908 100644
--- a/test/test_pte.cpp
+++ b/test/test_pte.cpp
@@ -65,7 +65,7 @@ template <typename T>
 void set_eos(T *eos) {
   EOS gr = Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
   EOS dr = DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
-                           0.4265, 0.001074e10);
+                          0.4265, 0.001074e10);
   EOS dp =
       DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
   eos[0] = gr.GetOnDevice();

From 97746216d5a03cddf65d2b587003702634b7a86e Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 14 Aug 2023 12:14:27 -0600
Subject: [PATCH 37/45] Test refactor. The getsgeos tests are now in their own
 file that respect build restrictions that reduce compile times. PTE tests
 still built under normal conditions.

---
 test/CMakeLists.txt      |  18 +++-
 test/pte_test_utils.hpp  |  92 +++++++++++++++++++
 test/test_get_sg_eos.cpp | 154 +++++++++++++++++++++++++++++++
 test/test_pte.cpp        | 191 +--------------------------------------
 4 files changed, 262 insertions(+), 193 deletions(-)
 create mode 100644 test/pte_test_utils.hpp
 create mode 100644 test/test_get_sg_eos.cpp

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 61fe8ed264..16d01e682c 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -40,11 +40,21 @@ if(SINGULARITY_USE_EOSPAC AND SINGULARITY_TEST_SESAME)
                         PRIVATE Catch2::Catch2 singularity-eos::singularity-eos)
 endif()
 
-if(SINGULARITY_BUILD_CLOSURE AND SINGULARITY_USE_SPINER)
-  add_executable(test_pte test_pte.cpp)
-  target_link_libraries(test_pte PRIVATE Catch2::Catch2
+if(SINGULARITY_BUILD_CLOSURE)
+  if(SINGULARITY_USE_SPINER)
+    add_executable(test_pte test_pte.cpp)
+    target_link_libraries(test_pte PRIVATE Catch2::Catch2
                                          singularity-eos::singularity-eos)
-  add_test(pte test_pte)
+    target_include_directories(test_pte PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+    add_test(pte test_pte)
+  endif()
+  if(SINGULARITY_USE_KOKKOS AND SINGULARITY_USE_FORTRAN)
+    add_executable(test_get_sg_eos test_get_sg_eos.cpp)
+    target_link_libraries(test_get_sg_eos PRIVATE Catch2::Catch2
+                                         singularity-eos::singularity-eos)
+    target_include_directories(test_get_sg_eos PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+    add_test(get_sg_eos test_get_sg_eos)
+  endif()
 endif()
 
 if(SINGULARITY_TEST_STELLAR_COLLAPSE)
diff --git a/test/pte_test_utils.hpp b/test/pte_test_utils.hpp
new file mode 100644
index 0000000000..023df25b09
--- /dev/null
+++ b/test/pte_test_utils.hpp
@@ -0,0 +1,92 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#ifndef _SINGULARITY_EOS_TEST_PTE_TEST_UTILS_
+#define _SINGULARITY_EOS_TEST_PTE_TEST_UTILS_
+
+#include <stdlib.h>
+
+#include <ports-of-call/portability.hpp>
+#include <ports-of-call/portable_arrays.hpp>
+#include <singularity-eos/eos/eos.hpp>
+
+constexpr int NMAT = 3;
+constexpr int NTRIAL = 100;
+constexpr int NPTS = NTRIAL * NMAT;
+constexpr int HIST_SIZE = 10;
+
+template <typename T>
+class LinearIndexer {
+ public:
+  PORTABLE_FUNCTION LinearIndexer() = default;
+  LinearIndexer(const T &t) : data_(t) {}
+  PORTABLE_INLINE_FUNCTION
+  auto &operator[](const int i) const { return data_(i); }
+
+ private:
+  T data_;
+};
+
+template <typename T>
+class Indexer2D {
+ public:
+  PORTABLE_FUNCTION Indexer2D() = default;
+  PORTABLE_FUNCTION Indexer2D(const int j, const T &t) : j_(j), data_(t) {}
+  Indexer2D(const int j, const T &&t) = delete; // prevents r-value binding
+  PORTABLE_INLINE_FUNCTION
+  auto &operator[](const int i) const { return data_(j_, i); }
+
+ private:
+  const int j_;
+  const T &data_;
+};
+
+template <typename T>
+inline void set_eos(T *eos) {
+  singularity::EOS gr = 
+      singularity::Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
+  singularity::EOS dr =
+      singularity::DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
+                                  0.4265, 0.001074e10);
+  singularity::EOS dp =
+      singularity::DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
+  eos[0] = gr.GetOnDevice();
+  eos[1] = dr.GetOnDevice();
+  eos[2] = dp.GetOnDevice();
+  return;
+}
+
+template <typename RealIndexer, typename EOSIndexer>
+inline void set_state(RealIndexer &&rho, RealIndexer &&vfrac, RealIndexer &&sie,
+                      RealIndexer &&temp, EOSIndexer &&eos) {
+
+  rho[0] = 8.93;
+  rho[1] = 1.89;
+  rho[2] = 2.5;
+
+  Real vsum = 0.;
+  for (int i = 0; i < NMAT; i++) {
+    temp[i] = 600.0;
+    sie[i] = eos[i].InternalEnergyFromDensityTemperature(rho[i], temp[i]);
+    vfrac[i] = rand() / (1.0 * RAND_MAX);
+    vsum += vfrac[i];
+  }
+
+  for (int i = 0; i < NMAT; i++)
+    vfrac[i] *= 1.0 / vsum;
+
+  return;
+}
+
+#endif // _SINGULARITY_EOS_TEST_PTE_TEST_UTILS_
diff --git a/test/test_get_sg_eos.cpp b/test/test_get_sg_eos.cpp
new file mode 100644
index 0000000000..f06dd4e2c0
--- /dev/null
+++ b/test/test_get_sg_eos.cpp
@@ -0,0 +1,154 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <iostream>
+#include <memory>
+#include <stdlib.h>
+
+#include <pte_test_utils.hpp>
+#include <ports-of-call/portability.hpp>
+#include <singularity-eos/closure/mixed_cell_models.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/eos/singularity_eos.hpp>
+
+using namespace singularity;
+
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+// TODO DAH: when the get_sg_eos function is moved out of sg,
+// this function will have to change how the PTE solutions
+// are obtained.
+int run_sg_get_eos_tests() {
+  int nfails = 0;
+  // initialize inputs outputs
+  static constexpr const double ev2k = 1.160451930280894026e4;
+  EOS eoss[NMAT];
+  set_eos(eoss);
+  // set volume fractions to equipartition
+  // all variables needed to check the pte solve
+  Real mfrac[NMAT];
+  Real P_true = 5.e10, T_true = 800.0;
+  Real T_true_ev = T_true / ev2k;
+  Real mass_tot = 0.0, sie_tot_true = 0.0, v_true = 1.0, rho_tot, spvol;
+  Real pmax, bmod, dpde, cv;
+  mfrac[0] = 0.67;
+  mfrac[1] = 0.14;
+  mfrac[2] = 0.19;
+  for (int i = 0; i < NMAT; ++i) {
+    mass_tot += mfrac[i];
+  }
+  rho_tot = mass_tot / v_true;
+  spvol = 1.0 / rho_tot;
+  int cell_offset = 1;
+  int eos_offset[NMAT];
+  for (int m = 0; m < NMAT; ++m) {
+    eos_offset[m] = m + 1;
+  }
+  // do a rho/e(P,T) solve
+  Real vfrac_true[NMAT], ie_true[NMAT];
+  get_sg_eos(NMAT, 1, 1, -1, eos_offset, eoss, &cell_offset, &P_true, &pmax, &v_true,
+             &spvol, &sie_tot_true, &T_true_ev, &bmod, &dpde, &cv, mfrac, vfrac_true,
+             ie_true, nullptr, nullptr, nullptr);
+  Real sie_tot_check = 0.0;
+  for (int m = 0; m < NMAT; ++m) {
+    const Real r_m = mfrac[m] / vfrac_true[m];
+    const Real sie_m = ie_true[m] / mfrac[m];
+    const Real p_eos = eoss[m].PressureFromDensityInternalEnergy(r_m, sie_m);
+    const Real p_resid = std::abs(P_true - p_eos) / P_true;
+    const Real t_eos = eoss[m].TemperatureFromDensityInternalEnergy(r_m, sie_m);
+    const Real t_resid = std::abs(T_true - t_eos) / T_true;
+    // check internal consitency of P-T input function
+    if (t_resid > 1.e-5 || p_resid > 1.e-5) {
+      printf("P-T: t_resid: %e | p_resid: %e\n", t_resid, p_resid);
+      nfails += 1;
+    }
+    sie_tot_check += ie_true[m];
+  }
+  sie_tot_check /= mass_tot;
+  // further check of internal consintency of P-T input function
+  if (std::abs(sie_tot_check - sie_tot_true) / std::abs(sie_tot_true) > 1.e-5) {
+    printf("P-T: sie_tot_true: %e | sie_tot_check: %e\n", sie_tot_true, sie_tot_check);
+    nfails += 1;
+  }
+  // obtain converged and consistent PTE solution
+  // do rho-T input solve
+  Real p_check, vfrac_check[NMAT], ie_check[NMAT];
+  get_sg_eos(NMAT, 1, 1, -3, eos_offset, eoss, &cell_offset, &p_check, &pmax, &v_true,
+             &spvol, &sie_tot_check, &T_true_ev, &bmod, &dpde, &cv, mfrac, vfrac_check,
+             ie_check, nullptr, nullptr, nullptr);
+  // check output pressure and sie, indicate failure if relative err is too large
+  if (std::abs(P_true - p_check) / std::abs(P_true) > 1.e-5 ||
+      std::abs(sie_tot_true - sie_tot_check) / std::abs(sie_tot_true) > 1.e-5) {
+    printf("r-T: p_true: %e | p_check: %e\n", P_true, p_check);
+    printf("r-T: sie_tot_true: %e | sie_tot_check: %e\n", sie_tot_true, sie_tot_check);
+    nfails += 1;
+  }
+  Real max_vfrac_resid = 0.0;
+  Real max_sie_resid = 0.0;
+  for (int m = 0; m < NMAT; ++m) {
+    max_vfrac_resid = std::max(max_vfrac_resid, std::abs(vfrac_true[m] - vfrac_check[m]) /
+                                                    std::abs(vfrac_true[m]));
+    max_sie_resid = std::max(max_sie_resid,
+                             std::abs(ie_true[m] - ie_check[m]) / std::abs(ie_true[m]));
+  }
+  if (max_vfrac_resid > 1.e-5 || max_sie_resid > 1.e-5) {
+    printf("r-T: vr: %e | sr: %e\n", max_vfrac_resid, max_sie_resid);
+    nfails += 1;
+  }
+  // do rho-P input solve
+  Real t_check;
+  get_sg_eos(NMAT, 1, 1, -2, eos_offset, eoss, &cell_offset, &P_true, &pmax, &v_true,
+             &spvol, &sie_tot_check, &t_check, &bmod, &dpde, &cv, mfrac, vfrac_check,
+             ie_check, nullptr, nullptr, nullptr);
+  // check output temperature and sie, indicate failure if relative err is too large
+  if (std::abs(T_true_ev - t_check) / std::abs(T_true_ev) > 1.e-5 ||
+      std::abs(sie_tot_true - sie_tot_check) / std::abs(sie_tot_true) > 1.e-5) {
+    printf("p-T: t_true: %e | t_check: %e\n", T_true_ev, t_check);
+    printf("p-T: sie_tot_true: %e | sie_tot_check: %e\n", sie_tot_true, sie_tot_check);
+    nfails += 1;
+  }
+  max_vfrac_resid = 0.0;
+  max_sie_resid = 0.0;
+  for (int m = 0; m < NMAT; ++m) {
+    max_vfrac_resid = std::max(max_vfrac_resid, std::abs(vfrac_true[m] - vfrac_check[m]) /
+                                                    std::abs(vfrac_true[m]));
+    max_sie_resid = std::max(max_sie_resid,
+                             std::abs(ie_true[m] - ie_check[m]) / std::abs(ie_true[m]));
+  }
+  if (max_vfrac_resid > 1.e-5 || max_sie_resid > 1.e-5) {
+    printf("p-T: vr: %e | sr: %e\n", max_vfrac_resid, max_sie_resid);
+    nfails += 1;
+  }
+  return nfails;
+}
+#endif
+
+int main(int argc, char *argv[]) {
+
+  int nfails_get_sg_eos = 1;
+#ifdef PORTABILITY_STRATEGY_KOKKOS
+  Kokkos::initialize();
+  {
+    // run the various solver tests:
+    // since this uses the sg_get_eos, only run
+    // if kokkos enable since that function requires it
+    // to run the solvers
+    nfails_get_sg_eos = run_sg_get_eos_tests();
+    if (nfails_get_sg_eos > 0) {
+      printf("nfails of fixed T/P solvers = %i\n", nfails_get_sg_eos);
+    }
+  }
+  Kokkos::finalize();
+#endif // PORTABILITY_STRATEGY_KOKKOS
+  return nfails_get_sg_eos;
+}
diff --git a/test/test_pte.cpp b/test/test_pte.cpp
index 8c1808d908..35330ef9ed 100644
--- a/test/test_pte.cpp
+++ b/test/test_pte.cpp
@@ -19,207 +19,24 @@
 #include <time.h>
 #include <vector>
 
+#include <pte_test_utils.hpp>
 #include <ports-of-call/portability.hpp>
 #include <ports-of-call/portable_arrays.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
-#include <singularity-eos/eos/singularity_eos.hpp>
 #include <spiner/databox.hpp>
 
-constexpr int NMAT = 3;
-constexpr int NTRIAL = 100;
-constexpr int NPTS = NTRIAL * NMAT;
-constexpr int HIST_SIZE = 10;
-
 using namespace singularity;
 
 using DataBox = Spiner::DataBox<Real>;
 
-template <typename T>
-class LinearIndexer {
- public:
-  PORTABLE_FUNCTION LinearIndexer() = default;
-  LinearIndexer(const T &t) : data_(t) {}
-  PORTABLE_INLINE_FUNCTION
-  auto &operator[](const int i) const { return data_(i); }
-
- private:
-  T data_;
-};
-
-template <typename T>
-class Indexer2D {
- public:
-  PORTABLE_FUNCTION Indexer2D() = default;
-  PORTABLE_FUNCTION Indexer2D(const int j, const T &t) : j_(j), data_(t) {}
-  Indexer2D(const int j, const T &&t) = delete; // prevents r-value binding
-  PORTABLE_INLINE_FUNCTION
-  auto &operator[](const int i) const { return data_(j_, i); }
-
- private:
-  const int j_;
-  const T &data_;
-};
-
-template <typename T>
-void set_eos(T *eos) {
-  EOS gr = Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
-  EOS dr = DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
-                          0.4265, 0.001074e10);
-  EOS dp =
-      DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
-  eos[0] = gr.GetOnDevice();
-  eos[1] = dr.GetOnDevice();
-  eos[2] = dp.GetOnDevice();
-}
-
-template <typename RealIndexer, typename EOSIndexer>
-void set_state(RealIndexer &&rho, RealIndexer &&vfrac, RealIndexer &&sie,
-               RealIndexer &&temp, EOSIndexer &&eos) {
-
-  rho[0] = 8.93;
-  rho[1] = 1.89;
-  rho[2] = 2.5;
-
-  Real vsum = 0.;
-  for (int i = 0; i < NMAT; i++) {
-    temp[i] = 600.0;
-    sie[i] = eos[i].InternalEnergyFromDensityTemperature(rho[i], temp[i]);
-    vfrac[i] = rand() / (1.0 * RAND_MAX);
-    vsum += vfrac[i];
-  }
-
-  for (int i = 0; i < NMAT; i++)
-    vfrac[i] *= 1.0 / vsum;
-}
-
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-// TODO DAH: when the get_sg_eos function is moved out of sg,
-// this function will have to change how the PTE solutions
-// are obtained.
-int run_sg_get_eos_tests() {
-  int nfails = 0;
-  // initialize inputs outputs
-  static constexpr const double ev2k = 1.160451930280894026e4;
-  EOS eoss[NMAT];
-  set_eos(eoss);
-  // set volume fractions to equipartition
-  // all variables needed to check the pte solve
-  Real mfrac[NMAT];
-  Real P_true = 5.e10, T_true = 800.0;
-  Real T_true_ev = T_true / ev2k;
-  Real mass_tot = 0.0, sie_tot_true = 0.0, v_true = 1.0, rho_tot, spvol;
-  Real pmax, bmod, dpde, cv;
-  mfrac[0] = 0.67;
-  mfrac[1] = 0.14;
-  mfrac[2] = 0.19;
-  for (int i = 0; i < NMAT; ++i) {
-    mass_tot += mfrac[i];
-  }
-  rho_tot = mass_tot / v_true;
-  spvol = 1.0 / rho_tot;
-  int cell_offset = 1;
-  int eos_offset[NMAT];
-  for (int m = 0; m < NMAT; ++m) {
-    eos_offset[m] = m + 1;
-  }
-  // do a rho/e(P,T) solve
-  Real vfrac_true[NMAT], ie_true[NMAT];
-  get_sg_eos(NMAT, 1, 1, -1, eos_offset, eoss, &cell_offset, &P_true, &pmax, &v_true,
-             &spvol, &sie_tot_true, &T_true_ev, &bmod, &dpde, &cv, mfrac, vfrac_true,
-             ie_true, nullptr, nullptr, nullptr);
-  Real sie_tot_check = 0.0;
-  for (int m = 0; m < NMAT; ++m) {
-    const Real r_m = mfrac[m] / vfrac_true[m];
-    const Real sie_m = ie_true[m] / mfrac[m];
-    const Real p_eos = eoss[m].PressureFromDensityInternalEnergy(r_m, sie_m);
-    const Real p_resid = std::abs(P_true - p_eos) / P_true;
-    const Real t_eos = eoss[m].TemperatureFromDensityInternalEnergy(r_m, sie_m);
-    const Real t_resid = std::abs(T_true - t_eos) / T_true;
-    // check internal consitency of P-T input function
-    if (t_resid > 1.e-5 || p_resid > 1.e-5) {
-      printf("P-T: t_resid: %e | p_resid: %e\n", t_resid, p_resid);
-      nfails += 1;
-    }
-    sie_tot_check += ie_true[m];
-  }
-  sie_tot_check /= mass_tot;
-  // further check of internal consintency of P-T input function
-  if (std::abs(sie_tot_check - sie_tot_true) / std::abs(sie_tot_true) > 1.e-5) {
-    printf("P-T: sie_tot_true: %e | sie_tot_check: %e\n", sie_tot_true, sie_tot_check);
-    nfails += 1;
-  }
-  // obtain converged and consistent PTE solution
-  // do rho-T input solve
-  Real p_check, vfrac_check[NMAT], ie_check[NMAT];
-  get_sg_eos(NMAT, 1, 1, -3, eos_offset, eoss, &cell_offset, &p_check, &pmax, &v_true,
-             &spvol, &sie_tot_check, &T_true_ev, &bmod, &dpde, &cv, mfrac, vfrac_check,
-             ie_check, nullptr, nullptr, nullptr);
-  // check output pressure and sie, indicate failure if relative err is too large
-  if (std::abs(P_true - p_check) / std::abs(P_true) > 1.e-5 ||
-      std::abs(sie_tot_true - sie_tot_check) / std::abs(sie_tot_true) > 1.e-5) {
-    printf("r-T: p_true: %e | p_check: %e\n", P_true, p_check);
-    printf("r-T: sie_tot_true: %e | sie_tot_check: %e\n", sie_tot_true, sie_tot_check);
-    nfails += 1;
-  }
-  Real max_vfrac_resid = 0.0;
-  Real max_sie_resid = 0.0;
-  for (int m = 0; m < NMAT; ++m) {
-    max_vfrac_resid = std::max(max_vfrac_resid, std::abs(vfrac_true[m] - vfrac_check[m]) /
-                                                    std::abs(vfrac_true[m]));
-    max_sie_resid = std::max(max_sie_resid,
-                             std::abs(ie_true[m] - ie_check[m]) / std::abs(ie_true[m]));
-  }
-  if (max_vfrac_resid > 1.e-5 || max_sie_resid > 1.e-5) {
-    printf("r-T: vr: %e | sr: %e\n", max_vfrac_resid, max_sie_resid);
-    nfails += 1;
-  }
-  // do rho-P input solve
-  Real t_check;
-  get_sg_eos(NMAT, 1, 1, -2, eos_offset, eoss, &cell_offset, &P_true, &pmax, &v_true,
-             &spvol, &sie_tot_check, &t_check, &bmod, &dpde, &cv, mfrac, vfrac_check,
-             ie_check, nullptr, nullptr, nullptr);
-  // check output temperature and sie, indicate failure if relative err is too large
-  if (std::abs(T_true_ev - t_check) / std::abs(T_true_ev) > 1.e-5 ||
-      std::abs(sie_tot_true - sie_tot_check) / std::abs(sie_tot_true) > 1.e-5) {
-    printf("p-T: t_true: %e | t_check: %e\n", T_true_ev, t_check);
-    printf("p-T: sie_tot_true: %e | sie_tot_check: %e\n", sie_tot_true, sie_tot_check);
-    nfails += 1;
-  }
-  max_vfrac_resid = 0.0;
-  max_sie_resid = 0.0;
-  for (int m = 0; m < NMAT; ++m) {
-    max_vfrac_resid = std::max(max_vfrac_resid, std::abs(vfrac_true[m] - vfrac_check[m]) /
-                                                    std::abs(vfrac_true[m]));
-    max_sie_resid = std::max(max_sie_resid,
-                             std::abs(ie_true[m] - ie_check[m]) / std::abs(ie_true[m]));
-  }
-  if (max_vfrac_resid > 1.e-5 || max_sie_resid > 1.e-5) {
-    printf("p-T: vr: %e | sr: %e\n", max_vfrac_resid, max_sie_resid);
-    nfails += 1;
-  }
-  return nfails;
-}
-#endif
-
 int main(int argc, char *argv[]) {
 
   int nsuccess = 0;
-  int nfails_get_sg_eos = 0;
 #ifdef PORTABILITY_STRATEGY_KOKKOS
   Kokkos::initialize();
 #endif
   {
-    // run the various solver tests:
-    // since this uses the sg_get_eos, only run
-    // if kokkos enable since that function requires it
-    // to run the solvers
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-    nfails_get_sg_eos = run_sg_get_eos_tests();
-    if (nfails_get_sg_eos > 0) {
-      printf("nfails of fixed T/P solvers = %i\n", nfails_get_sg_eos);
-    }
-#endif // PORTABILITY_STRATEGY_KOKKOS
        // EOS
 #ifdef PORTABILITY_STRATEGY_KOKKOS
     Kokkos::View<EOS *> eos_v("eos", NMAT);
@@ -387,9 +204,5 @@ int main(int argc, char *argv[]) {
 #endif
 
   // poor-man's ctest integration
-  if (nsuccess >= 0.5 * NTRIAL) {
-    return 0 + nfails_get_sg_eos; // exit success
-  } else {
-    return 1 + nfails_get_sg_eos; // exit failure
-  }
+  return (nsuccess >= 0.5 * NTRIAL) ? 0 : 1;
 }

From bdf02e3fe0142265306fbbd65938b771bab48fef Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Mon, 14 Aug 2023 12:25:42 -0600
Subject: [PATCH 38/45] Format.

---
 test/pte_test_utils.hpp  | 13 ++++++-------
 test/test_get_sg_eos.cpp |  2 +-
 test/test_pte.cpp        |  4 ++--
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/test/pte_test_utils.hpp b/test/pte_test_utils.hpp
index 023df25b09..d61b09747e 100644
--- a/test/pte_test_utils.hpp
+++ b/test/pte_test_utils.hpp
@@ -54,13 +54,12 @@ class Indexer2D {
 
 template <typename T>
 inline void set_eos(T *eos) {
-  singularity::EOS gr = 
-      singularity::Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47, 8.93, 297.0, 1.0e6, 0.383e7);
-  singularity::EOS dr =
-      singularity::DavisReactants(1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0,
-                                  0.4265, 0.001074e10);
-  singularity::EOS dp =
-      singularity::DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419, 3.2e10, 0.001072e10, 0.0);
+  singularity::EOS gr = singularity::Gruneisen(394000.0, 1.489, 0.0, 0.0, 2.02, 0.47,
+                                               8.93, 297.0, 1.0e6, 0.383e7);
+  singularity::EOS dr = singularity::DavisReactants(
+      1.890, 4.115e10, 1.0e6, 297.0, 1.8e5, 4.6, 0.34, 0.56, 0.0, 0.4265, 0.001074e10);
+  singularity::EOS dp = singularity::DavisProducts(0.798311, 0.58, 1.35, 2.66182, 0.75419,
+                                                   3.2e10, 0.001072e10, 0.0);
   eos[0] = gr.GetOnDevice();
   eos[1] = dr.GetOnDevice();
   eos[2] = dp.GetOnDevice();
diff --git a/test/test_get_sg_eos.cpp b/test/test_get_sg_eos.cpp
index f06dd4e2c0..85c664ddf6 100644
--- a/test/test_get_sg_eos.cpp
+++ b/test/test_get_sg_eos.cpp
@@ -16,8 +16,8 @@
 #include <memory>
 #include <stdlib.h>
 
-#include <pte_test_utils.hpp>
 #include <ports-of-call/portability.hpp>
+#include <pte_test_utils.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/singularity_eos.hpp>
diff --git a/test/test_pte.cpp b/test/test_pte.cpp
index 35330ef9ed..bfed57224f 100644
--- a/test/test_pte.cpp
+++ b/test/test_pte.cpp
@@ -19,9 +19,9 @@
 #include <time.h>
 #include <vector>
 
-#include <pte_test_utils.hpp>
 #include <ports-of-call/portability.hpp>
 #include <ports-of-call/portable_arrays.hpp>
+#include <pte_test_utils.hpp>
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <spiner/databox.hpp>
@@ -37,7 +37,7 @@ int main(int argc, char *argv[]) {
   Kokkos::initialize();
 #endif
   {
-       // EOS
+    // EOS
 #ifdef PORTABILITY_STRATEGY_KOKKOS
     Kokkos::View<EOS *> eos_v("eos", NMAT);
     auto eos_hv = Kokkos::create_mirror_view(eos_v);

From a77b09024e109bf8642fce8f00bdacbe32bba214 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 15 Aug 2023 11:55:52 -0600
Subject: [PATCH 39/45] Switch from lambdas with macros to functors.

---
 singularity-eos/eos/get_sg_eos.cpp         |  27 +-
 singularity-eos/eos/get_sg_eos.hpp         |  14 +-
 singularity-eos/eos/get_sg_eos_lambdas.hpp | 361 ++++++++++++++-------
 singularity-eos/eos/get_sg_eos_p_t.cpp     |   5 +-
 singularity-eos/eos/get_sg_eos_rho_e.cpp   |   9 +-
 singularity-eos/eos/get_sg_eos_rho_p.cpp   |   8 +-
 singularity-eos/eos/get_sg_eos_rho_t.cpp   |   8 +-
 7 files changed, 294 insertions(+), 138 deletions(-)

diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 42fe201f7e..d7cc9da196 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -142,15 +142,28 @@ int get_sg_eos( // sizing information
   // declare solver scratch, allocate in the case statement
   int pte_solver_scratch_size{};
   ScratchV<double> solver_scratch;
+  // declare init and final functors
+  auto input_int_enum = static_cast<input_condition>(input_int);
+  init_functor i_func;
+  final_functor f_func(temp_v, press_v, sie_v, bmod_v, cv_v,
+		       dpde_v, pte_mats, press_pte, vfrac_pte,
+		       temp_pte, sie_pte, frac_mass_v, frac_ie_v,
+		       frac_vol_v, vol_v, eos_v, pte_idxs, rho_pte,
+		       frac_bmod_v, frac_cv_v, frac_dpde_v, nmat,
+		       do_frac_bmod, do_frac_cv, do_frac_dpde);
+  // only initialize init functor when needed
+  if (input_int_enum != input_condition::P_T_INPUT) {
+    i_func = init_functor(frac_mass_v, pte_idxs, eos_offsets_v,
+			  frac_vol_v, pte_mats, vfrac_pte, sie_pte,
+			  temp_pte, press_pte, rho_pte, spvol_v,
+			  temp_v, press_v, sie_v, nmat);
+  }
 
   // create helper lambdas to reduce code duplication
-  // const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
-  // const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
   Kokkos::View<int, MemoryTraits<at_int>> res("PTE::num fails");
   Kokkos::View<int, MemoryTraits<at_int>> n_solves("PTE::num solves");
   const std::string perf_nums =
       "[" + std::to_string(nmat) + "," + std::to_string(ncell) + "]";
-  auto input_int_enum = static_cast<input_condition>(input_int);
   switch (input_int_enum) {
   case input_condition::RHO_T_INPUT: {
     // T-rho input
@@ -167,7 +180,7 @@ int get_sg_eos( // sizing information
         vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv);
+        do_frac_bmod, do_frac_dpde, do_frac_cv, i_func, f_func);
     break;
   }
   case input_condition::RHO_P_INPUT: {
@@ -185,7 +198,7 @@ int get_sg_eos( // sizing information
         vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv);
+        do_frac_bmod, do_frac_dpde, do_frac_cv, i_func, f_func);
     break;
   }
   case input_condition::P_T_INPUT: {
@@ -199,7 +212,7 @@ int get_sg_eos( // sizing information
         vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv);
+        do_frac_bmod, do_frac_dpde, do_frac_cv, f_func);
     break;
   }
   case input_condition::NORM_RHO_E_INPUT:
@@ -216,7 +229,7 @@ int get_sg_eos( // sizing information
         vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
         frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
         vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv);
+        do_frac_bmod, do_frac_dpde, do_frac_cv, i_func, f_func);
     break;
   }
   }
diff --git a/singularity-eos/eos/get_sg_eos.hpp b/singularity-eos/eos/get_sg_eos.hpp
index 144e250d13..196bf98d55 100644
--- a/singularity-eos/eos/get_sg_eos.hpp
+++ b/singularity-eos/eos/get_sg_eos.hpp
@@ -20,6 +20,12 @@
 
 using namespace singularity;
 
+// forward declare init/final functors
+namespace singularity {
+struct init_functor;
+struct final_functor;
+} // namespace singularity
+
 #ifdef PORTABILITY_STRATEGY_KOKKOS
 using Lrgt = Kokkos::LayoutRight;
 using Llft = Kokkos::LayoutLeft;
@@ -78,7 +84,7 @@ void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offs
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                       bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv);
+                      bool do_frac_cv, init_functor& i_func, final_functor& f_func);
 // rho P input
 void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offsets_v,
                       indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
@@ -93,7 +99,7 @@ void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offs
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                       bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv);
+                      bool do_frac_cv, init_functor& i_func, final_functor& f_func);
 // PT input
 void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
                     indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
@@ -108,7 +114,7 @@ void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offset
                     ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                     Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                     bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                    bool do_frac_cv);
+                    bool do_frac_cv, final_functor& f_func);
 // rho e input
 void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offsets_v,
                       indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
@@ -123,7 +129,7 @@ void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offs
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                       bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv);
+                      bool do_frac_cv, init_functor& i_func, final_functor& f_func);
 } // namespace singularity
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
diff --git a/singularity-eos/eos/get_sg_eos_lambdas.hpp b/singularity-eos/eos/get_sg_eos_lambdas.hpp
index 0f0bf1b910..ed474e81ad 100644
--- a/singularity-eos/eos/get_sg_eos_lambdas.hpp
+++ b/singularity-eos/eos/get_sg_eos_lambdas.hpp
@@ -16,121 +16,264 @@
 #define _SINGULARITY_EOS_EOS_GET_SG_EOS_LAMBDAS_HPP_
 
 #include <ports-of-call/portability.hpp>
+#include <singularity-eos/eos/get_sg_eos.hpp>
 
 #ifdef PORTABILITY_STRATEGY_KOKKOS
 
-#define SG_GET_SG_EOS_INIT_LAMBDA_DECL                                                   \
-  PORTABLE_LAMBDA(const int i, const int tid, double &mass_sum, int &npte,               \
-                  const Real t_mult, const Real s_mult, const Real p_mult) {             \
-    /* normalize mass fractions */                                                       \
-    /* first find the mass sum */                                                        \
-    /* also set idxs as the decrement of the eos offsets */                              \
-    /* to take into account 1 based indexing in fortran */                               \
-    for (int m = 0; m < nmat; ++m) {                                                     \
-      mass_sum += frac_mass_v(i, m);                                                     \
-      pte_idxs(tid, m) = eos_offsets_v(m) - 1;                                           \
-      frac_vol_v(i, m) = 0.0;                                                            \
-    }                                                                                    \
-    for (int m = 0; m < nmat; ++m) {                                                     \
-      frac_mass_v(i, m) /= mass_sum;                                                     \
-    }                                                                                    \
-    /* set inputs */                                                                     \
-    npte = 0;                                                                            \
-    for (int m = 0; m < nmat; ++m) {                                                     \
-      if (frac_mass_v(i, m) > 1.e-12) {                                                  \
-        pte_idxs(tid, npte) = eos_offsets_v(m) - 1;                                      \
-        pte_mats(tid, npte) = m;                                                         \
-        npte += 1;                                                                       \
-      }                                                                                  \
-      vfrac_pte(tid, m) = 0.0;                                                           \
-      sie_pte(tid, m) = 0.0;                                                             \
-      temp_pte(tid, m) = 0.0;                                                            \
-      press_pte(tid, m) = 0.0;                                                           \
-    }                                                                                    \
-    for (int mp = 0; mp < npte; ++mp) {                                                  \
-      const int m = pte_mats(tid, mp);                                                   \
-      rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m);                          \
-      vfrac_pte(tid, mp) = 1.0 / npte;                                                   \
-      temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult;                                     \
-      press_pte(tid, mp) = press_v(i) * p_mult;                                          \
-      sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult;                          \
-    }                                                                                    \
+namespace singularity {
+
+struct init_functor {
+private:
+  dev_frac_v frac_mass_v;
+  ScratchV<int> pte_idxs;
+  indirection_v eos_offsets_v;
+  dev_frac_v frac_vol_v;
+  ScratchV<int> pte_mats;
+  ScratchV<double> vfrac_pte;
+  ScratchV<double> sie_pte;
+  ScratchV<double> temp_pte;
+  ScratchV<double> press_pte;
+  ScratchV<double> rho_pte;
+  dev_v spvol_v;
+  dev_v temp_v;
+  dev_v press_v;
+  dev_v sie_v;
+  int nmat;
+public:
+  init_functor() = default;
+  init_functor(dev_frac_v& frac_mass_v_,
+               ScratchV<int>& pte_idxs_,
+               indirection_v& eos_offsets_v_,
+               dev_frac_v& frac_vol_v_,
+               ScratchV<int>& pte_mats_,
+               ScratchV<double>& vfrac_pte_,
+               ScratchV<double>& sie_pte_,
+               ScratchV<double>& temp_pte_,
+               ScratchV<double>& press_pte_,
+               ScratchV<double>& rho_pte_,
+               dev_v& spvol_v_,
+               dev_v& temp_v_,
+               dev_v& press_v_,
+               dev_v& sie_v_,
+	       int& nmat) :
+               frac_mass_v{frac_mass_v_},
+               pte_idxs{pte_idxs_},
+               eos_offsets_v{eos_offsets_v_},
+               frac_vol_v{frac_vol_v_},
+               pte_mats{pte_mats_},
+               vfrac_pte{vfrac_pte_},
+               sie_pte{sie_pte_},
+               temp_pte{temp_pte_},
+               press_pte{press_pte_},
+               rho_pte{rho_pte_},
+               spvol_v{spvol_v_},
+               temp_v{temp_v_},
+               press_v{press_v_},
+               sie_v{sie_v_},
+	       nmat{nmat}
+               { }
+    
+
+  PORTABLE_INLINE_FUNCTION
+  void operator() (const int i, const int tid, double &mass_sum, int &npte,
+		   const Real t_mult, const Real s_mult, const Real p_mult) const {
+    /* normalize mass fractions */
+    /* first find the mass sum */
+    /* also set idxs as the decrement of the eos offsets */
+    /* to take into account 1 based indexing in fortran */
+    for (int m = 0; m < nmat; ++m) {
+      mass_sum += frac_mass_v(i, m);
+      pte_idxs(tid, m) = eos_offsets_v(m) - 1;
+      frac_vol_v(i, m) = 0.0;
+    }
+    for (int m = 0; m < nmat; ++m) {
+      frac_mass_v(i, m) /= mass_sum;
+    }
+    /* set inputs */
+    npte = 0;
+    for (int m = 0; m < nmat; ++m) {
+      if (frac_mass_v(i, m) > 1.e-12) {
+        pte_idxs(tid, npte) = eos_offsets_v(m) - 1;
+        pte_mats(tid, npte) = m;
+        npte += 1;
+      }
+      vfrac_pte(tid, m) = 0.0;
+      sie_pte(tid, m) = 0.0;
+      temp_pte(tid, m) = 0.0;
+      press_pte(tid, m) = 0.0;
+    }
+    for (int mp = 0; mp < npte; ++mp) {
+      const int m = pte_mats(tid, mp);
+      rho_pte(tid, mp) = npte / spvol_v(i) * frac_mass_v(i, m);
+      vfrac_pte(tid, mp) = 1.0 / npte;
+      temp_pte(tid, mp) = temp_v(i) * ev2k * t_mult;
+      press_pte(tid, mp) = press_v(i) * p_mult;
+      sie_pte(tid, mp) = sie_v(i) * frac_mass_v(i, m) * s_mult;
+    }
+    return;
   }
+};
 
-#define SG_GET_SG_EOS_FINAL_LAMBDA_DECL                                                  \
-  PORTABLE_LAMBDA(const int i, const int tid, const int npte, const Real mass_sum,       \
-                  const Real t_mult, const Real s_mult, const Real p_mult,               \
-                  singularity::mix_impl::CacheAccessor &cache) {                         \
-    /* initialize averaged quantities to 0 */                                            \
-    const bool do_t = t_mult == 1.0;                                                     \
-    const bool do_s = s_mult == 1.0;                                                     \
-    const bool do_p = p_mult == 1.0;                                                     \
-    if (do_t) {                                                                          \
-      temp_v(i) = 0.0;                                                                   \
-    }                                                                                    \
-    if (do_p) {                                                                          \
-      press_v(i) = 0.0;                                                                  \
-    }                                                                                    \
-    if (do_s) {                                                                          \
-      sie_v(i) = 0.0;                                                                    \
-    }                                                                                    \
-    bmod_v(i) = 0.0;                                                                     \
-    cv_v(i) = 0.0;                                                                       \
-    dpde_v(i) = 0.0;                                                                     \
-    /* material loop for averaging and assigning per mat quantities */                   \
-    for (int mp = 0; mp < npte; ++mp) {                                                  \
-      const int m = pte_mats(tid, mp);                                                   \
-      /* pressure contribution from material m */                                        \
-      press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult;                    \
-      /* temperature contribution from material m */                                     \
-      temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult;                      \
-      const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum;                 \
-      /* sie contribution from material m */                                             \
-      sie_v(i) += ie_m * s_mult;                                                         \
-      /* assign per material specific internal energy */                                 \
-      frac_ie_v(i, m) = ie_m;                                                            \
-      /* assign volume fraction based on pte calculation */                              \
-      frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i);                                  \
-      /* calculate bulk modulus for material m */                                        \
-      const Real bmod_m = eos_v(pte_idxs(tid, mp))                                       \
-                              .BulkModulusFromDensityTemperature(                        \
-                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);       \
-      /* add bmod contribution from material m */                                        \
-      bmod_v(i) += bmod_m * vfrac_pte(tid, mp);                                          \
-      /* calculate specific heat for material m */                                       \
-      const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp))                                  \
-                                   .SpecificHeatFromDensityTemperature(                  \
-                                       rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);  \
-      /* add mass weighted contribution specific heat for material m */                  \
-      cv_v(i) += cv_m * frac_mass_v(i, m);                                               \
-      /* calculate gruneisen parameter for material m */                                 \
-      const Real dpde_m = eos_v(pte_idxs(tid, mp))                                       \
-                              .GruneisenParamFromDensityTemperature(                     \
-                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);       \
-      /* add gruneisen param contribution from material m */                             \
-      dpde_v(i) += dpde_m * vfrac_pte(tid, mp);                                          \
-      /* optionally assign per material quantities to per material arrays */             \
-      if (do_frac_bmod) {                                                                \
-        frac_bmod_v(i, m) = bmod_m;                                                      \
-      }                                                                                  \
-      if (do_frac_cv) {                                                                  \
-        frac_cv_v(i, m) = cv_m;                                                          \
-      }                                                                                  \
-      if (do_frac_dpde) {                                                                \
-        frac_dpde_v(i, m) = dpde_m;                                                      \
-      }                                                                                  \
-    }                                                                                    \
-    if (do_t) {                                                                          \
-      temp_v(i) /= ev2k;                                                                 \
-    }                                                                                    \
-    if (do_s) {                                                                          \
-      sie_v(i) /= mass_sum;                                                              \
-    }                                                                                    \
-    /* reset mass fractions to original values if not normalized to 1 */                 \
-    for (int m = 0; m < nmat; ++m) {                                                     \
-      frac_mass_v(i, m) *= mass_sum;                                                     \
-    }                                                                                    \
+struct final_functor {
+private:
+  dev_v temp_v;
+  dev_v press_v;
+  dev_v sie_v;
+  dev_v bmod_v;
+  dev_v cv_v;
+  dev_v dpde_v;
+  ScratchV<int> pte_mats;
+  ScratchV<double> press_pte;
+  ScratchV<double> vfrac_pte;
+  ScratchV<double> temp_pte;
+  ScratchV<double> sie_pte;
+  dev_frac_v frac_mass_v;
+  dev_frac_v frac_ie_v;
+  dev_frac_v frac_vol_v;
+  dev_v vol_v;
+  Kokkos::View<EOS *, Llft> eos_v;
+  ScratchV<int> pte_idxs;
+  ScratchV<double> rho_pte;
+  dev_frac_v frac_bmod_v;
+  dev_frac_v frac_cv_v;
+  dev_frac_v frac_dpde_v;
+  int nmat;
+  bool do_frac_bmod;
+  bool do_frac_cv;
+  bool do_frac_dpde;
+public:
+  final_functor(dev_v& temp_v_,
+                dev_v& press_v_,
+                dev_v& sie_v_,
+                dev_v& bmod_v_,
+                dev_v& cv_v_,
+                dev_v& dpde_v_,
+                ScratchV<int>& pte_mats_,
+                ScratchV<double>& press_pte_,
+                ScratchV<double>& vfrac_pte_,
+                ScratchV<double>& temp_pte_,
+                ScratchV<double>& sie_pte_,
+                dev_frac_v& frac_mass_v_,
+                dev_frac_v& frac_ie_v_,
+                dev_frac_v& frac_vol_v_,
+                dev_v& vol_v_,
+                Kokkos::View<EOS *, Llft>& eos_v_,
+                ScratchV<int>& pte_idxs_,
+                ScratchV<double>& rho_pte_,
+                dev_frac_v& frac_bmod_v_,
+                dev_frac_v& frac_cv_v_,
+                dev_frac_v& frac_dpde_v_,
+                int& nmat_,
+		bool do_frac_bmod_,
+                bool do_frac_cv_,
+                bool do_frac_dpde_) :
+                temp_v{temp_v_},
+                press_v{press_v_},
+                sie_v{sie_v_},
+                bmod_v{bmod_v_},
+                cv_v{cv_v_},
+                dpde_v{dpde_v_},
+                pte_mats{pte_mats_},
+                press_pte{press_pte_},
+                vfrac_pte{vfrac_pte_},
+                temp_pte{temp_pte_},
+                sie_pte{sie_pte_},
+                frac_mass_v{frac_mass_v_},
+                frac_ie_v{frac_ie_v_},
+                frac_vol_v{frac_vol_v_},
+                vol_v{vol_v_},
+                eos_v{eos_v_},
+                pte_idxs{pte_idxs_},
+                rho_pte{rho_pte_},
+                frac_bmod_v{frac_bmod_v_},
+                frac_cv_v{frac_cv_v_},
+                frac_dpde_v{frac_dpde_v_},
+                nmat{nmat_},
+                do_frac_bmod{do_frac_bmod_},
+	        do_frac_cv{do_frac_cv_},
+	        do_frac_dpde{do_frac_dpde_}
+                { }
+  
+public:
+  PORTABLE_INLINE_FUNCTION
+  void operator() (const int i, const int tid, const int npte, const Real mass_sum,
+                   const Real t_mult, const Real s_mult, const Real p_mult,
+                   singularity::mix_impl::CacheAccessor &cache) const {
+    /* initialize averaged quantities to 0 */
+    const bool do_t = t_mult == 1.0;
+    const bool do_s = s_mult == 1.0;
+    const bool do_p = p_mult == 1.0;
+    if (do_t) {
+      temp_v(i) = 0.0;
+    }
+    if (do_p) {
+      press_v(i) = 0.0;
+    }
+    if (do_s) {
+      sie_v(i) = 0.0;
+    }
+    bmod_v(i) = 0.0;
+    cv_v(i) = 0.0;
+    dpde_v(i) = 0.0;
+    /* material loop for averaging and assigning per mat quantities */
+    for (int mp = 0; mp < npte; ++mp) {
+      const int m = pte_mats(tid, mp);
+      /* pressure contribution from material m */
+      press_v(i) += press_pte(tid, mp) * vfrac_pte(tid, mp) * p_mult;
+      /* temperature contribution from material m */
+      temp_v(i) += temp_pte(tid, mp) * vfrac_pte(tid, mp) * t_mult;
+      const Real ie_m = sie_pte(tid, mp) * frac_mass_v(i, m) * mass_sum;
+      /* sie contribution from material m */
+      sie_v(i) += ie_m * s_mult;
+      /* assign per material specific internal energy */
+      frac_ie_v(i, m) = ie_m;
+      /* assign volume fraction based on pte calculation */
+      frac_vol_v(i, m) = vfrac_pte(tid, mp) * vol_v(i);
+      /* calculate bulk modulus for material m */
+      const Real bmod_m = eos_v(pte_idxs(tid, mp))
+                              .BulkModulusFromDensityTemperature(
+                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
+      /* add bmod contribution from material m */
+      bmod_v(i) += bmod_m * vfrac_pte(tid, mp);
+      /* calculate specific heat for material m */
+      const Real cv_m = ev2k * eos_v(pte_idxs(tid, mp))
+                                   .SpecificHeatFromDensityTemperature(
+                                       rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
+      /* add mass weighted contribution specific heat for material m */
+      cv_v(i) += cv_m * frac_mass_v(i, m);
+      /* calculate gruneisen parameter for material m */
+      const Real dpde_m = eos_v(pte_idxs(tid, mp))
+                              .GruneisenParamFromDensityTemperature(
+                                  rho_pte(tid, mp), temp_pte(tid, mp), cache[mp]);
+      /* add gruneisen param contribution from material m */
+      dpde_v(i) += dpde_m * vfrac_pte(tid, mp);
+      /* optionally assign per material quantities to per material arrays */
+      if (do_frac_bmod) {
+        frac_bmod_v(i, m) = bmod_m;
+      }
+      if (do_frac_cv) {
+        frac_cv_v(i, m) = cv_m;
+      }
+      if (do_frac_dpde) {
+        frac_dpde_v(i, m) = dpde_m;
+      }
+    }
+    if (do_t) {
+      temp_v(i) /= ev2k;
+    }
+    if (do_s) {
+      sie_v(i) /= mass_sum;
+    }
+    /* reset mass fractions to original values if not normalized to 1 */
+    for (int m = 0; m < nmat; ++m) {
+      frac_mass_v(i, m) *= mass_sum;
+    }
+    return;
   }
+};
+  
+} // namespace singularity
+
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
 #endif // _SINGULARITY_EOS_EOS_GET_SG_EOS_LAMBDAS_HPP_
diff --git a/singularity-eos/eos/get_sg_eos_p_t.cpp b/singularity-eos/eos/get_sg_eos_p_t.cpp
index b472cec2df..8a9e154f51 100644
--- a/singularity-eos/eos/get_sg_eos_p_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_p_t.cpp
@@ -32,8 +32,7 @@ void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offset
                     ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                     Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                     bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                    bool do_frac_cv) {
-  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+                    bool do_frac_cv, final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
@@ -84,7 +83,7 @@ void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offset
           vfrac_pte(tid, m) /= vfrac_tot;
         }
         // assign remaining outputs
-        final_lambda(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
+        f_func(i, tid, nmat, mass_sum, 0.0, 0.0, 0.0, cache);
         // assign max pressure
         pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
         // release the token used for scratch arrays
diff --git a/singularity-eos/eos/get_sg_eos_rho_e.cpp b/singularity-eos/eos/get_sg_eos_rho_e.cpp
index 69d340675e..e66b522cfe 100644
--- a/singularity-eos/eos/get_sg_eos_rho_e.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_e.cpp
@@ -32,9 +32,8 @@ void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offs
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                       bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv) {
-  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
-  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+                      bool do_frac_cv, init_functor& i_func,
+		      final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
@@ -46,7 +45,7 @@ void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offs
         double mass_sum{0.0};
         int npte{0};
         // initialize values for solver / lookup
-        init_lambda(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
+        i_func(i, tid, mass_sum, npte, 0.0, 1.0, 0.0);
         // get cache from offsets into scratch
         const int neq = npte + 1;
         singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
@@ -70,7 +69,7 @@ void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offs
                       temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
         }
         // assign outputs
-        final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
+        f_func(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
         // assign max pressure
         pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
         // release the token used for scratch arrays
diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
index 6c9239d657..85d9d5416a 100644
--- a/singularity-eos/eos/get_sg_eos_rho_p.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -32,9 +32,7 @@ void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offs
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                       bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv) {
-  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
-  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+                      bool do_frac_cv, init_functor& i_func, final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
@@ -46,7 +44,7 @@ void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offs
         double mass_sum{0.0};
         int npte{0};
         // initialize values for solver / lookup
-        init_lambda(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
+        i_func(i, tid, mass_sum, npte, 0.0, 0.0, 1.0);
         Real sie_tot_true{0.0};
         const int neq = npte + 1;
         singularity::mix_impl::CacheAccessor cache(&solver_scratch(tid, 0) +
@@ -91,7 +89,7 @@ void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offs
         // sie calculate explicitly already
         sie_v(i) = sie_tot_true;
         // assign remaining outputs
-        final_lambda(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
+        f_func(i, tid, npte, mass_sum, 1.0, 0.0, 0.0, cache);
         // assign max pressure
         pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
         // release the token used for scratch arrays
diff --git a/singularity-eos/eos/get_sg_eos_rho_t.cpp b/singularity-eos/eos/get_sg_eos_rho_t.cpp
index b557b631e3..da5929eed6 100644
--- a/singularity-eos/eos/get_sg_eos_rho_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_t.cpp
@@ -32,9 +32,7 @@ void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offs
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
                       bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv) {
-  const auto init_lambda = SG_GET_SG_EOS_INIT_LAMBDA_DECL;
-  const auto final_lambda = SG_GET_SG_EOS_FINAL_LAMBDA_DECL;
+                      bool do_frac_cv, init_functor& i_func, final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
@@ -46,7 +44,7 @@ void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offs
         double mass_sum{0.0};
         int npte{0};
         // initialize values for solver / lookup
-        init_lambda(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
+        i_func(i, tid, mass_sum, npte, 1.0, 0.0, 0.0);
         // calculate pte condition (lookup for 1 mat cell)
         Real sie_tot_true{0.0};
         const int neq = npte;
@@ -82,7 +80,7 @@ void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offs
         // total sie is known
         sie_v(i) = sie_tot_true;
         // assign quantities
-        final_lambda(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
+        f_func(i, tid, npte, mass_sum, 0.0, 0.0, 1.0, cache);
         // assign max pressure
         pmax_v(i) = press_v(i) > pmax_v(i) ? press_v(i) : pmax_v(i);
         // release the token used for scratch arrays

From ff334d2cadd6221b27cf86c9b2aa88f9c3926e88 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 15 Aug 2023 17:25:23 -0600
Subject: [PATCH 40/45] Using individual functions instead of ptofre, this was
 the source of long compile timesgit status Removing unnecessary function
 args.

---
 singularity-eos/eos/get_sg_eos.cpp       | 32 ++++++----------
 singularity-eos/eos/get_sg_eos.hpp       | 48 +++++++-----------------
 singularity-eos/eos/get_sg_eos_p_t.cpp   | 10 ++---
 singularity-eos/eos/get_sg_eos_rho_e.cpp | 24 ++++--------
 singularity-eos/eos/get_sg_eos_rho_p.cpp | 13 ++-----
 singularity-eos/eos/get_sg_eos_rho_t.cpp | 13 ++-----
 6 files changed, 46 insertions(+), 94 deletions(-)

diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index d7cc9da196..8382af5e40 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -176,11 +176,9 @@ int get_sg_eos( // sizing information
                                       pte_solver_scratch_size);
     const std::string rt_name = "PTE::solve (rho,T) input" + perf_nums;
     singularity::get_sg_eos_rho_t(
-        rt_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
-        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
-        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
-        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv, i_func, f_func);
+        rt_name.c_str(), ncell, offsets_v, eos_v, press_v, pmax_v, sie_v,
+	frac_mass_v, pte_idxs, pte_mats, press_pte, vfrac_pte, rho_pte, sie_pte,
+	temp_pte, solver_scratch, tokens, small_loop, i_func, f_func);
     break;
   }
   case input_condition::RHO_P_INPUT: {
@@ -194,11 +192,9 @@ int get_sg_eos( // sizing information
                                       pte_solver_scratch_size);
     const std::string rp_name = "PTE::solve (rho,P) input" + perf_nums;
     singularity::get_sg_eos_rho_p(
-        rp_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
-        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
-        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
-        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv, i_func, f_func);
+        rp_name.c_str(), ncell, offsets_v, eos_v, press_v, pmax_v, sie_v,
+	frac_mass_v, pte_idxs, pte_mats, press_pte, vfrac_pte, rho_pte, sie_pte,
+	temp_pte, solver_scratch, tokens, small_loop, i_func, f_func);
     break;
   }
   case input_condition::P_T_INPUT: {
@@ -209,10 +205,8 @@ int get_sg_eos( // sizing information
     const std::string pt_name = "PTE::solve (P,T) input" + perf_nums;
     singularity::get_sg_eos_p_t(
         pt_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
-        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
-        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
-        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv, f_func);
+        vol_v, spvol_v, sie_v, temp_v, frac_mass_v, pte_idxs, pte_mats, press_pte,
+        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop, f_func);
     break;
   }
   case input_condition::NORM_RHO_E_INPUT:
@@ -224,12 +218,10 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string re_name = "PTE::solve (rho,e) input" + perf_nums;
-    singularity::get_sg_eos_rho_p(
-        re_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
-        vol_v, spvol_v, sie_v, temp_v, bmod_v, dpde_v, cv_v, frac_mass_v, frac_vol_v,
-        frac_ie_v, frac_bmod_v, frac_dpde_v, frac_cv_v, pte_idxs, pte_mats, press_pte,
-        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop,
-        do_frac_bmod, do_frac_dpde, do_frac_cv, i_func, f_func);
+    singularity::get_sg_eos_rho_e(
+        re_name.c_str(), ncell, offsets_v, eos_v, press_v, pmax_v, sie_v, pte_idxs,
+	press_pte, vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens,
+	small_loop, i_func, f_func);
     break;
   }
   }
diff --git a/singularity-eos/eos/get_sg_eos.hpp b/singularity-eos/eos/get_sg_eos.hpp
index 196bf98d55..0f3b03f3e8 100644
--- a/singularity-eos/eos/get_sg_eos.hpp
+++ b/singularity-eos/eos/get_sg_eos.hpp
@@ -71,65 +71,45 @@ static constexpr const double ev2k = 1.160451930280894026e4;
 #ifdef PORTABILITY_STRATEGY_KOKKOS
 namespace singularity {
 // rho t input
-void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
-                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
-                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+void get_sg_eos_rho_t(const char *name, int ncell, indirection_v &offsets_v,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
+	              dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
                       ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
                       ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                       ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv, init_functor& i_func, final_functor& f_func);
+                      bool small_loop, init_functor& i_func, final_functor& f_func);
 // rho P input
-void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offsets_v,
-                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
-                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+void get_sg_eos_rho_p(const char *name, int ncell, indirection_v &offsets_v,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
+		      dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
                       ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
                       ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                       ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv, init_functor& i_func, final_functor& f_func);
+                      bool small_loop, init_functor& i_func, final_functor& f_func);
 // PT input
 void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
                     indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
                     dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                    dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                    dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                    dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                    dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                    dev_v &sie_v, dev_v &temp_v, dev_frac_v &frac_mass_v,
                     ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
                     ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                     ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                     ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                     Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                    bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                    bool do_frac_cv, final_functor& f_func);
+                    bool small_loop, final_functor& f_func);
 // rho e input
-void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offsets_v,
-                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
-                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
-                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+void get_sg_eos_rho_e(const char *name, int ncell, indirection_v &offsets_v,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
+		      dev_v &pmax_v, dev_v &sie_v, ScratchV<int> &pte_idxs,
                       ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                       ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv, init_functor& i_func, final_functor& f_func);
+                      bool small_loop, init_functor& i_func, final_functor& f_func);
 } // namespace singularity
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
diff --git a/singularity-eos/eos/get_sg_eos_p_t.cpp b/singularity-eos/eos/get_sg_eos_p_t.cpp
index 8a9e154f51..4c3e2bbb7e 100644
--- a/singularity-eos/eos/get_sg_eos_p_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_p_t.cpp
@@ -18,21 +18,19 @@
 #include <singularity-eos/eos/get_sg_eos.hpp>
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
+// any bmod vars, dpde, cv, frac vol, frac ie
+
 namespace singularity {
 void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
                     indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
                     dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                    dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                    dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                    dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                    dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+                    dev_v &sie_v, dev_v &temp_v, dev_frac_v &frac_mass_v,
                     ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
                     ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                     ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                     ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                     Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                    bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                    bool do_frac_cv, final_functor& f_func) {
+                    bool small_loop, final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
diff --git a/singularity-eos/eos/get_sg_eos_rho_e.cpp b/singularity-eos/eos/get_sg_eos_rho_e.cpp
index e66b522cfe..88fd896cd8 100644
--- a/singularity-eos/eos/get_sg_eos_rho_e.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_e.cpp
@@ -19,21 +19,14 @@
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 namespace singularity {
-void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offsets_v,
-                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
-                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
-                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
+void get_sg_eos_rho_e(const char *name, int ncell, indirection_v &offsets_v,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
+		      dev_v &pmax_v, dev_v &sie_v, ScratchV<int> &pte_idxs,
                       ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                       ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv, init_functor& i_func,
-		      final_functor& f_func) {
+                      bool small_loop, init_functor& i_func, final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
@@ -62,11 +55,10 @@ void get_sg_eos_rho_e(const char *name, int ncell, int nmat, indirection_v &offs
           const bool res_{PTESolver(method)};
         } else {
           // pure cell (nmat = 1)
-          // calculate sie from single eos
-          Real dpdr_m, dtdr_m, dpde_m, dtde_m;
-          eos_v(pte_idxs(tid, 0))
-              .PTofRE(rho_pte(tid, 0), sie_pte(tid, 0), cache[0], press_pte(tid, 0),
-                      temp_pte(tid, 0), dpdr_m, dpde_m, dtdr_m, dtde_m);
+	  temp_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+	      .TemperatureFromDensityInternalEnergy(rho_pte(tid, 0), sie_pte(tid, 0), cache[0]);
+	  press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+	      .PressureFromDensityTemperature(rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
         }
         // assign outputs
         f_func(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
index 85d9d5416a..13d1e82cff 100644
--- a/singularity-eos/eos/get_sg_eos_rho_p.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -19,20 +19,15 @@
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 namespace singularity {
-void get_sg_eos_rho_p(const char *name, int ncell, int nmat, indirection_v &offsets_v,
-                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
-                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+void get_sg_eos_rho_p(const char *name, int ncell, indirection_v &offsets_v,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
+		      dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
                       ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
                       ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                       ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv, init_functor& i_func, final_functor& f_func) {
+                      bool small_loop, init_functor& i_func, final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
diff --git a/singularity-eos/eos/get_sg_eos_rho_t.cpp b/singularity-eos/eos/get_sg_eos_rho_t.cpp
index da5929eed6..731a49f446 100644
--- a/singularity-eos/eos/get_sg_eos_rho_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_t.cpp
@@ -19,20 +19,15 @@
 #include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
 
 namespace singularity {
-void get_sg_eos_rho_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
-                      indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
-                      dev_v &press_v, dev_v &pmax_v, dev_v &vol_v, dev_v &spvol_v,
-                      dev_v &sie_v, dev_v &temp_v, dev_v &bmod_v, dev_v &dpde_v,
-                      dev_v &cv_v, dev_frac_v &frac_mass_v, dev_frac_v &frac_vol_v,
-                      dev_frac_v &frac_ie_v, dev_frac_v &frac_bmod_v,
-                      dev_frac_v &frac_dpde_v, dev_frac_v &frac_cv_v,
+void get_sg_eos_rho_t(const char *name, int ncell, indirection_v &offsets_v,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
+	              dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
                       ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
                       ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
                       ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                       ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, bool do_frac_bmod, bool do_frac_dpde,
-                      bool do_frac_cv, init_functor& i_func, final_functor& f_func) {
+                      bool small_loop, init_functor& i_func, final_functor& f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset

From 4b6c859f6abab0805b05b6ed8277f02dfad58414 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 15 Aug 2023 17:54:57 -0600
Subject: [PATCH 41/45] Change file name to reflect move from lambdas to
 functors.

---
 singularity-eos/CMakeLists.txt                                  | 2 +-
 singularity-eos/eos/get_sg_eos.cpp                              | 2 +-
 .../eos/{get_sg_eos_lambdas.hpp => get_sg_eos_functors.hpp}     | 0
 singularity-eos/eos/get_sg_eos_p_t.cpp                          | 2 +-
 singularity-eos/eos/get_sg_eos_rho_e.cpp                        | 2 +-
 singularity-eos/eos/get_sg_eos_rho_p.cpp                        | 2 +-
 singularity-eos/eos/get_sg_eos_rho_t.cpp                        | 2 +-
 7 files changed, 6 insertions(+), 6 deletions(-)
 rename singularity-eos/eos/{get_sg_eos_lambdas.hpp => get_sg_eos_functors.hpp} (100%)

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 4ca7484665..27081f4297 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -62,7 +62,7 @@ if (SINGULARITY_BUILD_CLOSURE)
     endif()
     list(APPEND EOS_HEADERS
          eos/get_sg_eos.hpp
-         eos/get_sg_eos_lambdas.hpp)
+         eos/get_sg_eos_functors.hpp)
   endif()
 endif()
 
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 8382af5e40..11ed39c96a 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -17,7 +17,7 @@
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
-#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+#include <singularity-eos/eos/get_sg_eos_functors.hpp>
 #include <singularity-eos/eos/singularity_eos.hpp>
 
 using namespace singularity;
diff --git a/singularity-eos/eos/get_sg_eos_lambdas.hpp b/singularity-eos/eos/get_sg_eos_functors.hpp
similarity index 100%
rename from singularity-eos/eos/get_sg_eos_lambdas.hpp
rename to singularity-eos/eos/get_sg_eos_functors.hpp
diff --git a/singularity-eos/eos/get_sg_eos_p_t.cpp b/singularity-eos/eos/get_sg_eos_p_t.cpp
index 4c3e2bbb7e..c81ec2828c 100644
--- a/singularity-eos/eos/get_sg_eos_p_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_p_t.cpp
@@ -16,7 +16,7 @@
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
-#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+#include <singularity-eos/eos/get_sg_eos_functors.hpp>
 
 // any bmod vars, dpde, cv, frac vol, frac ie
 
diff --git a/singularity-eos/eos/get_sg_eos_rho_e.cpp b/singularity-eos/eos/get_sg_eos_rho_e.cpp
index 88fd896cd8..4d63423376 100644
--- a/singularity-eos/eos/get_sg_eos_rho_e.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_e.cpp
@@ -16,7 +16,7 @@
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
-#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+#include <singularity-eos/eos/get_sg_eos_functors.hpp>
 
 namespace singularity {
 void get_sg_eos_rho_e(const char *name, int ncell, indirection_v &offsets_v,
diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
index 13d1e82cff..b8a92a28d3 100644
--- a/singularity-eos/eos/get_sg_eos_rho_p.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -16,7 +16,7 @@
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
-#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+#include <singularity-eos/eos/get_sg_eos_functors.hpp>
 
 namespace singularity {
 void get_sg_eos_rho_p(const char *name, int ncell, indirection_v &offsets_v,
diff --git a/singularity-eos/eos/get_sg_eos_rho_t.cpp b/singularity-eos/eos/get_sg_eos_rho_t.cpp
index 731a49f446..e1ddb6914d 100644
--- a/singularity-eos/eos/get_sg_eos_rho_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_t.cpp
@@ -16,7 +16,7 @@
 #include <singularity-eos/closure/mixed_cell_models.hpp>
 #include <singularity-eos/eos/eos.hpp>
 #include <singularity-eos/eos/get_sg_eos.hpp>
-#include <singularity-eos/eos/get_sg_eos_lambdas.hpp>
+#include <singularity-eos/eos/get_sg_eos_functors.hpp>
 
 namespace singularity {
 void get_sg_eos_rho_t(const char *name, int ncell, indirection_v &offsets_v,

From a225052514c121a789278d18ed064c47c62f15e0 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 15 Aug 2023 17:55:11 -0600
Subject: [PATCH 42/45] Remove unused variables.

---
 test/test_eos_noble_abel.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test_eos_noble_abel.cpp b/test/test_eos_noble_abel.cpp
index eab2e3e2d9..f9827fe309 100644
--- a/test/test_eos_noble_abel.cpp
+++ b/test/test_eos_noble_abel.cpp
@@ -532,8 +532,8 @@ SCENARIO("Test NobleAbel Entropy Calls", "[NobleAbel][NobleAbel5]") {
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
       // Gold standard values for a subset of lookups
-      constexpr std::array<Real, num> pressure_true{3.4450499999999993e+07};
-      constexpr std::array<Real, num> temperature_true{1.5320999999999999e+03};
+      //constexpr std::array<Real, num> pressure_true{3.4450499999999993e+07};
+      //constexpr std::array<Real, num> temperature_true{1.5320999999999999e+03};
       constexpr std::array<Real, num> entropy_true{-2.0177705273504910e+08};
 
 #ifdef PORTABILITY_STRATEGY_KOKKOS

From 55ceed2a93e4afc144caf9d72ebe42cb7ee4ce56 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Tue, 15 Aug 2023 17:59:26 -0600
Subject: [PATCH 43/45] format.

---
 singularity-eos/base/variadic_utils.hpp     |   3 +-
 singularity-eos/eos/eos.hpp                 |   4 +-
 singularity-eos/eos/get_sg_eos.cpp          |  50 ++++---
 singularity-eos/eos/get_sg_eos.hpp          |  42 +++---
 singularity-eos/eos/get_sg_eos_functors.hpp | 138 ++++++--------------
 singularity-eos/eos/get_sg_eos_p_t.cpp      |   2 +-
 singularity-eos/eos/get_sg_eos_rho_e.cpp    |  22 ++--
 singularity-eos/eos/get_sg_eos_rho_p.cpp    |  14 +-
 singularity-eos/eos/get_sg_eos_rho_t.cpp    |  14 +-
 test/test_eos_noble_abel.cpp                |   4 +-
 10 files changed, 121 insertions(+), 172 deletions(-)

diff --git a/singularity-eos/base/variadic_utils.hpp b/singularity-eos/base/variadic_utils.hpp
index 40a020511a..2d1aa9f7de 100644
--- a/singularity-eos/base/variadic_utils.hpp
+++ b/singularity-eos/base/variadic_utils.hpp
@@ -108,7 +108,8 @@ struct filter<ADAPTER, Pred, Variadic, T, Ts...> {
 template <template <typename> class FIRST, template <typename> class... Us,
           typename... Ts>
 constexpr auto filter_nested_variadic(adapt_list<FIRST, Us...> m, type_list<Ts...> l) {
-  using t1 = type_list<typename filter<FIRST, is_not_duplicate_nested, type_list, Ts...>::type>;
+  using t1 =
+      type_list<typename filter<FIRST, is_not_duplicate_nested, type_list, Ts...>::type>;
   constexpr typename flatten<t1>::type l1{};
   return filter_nested_variadic(adapt_list<Us...>{}, l1);
 }
diff --git a/singularity-eos/eos/eos.hpp b/singularity-eos/eos/eos.hpp
index 9c543ab555..76aeb2d937 100644
--- a/singularity-eos/eos/eos.hpp
+++ b/singularity-eos/eos/eos.hpp
@@ -113,8 +113,8 @@ static constexpr const auto combined_list_1 = singularity::detail::concat(
 static constexpr const auto ramped_all =
     transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
 // final combined list
-static constexpr const auto combined_list = singularity::detail::concat(
-    combined_list_1, ramped_all);
+static constexpr const auto combined_list =
+    singularity::detail::concat(combined_list_1, ramped_all);
 // a function that returns a Variant from a typelist
 template <typename... Ts>
 struct tl_to_Variant_struct {
diff --git a/singularity-eos/eos/get_sg_eos.cpp b/singularity-eos/eos/get_sg_eos.cpp
index 11ed39c96a..7e697d56fe 100644
--- a/singularity-eos/eos/get_sg_eos.cpp
+++ b/singularity-eos/eos/get_sg_eos.cpp
@@ -145,18 +145,15 @@ int get_sg_eos( // sizing information
   // declare init and final functors
   auto input_int_enum = static_cast<input_condition>(input_int);
   init_functor i_func;
-  final_functor f_func(temp_v, press_v, sie_v, bmod_v, cv_v,
-		       dpde_v, pte_mats, press_pte, vfrac_pte,
-		       temp_pte, sie_pte, frac_mass_v, frac_ie_v,
-		       frac_vol_v, vol_v, eos_v, pte_idxs, rho_pte,
-		       frac_bmod_v, frac_cv_v, frac_dpde_v, nmat,
-		       do_frac_bmod, do_frac_cv, do_frac_dpde);
+  final_functor f_func(temp_v, press_v, sie_v, bmod_v, cv_v, dpde_v, pte_mats, press_pte,
+                       vfrac_pte, temp_pte, sie_pte, frac_mass_v, frac_ie_v, frac_vol_v,
+                       vol_v, eos_v, pte_idxs, rho_pte, frac_bmod_v, frac_cv_v,
+                       frac_dpde_v, nmat, do_frac_bmod, do_frac_cv, do_frac_dpde);
   // only initialize init functor when needed
   if (input_int_enum != input_condition::P_T_INPUT) {
-    i_func = init_functor(frac_mass_v, pte_idxs, eos_offsets_v,
-			  frac_vol_v, pte_mats, vfrac_pte, sie_pte,
-			  temp_pte, press_pte, rho_pte, spvol_v,
-			  temp_v, press_v, sie_v, nmat);
+    i_func = init_functor(frac_mass_v, pte_idxs, eos_offsets_v, frac_vol_v, pte_mats,
+                          vfrac_pte, sie_pte, temp_pte, press_pte, rho_pte, spvol_v,
+                          temp_v, press_v, sie_v, nmat);
   }
 
   // create helper lambdas to reduce code duplication
@@ -175,10 +172,10 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string rt_name = "PTE::solve (rho,T) input" + perf_nums;
-    singularity::get_sg_eos_rho_t(
-        rt_name.c_str(), ncell, offsets_v, eos_v, press_v, pmax_v, sie_v,
-	frac_mass_v, pte_idxs, pte_mats, press_pte, vfrac_pte, rho_pte, sie_pte,
-	temp_pte, solver_scratch, tokens, small_loop, i_func, f_func);
+    singularity::get_sg_eos_rho_t(rt_name.c_str(), ncell, offsets_v, eos_v, press_v,
+                                  pmax_v, sie_v, frac_mass_v, pte_idxs, pte_mats,
+                                  press_pte, vfrac_pte, rho_pte, sie_pte, temp_pte,
+                                  solver_scratch, tokens, small_loop, i_func, f_func);
     break;
   }
   case input_condition::RHO_P_INPUT: {
@@ -191,10 +188,10 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string rp_name = "PTE::solve (rho,P) input" + perf_nums;
-    singularity::get_sg_eos_rho_p(
-        rp_name.c_str(), ncell, offsets_v, eos_v, press_v, pmax_v, sie_v,
-	frac_mass_v, pte_idxs, pte_mats, press_pte, vfrac_pte, rho_pte, sie_pte,
-	temp_pte, solver_scratch, tokens, small_loop, i_func, f_func);
+    singularity::get_sg_eos_rho_p(rp_name.c_str(), ncell, offsets_v, eos_v, press_v,
+                                  pmax_v, sie_v, frac_mass_v, pte_idxs, pte_mats,
+                                  press_pte, vfrac_pte, rho_pte, sie_pte, temp_pte,
+                                  solver_scratch, tokens, small_loop, i_func, f_func);
     break;
   }
   case input_condition::P_T_INPUT: {
@@ -203,10 +200,11 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string pt_name = "PTE::solve (P,T) input" + perf_nums;
-    singularity::get_sg_eos_p_t(
-        pt_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v, eos_v, press_v, pmax_v,
-        vol_v, spvol_v, sie_v, temp_v, frac_mass_v, pte_idxs, pte_mats, press_pte,
-        vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens, small_loop, f_func);
+    singularity::get_sg_eos_p_t(pt_name.c_str(), ncell, nmat, offsets_v, eos_offsets_v,
+                                eos_v, press_v, pmax_v, vol_v, spvol_v, sie_v, temp_v,
+                                frac_mass_v, pte_idxs, pte_mats, press_pte, vfrac_pte,
+                                rho_pte, sie_pte, temp_pte, solver_scratch, tokens,
+                                small_loop, f_func);
     break;
   }
   case input_condition::NORM_RHO_E_INPUT:
@@ -218,10 +216,10 @@ int get_sg_eos( // sizing information
     solver_scratch = ScratchV<double>(VAWI("PTE::scratch solver"), scratch_size,
                                       pte_solver_scratch_size);
     const std::string re_name = "PTE::solve (rho,e) input" + perf_nums;
-    singularity::get_sg_eos_rho_e(
-        re_name.c_str(), ncell, offsets_v, eos_v, press_v, pmax_v, sie_v, pte_idxs,
-	press_pte, vfrac_pte, rho_pte, sie_pte, temp_pte, solver_scratch, tokens,
-	small_loop, i_func, f_func);
+    singularity::get_sg_eos_rho_e(re_name.c_str(), ncell, offsets_v, eos_v, press_v,
+                                  pmax_v, sie_v, pte_idxs, press_pte, vfrac_pte, rho_pte,
+                                  sie_pte, temp_pte, solver_scratch, tokens, small_loop,
+                                  i_func, f_func);
     break;
   }
   }
diff --git a/singularity-eos/eos/get_sg_eos.hpp b/singularity-eos/eos/get_sg_eos.hpp
index 0f3b03f3e8..9baccd83e1 100644
--- a/singularity-eos/eos/get_sg_eos.hpp
+++ b/singularity-eos/eos/get_sg_eos.hpp
@@ -72,24 +72,24 @@ static constexpr const double ev2k = 1.160451930280894026e4;
 namespace singularity {
 // rho t input
 void get_sg_eos_rho_t(const char *name, int ncell, indirection_v &offsets_v,
-                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
-	              dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
-                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
-                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
-                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
-                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v, dev_v &pmax_v,
+                      dev_v &sie_v, dev_frac_v &frac_mass_v, ScratchV<int> &pte_idxs,
+                      ScratchV<int> &pte_mats, ScratchV<double> &press_pte,
+                      ScratchV<double> &vfrac_pte, ScratchV<double> &rho_pte,
+                      ScratchV<double> &sie_pte, ScratchV<double> &temp_pte,
+                      ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, init_functor& i_func, final_functor& f_func);
+                      bool small_loop, init_functor &i_func, final_functor &f_func);
 // rho P input
 void get_sg_eos_rho_p(const char *name, int ncell, indirection_v &offsets_v,
-                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
-		      dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
-                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
-                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
-                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
-                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v, dev_v &pmax_v,
+                      dev_v &sie_v, dev_frac_v &frac_mass_v, ScratchV<int> &pte_idxs,
+                      ScratchV<int> &pte_mats, ScratchV<double> &press_pte,
+                      ScratchV<double> &vfrac_pte, ScratchV<double> &rho_pte,
+                      ScratchV<double> &sie_pte, ScratchV<double> &temp_pte,
+                      ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, init_functor& i_func, final_functor& f_func);
+                      bool small_loop, init_functor &i_func, final_functor &f_func);
 // PT input
 void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offsets_v,
                     indirection_v &eos_offsets_v, Kokkos::View<EOS *, Llft> &eos_v,
@@ -100,16 +100,16 @@ void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offset
                     ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                     ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                     Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                    bool small_loop, final_functor& f_func);
+                    bool small_loop, final_functor &f_func);
 // rho e input
 void get_sg_eos_rho_e(const char *name, int ncell, indirection_v &offsets_v,
-                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
-		      dev_v &pmax_v, dev_v &sie_v, ScratchV<int> &pte_idxs,
-                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
-                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
-                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v, dev_v &pmax_v,
+                      dev_v &sie_v, ScratchV<int> &pte_idxs, ScratchV<double> &press_pte,
+                      ScratchV<double> &vfrac_pte, ScratchV<double> &rho_pte,
+                      ScratchV<double> &sie_pte, ScratchV<double> &temp_pte,
+                      ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, init_functor& i_func, final_functor& f_func);
+                      bool small_loop, init_functor &i_func, final_functor &f_func);
 } // namespace singularity
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
diff --git a/singularity-eos/eos/get_sg_eos_functors.hpp b/singularity-eos/eos/get_sg_eos_functors.hpp
index ed474e81ad..f8680eacd3 100644
--- a/singularity-eos/eos/get_sg_eos_functors.hpp
+++ b/singularity-eos/eos/get_sg_eos_functors.hpp
@@ -23,7 +23,7 @@
 namespace singularity {
 
 struct init_functor {
-private:
+ private:
   dev_frac_v frac_mass_v;
   ScratchV<int> pte_idxs;
   indirection_v eos_offsets_v;
@@ -39,44 +39,24 @@ struct init_functor {
   dev_v press_v;
   dev_v sie_v;
   int nmat;
-public:
+
+ public:
   init_functor() = default;
-  init_functor(dev_frac_v& frac_mass_v_,
-               ScratchV<int>& pte_idxs_,
-               indirection_v& eos_offsets_v_,
-               dev_frac_v& frac_vol_v_,
-               ScratchV<int>& pte_mats_,
-               ScratchV<double>& vfrac_pte_,
-               ScratchV<double>& sie_pte_,
-               ScratchV<double>& temp_pte_,
-               ScratchV<double>& press_pte_,
-               ScratchV<double>& rho_pte_,
-               dev_v& spvol_v_,
-               dev_v& temp_v_,
-               dev_v& press_v_,
-               dev_v& sie_v_,
-	       int& nmat) :
-               frac_mass_v{frac_mass_v_},
-               pte_idxs{pte_idxs_},
-               eos_offsets_v{eos_offsets_v_},
-               frac_vol_v{frac_vol_v_},
-               pte_mats{pte_mats_},
-               vfrac_pte{vfrac_pte_},
-               sie_pte{sie_pte_},
-               temp_pte{temp_pte_},
-               press_pte{press_pte_},
-               rho_pte{rho_pte_},
-               spvol_v{spvol_v_},
-               temp_v{temp_v_},
-               press_v{press_v_},
-               sie_v{sie_v_},
-	       nmat{nmat}
-               { }
-    
+  init_functor(dev_frac_v &frac_mass_v_, ScratchV<int> &pte_idxs_,
+               indirection_v &eos_offsets_v_, dev_frac_v &frac_vol_v_,
+               ScratchV<int> &pte_mats_, ScratchV<double> &vfrac_pte_,
+               ScratchV<double> &sie_pte_, ScratchV<double> &temp_pte_,
+               ScratchV<double> &press_pte_, ScratchV<double> &rho_pte_, dev_v &spvol_v_,
+               dev_v &temp_v_, dev_v &press_v_, dev_v &sie_v_, int &nmat)
+      : frac_mass_v{frac_mass_v_}, pte_idxs{pte_idxs_}, eos_offsets_v{eos_offsets_v_},
+        frac_vol_v{frac_vol_v_}, pte_mats{pte_mats_}, vfrac_pte{vfrac_pte_},
+        sie_pte{sie_pte_}, temp_pte{temp_pte_}, press_pte{press_pte_}, rho_pte{rho_pte_},
+        spvol_v{spvol_v_}, temp_v{temp_v_}, press_v{press_v_}, sie_v{sie_v_}, nmat{nmat} {
+  }
 
   PORTABLE_INLINE_FUNCTION
-  void operator() (const int i, const int tid, double &mass_sum, int &npte,
-		   const Real t_mult, const Real s_mult, const Real p_mult) const {
+  void operator()(const int i, const int tid, double &mass_sum, int &npte,
+                  const Real t_mult, const Real s_mult, const Real p_mult) const {
     /* normalize mass fractions */
     /* first find the mass sum */
     /* also set idxs as the decrement of the eos offsets */
@@ -115,7 +95,7 @@ struct init_functor {
 };
 
 struct final_functor {
-private:
+ private:
   dev_v temp_v;
   dev_v press_v;
   dev_v sie_v;
@@ -141,64 +121,32 @@ struct final_functor {
   bool do_frac_bmod;
   bool do_frac_cv;
   bool do_frac_dpde;
-public:
-  final_functor(dev_v& temp_v_,
-                dev_v& press_v_,
-                dev_v& sie_v_,
-                dev_v& bmod_v_,
-                dev_v& cv_v_,
-                dev_v& dpde_v_,
-                ScratchV<int>& pte_mats_,
-                ScratchV<double>& press_pte_,
-                ScratchV<double>& vfrac_pte_,
-                ScratchV<double>& temp_pte_,
-                ScratchV<double>& sie_pte_,
-                dev_frac_v& frac_mass_v_,
-                dev_frac_v& frac_ie_v_,
-                dev_frac_v& frac_vol_v_,
-                dev_v& vol_v_,
-                Kokkos::View<EOS *, Llft>& eos_v_,
-                ScratchV<int>& pte_idxs_,
-                ScratchV<double>& rho_pte_,
-                dev_frac_v& frac_bmod_v_,
-                dev_frac_v& frac_cv_v_,
-                dev_frac_v& frac_dpde_v_,
-                int& nmat_,
-		bool do_frac_bmod_,
-                bool do_frac_cv_,
-                bool do_frac_dpde_) :
-                temp_v{temp_v_},
-                press_v{press_v_},
-                sie_v{sie_v_},
-                bmod_v{bmod_v_},
-                cv_v{cv_v_},
-                dpde_v{dpde_v_},
-                pte_mats{pte_mats_},
-                press_pte{press_pte_},
-                vfrac_pte{vfrac_pte_},
-                temp_pte{temp_pte_},
-                sie_pte{sie_pte_},
-                frac_mass_v{frac_mass_v_},
-                frac_ie_v{frac_ie_v_},
-                frac_vol_v{frac_vol_v_},
-                vol_v{vol_v_},
-                eos_v{eos_v_},
-                pte_idxs{pte_idxs_},
-                rho_pte{rho_pte_},
-                frac_bmod_v{frac_bmod_v_},
-                frac_cv_v{frac_cv_v_},
-                frac_dpde_v{frac_dpde_v_},
-                nmat{nmat_},
-                do_frac_bmod{do_frac_bmod_},
-	        do_frac_cv{do_frac_cv_},
-	        do_frac_dpde{do_frac_dpde_}
-                { }
-  
-public:
+
+ public:
+  final_functor(dev_v &temp_v_, dev_v &press_v_, dev_v &sie_v_, dev_v &bmod_v_,
+                dev_v &cv_v_, dev_v &dpde_v_, ScratchV<int> &pte_mats_,
+                ScratchV<double> &press_pte_, ScratchV<double> &vfrac_pte_,
+                ScratchV<double> &temp_pte_, ScratchV<double> &sie_pte_,
+                dev_frac_v &frac_mass_v_, dev_frac_v &frac_ie_v_, dev_frac_v &frac_vol_v_,
+                dev_v &vol_v_, Kokkos::View<EOS *, Llft> &eos_v_,
+                ScratchV<int> &pte_idxs_, ScratchV<double> &rho_pte_,
+                dev_frac_v &frac_bmod_v_, dev_frac_v &frac_cv_v_,
+                dev_frac_v &frac_dpde_v_, int &nmat_, bool do_frac_bmod_,
+                bool do_frac_cv_, bool do_frac_dpde_)
+      : temp_v{temp_v_}, press_v{press_v_}, sie_v{sie_v_}, bmod_v{bmod_v_}, cv_v{cv_v_},
+        dpde_v{dpde_v_}, pte_mats{pte_mats_}, press_pte{press_pte_},
+        vfrac_pte{vfrac_pte_}, temp_pte{temp_pte_}, sie_pte{sie_pte_},
+        frac_mass_v{frac_mass_v_}, frac_ie_v{frac_ie_v_}, frac_vol_v{frac_vol_v_},
+        vol_v{vol_v_}, eos_v{eos_v_}, pte_idxs{pte_idxs_}, rho_pte{rho_pte_},
+        frac_bmod_v{frac_bmod_v_}, frac_cv_v{frac_cv_v_},
+        frac_dpde_v{frac_dpde_v_}, nmat{nmat_}, do_frac_bmod{do_frac_bmod_},
+        do_frac_cv{do_frac_cv_}, do_frac_dpde{do_frac_dpde_} {}
+
+ public:
   PORTABLE_INLINE_FUNCTION
-  void operator() (const int i, const int tid, const int npte, const Real mass_sum,
-                   const Real t_mult, const Real s_mult, const Real p_mult,
-                   singularity::mix_impl::CacheAccessor &cache) const {
+  void operator()(const int i, const int tid, const int npte, const Real mass_sum,
+                  const Real t_mult, const Real s_mult, const Real p_mult,
+                  singularity::mix_impl::CacheAccessor &cache) const {
     /* initialize averaged quantities to 0 */
     const bool do_t = t_mult == 1.0;
     const bool do_s = s_mult == 1.0;
@@ -271,7 +219,7 @@ struct final_functor {
     return;
   }
 };
-  
+
 } // namespace singularity
 
 #endif // PORTABILITY_STRATEGY_KOKKOS
diff --git a/singularity-eos/eos/get_sg_eos_p_t.cpp b/singularity-eos/eos/get_sg_eos_p_t.cpp
index c81ec2828c..fb1db64d2d 100644
--- a/singularity-eos/eos/get_sg_eos_p_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_p_t.cpp
@@ -30,7 +30,7 @@ void get_sg_eos_p_t(const char *name, int ncell, int nmat, indirection_v &offset
                     ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
                     ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
                     Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                    bool small_loop, final_functor& f_func) {
+                    bool small_loop, final_functor &f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
diff --git a/singularity-eos/eos/get_sg_eos_rho_e.cpp b/singularity-eos/eos/get_sg_eos_rho_e.cpp
index 4d63423376..43049e31a7 100644
--- a/singularity-eos/eos/get_sg_eos_rho_e.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_e.cpp
@@ -20,13 +20,13 @@
 
 namespace singularity {
 void get_sg_eos_rho_e(const char *name, int ncell, indirection_v &offsets_v,
-                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
-		      dev_v &pmax_v, dev_v &sie_v, ScratchV<int> &pte_idxs,
-                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
-                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
-                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v, dev_v &pmax_v,
+                      dev_v &sie_v, ScratchV<int> &pte_idxs, ScratchV<double> &press_pte,
+                      ScratchV<double> &vfrac_pte, ScratchV<double> &rho_pte,
+                      ScratchV<double> &sie_pte, ScratchV<double> &temp_pte,
+                      ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, init_functor& i_func, final_functor& f_func) {
+                      bool small_loop, init_functor &i_func, final_functor &f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
@@ -55,10 +55,12 @@ void get_sg_eos_rho_e(const char *name, int ncell, indirection_v &offsets_v,
           const bool res_{PTESolver(method)};
         } else {
           // pure cell (nmat = 1)
-	  temp_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-	      .TemperatureFromDensityInternalEnergy(rho_pte(tid, 0), sie_pte(tid, 0), cache[0]);
-	  press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
-	      .PressureFromDensityTemperature(rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
+          temp_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+                                 .TemperatureFromDensityInternalEnergy(
+                                     rho_pte(tid, 0), sie_pte(tid, 0), cache[0]);
+          press_pte(tid, 0) = eos_v(pte_idxs(tid, 0))
+                                  .PressureFromDensityTemperature(
+                                      rho_pte(tid, 0), temp_pte(tid, 0), cache[0]);
         }
         // assign outputs
         f_func(i, tid, npte, mass_sum, 1.0, 0.0, 1.0, cache);
diff --git a/singularity-eos/eos/get_sg_eos_rho_p.cpp b/singularity-eos/eos/get_sg_eos_rho_p.cpp
index b8a92a28d3..dc6da80ecc 100644
--- a/singularity-eos/eos/get_sg_eos_rho_p.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_p.cpp
@@ -20,14 +20,14 @@
 
 namespace singularity {
 void get_sg_eos_rho_p(const char *name, int ncell, indirection_v &offsets_v,
-                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
-		      dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
-                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
-                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
-                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
-                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v, dev_v &pmax_v,
+                      dev_v &sie_v, dev_frac_v &frac_mass_v, ScratchV<int> &pte_idxs,
+                      ScratchV<int> &pte_mats, ScratchV<double> &press_pte,
+                      ScratchV<double> &vfrac_pte, ScratchV<double> &rho_pte,
+                      ScratchV<double> &sie_pte, ScratchV<double> &temp_pte,
+                      ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, init_functor& i_func, final_functor& f_func) {
+                      bool small_loop, init_functor &i_func, final_functor &f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
diff --git a/singularity-eos/eos/get_sg_eos_rho_t.cpp b/singularity-eos/eos/get_sg_eos_rho_t.cpp
index e1ddb6914d..f1b91eed1f 100644
--- a/singularity-eos/eos/get_sg_eos_rho_t.cpp
+++ b/singularity-eos/eos/get_sg_eos_rho_t.cpp
@@ -20,14 +20,14 @@
 
 namespace singularity {
 void get_sg_eos_rho_t(const char *name, int ncell, indirection_v &offsets_v,
-                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v,
-	              dev_v &pmax_v, dev_v &sie_v, dev_frac_v &frac_mass_v,
-                      ScratchV<int> &pte_idxs, ScratchV<int> &pte_mats,
-                      ScratchV<double> &press_pte, ScratchV<double> &vfrac_pte,
-                      ScratchV<double> &rho_pte, ScratchV<double> &sie_pte,
-                      ScratchV<double> &temp_pte, ScratchV<double> &solver_scratch,
+                      Kokkos::View<EOS *, Llft> &eos_v, dev_v &press_v, dev_v &pmax_v,
+                      dev_v &sie_v, dev_frac_v &frac_mass_v, ScratchV<int> &pte_idxs,
+                      ScratchV<int> &pte_mats, ScratchV<double> &press_pte,
+                      ScratchV<double> &vfrac_pte, ScratchV<double> &rho_pte,
+                      ScratchV<double> &sie_pte, ScratchV<double> &temp_pte,
+                      ScratchV<double> &solver_scratch,
                       Kokkos::Experimental::UniqueToken<DES, KGlobal> &tokens,
-                      bool small_loop, init_functor& i_func, final_functor& f_func) {
+                      bool small_loop, init_functor &i_func, final_functor &f_func) {
   portableFor(
       name, 0, ncell, PORTABLE_LAMBDA(const int &iloop) {
         // cell offset
diff --git a/test/test_eos_noble_abel.cpp b/test/test_eos_noble_abel.cpp
index f9827fe309..5d6b4264bd 100644
--- a/test/test_eos_noble_abel.cpp
+++ b/test/test_eos_noble_abel.cpp
@@ -532,8 +532,8 @@ SCENARIO("Test NobleAbel Entropy Calls", "[NobleAbel][NobleAbel5]") {
 #endif // PORTABILITY_STRATEGY_KOKKOS
 
       // Gold standard values for a subset of lookups
-      //constexpr std::array<Real, num> pressure_true{3.4450499999999993e+07};
-      //constexpr std::array<Real, num> temperature_true{1.5320999999999999e+03};
+      // constexpr std::array<Real, num> pressure_true{3.4450499999999993e+07};
+      // constexpr std::array<Real, num> temperature_true{1.5320999999999999e+03};
       constexpr std::array<Real, num> entropy_true{-2.0177705273504910e+08};
 
 #ifdef PORTABILITY_STRATEGY_KOKKOS

From 305f7e67333848984b061cec805e4feb891cdd09 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Wed, 16 Aug 2023 10:31:44 -0600
Subject: [PATCH 44/45] Correct cmake logic for get_sg_eos. Previously, built
 with closure and tests. Now only builds with closure and fortran.

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

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 27081f4297..f243d057f7 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -50,7 +50,7 @@ set(EOS_SRCS
 if (SINGULARITY_BUILD_CLOSURE)
   list(APPEND EOS_HEADERS
        closure/mixed_cell_models.hpp)
-  if (SINGULARITY_USE_FORTRAN OR SINGULARITY_BUILD_TESTS)
+  if (SINGULARITY_USE_FORTRAN)
     list(APPEND EOS_SRCS 
          eos/get_sg_eos.cpp)
     if (SINGULARITY_USE_KOKKOS)

From ed5a121a72219ab63a79e352511a1ead129233d4 Mon Sep 17 00:00:00 2001
From: Daniel Holladay <dholladay00@users.noreply.github.com>
Date: Wed, 16 Aug 2023 10:53:46 -0600
Subject: [PATCH 45/45] Edit changelog.

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

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1580521083..ba1c4ac246 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -43,6 +43,7 @@
 
 ### Infrastructure (changes irrelevant to downstream codes)
 - [[PR190]](https://github.com/lanl/singularity-eos/pull/190) update CI on re-git
+- [[PR245]](https://github.com/lanl/singularity-eos/pull/245) Separating get_sg_eos to other files. Build/compilation improvements, warning fixes/suppression.
 
 ### Removed (removing behavior/API/varaibles/...)