{
} yes
BOOLEAN do_restrict "Automatically restrict fine to coarse grid functions"

BOOLEAN restrict_during_sync "Restrict fine to coarse grid functions when syncing"
{
} no

void Restrict(int level, const vector<int> &groups);

                     const int *groups, const int *directions) {

                     const int *groups0, const int *directions) {

  assert(groups);

  assert(groups0);

      buf << unique_ptr<char>(CCTK_GroupName(groups[n])).get();

      buf << unique_ptr<char>(CCTK_GroupName(groups0[n])).get();

  }
  const int gi_regrid_error = CCTK_GroupIndex("CarpetX::regrid_error");
  assert(gi_regrid_error >= 0);
  const int gi_refinement_level = CCTK_GroupIndex("CarpetX::refinement_level");
  assert(gi_refinement_level >= 0);
  vector<int> groups;
  for (int n = 0; n < numgroups; ++n) {
    int gi = groups0[n];
    if (CCTK_GroupTypeI(gi) != CCTK_GF)
      continue;
    // Don't restrict the regridding error nor the refinement level
    if (gi == gi_regrid_error || gi == gi_refinement_level)
      continue;
    // Don't restrict groups that have restriction disabled
    groups.push_back(gi);
  }
  if (restrict_during_sync) {
    if (current_level == -1)
      for (int level = 0; level < int(ghext->leveldata.size()); ++level)
        Restrict(level, groups);
    else
      Restrict(current_level, groups);

    for (int n = 0; n < numgroups; ++n) {
      int gi = groups[n];

    for (const int gi : groups) {

      if (group.grouptype != CCTK_GF)
        continue;

      assert(group.grouptype == CCTK_GF);

void Restrict(int level) {

void Restrict(int level, const vector<int> &groups) {

  if (!do_restrict)
    return;

  for (int gi = 0; gi < int(leveldata.groupdata.size()); ++gi) {

  for (const int gi : groups) {

    if (group.grouptype != CCTK_GF)
      continue;

    assert(group.grouptype == CCTK_GF);

  }
}
void Restrict(int level) {
  const int gi_regrid_error = CCTK_GroupIndex("CarpetX::regrid_error");
  assert(gi_regrid_error >= 0);
  const int gi_refinement_level = CCTK_GroupIndex("CarpetX::refinement_level");
  assert(gi_refinement_level >= 0);
  const int numgroups = CCTK_NumGroups();
  vector<int> groups;
  groups.reserve(numgroups);
  for (int gi = 0; gi < numgroups; ++gi) {
    if (CCTK_GroupTypeI(gi) != CCTK_GF)
      continue;
    // Don't restrict the regridding error nor the refinement level
    if (gi == gi_regrid_error || gi == gi_refinement_level)
      continue;
    // Don't restrict groups that have restriction disabled
    const bool do_restrict = get_group_restrict_flag(gi);
    if (!do_restrict)
      continue;
    groups.push_back(gi);

  Restrict(level, groups);