# This group is not scheduled explicitly here; it will be scheduled dynamically
# from  ODESolvers_solve
SCHEDULE GROUP ODESolvers_RHS

# This group will also be scheduled dynamically from  ODESolvers_solve
SCHEDULE GROUP ODESolvers_RHS AT poststep

#include <util_Table.h>

#include <string>

  vector<string> varnames;

  result.varnames = varnames;

    if (x->contains_nan())
      CCTK_VERROR("statecomp_t::copy.x: Variable %s contains nans",
                  varnames.at(n).c_str());

    if (y->contains_nan())
      CCTK_VERROR("statecomp_t::copy.y: Variable %s contains nans",
                  result.varnames.at(n).c_str());

    // TODO: Update Saxpy call when using AMReX 19.12 or later
    const auto nghosts = y.mfabs.at(n)->nGrowVect();
    for (int d = 0; d < 3; ++d)
      assert(nghosts[d] == nghosts[0]);

    assert(x.mfabs.at(n)->nGrowVect() == y.mfabs.at(n)->nGrowVect());
    if (x.mfabs.at(n)->contains_nan())
      CCTK_VERROR("statecomp_t::axpy.x: Variable %s contains nans",
                  x.varnames.at(n).c_str());

                    y.mfabs.at(n)->nComp(), nghosts[0]);

                    y.mfabs.at(n)->nComp(), y.mfabs.at(n)->nGrowVect());
    if (y.mfabs.at(n)->contains_nan())
      CCTK_VERROR("statecomp_t::axpy.y: Variable %s contains nans",
                  y.varnames.at(n).c_str());

    // TODO: Update Lincomb call when using AMReX 19.12 or later
    const auto nghosts = z.mfabs.at(n)->nGrowVect();
    for (int d = 0; d < 3; ++d)
      assert(nghosts[d] == nghosts[0]);

    assert(x.mfabs.at(n)->nGrowVect() == z.mfabs.at(n)->nGrowVect());
    assert(y.mfabs.at(n)->nGrowVect() == z.mfabs.at(n)->nGrowVect());
    if (x.mfabs.at(n)->contains_nan())
      CCTK_VERROR("statecomp_t::lincomb.x: Variable %s contains nans",
                  x.varnames.at(n).c_str());
    if (y.mfabs.at(n)->contains_nan())
      CCTK_VERROR("statecomp_t::lincomb.y: Variable %s contains nans",
                  y.varnames.at(n).c_str());

                      *y.mfabs.at(n), 0, 0, z.mfabs.at(n)->nComp(), nghosts[0]);

                      *y.mfabs.at(n), 0, 0, z.mfabs.at(n)->nComp(),
                      z.mfabs.at(n)->nGrowVect());
    if (z.mfabs.at(n)->contains_nan())
      CCTK_VERROR("statecomp_t::lincomb.z %s contains nans",
                  z.varnames.at(n).c_str());

int get_group_rhs(const int gi) {
  assert(gi >= 0);
  const int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  vector<char> rhs_buf(1000);
  const int iret =
      Util_TableGetString(tags, rhs_buf.size(), rhs_buf.data(), "rhs");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    rhs_buf[0] = '\0'; // default: empty (no RHS)
  } else if (iret >= 0) {
    // do nothing
  } else {
    assert(0);
  }
  const string str(rhs_buf.data());
  if (str.empty())
    return -1; // No RHS specified
  auto str1 = str;
  if (str1.find(':') == string::npos) {
    const char *impl = CCTK_GroupImplementationI(gi);
    str1 = string(impl) + "::" + str1;
  }
  const int gi1 = CCTK_GroupIndex(str1.c_str());
  assert(gi1 >= 0); // Check fluxes are valid groups
  const int flux = gi1;

  assert(flux != gi);
  return flux;
}
///////////////////////////////////////////////////////////////////////////////

  CCTK_VINFO("Integrator is %s", method);

      if (groupdata.groupindex == CCTK_GroupIndex("TestODESolvers::state")) {
        const int rhs_gi = CCTK_GroupIndex("TestODESolvers::rhs");

      const int rhs_gi = get_group_rhs(groupdata.groupindex);
      if (rhs_gi >= 0) {

        assert(rhs_groupdata.numvars == groupdata.numvars);

          var.varnames.push_back(
              CCTK_FullVarName(groupdata.firstvarindex + vi));

          rhs.varnames.push_back(
              CCTK_FullVarName(rhs_groupdata.firstvarindex + vi));

  const int nvars = int(var.mfabs.size());
  CCTK_VINFO("  Integrating %d variables", nvars);
  if (nvars == 0)
    CCTK_VWARN(CCTK_WARN_ALERT, "Integrating %d variables", nvars);

    CCTK_VINFO("Calculating RHS #1 at t=%g", double(cctkGH->cctk_time));

    CCTK_VINFO("Calculating RHS #2 at t=%g", double(cctkGH->cctk_time));

  CCTK_VINFO("Calculated new state at t=%g", double(cctkGH->cctk_time));