assert(groupdata.valid.at(tl).at(vi).valid_int);

  error_if_invalid(leveldata, groupdata, tl, vi, make_valid_int(),
                   [] { return "ErrorEst"; });

    scalargroupdata.why_valid.resize(group.numtimelevels);

      scalargroupdata.why_valid.at(tl).resize(scalargroupdata.numvars);

        auto &valid = scalargroupdata.valid.at(tl).at(vi);

        valid_t valid;

        scalargroupdata.why_valid.at(tl).at(vi) = {"SetupGlobals"};

        scalargroupdata.valid.at(tl).at(vi).set(valid,
                                                [] { return "SetupGlobals"; });

        check_valid(scalargroupdata, vi, tl, [&]() { return "SetupGlobals"; });

        check_valid(scalargroupdata, vi, tl, [] { return "SetupGlobals"; });

    groupdata.why_valid.resize(group.numtimelevels);

      groupdata.valid.at(tl) = vector<valid_t>(groupdata.numvars);
      groupdata.why_valid.at(tl) =
          vector<why_valid_t>(groupdata.numvars, {"SetupLevel"});
      for (int vi = 0; vi < groupdata.numvars; ++vi)

      groupdata.valid.at(tl).resize(groupdata.numvars);
      for (int vi = 0; vi < groupdata.numvars; ++vi) {
        groupdata.valid.at(tl).at(vi).set(valid_t(false),
                                          [] { return "SetupLevel"; });

      }

    groupdata.valid.resize(ntls);

      groupdata.valid.at(tl) = vector<valid_t>(groupdata.numvars);
      groupdata.why_valid.at(tl) =
          vector<why_valid_t>(groupdata.numvars, {"MakeNewLevelFromCoarse"});

      groupdata.valid.at(tl).resize(groupdata.numvars);
      for (int vi = 0; vi < groupdata.numvars; ++vi)
        groupdata.valid.at(tl).at(vi).set(
            valid_t(false), [] { return "MakeNewLevelFromCoarse"; });

        all_invalid &= !coarsegroupdata.valid.at(tl).at(vi).valid_any();

        all_invalid &= !coarsegroupdata.valid.at(tl).at(vi).get().valid_any();

        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          groupdata.valid.at(tl).at(vi) = valid_t(false);
          groupdata.why_valid.at(tl).at(vi) = {
              "MakeNewLevelFromCoarse: coarse grid is all invalid"};
        }

        for (int vi = 0; vi < groupdata.numvars; ++vi)
          groupdata.valid.at(tl).at(vi).set(valid_t(false), [] {
            return "MakeNewLevelFromCoarse: coarse grid is invalid";
          });

        // Expext coarse grid data to be valid
        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          if (!coarsegroupdata.valid.at(tl).at(vi).valid_all()) {
            valid_t all_valid(true);
            CCTK_VERROR("MakeNewLevelFromCoarse before prolongation: Grid "
                        "function \"%s\" is invalid on refinement level %d, "
                        "time level %d; expected valid %s, found valid %s",
                        CCTK_FullVarName(coarsegroupdata.firstvarindex + vi),
                        coarseleveldata.level, tl, string(all_valid).c_str(),
                        string(coarsegroupdata.valid.at(tl).at(vi)).c_str());
          }
        }

        // Expect coarse grid data to be valid

          check_valid(coarseleveldata, coarsegroupdata, vi, tl, [&]() {

          error_if_invalid(
              coarseleveldata, coarsegroupdata, vi, tl, make_valid_all(),
              [] { return "MakeNewLevelFromCoarse before prolongation"; });
          check_valid(coarseleveldata, coarsegroupdata, vi, tl, [] {

          auto &valid = groupdata.valid.at(tl).at(vi);
          valid.valid_int = coarsegroupdata.valid.at(tl).at(vi).valid_all();
          valid.valid_outer = false;
          valid.valid_ghosts = false;
          groupdata.why_valid.at(tl).at(vi) = {
              "MakeNewLevelFromCoarse: prolongated"};

          groupdata.valid.at(tl).at(vi).set(make_valid_int(), [] {
            return "MakeNewLevelFromCoarse after prolongation";
          });

        check_valid(leveldata, groupdata, vi, tl, [&]() {
          return "MakeNewLevelFromCoarse after prolongation";
        });

        check_valid(leveldata, groupdata, vi, tl,
                    [] { return "MakeNewLevelFromCoarse after prolongation"; });

      auto valid = vector<valid_t>(groupdata.numvars);
      auto why_valid = vector<why_valid_t>(groupdata.numvars, {"RemakeLevel"});

      auto valid = vector<why_valid_t>(
          groupdata.numvars, why_valid_t([] { return "RemakeLevel"; }));

          all_invalid &= !coarsegroupdata.valid.at(tl).at(vi).valid_any() &&
                         !groupdata.valid.at(tl).at(vi).valid_any();

          all_invalid &=
              !coarsegroupdata.valid.at(tl).at(vi).get().valid_any() &&
              !groupdata.valid.at(tl).at(vi).get().valid_any();

            const bool cond = coarsegroupdata.valid.at(tl).at(vi).valid_all() &&
                              groupdata.valid.at(tl).at(vi).valid_all();
            if (!cond)
              CCTK_VERROR(
                  "Found invalid input data: RemakeLevel level %d, "
                  "variable %s%s: need everything defined, have coarse "
                  "%s (%s), have current %s (%s)",
                  leveldata.level,
                  CCTK_FullVarName(groupdata.firstvarindex + vi),
                  string("_p", tl).c_str(),
                  string(coarsegroupdata.valid.at(tl).at(vi)).c_str(),
                  string(coarsegroupdata.why_valid.at(tl).at(vi)).c_str(),
                  string(groupdata.valid.at(tl).at(vi)).c_str(),
                  string(groupdata.why_valid.at(tl).at(vi)).c_str());

            error_if_invalid(coarseleveldata, coarsegroupdata, vi, tl,
                             make_valid_all(),
                             [] { return "RemakeLevel before prolongation"; });
            error_if_invalid(leveldata, groupdata, vi, tl, make_valid_all(),
                             [] { return "RemakeLevel before prolongation"; });

                        [&]() { return "RemakeLevel before prolongation"; });

                        [] { return "RemakeLevel before prolongation"; });

          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            valid.at(vi).valid_int =
                coarsegroupdata.valid.at(tl).at(vi).valid_all() &&
                groupdata.valid.at(tl).at(vi).valid_all();
            valid.at(vi).valid_outer = false;
            valid.at(vi).valid_ghosts = false;
            why_valid.at(vi) = {"RemakeLevel: copied and prolongated"};
          }

          for (int vi = 0; vi < groupdata.numvars; ++vi)
            valid.at(vi) = why_valid_t(make_valid_int(), [] {
              return "RemakeLevel after prolongation";
            });

      groupdata.why_valid.at(tl) = move(why_valid);

                    [&]() { return "RemakeLevel after prolongation"; });

                    [] { return "RemakeLevel after prolongation"; });

