eschnett/cactusamrex - Change VMCDMDXKME66ESRMB3PYSUZZH2XG2GIQMEOEKRH33WGCEBPXTWUQC

CarpetX: Only regrid the state vector. Sync and prolongate all requested variables.

Created by Erik Schnetter on December 23, 2019

VMCDMDXKME66ESRMB3PYSUZZH2XG2GIQMEOEKRH33WGCEBPXTWUQC

Dependencies

In channels

master

main

Change contents

Replacement in CarpetX/src/driver.cxx at line 54 [7.15972]

B:BD[6.20] → [6.20:99]

void SetupLevel(int level, const BoxArray &ba, const DistributionMapping &dm);

[6.20]

[6.99]

void SetupLevel(int level, const BoxArray &ba, const DistributionMapping &dm,
                const function<string()> &why);

Insertion in CarpetX/src/driver.cxx at line 59 [7.15972]

[8.82]

[9.0]


bool get_group_checkpoint_flag(const int gi) {
  int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  char buf[100];
  int iret = Util_TableGetString(tags, sizeof buf, buf, "checkpoint");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    return true;
  } else if (iret >= 0) {
    string str(buf);
    for (auto &c : str)
      c = tolower(c);
    if (str == "yes")
      return true;
    if (str == "no")
      return false;
    assert(0);
  } else {
    assert(0);
  }
}
bool get_group_restrict_flag(const int gi) {
  int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  char buf[100];
  int iret = Util_TableGetString(tags, sizeof buf, buf, "restrict");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    return true;
  } else if (iret >= 0) {
    string str(buf);
    for (auto &c : str)
      c = tolower(c);
    if (str == "yes")
      return true;
    if (str == "no")
      return false;
    assert(0);
  } else {
    assert(0);
  }
}

Insertion in CarpetX/src/driver.cxx at line 102 [7.15972]

[9.1]

array<int, dim> get_group_indextype(const int gi) {
  assert(gi >= 0);
  const int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  array<CCTK_INT, dim> index;
  int iret = Util_TableGetIntArray(tags, dim, index.data(), "index");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    index = {1, 1, 1}; // default: cell-centred
  } else if (iret >= 0) {
    assert(iret == dim);
  } else {
    assert(0);
  }
  array<int, dim> indextype;
  for (int d = 0; d < dim; ++d)
    indextype[d] = index[d];
  return indextype;
}
array<int, dim> get_group_fluxes(const int gi) {
  assert(gi >= 0);
  const int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  vector<char> fluxes_buf(1000);
  const int iret =
      Util_TableGetString(tags, fluxes_buf.size(), fluxes_buf.data(), "fluxes");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    fluxes_buf[0] = '\0'; // default: empty (no fluxes)
  } else if (iret >= 0) {
    // do nothing
  } else {
    assert(0);
  }
  const string str(fluxes_buf.data());
  vector<string> strs;
  size_t end = 0;
  while (end < str.size()) {
    size_t begin = str.find_first_not_of(' ', end);
    if (begin == string::npos)
      break;
    end = str.find(' ', begin);
    strs.push_back(str.substr(begin, end - begin));
  }
  array<int, dim> fluxes;
  fluxes.fill(-1);
  if (strs.empty())
    return fluxes; // No fluxes specified
  assert(strs.size() == dim); // Check number of fluxes
  for (int d = 0; d < dim; ++d) {
    auto str1 = strs[d];
    if (str1.find(':') == string::npos) {
      const char *impl = CCTK_GroupImplementationI(gi);
      str1 = string(impl) + "::" + str1;
    }
    int gi1 = CCTK_GroupIndex(str1.c_str());
    assert(gi1 >= 0); // Check fluxes are valid groups
    fluxes[d] = gi1;
  }
  for (int d = 0; d < dim; ++d)
    for (int d1 = d + 1; d1 < dim; ++d1)
      assert(fluxes[d] != fluxes[d1]); // Check groups are all different
  return fluxes;
}
array<int, dim> get_group_nghostzones(const int gi) {
  DECLARE_CCTK_PARAMETERS;
  assert(gi >= 0);
  const int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  array<CCTK_INT, dim> nghostzones;
  int iret =
      Util_TableGetIntArray(tags, dim, nghostzones.data(), "nghostzones");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    // default: use driver parameter
    nghostzones = {ghost_size, ghost_size, ghost_size};
  } else if (iret >= 0) {
    assert(iret == dim);
  } else {
    assert(0);
  }
  return nghostzones;
}
////////////////////////////////////////////////////////////////////////////////

Insertion in CarpetX/src/driver.cxx at line 293 [7.15972]

[6.1338]

    scalargroupdata.do_checkpoint = get_group_checkpoint_flag(gi);
    scalargroupdata.do_restrict = get_group_restrict_flag(gi);

Deletion in CarpetX/src/driver.cxx at line 318 [7.15972]

B:BD[6.2160] → [6.2160:2166]

B:BD[6.2167] → [6.2167:2168]

∅:D[6.2168] → [10.397:728]

B:BD[10.397] → [10.397:728]

B:BD[10.728] → [11.300:326]

∅:D[11.326] → [10.739:764]

B:BD[10.739] → [10.739:764]

