fix RKC integration with SDC (#1497)

Author: zingale

integration/RKC/actual_integrator_sdc.H

@@ -16,7 +16,7 @@ using namespace integrator_rp;
 
 template <typename BurnT>
 AMREX_GPU_HOST_DEVICE AMREX_INLINE
-void actual_integrator (BurnT& state, Real dt)
+void actual_integrator (BurnT& state, amrex::Real dt, bool is_retry=false)
 {
     constexpr int int_neqs = integrator_neqs<BurnT>();
 
@@ -38,46 +38,63 @@ void actual_integrator (BurnT& state, Real dt)
     // Save the initial composition and temperature for our later diagnostics.
 
 #ifndef AMREX_USE_GPU
-    Real xn_in[NumSpec];
+    amrex::Real xn_in[NumSpec];
     for (int n = 0; n < NumSpec; ++n) {
         xn_in[n] = state.y[SFS+n] / state.y[SRHO];
     }
     // we are assuming that the temperature was valid on input
-    Real T_in = state.T;
+    amrex::Real T_in = state.T;
 #ifdef AUX_THERMO
-    Real aux_in[NumAux];
+    amrex::Real aux_in[NumAux];
     for (int n = 0; n < NumAux; ++n) {
         aux_in[n] = state.y[SFX+n] / state.y[SRHO];
     }
 #endif
-    Real rhoe_in = state.y[SEINT];
+    amrex::Real rhoe_in = state.y[SEINT];
 #endif
 
 
     // Set the tolerances.
 
-    Real sdc_tol_fac = std::pow(sdc_burn_tol_factor, state.num_sdc_iters - state.sdc_iter - 1);
+    amrex::Real sdc_tol_fac = std::pow(sdc_burn_tol_factor, state.num_sdc_iters - state.sdc_iter - 1);
 
     // we use 1-based indexing inside of RKC, so we need to shift the
     // indices SRHO, SFS, etc by 1
 
-    Real sdc_min_density = amrex::min(state.rho, state.rho_orig + state.ydot_a[SRHO] * dt);
+    amrex::Real sdc_min_density = amrex::min(state.rho, state.rho_orig + state.ydot_a[SRHO] * dt);
 
-    rkc_state.atol_enuc = sdc_min_density * atol_enuc * sdc_tol_fac;
-    rkc_state.rtol_enuc = rtol_enuc * sdc_tol_fac;
+    if (!is_retry) {
+
+        rkc_state.atol_enuc = sdc_min_density * atol_enuc * sdc_tol_fac;
+        rkc_state.rtol_enuc = rtol_enuc * sdc_tol_fac;
+
+        // Note: we define the input atol for species to refer only to the
+        // mass fraction part, and we multiply by a representative density
+        // so that atol becomes an absolutely tolerance on (rho X)
+
+        rkc_state.atol_spec = sdc_min_density * atol_spec * sdc_tol_fac;
+        rkc_state.rtol_spec = rtol_spec * sdc_tol_fac;
+
+    } else {
+
+        rkc_state.atol_enuc = sdc_min_density * retry_atol_enuc * sdc_tol_fac;
+        rkc_state.rtol_enuc = retry_rtol_enuc * sdc_tol_fac;
+
+        // Note: we define the input atol for species to refer only to the
+        // mass fraction part, and we multiply by a representative density
+        // so that atol becomes an absolutely tolerance on (rho X)
+
+        rkc_state.atol_spec = sdc_min_density * retry_atol_spec * sdc_tol_fac;
+        rkc_state.rtol_spec = retry_rtol_spec * sdc_tol_fac;
+
+    }
 
     if (scale_system) {
         // the absolute tol for energy needs to reflect the scaled
         // energy the integrator sees
         rkc_state.atol_enuc /= state.e_scale;
     }
 
-    // Note: we define the input atol for species to refer only to the
-    // mass fraction part, and we multiply by a representative density
-    // so that atol becomes an absolutely tolerance on (rho X)
-
-    rkc_state.atol_spec = sdc_min_density * atol_spec * sdc_tol_fac;
-    rkc_state.rtol_spec = rtol_spec * sdc_tol_fac;
 
     // Call the integration routine.
 
@@ -98,7 +115,7 @@ void actual_integrator (BurnT& state, Real dt)
     // we only evolved (rho e), not (rho E), so we need to update the
     // total energy now to ensure we are conservative
 
-    Real rho_Sdot = 0.0_rt;
+    amrex::Real rho_Sdot = 0.0_rt;
     if (state.time > 0) {
         rho_Sdot = (state.y[SEINT] - state.rhoe_orig) / state.time - state.ydot_a[SEINT];
     }
@@ -164,14 +181,14 @@ void actual_integrator (BurnT& state, Real dt)
         std::cout << "temp start = " << std::setprecision(16) << T_in << std::endl;
         std::cout << "rhoe start = " << std::setprecision(16) << rhoe_in << std::endl;
         std::cout << "xn start = ";
-        for (int n = 0; n < NumSpec; ++n) {
-            std::cout << std::setprecision(16) << xn_in[n] << " ";
+        for (auto X : xn_in) {
+            std::cout << std::setprecision(16) << X << " ";
         }
         std::cout << std::endl;
 #ifdef AUX_THERMO
         std::cout << "aux start = ";
-        for (int n = 0; n < NumAux; ++n) {
-            std::cout << std::setprecision(16) << aux_in[n] << " ";
+        for (auto aux : aux_in) {
+            std::cout << std::setprecision(16) << aux << " ";
         }
         std::cout << std::endl;
 #endif

integration/utils/circle_theorem.H

@@ -5,8 +5,7 @@
 #ifdef STRANG
 #include <integrator_type_strang.H>
 #include <integrator_rhs_strang.H>
-#endif
-#ifdef SDC
+#else
 #include <integrator_type_sdc.H>
 #include <integrator_rhs_sdc.H>
 #endif
@@ -23,7 +22,11 @@ void circle_theorem_sprad(const amrex::Real time, BurnT& state, T& int_state, am
     if (integrator_rp::jacobian == 1) {
         jac(time, state, int_state, jac_array);
     } else {
+#ifdef STRANG
         integrator_to_burn(int_state, state);
+#else
+        int_to_burn(time, int_state, state);
+#endif
         jac_info_t jac_info;
         jac_info.h = 0.0_rt;
         numerical_jac(state, jac_info, jac_array);