#warning "CONTINUE HERE: why_valid"

#include <functional>

struct why_valid_t {
  string why_int, why_outer, why_ghosts;
  why_valid_t() : why_valid_t("<unknown reason>") {}
  why_valid_t(const string &why)
      : why_int(why), why_outer(why), why_ghosts(why) {}

inline constexpr valid_t make_valid_int() {
  valid_t valid;
  valid.valid_int = true;
  return valid;
}
inline constexpr valid_t make_valid_outer() {
  valid_t valid;
  valid.valid_outer = true;
  return valid;
}
inline constexpr valid_t make_valid_ghosts() {
  valid_t valid;
  valid.valid_ghosts = true;
  return valid;
}
inline constexpr valid_t make_valid_all() { return ~valid_t(); }

  friend ostream &operator<<(ostream &os, const why_valid_t why) {
    return os << "why_valid_t{int:" << why.why_int << ","
              << "outer:" << why.why_outer << ","
              << "ghosts:" << why.why_ghosts << "}";
  }
  operator string() const {
    ostringstream buf;
    buf << *this;
    return buf.str();
  }
};

class why_valid_t {
  valid_t valid;
  function<string()> why_int, why_outer, why_ghosts;
public:
  why_valid_t() : why_valid_t([] { return "<unknown reason>"; }) {}
  why_valid_t(const function<string()> &why) : why_valid_t(false, why) {}
  why_valid_t(bool b, const function<string()> &why)
      : why_valid_t(valid_t(b), why) {}
  why_valid_t(const valid_t &val, const function<string()> &why)
      : valid(val), why_int(why), why_outer(why), why_ghosts(why) {}
  const valid_t &get() const { return valid; }
  void set(const valid_t &val, const function<string()> &why) {
    auto old_valid = valid;
    valid = val;
    auto new_valid = valid;
    if (new_valid.valid_int != old_valid.valid_int)
      why_int = why;
    if (new_valid.valid_outer != old_valid.valid_outer)
      why_outer = why;
    if (new_valid.valid_ghosts != old_valid.valid_ghosts)
      why_ghosts = why;
  }
  void set_int(bool b, const function<string()> &why) {
    auto val = valid;
    val.valid_int = b;
    set(val, why);
  }
  void set_outer(bool b, const function<string()> &why) {
    auto val = valid;
    val.valid_outer = b;
    set(val, why);
  }
  void set_ghosts(bool b, const function<string()> &why) {
    auto val = valid;
    val.valid_ghosts = b;
    set(val, why);
  }
  void set_and(const valid_t &val, const function<string()> &why) {
    set(valid & val, why);
  }
  void set_or(const valid_t &val, const function<string()> &why) {
    set(valid | val, why);
  }
  friend ostream &operator<<(ostream &os, const why_valid_t why) {
    return os << why.valid << ","
              << "why{int:" << why.why_int() << ","
              << "outer:" << why.why_outer() << ","
              << "ghosts:" << why.why_ghosts() << "}";
  }
  operator string() const {
    ostringstream buf;
    buf << *this;
    return buf.str();
  }
};

    vector<vector<valid_t> > valid;         // [time level][var index]
    vector<vector<why_valid_t> > why_valid; // [time level][var index]

    vector<vector<why_valid_t> > valid; // [time level][var index]

        linsolve.cxx                            \

        linsolve.cxx				\
        logo.cxx				\

    if (!groupdata.valid.at(tl).at(vi).valid_int)
      CCTK_VWARN(CCTK_WARN_ALERT,
                 "Variable %s has invalid data in the interior of level %d",
                 CCTK_FullVarName(groupdata.firstvarindex + vi),
                 leveldata.level);

    warn_if_invalid(leveldata, groupdata, vi, tl, make_valid_int(),
                    [] { return "Before reduction"; });