B:BD[10.764] → [11.327:353]

  }
}
array<int, dim> get_group_indextype(const int gi) {
  assert(gi >= 0);
  const int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  array<CCTK_INT, dim> index;
  int iret = Util_TableGetIntArray(tags, dim, index.data(), "index");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    index = {1, 1, 1}; // default: cell-centred
  } else if (iret >= 0) {
    assert(iret == dim);
  } else {
    assert(0);

Deletion in CarpetX/src/driver.cxx at line 319 [7.15972]

B:BD[12.2152] → [10.765:875]

  array<int, dim> indextype;
  for (int d = 0; d < dim; ++d)
    indextype[d] = index[d];
  return indextype;

Replacement in CarpetX/src/driver.cxx at line 321 [7.15972]

B:BD[13.76] → [13.76:519]

∅:D[13.519] → [14.1301:1302]

∅:D[10.891] → [14.1301:1302]

B:BD[15.1273] → [14.1301:1302]

B:BD[14.1302] → [13.520:1474]

B:BD[13.1474] → [16.896:950]

array<int, dim> get_group_fluxes(const int gi) {
  assert(gi >= 0);
  const int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  vector<char> fluxes_buf(1000);
  const int iret =
      Util_TableGetString(tags, fluxes_buf.size(), fluxes_buf.data(), "fluxes");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    fluxes_buf[0] = '\0'; // default: empty (no fluxes)
  } else if (iret >= 0) {
    // do nothing
  } else {
    assert(0);
  }
  const string str(fluxes_buf.data());
  vector<string> strs;
  size_t end = 0;
  while (end < str.size()) {
    size_t begin = str.find_first_not_of(' ', end);
    if (begin == string::npos)
      break;
    end = str.find(' ', begin);
    strs.push_back(str.substr(begin, end - begin));
  }
  array<int, dim> fluxes;
  fluxes.fill(-1);
  if (strs.empty())
    return fluxes; // No fluxes specified
  assert(strs.size() == dim); // Check number of fluxes
  for (int d = 0; d < dim; ++d) {
    auto str1 = strs[d];
    if (str1.find(':') == string::npos) {
      const char *impl = CCTK_GroupImplementationI(gi);
      str1 = string(impl) + "::" + str1;
    }
    int gi1 = CCTK_GroupIndex(str1.c_str());
    assert(gi1 >= 0); // Check fluxes are valid groups
    fluxes[d] = gi1;
  }
  for (int d = 0; d < dim; ++d)
    for (int d1 = d + 1; d1 < dim; ++d1)
      assert(fluxes[d] != fluxes[d1]); // Check groups are all different
  return fluxes;
}
array<int, dim> get_group_nghostzones(const int gi) {

[13.76]

[16.950]

void SetupLevel(int level, const BoxArray &ba, const DistributionMapping &dm,
                const function<string()> &why) {

Deletion in CarpetX/src/driver.cxx at line 324 [7.15972]

B:BD[16.977] → [16.977:1431]

∅:D[16.1431] → [14.1302:1409]

∅:D[13.1474] → [14.1302:1409]

B:BD[14.1302] → [14.1302:1409]

  assert(gi >= 0);
  const int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  array<CCTK_INT, dim> nghostzones;
  int iret =
      Util_TableGetIntArray(tags, dim, nghostzones.data(), "nghostzones");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    // default: use driver parameter
    nghostzones = {ghost_size, ghost_size, ghost_size};
  } else if (iret >= 0) {
    assert(iret == dim);
  } else {
    assert(0);
  }
  return nghostzones;
}
void SetupLevel(int level, const BoxArray &ba, const DistributionMapping &dm) {
  DECLARE_CCTK_PARAMETERS;

Insertion in CarpetX/src/driver.cxx at line 357 [7.15972]

[14.2191]

[10.1100]

    groupdata.do_checkpoint = get_group_checkpoint_flag(gi);
    groupdata.do_restrict = get_group_restrict_flag(gi);

Replacement in CarpetX/src/driver.cxx at line 373 [7.15972]

B:BD[16.1612] → [5.68:202]

      groupdata.valid.at(tl).resize(groupdata.numvars,
                                    why_valid_t([] { return "SetupLevel"; }));

[16.1612]

[5.202]

      groupdata.valid.at(tl).resize(groupdata.numvars, why_valid_t(why));

Replacement in CarpetX/src/driver.cxx at line 618 [7.15972]
B:BD[14.2577] → [14.2577:2606]
```
  SetupLevel(level, ba, dm);
```
[14.2577]
[17.380]
```
  SetupLevel(level, ba, dm, [] { return "MakeNewLevelFromScratch"; });
```
Replacement in CarpetX/src/driver.cxx at line 637 [7.15972]
B:BD[14.2753] → [14.2753:2782]
```
  SetupLevel(level, ba, dm);
```
[14.2753]
[14.2782]
```
  SetupLevel(level, ba, dm, [] { return "MakeNewLevelFromCoarse"; });
```
Insertion in CarpetX/src/driver.cxx at line 655 [7.15972]
[18.697]
[14.3180]

Replacement in CarpetX/src/driver.cxx at line 669 [7.15972]

B:BD[14.3504] → [19.1638:1727]

∅:D[19.1727] → [14.3593:3683]

B:BD[14.3593] → [14.3593:3683]

    // If there is more than one time level, then we don't prolongate
    // the oldest.
    int ntls = groupdata.mfab.size();
    int prolongate_tl = ntls > 1 ? ntls - 1 : ntls;

[14.3504]

[20.604]

    const int ntls = groupdata.mfab.size();
    // We only prolongate the state vector. And if there is more than
    // one time level, then we don't prolongate the oldest.
    const int prolongate_tl =
        groupdata.do_checkpoint ? (ntls > 1 ? ntls - 1 : ntls) : 0;

Replacement in CarpetX/src/driver.cxx at line 679 [7.15972]

B:BD[20.748] → [20.748:861]

∅:D[20.861] → [21.673:679]

B:BD[21.673] → [21.673:679]

∅:D[21.679] → [17.755:804]

B:BD[17.755] → [17.755:804]

B:BD[17.804] → [11.550:690]

B:BD[11.690] → [20.862:941]

∅:D[21.753] → [11.834:859]

∅:D[20.941] → [11.834:859]

∅:D[22.279] → [11.834:859]

B:BD[11.834] → [11.834:859]

B:BD[11.859] → [20.942:1145]

∅:D[20.1145] → [11.1044:1059]

B:BD[11.1044] → [11.1044:1059]

        groupdata.valid.at(tl).at(vi).set(
            valid_t(false), [] { return "MakeNewLevelFromCoarse"; });
    }
    for (int tl = 0; tl < prolongate_tl; ++tl) {
      // Only interpolate if coarse grid data are valid
      bool all_invalid = true;
      for (int vi = 0; vi < groupdata.numvars; ++vi)
        all_invalid &= !coarsegroupdata.valid.at(tl).at(vi).get().valid_any();
      if (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";
          });
      } else {

[20.748]

[20.1146]

        groupdata.valid.at(tl).at(vi).set(valid_t(false), [] {
          return "MakeNewLevelFromCoarse: not prolongated because variable is "
                 "not evolved";
        });
      if (tl < prolongate_tl) {

Replacement in CarpetX/src/driver.cxx at line 699 [7.15972]
∅:D[23.563] → [11.1472:1529]
∅:D[24.111] → [11.1472:1529]
B:BD[11.1472] → [11.1472:1529]
```
        for (int vi = 0; vi < groupdata.numvars; ++vi) {
```
[23.563]
[20.1442]
```
        for (int vi = 0; vi < groupdata.numvars; ++vi)
```
Deletion in CarpetX/src/driver.cxx at line 703 [7.15972]
∅:D[21.1343] → [11.1764:1774]
∅:D[20.1587] → [11.1764:1774]
∅:D[22.879] → [11.1764:1774]
B:BD[11.1764] → [11.1764:1774]
```
        }
```
Insertion in CarpetX/src/driver.cxx at line 704 [7.15972]
[11.1782]
[25.134]
Replacement in CarpetX/src/driver.cxx at line 710 [7.15972]
∅:D[11.1837] → [17.1100:1106]
∅:D[25.249] → [17.1100:1106]
B:BD[17.1100] → [17.1100:1106]
∅:D[27.108] → [14.4081:4085]
∅:D[28.105] → [14.4081:4085]
∅:D[17.1106] → [14.4081:4085]
B:BD[14.4081] → [14.4081:4085]
```
    }
  }
```
[25.249]
[17.1107]
```
    } // for tl
  } // for gi
```

Insertion in CarpetX/src/driver.cxx at line 731 [7.15972]

[14.4281]

[29.40]

  assert(leveldata.level > 0);
  auto &coarseleveldata = ghext->leveldata.at(level - 1);

Deletion in CarpetX/src/driver.cxx at line 749 [7.15972]

∅:D[30.614] → [31.0:284]

B:BD[14.4427] → [31.0:284]

∅:D[31.284] → [14.4427:4607]

B:BD[14.4427] → [14.4427:4607]

B:BD[14.5195] → [14.5195:5196]

B:BD[14.5196] → [10.1999:2060]

∅:D[10.2060] → [14.5305:5306]

B:BD[14.5305] → [14.5305:5306]

B:BD[14.5306] → [10.2061:2191]


    const BoxArray &gba = convert(
        ba,
        IndexType(groupdata.indextype[0] ? IndexType::CELL : IndexType::NODE,
                  groupdata.indextype[1] ? IndexType::CELL : IndexType::NODE,
                  groupdata.indextype[2] ? IndexType::CELL : IndexType::NODE));
    // If there is more than one time level, then we don't
    // prolongate the oldest.
    int ntls = groupdata.mfab.size();
    int prolongate_tl = ntls > 1 ? ntls - 1 : ntls;
    // This must not happen
    assert(leveldata.level > 0);
    // Copy from same level and/or prolongate from next coarser level
    auto &coarseleveldata = ghext->leveldata.at(level - 1);

Insertion in CarpetX/src/driver.cxx at line 765 [7.15972]

[10.2942]


    const BoxArray &gba = convert(
        ba,
        IndexType(groupdata.indextype[0] ? IndexType::CELL : IndexType::NODE,
                  groupdata.indextype[1] ? IndexType::CELL : IndexType::NODE,
                  groupdata.indextype[2] ? IndexType::CELL : IndexType::NODE));
    const int ntls = groupdata.mfab.size();
    // We only prolongate the state vector. And if there is more than
    // one time level, then we don't prolongate the oldest.
    const int prolongate_tl =
        groupdata.do_checkpoint ? (ntls > 1 ? ntls - 1 : ntls) : 0;

Replacement in CarpetX/src/driver.cxx at line 781 [7.15972]

B:BD[16.1754] → [5.256:383]

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

[16.1754]

[32.129]

      vector<why_valid_t> valid(groupdata.numvars, why_valid_t([] {
                                  return "RemakeLevel: not prolongated/copied "
                                         "because variable is not evolved";
                                }));

Insertion in CarpetX/src/driver.cxx at line 801 [7.15972]
[14.6442]
[17.1433]

Replacement in CarpetX/src/driver.cxx at line 803 [7.15972]

B:BD[17.1465] → [11.1880:2026]

B:BD[11.2026] → [20.1834:1995]

∅:D[21.1571] → [11.2313:2340]

∅:D[20.1995] → [11.2313:2340]

B:BD[11.2313] → [11.2313:2340]

B:BD[11.2340] → [33.0:24]

∅:D[33.24] → [11.2424:2500]

B:BD[11.2424] → [11.2424:2500]

B:BD[11.2500] → [20.1996:2351]

∅:D[21.2373] → [34.285:351]

∅:D[20.2351] → [34.285:351]

B:BD[11.3354] → [34.285:351]

B:BD[34.351] → [20.2352:2427]

∅:D[34.429] → [25.317:473]

∅:D[20.2427] → [25.317:473]

B:BD[25.317] → [25.317:473]

B:BD[25.473] → [29.80:139]

∅:D[29.139] → [25.520:578]

B:BD[25.520] → [25.520:578]

∅:D[25.578] → [11.3354:3366]

B:BD[11.3354] → [11.3354:3366]

        // Only interpolate if coarse grid data are valid
        bool all_invalid = true;
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          all_invalid &=
              !coarsegroupdata.valid.at(tl).at(vi).get().valid_any() &&
              !groupdata.valid.at(tl).at(vi).get().valid_any();
        if (all_invalid) {
          // do nothing
        } else {
          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            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"; });
            check_valid(coarseleveldata, coarsegroupdata, vi, tl,
                        [] { return "RemakeLevel before prolongation"; });
            // We cannot call this function since it would try to
            // traverse the old grid function with the new grid
            // structure.
            // TODO: Use explicit loop instead (see above)
            // check_valid(leveldata, groupdata, vi, tl);
          }

[17.1465]

[11.3366]

        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          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"; });
          check_valid(coarseleveldata, coarsegroupdata, vi, tl,
                      [] { return "RemakeLevel before prolongation"; });
          // We cannot call this function since it would try to
          // traverse the old grid function with the new grid
          // structure.
          // TODO: Use explicit loop instead (see above)
          // check_valid(leveldata, groupdata, vi, tl);
        }

Replacement in CarpetX/src/driver.cxx at line 818 [7.15972]

B:BD[11.3367] → [24.112:343]

∅:D[24.343] → [11.3368:3447]

B:BD[10.3903] → [11.3368:3447]

B:BD[11.3447] → [23.622:686]

          FillPatchTwoLevels(*mfab, 0.0, {&*coarsegroupdata.mfab.at(tl)}, {0.0},
                             {&*groupdata.mfab.at(tl)}, {0.0}, 0, 0,
                             groupdata.numvars, ghext->amrcore->Geom(level - 1),
                             ghext->amrcore->Geom(level), cphysbc, 0, fphysbc,
                             0, reffact, interpolator, bcs, 0);

[11.3367]

[11.3520]

        // Copy from same level and/or prolongate from next coarser level
        FillPatchTwoLevels(*mfab, 0.0, {&*coarsegroupdata.mfab.at(tl)}, {0.0},
                           {&*groupdata.mfab.at(tl)}, {0.0}, 0, 0,
                           groupdata.numvars, ghext->amrcore->Geom(level - 1),
                           ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0,
                           reffact, interpolator, bcs, 0);

Replacement in CarpetX/src/driver.cxx at line 825 [7.15972]

B:BD[11.3521] → [20.2428:2618]

∅:D[20.2618] → [17.1838:1848]

∅:D[24.818] → [17.1838:1848]

B:BD[17.1838] → [17.1838:1848]

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

[11.3521]

[17.1848]

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

Insertion in CarpetX/src/driver.cxx at line 830 [7.15972]
[17.1856]
[10.4051]
Deletion in CarpetX/src/driver.cxx at line 833 [7.15972]
∅:D[21.2626] → [13.2531:2532]
B:BD[17.1901] → [13.2531:2532]
Replacement in CarpetX/src/driver.cxx at line 843 [7.15972]
∅:D[10.4093] → [14.6442:6452]
∅:D[11.3638] → [14.6442:6452]
∅:D[25.694] → [14.6442:6452]
∅:D[17.1901] → [14.6442:6452]
B:BD[14.6442] → [14.6442:6452]
```
    }
  }
```
[25.694]
[17.1902]
```
    } // for tl
  } // for gi
```

Replacement in CarpetX/src/driver.cxx at line 898 [7.15972]

B:BD[4.251] → [4.251:342]

  buf << "AMR driver provided by CarpetX, using AMReX " << amrex::Version()
      << " (";

[4.251]

[4.342]

  buf << "AMR driver provided by CarpetX,\n"
      << "using AMReX " << amrex::Version() << " (";

Replacement in CarpetX/src/driver.cxx at line 1040 [7.15972]

B:BD[35.1707] → [36.4307:4442]

B:BD[36.4442] → [37.2900:2952]

∅:D[38.1273] → [35.1757:1778]

∅:D[37.2952] → [35.1757:1778]

B:BD[35.1757] → [35.1757:1778]

  // Should we really do this? Cactus's extension handling mechanism
  // becomes inconsistent once extensions have been unregistered.
  int iret = CCTK_UnregisterGHExtension("CarpetX");
  assert(iret == 0);

[35.1707]

[35.1778]

  if (false) {
    // Should we really do this? Cactus's extension handling mechanism
    // becomes inconsistent once extensions have been unregistered.
    int iret = CCTK_UnregisterGHExtension("CarpetX");
    assert(iret == 0);
  }

Insertion in CarpetX/src/driver.hxx at line 234 [7.15275]

[6.2641]

[20.4940]

    bool do_checkpoint; // whether to checkpoint
    bool do_restrict;   // whether to restrict

Deletion in CarpetX/src/schedule.cxx at line 1259 [40.531]

B:BD[39.4940] → [11.5040:5043]

B:BD[11.5043] → [41.0:12]

∅:D[41.12] → [11.5043:5521]

B:BD[11.5043] → [11.5043:5521]

}
namespace {
bool get_group_checkpoint_flag(const int gi) {
  int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  char buf[100];
  int iret = Util_TableGetString(tags, sizeof buf, buf, "checkpoint");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    return true;
  } else if (iret >= 0) {
    string str(buf);
    for (auto &c : str)
      c = tolower(c);
    if (str == "yes")
      return true;
    if (str == "no")
      return false;
    assert(0);
  } else {
    assert(0);
  }

Deletion in CarpetX/src/schedule.cxx at line 1260 [40.531]
B:BD[11.5523] → [41.13:28]
```
} // namespace
```

Replacement in CarpetX/src/schedule.cxx at line 1264 [40.531]

B:BD[11.5608] → [33.230:261]

∅:D[33.261] → [11.5608:5662]

B:BD[11.5608] → [11.5608:5662]

B:BD[11.5662] → [6.9113:9290]