////////////////////////////////////////////////////////////////////////////////

// Ensure grid functions are valid
void error_if_invalid(const GHExt::LevelData &leveldata,
                      const GHExt::CommonGroupData &groupdata, int vi, int tl,
                      const valid_t &required, const function<string()> &msg) {
  const valid_t &have = groupdata.valid.at(tl).at(vi).get();
  if (CCTK_BUILTIN_EXPECT((required & ~have).valid_any(), false))
    CCTK_VERROR(
        "%s: Grid function \"%s\" is invalid on refinement level %d, time "
        "level %d; required %s, found %s",
        msg().c_str(), CCTK_FullVarName(groupdata.firstvarindex + vi),
        leveldata.level, tl, string(required).c_str(),
        string(groupdata.valid.at(tl).at(vi)).c_str());
}
void warn_if_invalid(const GHExt::LevelData &leveldata,
                     const GHExt::CommonGroupData &groupdata, int vi, int tl,
                     const valid_t &required, const function<string()> &msg) {
  const valid_t &have = groupdata.valid.at(tl).at(vi).get();
  if (CCTK_BUILTIN_EXPECT((required & ~have).valid_any(), false))
    CCTK_VWARN(
        CCTK_WARN_ALERT,
        "%s: Grid function \"%s\" is invalid on refinement level %d, time "
        "level %d; required %s, found %s",
        msg().c_str(), CCTK_FullVarName(groupdata.firstvarindex + vi),
        leveldata.level, tl, string(required).c_str(),
        string(groupdata.valid.at(tl).at(vi)).c_str());
}

  const valid_t &valid = groupdata.valid.at(tl).at(vi);
  if (valid.valid_int && valid.valid_outer && valid.valid_ghosts)

  const valid_t &valid = groupdata.valid.at(tl).at(vi).get();
  if (valid.valid_all())

  const valid_t &valid = groupdata.valid.at(tl).at(vi);
  if (!valid.valid_int && !valid.valid_outer && !valid.valid_ghosts)

  const valid_t &valid = groupdata.valid.at(tl).at(vi).get();
  if (!valid.valid_any())

        leveldata.level, tl, string(valid).c_str());

        leveldata.level, tl, string(groupdata.valid.at(tl).at(vi)).c_str());
}
// Ensure grid functions are valid
void error_if_invalid(const GHExt::CommonGroupData &groupdata, int vi, int tl,
                      const valid_t &required, const function<string()> &msg) {
  const valid_t &have = groupdata.valid.at(tl).at(vi).get();
  if (CCTK_BUILTIN_EXPECT((required & ~have).valid_any(), false))
    CCTK_VERROR("%s: Grid function \"%s\" is invalid on time level %d; "
                "required %s, found %s",
                msg().c_str(), CCTK_FullVarName(groupdata.firstvarindex + vi),
                tl, string(required).c_str(),
                string(groupdata.valid.at(tl).at(vi)).c_str());
}
void warn_if_invalid(const GHExt::CommonGroupData &groupdata, int vi, int tl,
                     const valid_t &required, const function<string()> &msg) {
  const valid_t &have = groupdata.valid.at(tl).at(vi).get();
  if (CCTK_BUILTIN_EXPECT((required & ~have).valid_any(), false))
    CCTK_VWARN(CCTK_WARN_ALERT,
               "%s: Grid function \"%s\" is invalid on time level %d; "
               "required %s, found %s",
               msg().c_str(), CCTK_FullVarName(groupdata.firstvarindex + vi),
               tl, string(required).c_str(),
               string(groupdata.valid.at(tl).at(vi)).c_str());

  const valid_t &valid = scalargroupdata.valid.at(tl).at(vi);

  const valid_t &valid = scalargroupdata.valid.at(tl).at(vi).get();

  const valid_t &valid = scalargroupdata.valid.at(tl).at(vi);

  const valid_t &valid = scalargroupdata.valid.at(tl).at(vi).get();

        string(valid).c_str());

        string(scalargroupdata.valid.at(tl).at(vi)).c_str());

            const auto &valid = groupdata.valid.at(tl).at(vi);

            const auto &valid = groupdata.valid.at(tl).at(vi).get();

            groupdata.valid.at(tl).at(vi) = valid_t();

            groupdata.valid.at(tl).at(vi).set(valid_t(), [] {
              return "InvalidateTimelevels (invalidate all "
                     "non-checkpointed variables)";
            });

            scalargroupdata.valid.at(tl).at(vi).valid_int = false;

            scalargroupdata.valid.at(tl).at(vi).set_int(false, [] {
              return "InvalidateTimelevels (invalidate all non-checkpointed "
                     "variables)";
            });

        groupdata.mfab.at(0) = move(tmp);
        vector<valid_t> vtmp = move(groupdata.valid.at(ntls - 1));

        auto tmp_valid = move(groupdata.valid.at(ntls - 1));

        groupdata.valid.at(0) = move(vtmp);

        groupdata.valid.at(0) = move(tmp_valid);

          groupdata.valid.at(0).at(vi) = valid_t();

          groupdata.valid.at(0).at(vi) = why_valid_t(valid_t(), [] {
            return "CycletimeLevels (invalidate current time level)";
          });

        vector<valid_t> vtmp = move(scalargroupdata.valid.at(ntls - 1));

        auto tmp_valid = move(scalargroupdata.valid.at(ntls - 1));

        scalargroupdata.valid.at(0) = move(vtmp);

        scalargroupdata.valid.at(0) = move(tmp_valid);

          scalargroupdata.valid.at(0).at(vi) = valid_t();

          scalargroupdata.valid.at(0).at(vi).set_int(false, [] {
            return "CycletimeLevels (invalidate current time level)";
          });

}

} // namespace CarpetX

          const valid_t &have = groupdata.valid.at(rd.tl).at(rd.vi);
          // "x <= y" for booleans means "x implies y"
          const bool cond = need.valid_int <= have.valid_int &&
                            need.valid_outer <= have.valid_outer &&
                            need.valid_ghosts <= have.valid_ghosts;
          if (!cond)
            CCTK_VERROR("Found invalid input data: iteration %d %s: %s::%s, "
                        "level %d, "
                        "variable %s%s: need %s, have %s",
                        cctkGH->cctk_iteration, attribute->where,
                        attribute->thorn, attribute->routine, leveldata.level,
                        CCTK_FullVarName(groupdata.firstvarindex + rd.vi),
                        string("_p", rd.tl).c_str(), string(need).c_str(),
                        string(have).c_str());
          check_valid(leveldata, groupdata, rd.vi, rd.tl, [&]() {

          error_if_invalid(leveldata, groupdata, rd.vi, rd.tl, need, [&] {
            ostringstream buf;
            buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
                << attribute->where << ": " << attribute->thorn
                << "::" << attribute->routine << " checking input";
            return buf.str();
          });
          check_valid(leveldata, groupdata, rd.vi, rd.tl, [&] {

        const valid_t &have = scalargroupdata.valid.at(rd.tl).at(rd.vi);
        // "x <= y" for booleans means "x implies y"
        const bool cond = need.valid_int <= have.valid_int &&
                          need.valid_outer <= have.valid_outer &&
                          need.valid_ghosts <= have.valid_ghosts;
        if (!cond)
          CCTK_VERROR("Found invalid input data: iteration %d %s: %s::%s, "
                      "variable %s%s: need %s, have %s",
                      cctkGH->cctk_iteration, attribute->where,
                      attribute->thorn, attribute->routine,
                      CCTK_FullVarName(scalargroupdata.firstvarindex + rd.vi),
                      string("_p", rd.tl).c_str(), string(need).c_str(),
                      string(have).c_str());
        check_valid(scalargroupdata, rd.vi, rd.tl, [&]() {

        error_if_invalid(scalargroupdata, rd.vi, rd.tl, need, [&] {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking input";
          return buf.str();
        });
        check_valid(scalargroupdata, rd.vi, rd.tl, [&] {

          valid_t &have = groupdata.valid.at(wr.tl).at(wr.vi);
          have.valid_int &= need.valid_int || !provided.valid_int;
          have.valid_outer &= need.valid_outer || !provided.valid_outer;
          have.valid_ghosts &= need.valid_ghosts || !provided.valid_ghosts;

          groupdata.valid.at(wr.tl).at(wr.vi).set_and(
              need | ~provided,
              [iteration = cctkGH->cctk_iteration, where = attribute->where,
               thorn = attribute->thorn, routine = attribute->routine] {
                ostringstream buf;
                buf << "CallFunction iteration " << iteration << " " << where
                    << ": " << thorn << "::" << routine
                    << ": Poison output variables that are not input variables";
                return buf.str();
              });

        valid_t &have = scalargroupdata.valid.at(wr.tl).at(wr.vi);
        have.valid_int &= need.valid_int || !provided.valid_int;
        have.valid_outer &= need.valid_outer || !provided.valid_outer;
        have.valid_ghosts &= need.valid_ghosts || !provided.valid_ghosts;

        scalargroupdata.valid.at(wr.tl).at(wr.vi).set_and(
            need | ~provided,
            [iteration = cctkGH->cctk_iteration, where = attribute->where,
             thorn = attribute->thorn, routine = attribute->routine] {
              ostringstream buf;
              buf << "CallFunction iteration " << iteration << " " << where
                  << ": " << thorn << "::" << routine
                  << ": Poison output variables that are not input variables";
              return buf.str();
            });

        const int numtimelevels = 1; // TODO

        const int numtimelevels = 1; // is expanded later if necessary

          valid_t &have = groupdata.valid.at(wr.tl).at(wr.vi);
          have.valid_int |= provided.valid_int;
          have.valid_outer |= provided.valid_outer;
          have.valid_ghosts |= provided.valid_ghosts;

          groupdata.valid.at(wr.tl).at(wr.vi).set_or(
              provided,
              [iteration = cctkGH->cctk_iteration, where = attribute->where,
               thorn = attribute->thorn, routine = attribute->routine] {
                ostringstream buf;
                buf << "CallFunction iteration " << iteration << " " << where
                    << ": " << thorn << "::" << routine
                    << ": Mark output variables as valid";
                return buf.str();
              });

        valid_t &have = scalargroupdata.valid.at(wr.tl).at(wr.vi);
        have.valid_int |= provided.valid_int;
        have.valid_outer |= provided.valid_outer;
        have.valid_ghosts |= provided.valid_ghosts;

        scalargroupdata.valid.at(wr.tl).at(wr.vi).set_or(
            provided,
            [iteration = cctkGH->cctk_iteration, where = attribute->where,
             thorn = attribute->thorn, routine = attribute->routine] {
              ostringstream buf;
              buf << "CallFunction iteration " << iteration << " " << where
                  << ": " << thorn << "::" << routine
                  << ": Mark output variables as valid";
              return buf.str();
            });

          valid_t &have = groupdata.valid.at(inv.tl).at(inv.vi);
          have.valid_int &= !provided.valid_int;
          have.valid_outer &= !provided.valid_outer;
          have.valid_ghosts &= !provided.valid_ghosts;

          groupdata.valid.at(inv.tl).at(inv.vi).set_and(
              ~provided,
              [iteration = cctkGH->cctk_iteration, where = attribute->where,
               thorn = attribute->thorn, routine = attribute->routine] {
                ostringstream buf;
                buf << "CallFunction iteration " << iteration << " " << where
                    << ": " << thorn << "::" << routine
                    << ": Mark invalid variables as invalid";
                return buf.str();
              });

        valid_t &have = scalargroupdata.valid.at(inv.tl).at(inv.vi);
        have.valid_int &= !provided.valid_int;
        have.valid_outer &= !provided.valid_outer;
        have.valid_ghosts &= !provided.valid_ghosts;

        scalargroupdata.valid.at(inv.tl).at(inv.vi).set_and(
            ~provided,
            [iteration = cctkGH->cctk_iteration, where = attribute->where,
             thorn = attribute->thorn, routine = attribute->routine] {
              ostringstream buf;
              buf << "CallFunction iteration " << iteration << " " << where
                  << ": " << thorn << "::" << routine
                  << ": Mark invalid variables as invalid";
              return buf.str();
            });

          bool all_valid = true;

            if (!groupdata.valid.at(tl).at(vi).valid_int) {
              CCTK_VWARN(
                  CCTK_WARN_ALERT,
                  "Grid function '%s' interior not valid before restrict",
                  CCTK_FullVarName(vi));
              all_valid = false;
            }
          }
          if (!all_valid) {
            CCTK_ERROR(
                "Found grid functions that are not valid in the interior");
          }
          for (int vi = 0; vi < groupdata.numvars; ++vi)
            groupdata.valid.at(tl).at(vi).valid_ghosts = false;
          for (int vi = 0; vi < groupdata.numvars; ++vi) {

            error_if_invalid(leveldata, groupdata, tl, vi, make_valid_int(),
                             [] { return "SyncGroupsByDirI before syncing"; });
            groupdata.valid.at(tl).at(vi).set_and(~make_valid_ghosts(), [] {
              return "SyncGroupsByDirI before syncing: Mark ghost zones as "
                     "invalid";
            });

                        [&]() { return "SyncGroupsByDirI before syncing"; });

                        [] { return "SyncGroupsByDirI before syncing"; });

            groupdata.valid.at(tl).at(vi).valid_ghosts =
                groupdata.valid.at(tl).at(vi).valid_int;

            groupdata.valid.at(tl).at(vi).set_ghosts(true, [] {
              return "SyncGroupsByDirI after syncing: Mark ghost zones as "
                     "valid";
            });

            all_invalid &= !coarsegroupdata.valid.at(tl).at(vi).valid_int &&
                           !coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                           !coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&
                           !groupdata.valid.at(tl).at(vi).valid_int;

            all_invalid &=
                !coarsegroupdata.valid.at(tl).at(vi).get().valid_any() &&
                !groupdata.valid.at(tl).at(vi).get().valid_int;

            for (int vi = 0; vi < groupdata.numvars; ++vi) {
              groupdata.valid.at(tl).at(vi).valid_int = false;
              groupdata.valid.at(tl).at(vi).valid_outer = false;
              groupdata.valid.at(tl).at(vi).valid_ghosts = false;
            }

            for (int vi = 0; vi < groupdata.numvars; ++vi)
              groupdata.valid.at(tl).at(vi).set(valid_t(), [] {
                return "SyncGroupsByDirI skipping prolongation: Mark as "
                       "invalid because neither coarse grid nor fine grid "
                       "interior are valid";
              });

            bool some_sources_invalid = false;

              if (!coarsegroupdata.valid.at(tl).at(vi).valid_int) {
                CCTK_VWARN(CCTK_WARN_ALERT,
                  "Prolongation requires valid interior in coarse grid (level = %d), but found it invalid for '%s' on timelevel %d",
                  level - 1, CCTK_FullVarName(vi), tl);
                some_sources_invalid = true;
              }
              if (!coarsegroupdata.valid.at(tl).at(vi).valid_outer) {
                CCTK_VWARN(CCTK_WARN_ALERT,
                  "Prolongation requires valid boundary in coarse grid (level = %d), but found it invalid for '%s' on timelevel %d",
                  level - 1, CCTK_FullVarName(vi), tl);
                some_sources_invalid = true;
              }
              if (!coarsegroupdata.valid.at(tl).at(vi).valid_ghosts) {
                CCTK_VWARN(CCTK_WARN_ALERT,
                  "Prolongation requires valid ghosts in coarse grid (level = %d), but found it invalid for '%s' on timelevel %d",
                  level - 1, CCTK_FullVarName(vi), tl);
                some_sources_invalid = true;
              }
              if (!groupdata.valid.at(tl).at(vi).valid_int) {
                CCTK_VWARN(CCTK_WARN_ALERT,
                  "Prolongation expects valid interior in fine grid (level = %d), but found it invalid for '%s' on timelevel %d",
                  level, CCTK_FullVarName(vi), tl);
                some_sources_invalid = true;
              }
            }
            if (some_sources_invalid)
              CCTK_ERROR("Some sources for prolongation were invalid");
            for (int vi = 0; vi < groupdata.numvars; ++vi)
              groupdata.valid.at(tl).at(vi).valid_ghosts = false;
            for (int vi = 0; vi < groupdata.numvars; ++vi) {

              groupdata.valid.at(tl).at(vi).set_ghosts(false, [] {
                return "SyncGroupsByDirI before prolongation: Mark ghosts as "
                       "invalid";
              });

              check_valid(coarseleveldata, coarsegroupdata, vi, tl, [&]() {

              error_if_invalid(coarseleveldata, coarsegroupdata, vi, tl,
                               make_valid_all(), [] {
                                 return "SyncGroupsByDirI on coarse level "
                                        "before prolongation";
                               });
              error_if_invalid(
                  leveldata, groupdata, vi, tl, make_valid_int(), [] {
                    return "SyncGroupsByDirI on fine level before prolongation";
                  });
              check_valid(coarseleveldata, coarsegroupdata, vi, tl, [] {

              check_valid(leveldata, groupdata, vi, tl, [&]() {

              check_valid(leveldata, groupdata, vi, tl, [] {

              groupdata.valid.at(tl).at(vi).valid_ghosts =
                  coarsegroupdata.valid.at(tl).at(vi).valid_int &&
                  coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                  coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&
                  groupdata.valid.at(tl).at(vi).valid_int;
          } // if all_invalid

              groupdata.valid.at(tl).at(vi).set_ghosts(
                  true, [] { return "SyncGroupsByDirI after prolongation"; });
          } // if not all_invalid

        assert(finegroupdata.valid.at(tl).at(vi).valid_int);
        assert(groupdata.valid.at(tl).at(vi).valid_int);

        error_if_invalid(fineleveldata, finegroupdata, vi, tl, make_valid_int(),
                         [] { return "Reflux: Fine level data"; });
        error_if_invalid(leveldata, groupdata, vi, tl, make_valid_int(),
                         [] { return "Reflux: Coarse level data"; });

          assert(flux_finegroupdata.valid.at(tl).at(vi).valid_int);
          assert(flux_groupdata.valid.at(tl).at(vi).valid_int);

          error_if_invalid(
              fineleveldata, flux_finegroupdata, vi, tl, make_valid_int(), [&] {
                ostringstream buf;
                buf << "Reflux: Fine level flux in direction " << d;
                return buf.str();
              });
          error_if_invalid(
              leveldata, flux_groupdata, vi, tl, make_valid_int(), [&] {
                ostringstream buf;
                buf << "Reflux: Coarse level flux in direction " << d;
                return buf.str();
              });

        all_invalid &= !finegroupdata.valid.at(tl).at(vi).valid_int &&
                       !groupdata.valid.at(tl).at(vi).valid_int;

        all_invalid &= !finegroupdata.valid.at(tl).at(vi).get().valid_int &&
                       !groupdata.valid.at(tl).at(vi).get().valid_int;

          groupdata.valid.at(tl).at(vi).valid_outer = false;
          groupdata.valid.at(tl).at(vi).valid_ghosts = false;

          groupdata.valid.at(tl).at(vi).set_and(make_valid_int(), [] {
            return "Restrict on fine level skipping restricting (both fine and "
                   "coarse level data are invalid)";
          });

          assert(finegroupdata.valid.at(tl).at(vi).valid_int &&
                 groupdata.valid.at(tl).at(vi).valid_int);

          error_if_invalid(
              fineleveldata, finegroupdata, vi, tl, make_valid_int(),
              [] { return "Restrict on fine level before restricting"; });

          check_valid(fineleveldata, finegroupdata, vi, tl, [&]() {

          check_valid(fineleveldata, finegroupdata, vi, tl, [] {

          });
          error_if_invalid(leveldata, groupdata, vi, tl, make_valid_int(), [] {
            return "Restrict on coarse level before restricting";

          check_valid(leveldata, groupdata, vi, tl, [&]() {

          check_valid(leveldata, groupdata, vi, tl, [] {

        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          groupdata.valid.at(tl).at(vi).valid_int &=
              finegroupdata.valid.at(tl).at(vi).valid_int;
          groupdata.valid.at(tl).at(vi).valid_outer = false;
          groupdata.valid.at(tl).at(vi).valid_ghosts = false;
        }

        for (int vi = 0; vi < groupdata.numvars; ++vi)
          groupdata.valid.at(tl).at(vi).set(make_valid_int(),
                                            [] { return "Restrict"; });

void error_if_invalid(const GHExt::LevelData &leveldata,
                      const GHExt::CommonGroupData &groupdata, int vi, int tl,
                      const valid_t &required, const function<string()> &msg);
void warn_if_invalid(const GHExt::LevelData &leveldata,
                     const GHExt::CommonGroupData &groupdata, int vi, int tl,
                     const valid_t &required, const function<string()> &msg);

void error_if_invalid(const GHExt::CommonGroupData &groupdata, int vi, int tl,
                      const valid_t &required, const function<string()> &msg);
void warn_if_invalid(const GHExt::CommonGroupData &groupdata, int vi, int tl,
                     const valid_t &required, const function<string()> &msg);