  assert(current_level == -1);
  for (auto &restrict leveldata : ghext->leveldata) {
    const int num_groups = CCTK_NumGroups();
    for (int gi = 0; gi < num_groups; ++gi) {
      cGroup group;
      int ierr = CCTK_GroupData(gi, &group);
      assert(!ierr);

[11.5608]

[6.9290]

  const int num_groups = CCTK_NumGroups();
  for (int gi = 0; gi < num_groups; ++gi) {
    cGroup group;
    int ierr = CCTK_GroupData(gi, &group);
    assert(!ierr);

Replacement in CarpetX/src/schedule.cxx at line 1270 [40.531]

B:BD[6.9291] → [6.9291:9347]

      if (group.grouptype != CCTK_GF)
        continue;

[6.9291]

[6.9347]

    if (group.grouptype == CCTK_GF) {

Replacement in CarpetX/src/schedule.cxx at line 1272 [40.531]

B:BD[6.9348] → [30.1909:1971]

∅:D[6.9409] → [11.5721:5911]

∅:D[30.1971] → [11.5721:5911]

B:BD[11.5721] → [11.5721:5911]

B:BD[11.5911] → [42.40:143]

B:BD[42.143] → [20.8419:8610]

∅:D[20.8610] → [42.198:256]

B:BD[42.198] → [42.198:256]

      auto &restrict groupdata = *leveldata.groupdata.at(gi);
      const bool checkpoint = get_group_checkpoint_flag(groupdata.groupindex);
      if (!checkpoint) {
        // Invalidate all time levels
        const int ntls = groupdata.mfab.size();
        for (int tl = 0; tl < ntls; ++tl) {
          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            groupdata.valid.at(tl).at(vi).set(valid_t(), [] {
              return "InvalidateTimelevels (invalidate all "
                     "non-checkpointed variables)";
            });
            poison_invalid(leveldata, groupdata, vi, tl);

[6.9348]

[11.6127]

      assert(current_level == -1);
      for (auto &restrict leveldata : ghext->leveldata) {
        auto &restrict groupdata = *leveldata.groupdata.at(gi);
        if (!groupdata.do_checkpoint) {
          // Invalidate all time levels
          const int ntls = groupdata.mfab.size();
          for (int tl = 0; tl < ntls; ++tl) {
            for (int vi = 0; vi < groupdata.numvars; ++vi) {
              groupdata.valid.at(tl).at(vi).set(valid_t(), [] {
                return "InvalidateTimelevels (invalidate all "
                       "non-checkpointed variables)";
              });
              poison_invalid(leveldata, groupdata, vi, tl);
            }

Deletion in CarpetX/src/schedule.cxx at line 1290 [40.531]

B:BD[11.6163] → [11.6163:6167]

B:BD[11.6167] → [6.9410:9667]

  }
  // invalidate scalars
  {
    auto &restrict globaldata = ghext->globaldata;
    const int num_groups = CCTK_NumGroups();
    for (int gi = 0; gi < num_groups; ++gi) {
      cGroup group;
      int ierr = CCTK_GroupData(gi, &group);
      assert(!ierr);

Replacement in CarpetX/src/schedule.cxx at line 1291 [40.531]

B:BD[6.9668] → [6.9668:9728]

      if (group.grouptype != CCTK_SCALAR)
        continue;

[6.9668]

[6.9728]

    // Invalidate scalars
    if (group.grouptype == CCTK_SCALAR) {

Insertion in CarpetX/src/schedule.cxx at line 1294 [40.531]
[6.9729]
[30.1972]
```
      auto &restrict globaldata = ghext->globaldata;
```
Replacement in CarpetX/src/schedule.cxx at line 1296 [40.531]
∅:D[30.2047] → [43.1488:1583]
B:BD[6.9803] → [43.1488:1583]
∅:D[43.1583] → [6.9888:9913]
B:BD[6.9888] → [6.9888:9913]
```
      const bool checkpoint =
          get_group_checkpoint_flag(scalargroupdata.groupindex);
      if (!checkpoint) {
```
[30.2047]
[6.9913]
```
      if (!scalargroupdata.do_checkpoint) {
```
Replacement in CarpetX/src/schedule.cxx at line 1311 [40.531]
B:BD[6.10264] → [6.10264:10268]
```
  }
```
[6.10264]
[39.4940]
```
  } // for gi
```

Replacement in CarpetX/src/schedule.cxx at line 1321 [40.531]

B:BD[44.2105] → [33.262:293]

∅:D[33.293] → [45.2656:2710]

B:BD[46.2170] → [45.2656:2710]

B:BD[45.2710] → [6.10269:10446]

  assert(current_level == -1);
  for (auto &restrict leveldata : ghext->leveldata) {
    const int num_groups = CCTK_NumGroups();
    for (int gi = 0; gi < num_groups; ++gi) {
      cGroup group;
      int ierr = CCTK_GroupData(gi, &group);
      assert(!ierr);

[44.2105]

[6.10446]

  const int num_groups = CCTK_NumGroups();
  for (int gi = 0; gi < num_groups; ++gi) {
    cGroup group;
    int ierr = CCTK_GroupData(gi, &group);
    assert(!ierr);

Replacement in CarpetX/src/schedule.cxx at line 1327 [40.531]
B:BD[6.10447] → [6.10447:10503]
```
      if (group.grouptype != CCTK_GF)
        continue;
```
[6.10447]
[6.10503]
```
    if (group.grouptype == CCTK_GF) {
```

Replacement in CarpetX/src/schedule.cxx at line 1329 [40.531]

B:BD[6.10504] → [30.2048:2110]

∅:D[6.10565] → [47.1770:1816]

∅:D[30.2110] → [47.1770:1816]

∅:D[45.2769] → [47.1770:1816]

B:BD[48.3212] → [47.1770:1816]

B:BD[47.1816] → [11.6168:6230]

∅:D[11.6230] → [47.1816:1838]

B:BD[47.1816] → [47.1816:1838]

B:BD[47.1838] → [5.623:832]

∅:D[5.832] → [11.6343:6398]

∅:D[20.8920] → [11.6343:6398]

B:BD[11.6343] → [11.6343:6398]

B:BD[11.6398] → [5.833:892]

∅:D[5.892] → [20.8990:9074]

B:BD[20.8990] → [20.8990:9074]

∅:D[20.9074] → [11.6450:6560]

B:BD[11.6450] → [11.6450:6560]

      auto &restrict groupdata = *leveldata.groupdata.at(gi);
      const int ntls = groupdata.mfab.size();
      // Rotate time levels and invalidate current time level
      if (ntls > 1) {
        rotate(groupdata.mfab.begin(), groupdata.mfab.end() - 1,
               groupdata.mfab.end());
        rotate(groupdata.valid.begin(), groupdata.valid.end() - 1,
               groupdata.valid.end());
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          groupdata.valid.at(0).at(vi).set(valid_t(), [] {
            return "CycletimeLevels (invalidate current time level)";
          });
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          poison_invalid(leveldata, groupdata, vi, 0);

[6.10504]

[47.2063]

      assert(current_level == -1);
      for (auto &restrict leveldata : ghext->leveldata) {
        auto &restrict groupdata = *leveldata.groupdata.at(gi);
        const int ntls = groupdata.mfab.size();
        // Rotate time levels and invalidate current time level
        if (ntls > 1) {
          rotate(groupdata.mfab.begin(), groupdata.mfab.end() - 1,
                 groupdata.mfab.end());
          rotate(groupdata.valid.begin(), groupdata.valid.end() - 1,
                 groupdata.valid.end());
          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            groupdata.valid.at(0).at(vi).set(valid_t(), [] {
              return "CycletimeLevels (invalidate current time level)";
            });
            poison_invalid(leveldata, groupdata, vi, 0);
          }
        }
        for (int tl = 0; tl < ntls; ++tl)
          for (int vi = 0; vi < groupdata.numvars; ++vi)
            check_valid(leveldata, groupdata, vi, tl,
                        [&]() { return "CycleTimelevels"; });

Deletion in CarpetX/src/schedule.cxx at line 1351 [40.531]

B:BD[47.2071] → [16.12880:13087]

      for (int tl = 0; tl < ntls; ++tl)
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          check_valid(leveldata, groupdata, vi, tl,
                      [&]() { return "CycleTimelevels"; });

Deletion in CarpetX/src/schedule.cxx at line 1352 [40.531]

B:BD[48.3468] → [47.2072:2076]

B:BD[47.2076] → [6.10566:10818]

  }
  // cycle scalars
  {
    auto &restrict globaldata = ghext->globaldata;
    const int num_groups = CCTK_NumGroups();
    for (int gi = 0; gi < num_groups; ++gi) {
      cGroup group;
      int ierr = CCTK_GroupData(gi, &group);
      assert(!ierr);

Replacement in CarpetX/src/schedule.cxx at line 1353 [40.531]

B:BD[6.10819] → [6.10819:10879]

      if (group.grouptype != CCTK_SCALAR)
        continue;

[6.10819]

[6.10879]

    // cycle scalars
    if (group.grouptype == CCTK_SCALAR) {

Insertion in CarpetX/src/schedule.cxx at line 1356 [40.531]
[6.10880]
[30.2111]
```
      auto &restrict globaldata = ghext->globaldata;
```
Replacement in CarpetX/src/schedule.cxx at line 1365 [40.531]
∅:D[5.1138] → [6.11561:11622]
∅:D[20.9198] → [6.11561:11622]
B:BD[6.11561] → [6.11561:11622]
```
        for (int vi = 0; vi < scalargroupdata.numvars; ++vi)
```
[5.1138]
[20.9199]
```
        for (int vi = 0; vi < scalargroupdata.numvars; ++vi) {
```
Deletion in CarpetX/src/schedule.cxx at line 1369 [40.531]
∅:D[20.9348] → [6.11680:11741]
B:BD[6.11680] → [6.11680:11741]
```
        for (int vi = 0; vi < scalargroupdata.numvars; ++vi)
```
Insertion in CarpetX/src/schedule.cxx at line 1370 [40.531]
[6.11791]
[6.11791]
```
        }
```

Insertion in CarpetX/src/schedule.cxx at line 1372 [40.531]

[6.11799]

      for (int tl = 0; tl < ntls; ++tl)
        for (int vi = 0; vi < scalargroupdata.numvars; ++vi)
          check_valid(scalargroupdata, vi, tl,
                      [&]() { return "CycleTimelevels"; });

Replacement in CarpetX/src/schedule.cxx at line 1377 [40.531]
B:BD[6.11805] → [6.11805:11809]
```
  }
```
[6.11805]
[20.9349]
```
  } // for gi
```
Deletion in CarpetX/src/schedule.cxx at line 1824 [40.531]
B:BD[49.901] → [49.901:961]
```
    // Don't restrict groups that have restriction disabled
```
Replacement in CarpetX/src/schedule.cxx at line 1828 [40.531]
B:BD[49.1022] → [49.1022:1051]
```
    if (current_level == -1)
```
[49.1022]
[2.0]
```
    if (current_level == -1) {
```

Replacement in CarpetX/src/schedule.cxx at line 1831 [40.531]

B:BD[49.1157] → [3.0:73]

    else {
      if (current_level < int(ghext->leveldata.size()) - 1) {

[49.1157]

[3.73]

    } else {
      if (current_level < int(ghext->leveldata.size()) - 1)

Deletion in CarpetX/src/schedule.cxx at line 1834 [40.531]
B:BD[3.114] → [3.114:122]
```
      }
```
Insertion in CarpetX/src/schedule.cxx at line 1862 [40.531]
[50.92]
[5.1139]
```
            // Synchronization only uses the interior
```
Insertion in CarpetX/src/schedule.cxx at line 1905 [40.531]
[51.1461]
[17.11266]

Replacement in CarpetX/src/schedule.cxx at line 1908 [40.531]

B:BD[52.1] → [52.1:143]

B:BD[52.143] → [20.13980:14145]

          // Only prolongate valid grid functions
          bool all_invalid = true;
          for (int vi = 0; vi < groupdata.numvars; ++vi)
            all_invalid &=
                !coarsegroupdata.valid.at(tl).at(vi).get().valid_any() &&
                !groupdata.valid.at(tl).at(vi).get().valid_int;

[52.1]

[52.366]

          // // Only prolongate valid grid functions
          // bool all_invalid = true;
          // for (int vi = 0; vi < groupdata.numvars; ++vi)
          //   all_invalid &=
          //       !coarsegroupdata.valid.at(tl).at(vi).get().valid_any() &&
          //       !groupdata.valid.at(tl).at(vi).get().valid_int;
          // if (all_invalid) {

Replacement in CarpetX/src/schedule.cxx at line 1917 [40.531]

B:BD[52.367] → [52.367:396]

          if (all_invalid) {

[52.367]

[52.396]

          //   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";
          //     });

Replacement in CarpetX/src/schedule.cxx at line 1924 [40.531]

B:BD[52.397] → [20.14146:14482]

            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";
              });

[52.397]

[52.598]

          // } else {

Replacement in CarpetX/src/schedule.cxx at line 1926 [40.531]

B:BD[52.599] → [52.599:618]

          } else {

[52.599]

[52.618]

          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            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";
                });
            poison_invalid(leveldata, groupdata, vi, tl);
            check_valid(coarseleveldata, coarsegroupdata, vi, tl, [] {
              return "SyncGroupsByDirI on coarse level before prolongation";
            });
            check_valid(leveldata, groupdata, vi, tl, [] {
              return "SyncGroupsByDirI on fine level before prolongation";
            });
            groupdata.valid.at(tl).at(vi).set_ghosts(false, [] {
              return "SyncGroupsByDirI before prolongation: Mark ghosts as "
                     "invalid";
            });
          }
          FillPatchTwoLevels(
              *groupdata.mfab.at(tl), 0.0, {&*coarsegroupdata.mfab.at(tl)},
              {0.0}, {&*groupdata.mfab.at(tl)}, {0.0}, 0, 0, groupdata.numvars,
              ghext->amrcore->Geom(level - 1), ghext->amrcore->Geom(level),
              cphysbc, 0, fphysbc, 0, reffact, interpolator, bcs, 0);
          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            groupdata.valid.at(tl).at(vi).set_ghosts(
                true, [] { return "SyncGroupsByDirI after prolongation"; });
          }
        } // if not all_invalid
      }   // for tl

Replacement in CarpetX/src/schedule.cxx at line 1960 [40.531]

B:BD[53.47] → [53.47:108]

B:BD[53.108] → [20.14483:14681]

∅:D[20.14681] → [42.702:762]

B:BD[42.702] → [42.702:762]

B:BD[42.762] → [20.14682:15262]

∅:D[20.15262] → [34.1794:1891]

B:BD[34.1794] → [34.1794:1891]

B:BD[34.1891] → [20.15263:15324]

∅:D[20.15324] → [34.1955:2050]

B:BD[34.1955] → [34.1955:2050]

B:BD[34.2050] → [42.763:887]

∅:D[42.887] → [34.2051:2299]

B:BD[54.11486] → [34.2051:2299]

B:BD[34.2299] → [42.888:947]

B:BD[42.947] → [20.15325:15494]

∅:D[20.15494] → [52.650:672]

B:BD[52.650] → [52.650:672]

∅:D[52.672] → [51.1792:1800]

∅:D[54.11731] → [51.1792:1800]

∅:D[27.25402] → [51.1792:1800]

∅:D[28.292] → [51.1792:1800]

∅:D[17.11622] → [51.1792:1800]

B:BD[51.1792] → [51.1792:1800]

            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";
              });
              poison_invalid(leveldata, groupdata, 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, [] {
                return "SyncGroupsByDirI on coarse level before prolongation";
              });
              check_valid(leveldata, groupdata, vi, tl, [] {
                return "SyncGroupsByDirI on fine level before prolongation";
              });
            }
            FillPatchTwoLevels(
                *groupdata.mfab.at(tl), 0.0, {&*coarsegroupdata.mfab.at(tl)},
                {0.0}, {&*groupdata.mfab.at(tl)}, {0.0}, 0, 0,
                groupdata.numvars, ghext->amrcore->Geom(level - 1),
                ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0, reffact,
                interpolator, bcs, 0);
            for (int vi = 0; vi < groupdata.numvars; ++vi)
              groupdata.valid.at(tl).at(vi).set_ghosts(
                  true, [] { return "SyncGroupsByDirI after prolongation"; });
          } // if not all_invalid
        }   // for tl
      }

[52.619]

[11.8592]

      // }

Replacement in CarpetX/src/schedule.cxx at line 2003 [40.531]

B:BD[13.3931] → [20.15495:15787]

        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"; });

[13.3931]

[13.4169]

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

Insertion in CarpetX/src/schedule.cxx at line 2042 [40.531]

[13.5777]


      for (int vi = 0; vi < finegroupdata.numvars; ++vi) {
        check_valid(fineleveldata, finegroupdata, vi, tl, [&]() {
          return "Reflux after refluxing: Fine level data";
        });
      }

Replacement in CarpetX/src/schedule.cxx at line 2049 [40.531]
B:BD[13.5783] → [41.29:33]
```
  }
```
[13.5783]
[41.33]
```
  } // for gi
```

Deletion in CarpetX/src/schedule.cxx at line 2052 [40.531]

B:BD[41.36] → [41.36:518]

∅:D[41.518] → [13.5783:5787]

B:BD[13.5783] → [13.5783:5787]

∅:D[13.5787] → [40.5952:5954]

∅:D[55.667] → [40.5952:5954]

B:BD[40.5952] → [40.5952:5954]

B:BD[40.5954] → [41.519:534]

∅:D[41.534] → [40.5954:5955]

B:BD[40.5954] → [40.5954:5955]

namespace {
bool get_group_restrict_flag(const int gi) {
  int tags = CCTK_GroupTagsTableI(gi);
  assert(tags >= 0);
  char buf[100];
  int iret = Util_TableGetString(tags, sizeof buf, buf, "restrict");
  if (iret == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
    return true;
  } else if (iret >= 0) {
    string str(buf);
    for (auto &c : str)
      c = tolower(c);
    if (str == "yes")
      return true;
    if (str == "no")
      return false;
    assert(0);
  } else {
    assert(0);
  }
}
} // namespace

Insertion in CarpetX/src/schedule.cxx at line 2075 [40.531]

[6.14295]

[14.8625]

    auto &groupdata = *leveldata.groupdata.at(gi);
    const auto &finegroupdata = *fineleveldata.groupdata.at(gi);
    const IntVect reffact{2, 2, 2};

Replacement in CarpetX/src/schedule.cxx at line 2083 [40.531]

B:BD[41.595] → [41.595:675]

    const bool do_restrict = get_group_restrict_flag(gi);
    if (!do_restrict)

[41.595]

[41.675]

    if (!groupdata.do_restrict)

Replacement in CarpetX/src/schedule.cxx at line 2086 [40.531]

B:BD[41.692] → [30.3270:3386]

B:BD[30.3386] → [56.7583:7670]

    auto &groupdata = *leveldata.groupdata.at(gi);
    const auto &finegroupdata = *fineleveldata.groupdata.at(gi);
    // If there is more than one time level, then we don't restrict the
    // oldest.

[41.692]

[29.199]

    // If there is more than one time level, then we don't restrict the oldest.

Deletion in CarpetX/src/schedule.cxx at line 2090 [40.531]
B:BD[57.920] → [57.920:956]
```
    const IntVect reffact{2, 2, 2};
```

Replacement in CarpetX/src/schedule.cxx at line 2092 [40.531]

B:BD[58.161] → [56.7671:7761]

∅:D[33.819] → [11.8792:8876]

∅:D[56.7761] → [11.8792:8876]

∅:D[16.13726] → [11.8792:8876]

∅:D[13.5959] → [11.8792:8876]

B:BD[11.8792] → [11.8792:8876]

B:BD[11.8876] → [20.16313:16461]

∅:D[20.16461] → [17.12646:12647]

∅:D[11.9085] → [17.12646:12647]

B:BD[17.12646] → [17.12646:12647]

B:BD[17.12647] → [11.9086:9112]

B:BD[11.9112] → [22.11254:11311]

B:BD[22.11311] → [20.16462:16681]

∅:D[20.16681] → [22.11434:11444]

B:BD[22.11434] → [22.11434:11444]

      // Only restrict valid grid functions. Restriction only uses the
      // interior.
      bool all_invalid = true;
      for (int vi = 0; vi < groupdata.numvars; ++vi)
        all_invalid &= !finegroupdata.valid.at(tl).at(vi).get().valid_int &&
                       !groupdata.valid.at(tl).at(vi).get().valid_int;
      if (all_invalid) {
        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          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)";
          });
        }

[58.161]

[11.9297]

      for (int vi = 0; vi < groupdata.numvars; ++vi) {

Replacement in CarpetX/src/schedule.cxx at line 2094 [40.531]

B:BD[11.9298] → [11.9298:9314]

B:BD[11.9314] → [25.3064:3121]

      } else {
        for (int vi = 0; vi < groupdata.numvars; ++vi) {

[11.9298]

[20.16682]

        // Restriction only uses the interior
        error_if_invalid(
            fineleveldata, finegroupdata, vi, tl, make_valid_int(),
            [] { return "Restrict on fine level before restricting"; });
        poison_invalid(fineleveldata, finegroupdata, vi, tl);
        check_valid(fineleveldata, finegroupdata, vi, tl,
                    [] { return "Restrict on fine level before restricting"; });
        error_if_invalid(leveldata, groupdata, vi, tl, make_valid_int(), [] {
          return "Restrict on coarse level before restricting";
        });
        poison_invalid(leveldata, groupdata, vi, tl);
        check_valid(leveldata, groupdata, vi, tl, [] {
          return "Restrict on coarse level before restricting";
        });
      }

Deletion in CarpetX/src/schedule.cxx at line 2110 [40.531]

B:BD[20.16683] → [20.16683:16856]

∅:D[20.16856] → [33.820:884]

B:BD[11.9558] → [33.820:884]

B:BD[33.884] → [20.16857:16922]

∅:D[20.16922] → [34.2501:2565]

B:BD[34.2501] → [34.2501:2565]

B:BD[34.2565] → [20.16923:17083]

∅:D[20.17083] → [34.2565:2579]

B:BD[34.2565] → [34.2565:2579]

∅:D[34.2579] → [33.885:941]

B:BD[25.3311] → [33.885:941]

B:BD[33.941] → [20.17084:17141]

∅:D[20.17141] → [34.2640:2720]

B:BD[34.2640] → [34.2640:2720]

∅:D[34.2720] → [25.3364:3374]

B:BD[25.3364] → [25.3364:3374]

∅:D[25.3374] → [11.9558:9559]

B:BD[11.9558] → [11.9558:9559]

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

Replacement in CarpetX/src/schedule.cxx at line 2112 [40.531]

B:BD[16.13947] → [16.13947:14145]

∅:D[16.14145] → [25.3375:3495]

B:BD[11.9620] → [25.3375:3495]

B:BD[25.3495] → [16.14146:14179]

∅:D[16.14179] → [25.3496:3616]

B:BD[11.9943] → [25.3496:3616]

B:BD[25.3616] → [16.14180:14213]

∅:D[16.14213] → [25.3617:3737]

B:BD[11.10266] → [25.3617:3737]

B:BD[25.3737] → [16.14214:14247]

∅:D[16.14247] → [25.3738:3816]

B:BD[11.10453] → [25.3738:3816]

∅:D[25.3816] → [11.10532:10584]

B:BD[11.10532] → [11.10532:10584]

B:BD[11.10584] → [16.14248:14282]

∅:D[16.14282] → [11.10597:10618]

B:BD[11.10597] → [11.10597:10618]

B:BD[11.10618] → [16.14283:14293]

∅:D[16.14293] → [17.12936:12937]

∅:D[11.10618] → [17.12936:12937]

B:BD[17.12936] → [17.12936:12937]

B:BD[17.12937] → [20.17142:17331]

        // rank: 0: vertex, 1: edge, 2: face, 3: volume
        int rank = 0;
        for (int d = 0; d < dim; ++d)
          rank += groupdata.indextype[d];
        switch (rank) {
        case 0:
          average_down_nodal(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                             reffact);
          break;
        case 1:
          average_down_edges(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                             reffact);
          break;
        case 2:
          average_down_faces(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                             reffact);
          break;
        case 3:
          average_down(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl), 0,
                       groupdata.numvars, reffact);
          break;
        default:
          assert(0);
        }
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          groupdata.valid.at(tl).at(vi).set(make_valid_int(),
                                            [] { return "Restrict"; });

[16.13947]

[58.1257]

      // rank: 0: vertex, 1: edge, 2: face, 3: volume
      int rank = 0;
      for (int d = 0; d < dim; ++d)
        rank += groupdata.indextype[d];
      switch (rank) {
      case 0:
        average_down_nodal(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                           reffact);
        break;
      case 1:
        average_down_edges(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                           reffact);
        break;
      case 2:
        average_down_faces(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                           reffact);
        break;
      case 3:
        average_down(*finegroupdata.mfab.at(tl), *groupdata.mfab.at(tl), 0,
                     groupdata.numvars, reffact);
        break;
      default:
        assert(0);

Insertion in CarpetX/src/schedule.cxx at line 2137 [40.531]
[11.10912]
[25.3938]
```
      // TODO: Also remember old why_valid for interior?
```

Insertion in CarpetX/src/schedule.cxx at line 2139 [40.531]

[25.3993]

[11.10965]

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

Replacement in CarpetX/src/schedule.cxx at line 2146 [40.531]
∅:D[11.11019] → [31.1809:1815]
∅:D[25.4053] → [31.1809:1815]
B:BD[31.1809] → [31.1809:1815]
B:BD[31.1815] → [49.1447:1451]
```
    }
  }
```
[25.4053]
[49.1451]
```
    } // for tl
  }   // for gi
```

Deletion in CarpetX/src/schedule.cxx at line 2163 [40.531]

B:BD[49.1894] → [49.1894:2194]

    // 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;

CarpetX: Only regrid the state vector. Sync and prolongate all requested variables.

Dependencies

In channels

Change contents

Replacement in CarpetX/src/driver.cxx at line 54 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 59 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 102 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 293 [7.15972]

Deletion in CarpetX/src/driver.cxx at line 318 [7.15972]

Deletion in CarpetX/src/driver.cxx at line 319 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 321 [7.15972]

Deletion in CarpetX/src/driver.cxx at line 324 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 357 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 373 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 618 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 637 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 655 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 669 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 679 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 699 [7.15972]

Deletion in CarpetX/src/driver.cxx at line 703 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 704 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 710 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 731 [7.15972]

Deletion in CarpetX/src/driver.cxx at line 749 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 765 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 781 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 801 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 803 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 818 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 825 [7.15972]

Insertion in CarpetX/src/driver.cxx at line 830 [7.15972]

Deletion in CarpetX/src/driver.cxx at line 833 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 843 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 898 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 1040 [7.15972]

Insertion in CarpetX/src/driver.hxx at line 234 [7.15275]

Deletion in CarpetX/src/schedule.cxx at line 1259 [40.531]

Deletion in CarpetX/src/schedule.cxx at line 1260 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1264 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1270 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1272 [40.531]

Deletion in CarpetX/src/schedule.cxx at line 1290 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1291 [40.531]

Insertion in CarpetX/src/schedule.cxx at line 1294 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1296 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1311 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1321 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1327 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1329 [40.531]

Deletion in CarpetX/src/schedule.cxx at line 1351 [40.531]

Deletion in CarpetX/src/schedule.cxx at line 1352 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1353 [40.531]

Insertion in CarpetX/src/schedule.cxx at line 1356 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1365 [40.531]

Deletion in CarpetX/src/schedule.cxx at line 1369 [40.531]

Insertion in CarpetX/src/schedule.cxx at line 1370 [40.531]

Insertion in CarpetX/src/schedule.cxx at line 1372 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1377 [40.531]

Deletion in CarpetX/src/schedule.cxx at line 1824 [40.531]

Replacement in CarpetX/src/schedule.cxx at line 1828 [40.531]