eschnett/cactusamrex - Change T3TZRPPAIA24I3YL3JFB4XEAYCWU3HJAJUCF7NNIFMP4I5X4SM5QC

CarpetX: Keep track of validity of outer boundary and ghost zones separately

Created by Erik Schnetter on December 18, 2019

T3TZRPPAIA24I3YL3JFB4XEAYCWU3HJAJUCF7NNIFMP4I5X4SM5QC

Dependencies

In channels

master

main

Change contents

Replacement in CarpetX/src/driver.cxx at line 170 [11.15972]

B:BD[10.1887] → [10.1887:1949]

        scalargroupdata.valid.at(tl).at(vi).valid_bnd = true;

[10.1887]

[10.1949]

        scalargroupdata.valid.at(tl).at(vi).valid_outer = true;
        scalargroupdata.valid.at(tl).at(vi).valid_ghosts = true;

Replacement in CarpetX/src/driver.cxx at line 623 [11.15972]

B:BD[12.763] → [12.763:834]

                       !coarsegroupdata.valid.at(tl).at(vi).valid_bnd;

[12.763]

[12.834]

                       !coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                       !coarsegroupdata.valid.at(tl).at(vi).valid_ghosts;

Replacement in CarpetX/src/driver.cxx at line 628 [11.15972]

B:BD[12.975] → [12.975:1034]

          groupdata.valid.at(tl).at(vi).valid_bnd = false;

[12.975]

[12.1034]

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

Replacement in CarpetX/src/driver.cxx at line 635 [11.15972]

B:BD[13.167] → [13.167:233]

                coarsegroupdata.valid.at(tl).at(vi).valid_bnd)) {

[13.167]

[13.233]

                coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                coarsegroupdata.valid.at(tl).at(vi).valid_ghosts)) {

Replacement in CarpetX/src/driver.cxx at line 639 [11.15972]

B:BD[13.304] → [13.304:344]

            all_valid.valid_bnd = true;

[13.304]

[9.58]

            all_valid.valid_outer = true;
            all_valid.valid_ghosts = true;

Replacement in CarpetX/src/driver.cxx at line 662 [11.15972]

B:BD[12.1644] → [12.1644:1764]

              coarsegroupdata.valid.at(tl).at(vi).valid_bnd;
          groupdata.valid.at(tl).at(vi).valid_bnd = false;

[12.1644]

[12.1764]

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

Replacement in CarpetX/src/driver.cxx at line 766 [11.15972]

B:BD[12.2101] → [12.2101:2176]

                         !coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&

[12.2101]

[12.2176]

                         !coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                         !coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&

Replacement in CarpetX/src/driver.cxx at line 769 [11.15972]

B:BD[12.2245] → [12.2245:2312]

                         !groupdata.valid.at(tl).at(vi).valid_bnd;

[12.2245]

[12.2312]

                         !groupdata.valid.at(tl).at(vi).valid_outer &&
                         !groupdata.valid.at(tl).at(vi).valid_ghosts;

Replacement in CarpetX/src/driver.cxx at line 776 [11.15972]

B:BD[12.2500] → [12.2500:2658]

            const bool cond = coarsegroupdata.valid.at(tl).at(vi).valid_int &&
                              coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&

[12.2500]

[12.2658]

            const bool cond =
                coarsegroupdata.valid.at(tl).at(vi).valid_int &&
                coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&

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

B:BD[12.2731] → [12.2731:2802]

                              groupdata.valid.at(tl).at(vi).valid_bnd;

[12.2731]

[12.2802]

                groupdata.valid.at(tl).at(vi).valid_outer &&
                groupdata.valid.at(tl).at(vi).valid_ghosts;

Replacement in CarpetX/src/driver.cxx at line 810 [11.15972]

B:BD[14.581] → [14.581:646]

                coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&

[14.581]

[14.646]

                coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&

Replacement in CarpetX/src/driver.cxx at line 813 [11.15972]

B:BD[14.705] → [14.705:762]

B:BD[14.762] → [15.63:107]

                groupdata.valid.at(tl).at(vi).valid_bnd;
            valid.at(vi).valid_bnd = false;

[14.705]

[14.806]

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

Replacement in CarpetX/src/driver.hxx at line 66 [11.15275]

B:BD[16.2210] → [16.2210:2291]

  bool valid_int, valid_bnd;
  valid_t() : valid_int(false), valid_bnd(false) {}

[16.2210]

[16.2291]

  bool valid_int, valid_outer, valid_ghosts;
  valid_t() : valid_int(false), valid_outer(false), valid_ghosts(false) {}

Replacement in CarpetX/src/driver.hxx at line 70 [11.15275]

B:BD[5.81] → [5.81:181]

    return make_tuple(x.valid_int, x.valid_bnd) ==
           make_tuple(y.valid_int, y.valid_bnd);

[5.81]

[5.181]

    return make_tuple(x.valid_int, x.valid_outer, x.valid_ghosts) ==
           make_tuple(y.valid_int, y.valid_outer, y.valid_ghosts);

Replacement in CarpetX/src/driver.hxx at line 74 [11.15275]

B:BD[16.2354] → [5.186:285]

    return make_tuple(x.valid_int, x.valid_bnd) <
           make_tuple(y.valid_int, y.valid_bnd);

[16.2354]

[16.2446]

    return make_tuple(x.valid_int, x.valid_outer, x.valid_ghosts) <
           make_tuple(y.valid_int, y.valid_outer, y.valid_ghosts);

Replacement in CarpetX/src/driver.hxx at line 79 [11.15275]

B:BD[16.2568] → [16.2568:2666]

    return os << "[int:" << str(v.valid_int) << ",bnd:" << str(v.valid_bnd)
              << "]";

[16.2568]

[16.2666]

    return os << "[int:" << str(v.valid_int) << ",outer:" << str(v.valid_outer)
              << ",ghosts:" << str(v.valid_ghosts) << "]";

Replacement in CarpetX/src/loop.hxx at line 312 [18.5481]

B:BD[17.9951] → [6.6166:6221]

enum class where_t { everywhere, interior, boundary };

[17.9951]

[6.6221]

enum class where_t { everywhere, interior, boundary, ghosts };

Insertion in CarpetX/src/loop.hxx at line 321 [18.5481]
[19.1688]
[19.1688]
```
  vect<int, dim> NI; // outward boundary normal, or zero
```

Insertion in CarpetX/src/loop.hxx at line 332 [18.5481]

[3.288]

[20.327]

       << "nijk:"
       << "{" << p.NI[0] << "," << p.NI[1] << "," << p.NI[2] << "}"

Replacement in CarpetX/src/loop.hxx at line 384 [18.5481]

B:BD[18.6740] → [18.6740:6802]

                const array<int, dim> &restrict imax) const {

[18.6740]

[17.10198]

                const array<int, dim> &restrict imax,
                const array<int, dim> &restrict inormal) const {

Replacement in CarpetX/src/loop.hxx at line 407 [18.5481]

B:BD[19.1797] → [19.1797:1860]

          const PointDesc p{i, j, k, x, y, z, idx, dj, dk, I};

[19.1797]

[17.10734]

          const PointDesc p{i, j, k, x, y, z, idx, dj, dk, I, inormal};

Insertion in CarpetX/src/loop.hxx at line 425 [18.5481]
[18.7582]
[18.7582]
```
    constexpr array<int, dim> inormal{0, 0, 0};
```
Replacement in CarpetX/src/loop.hxx at line 427 [18.5481]
B:BD[18.7583] → [17.10998:11039]
```
    loop_box<CI, CJ, CK>(f, imin, imax);
```
[18.7583]
[18.7612]
```
    loop_box<CI, CJ, CK>(f, imin, imax, inormal);
```
Insertion in CarpetX/src/loop.hxx at line 440 [18.5481]
[18.7885]
[18.7885]
```
    constexpr array<int, dim> inormal{0, 0, 0};
```
Replacement in CarpetX/src/loop.hxx at line 442 [18.5481]
B:BD[18.7886] → [17.11304:11345]
```
    loop_box<CI, CJ, CK>(f, imin, imax);
```
[18.7886]
[18.7915]
```
    loop_box<CI, CJ, CK>(f, imin, imax, inormal);
```

Replacement in CarpetX/src/loop.hxx at line 451 [18.5481]

∅:D[17.11484] → [18.8105:8228]

B:BD[18.8105] → [18.8105:8228]

    for (int dir = 0; dir < dim; ++dir) {
      for (int face = 0; face < 2; ++face) {
        if (bbox[2 * dir + face]) {

[17.11484]

[18.8228]

    for (int nk = -1; nk <= +1; ++nk) {
      for (int nj = -1; nj <= +1; ++nj) {
        for (int ni = -1; ni <= +1; ++ni) {
          if ((ni != 0 && bbox[0 + (ni == -1 ? 0 : 1)]) ||
              (nj != 0 && bbox[2 + (nj == -1 ? 0 : 1)]) ||
              (nk != 0 && bbox[4 + (nk == -1 ? 0 : 1)])) {
            const array<int, dim> inormal{ni, nj, nk};

Replacement in CarpetX/src/loop.hxx at line 460 [18.5481]

B:BD[18.8229] → [18.8229:8385]

B:BD[18.8385] → [6.6626:6789]

          array<int, dim> imin, imax;
          for (int d = 0; d < dim; ++d) {
            // by default, include interior and outer boundaries and ghosts
            int ghost_offset = nghostzones[d] - group_nghostzones[d];
            imin[d] = ghost_offset;
            imax[d] = lsh[d] + offset[d] - ghost_offset;

[18.8229]

[18.8440]

            array<int, dim> imin, imax;
            for (int d = 0; d < dim; ++d) {
              const int ghost_offset = nghostzones[d] - group_nghostzones[d];
              const int begin_bnd = ghost_offset;
              const int begin_int = nghostzones[d];
              const int end_int = lsh[d] + offset[d] - nghostzones[d];
              const int end_bnd = lsh[d] + offset[d] - ghost_offset;
              switch (inormal[d]) {
              case -1: // lower boundary
                imin[d] = begin_bnd;
                imax[d] = begin_int;
                break;
              case 0: // interior
                imin[d] = begin_int;
                imax[d] = end_int;
                break;
              case +1: // upper boundary
                imin[d] = end_int;
                imax[d] = end_bnd;
                break;
              default:
                assert(0);
              }

Replacement in CarpetX/src/loop.hxx at line 484 [18.5481]

B:BD[18.8441] → [18.8441:8656]

B:BD[18.8656] → [17.11528:11608]

            // avoid covering edges and corners multiple times
            if (d < dir) {
              if (bbox[2 * d])
                imin[d] = nghostzones[d]; // only interior
              if (bbox[2 * d + 1])
                imax[d] = lsh[d] + offset[d] - nghostzones[d]; // only interior

[18.8441]

[18.8724]

              imin[d] = max(tmin[d], imin[d]);
              imax[d] =
                  min(tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0), imax[d]);

Deletion in CarpetX/src/loop.hxx at line 488 [18.5481]

B:BD[18.8738] → [18.8738:8877]

B:BD[18.8877] → [17.11609:11676]

          }
          // only one face on outer boundary
          if (face == 0)
            imax[dir] = nghostzones[dir];
          else
            imin[dir] = lsh[dir] + offset[dir] - nghostzones[dir];

Replacement in CarpetX/src/loop.hxx at line 489 [18.5481]

B:BD[18.8931] → [18.8931:9018]

B:BD[18.9018] → [17.11677:11776]

          for (int d = 0; d < dim; ++d) {
            imin[d] = max(tmin[d], imin[d]);
            imax[d] =
                min(tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0), imax[d]);

[18.8931]

[18.9063]

            loop_box<CI, CJ, CK>(f, imin, imax, inormal);

Insertion in CarpetX/src/loop.hxx at line 491 [18.5481]

[18.9075]

        }
      }
    }
  }
  // Loop over all outer ghost points. This includes ghost edges/corners on
  // non-ghost faces.
  template <int CI, int CJ, int CK, typename F>
  void loop_ghosts(const array<int, dim> &group_nghostzones, const F &f) const {
    constexpr array<int, dim> offset{!CI, !CJ, !CK};

Replacement in CarpetX/src/loop.hxx at line 502 [18.5481]

B:BD[18.9076] → [17.11777:11824]

          loop_box<CI, CJ, CK>(f, imin, imax);

[18.9076]

[18.9111]

    for (int nk = -1; nk <= +1; ++nk) {
      for (int nj = -1; nj <= +1; ++nj) {
        for (int ni = -1; ni <= +1; ++ni) {
          if ((ni != 0 && !bbox[0 + (ni == -1 ? 0 : 1)]) ||
              (nj != 0 && !bbox[2 + (nj == -1 ? 0 : 1)]) ||
              (nk != 0 && !bbox[4 + (nk == -1 ? 0 : 1)])) {
            const array<int, dim> inormal{ni, nj, nk};
            array<int, dim> imin, imax;
            for (int d = 0; d < dim; ++d) {
              const int ghost_offset = nghostzones[d] - group_nghostzones[d];
              const int begin_bnd = ghost_offset;
              const int begin_int = nghostzones[d];
              const int end_int = lsh[d] + offset[d] - nghostzones[d];
              const int end_bnd = lsh[d] + offset[d] - ghost_offset;
              switch (inormal[d]) {
              case -1: // lower boundary
                imin[d] = begin_bnd;
                imax[d] = begin_int;
                break;
              case 0: // interior
                imin[d] = begin_int;
                imax[d] = end_int;
                break;
              case +1: // upper boundary
                imin[d] = end_int;
                imax[d] = end_bnd;
                break;
              default:
                assert(0);
              }
              imin[d] = max(tmin[d], imin[d]);
              imax[d] =
                  min(tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0), imax[d]);
            }
            loop_box<CI, CJ, CK>(f, imin, imax, inormal);
          }

Insertion in CarpetX/src/loop.hxx at line 557 [18.5481]

[6.7217]

[17.13011]

    case where_t::ghosts:
      return loop_ghosts<CI, CJ, CK>(group_nghostzones, f);

Insertion in CarpetX/src/loop.hxx at line 633 [18.5481]

[6.9132]

[17.15142]

}
template <int CI, int CJ, int CK, typename F>
void loop_ghosts(const cGH *cctkGH, const F &f) {
  loop<CI, CJ, CK>(cctkGH, where_t::ghosts, f);

Replacement in CarpetX/src/schedule.cxx at line 249 [21.531]

B:BD[12.4064] → [12.4064:4106]

  if (valid.valid_int && valid.valid_bnd)

[12.4064]

[12.4106]

  if (valid.valid_int && valid.valid_outer && valid.valid_ghosts)

Replacement in CarpetX/src/schedule.cxx at line 260 [21.531]

B:BD[17.16690] → [6.11295:11314]

∅:D[6.11314] → [12.4497:4525]

B:BD[17.16690] → [12.4497:4525]

B:BD[12.4525] → [6.11315:11426]

    where_t where;
    if (!valid.valid_int) {
      if (!valid.valid_bnd)
        where = where_t::everywhere;
      else
        where = where_t::interior;

[17.16690]

[12.4820]

    if (!valid.valid_int && !valid.valid_outer && !valid.valid_ghosts) {
      grid.loop_idx(where_t::everywhere, groupdata.indextype,
                    groupdata.nghostzones,
                    [&](const Loop::PointDesc &p) { ptr_(p.I) = 0.0 / 0.0; });

Replacement in CarpetX/src/schedule.cxx at line 265 [21.531]

B:BD[12.4833] → [6.11427:11501]

∅:D[6.11501] → [12.4999:5018]

B:BD[12.4999] → [12.4999:5018]

      if (!valid.valid_bnd)
        where = where_t::boundary;
      else
        assert(0);

[12.4833]

[12.5026]

      if (!valid.valid_int)
        grid.loop_idx(where_t::interior, groupdata.indextype,
                      groupdata.nghostzones,
                      [&](const Loop::PointDesc &p) { ptr_(p.I) = 0.0 / 0.0; });
      if (!valid.valid_outer)
        grid.loop_idx(where_t::boundary, groupdata.indextype,
                      groupdata.nghostzones,
                  [&](const Loop::PointDesc &p) { ptr_(p.I) = 0.0 / 0.0; });
      if (!valid.valid_ghosts)
        grid.loop_idx(where_t::ghosts, groupdata.indextype,
                      groupdata.nghostzones,
                      [&](const Loop::PointDesc &p) { ptr_(p.I) = 0.0 / 0.0; });

Deletion in CarpetX/src/schedule.cxx at line 278 [21.531]

B:BD[12.5032] → [6.11502:11648]

    grid.loop_idx(where, groupdata.indextype, groupdata.nghostzones,
                  [&](const Loop::PointDesc &p) { ptr_(p.I) = 0.0 / 0.0; });

Replacement in CarpetX/src/schedule.cxx at line 292 [21.531]

B:BD[22.994] → [22.994:1038]

  if (!valid.valid_int && !valid.valid_bnd)

[22.994]

[22.1038]

  if (!valid.valid_int && !valid.valid_outer && !valid.valid_ghosts)

Replacement in CarpetX/src/schedule.cxx at line 304 [21.531]

B:BD[12.5039] → [6.11768:11787]

∅:D[6.11787] → [22.1453:1480]

B:BD[12.5039] → [22.1453:1480]

B:BD[22.1480] → [6.11788:11898]

    where_t where;
    if (valid.valid_int) {
      if (valid.valid_bnd)
        where = where_t::everywhere;
      else
        where = where_t::interior;

[12.5039]

[22.1782]

    if (valid.valid_int && valid.valid_outer && valid.valid_ghosts) {
      grid.loop_idx(where_t::everywhere, groupdata.indextype,
                    groupdata.nghostzones, [&](const Loop::PointDesc &p) {
                      if (CCTK_BUILTIN_EXPECT(CCTK_isnan(ptr_(p.I)), false))
                        found_nan = true;
                    });

Replacement in CarpetX/src/schedule.cxx at line 311 [21.531]

B:BD[22.1795] → [6.11899:11972]

∅:D[6.11972] → [22.1964:1983]

B:BD[22.1964] → [22.1964:1983]

B:BD[22.1991] → [22.1991:1997]

B:BD[22.1997] → [6.11973:12162]

      if (valid.valid_bnd)
        where = where_t::boundary;
      else
        assert(0);
    }
    grid.loop_idx(where, groupdata.indextype, groupdata.nghostzones,
                  [&](const Loop::PointDesc &p) {
                    if (CCTK_BUILTIN_EXPECT(isnan(ptr_(p.I)), false))

[22.1795]

[6.12162]

      if (valid.valid_int)
        grid.loop_idx(where_t::interior, groupdata.indextype,
                      groupdata.nghostzones, [&](const Loop::PointDesc &p) {
                        if (CCTK_BUILTIN_EXPECT(CCTK_isnan(ptr_(p.I)), false))
                          found_nan = true;
                      });
      if (valid.valid_outer)
        grid.loop_idx(where_t::boundary, groupdata.indextype,
                      groupdata.nghostzones, [&](const Loop::PointDesc &p) {
                        if (CCTK_BUILTIN_EXPECT(CCTK_isnan(ptr_(p.I)), false))
                          found_nan = true;
                      });
      if (valid.valid_ghosts)
        grid.loop_idx(where_t::ghosts, groupdata.indextype,
                      groupdata.nghostzones, [&](const Loop::PointDesc &p) {
                        if (CCTK_BUILTIN_EXPECT(CCTK_isnan(ptr_(p.I)), false))

Insertion in CarpetX/src/schedule.cxx at line 330 [21.531]
[22.2001]
[23.329]
```
  }
```

Replacement in CarpetX/src/schedule.cxx at line 332 [21.531]

B:BD[23.330] → [23.330:563]

  if (CCTK_BUILTIN_EXPECT(found_nan, false)) {
    const char *where = valid.valid_int && valid.valid_bnd
                            ? "interior and boundary"
                            : valid.valid_int ? "interior" : "boundary";

[23.330]

[24.707]

  if (CCTK_BUILTIN_EXPECT(found_nan, false))

Replacement in CarpetX/src/schedule.cxx at line 337 [21.531]
B:BD[25.213] → [25.213:250]
∅:D[25.250] → [10.5602:5606]
B:BD[23.797] → [10.5602:5606]
```
        leveldata.level, tl, where);
  }
```
[25.213]
[10.5606]
```
        leveldata.level, tl, string(valid).c_str());
```

Replacement in CarpetX/src/schedule.cxx at line 348 [21.531]

B:BD[10.5887] → [10.5887:5929]

  if (valid.valid_int && valid.valid_bnd)

[10.5887]

[10.5929]

  if (valid.valid_int && valid.valid_outer && valid.valid_ghosts)

Replacement in CarpetX/src/schedule.cxx at line 352 [21.531]
∅:D[8.66] → [10.6005:6032]
B:BD[10.6005] → [10.6005:6032]
```
  assert(valid.valid_bnd);
```
[8.66]
[10.6032]
```
  assert(valid.valid_outer && valid.valid_ghosts);
```

Replacement in CarpetX/src/schedule.cxx at line 369 [21.531]

B:BD[10.6437] → [10.6437:6481]

  if (!valid.valid_int && !valid.valid_bnd)

[10.6437]

[10.6481]

  if (!valid.valid_int && !valid.valid_outer && !valid.valid_ghosts)

Replacement in CarpetX/src/schedule.cxx at line 373 [21.531]
∅:D[8.133] → [10.6557:6584]
B:BD[10.6557] → [10.6557:6584]
```
  assert(valid.valid_bnd);
```
[8.133]
[10.6584]
```
  assert(valid.valid_outer && valid.valid_ghosts);
```
Replacement in CarpetX/src/schedule.cxx at line 378 [21.531]
∅:D[7.312] → [10.6715:6766]
B:BD[10.6715] → [10.6715:6766]
```
    if (CCTK_BUILTIN_EXPECT(isnan(*ptr), false)) {
```
[7.312]
[10.6766]
```
    if (CCTK_BUILTIN_EXPECT(CCTK_isnan(*ptr), false)) {
```

Replacement in CarpetX/src/schedule.cxx at line 383 [21.531]

B:BD[10.6801] → [10.6801:7034]

  if (CCTK_BUILTIN_EXPECT(found_nan, false)) {
    const char *where = valid.valid_int && valid.valid_bnd
                            ? "interior and boundary"
                            : valid.valid_int ? "interior" : "boundary";

[10.6801]

[27.747]

  if (CCTK_BUILTIN_EXPECT(found_nan, false))

Replacement in CarpetX/src/schedule.cxx at line 387 [21.531]
B:BD[27.924] → [27.924:940]
∅:D[27.940] → [10.7215:7219]
B:BD[10.7215] → [10.7215:7219]
```
        where);
  }
```
[27.924]
[26.2]
```
        string(valid).c_str());
```

Replacement in CarpetX/src/schedule.cxx at line 792 [21.531]

B:BD[28.19] → [2.0:29]

∅:D[2.29] → [28.20:50]

B:BD[29.626] → [28.20:50]

B:BD[28.50] → [2.30:124]

∅:D[2.124] → [28.51:81]

B:BD[29.674] → [28.51:81]

    if (where & WH_INTERIOR)
      valid.valid_int = true;
    // We treat "ghost" and "boundary" as the same
    if (where & (WH_GHOSTS | WH_BOUNDARY))
      valid.valid_bnd = true;

[28.19]

[28.149]

    valid.valid_int = where & WH_INTERIOR;
    valid.valid_outer = where & WH_BOUNDARY;
    valid.valid_ghosts = where & WH_GHOSTS;

Replacement in CarpetX/src/schedule.cxx at line 1279 [21.531]

B:BD[30.637] → [30.637:699]

                            need.valid_bnd <= have.valid_bnd;

[30.637]

[30.699]

                            need.valid_outer <= have.valid_outer &&
                            need.valid_ghosts <= have.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1307 [21.531]

B:BD[16.9626] → [16.9626:9686]

                          need.valid_bnd <= have.valid_bnd;

[16.9626]

[16.9686]

                          need.valid_outer <= have.valid_outer &&
                          need.valid_ghosts <= have.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1354 [21.531]

B:BD[30.2960] → [30.2960:3027]

          have.valid_bnd &= need.valid_bnd || !provided.valid_bnd;

[30.2960]

[30.3027]

          have.valid_outer &= need.valid_outer || !provided.valid_outer;
          have.valid_ghosts &= need.valid_ghosts || !provided.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1366 [21.531]

B:BD[12.7668] → [12.7668:7733]

        have.valid_bnd &= need.valid_bnd || !provided.valid_bnd;

[12.7668]

[30.3341]

        have.valid_outer &= need.valid_outer || !provided.valid_outer;
        have.valid_ghosts &= need.valid_ghosts || !provided.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1436 [21.531]

B:BD[30.3801] → [30.3801:3849]

          have.valid_bnd |= provided.valid_bnd;

[30.3801]

[30.3849]

          have.valid_outer |= provided.valid_outer;
          have.valid_ghosts |= provided.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1454 [21.531]

B:BD[16.10978] → [16.10978:11024]

        have.valid_bnd |= provided.valid_bnd;

[16.10978]

[30.4410]

        have.valid_outer |= provided.valid_outer;
        have.valid_ghosts |= provided.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1480 [21.531]

B:BD[30.5156] → [30.5156:5205]

          have.valid_bnd &= !provided.valid_bnd;

[30.5156]

[30.5205]

          have.valid_outer &= !provided.valid_outer;
          have.valid_ghosts &= !provided.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1498 [21.531]

B:BD[31.937] → [31.937:984]

        have.valid_bnd &= !provided.valid_bnd;

[31.937]

[30.5771]

        have.valid_outer &= !provided.valid_outer;
        have.valid_ghosts &= !provided.valid_ghosts;

Replacement in CarpetX/src/schedule.cxx at line 1600 [21.531]

B:BD[12.7927] → [12.7927:7988]

            groupdata.valid.at(tl).at(vi).valid_bnd = false;

[12.7927]

[22.2140]

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

Replacement in CarpetX/src/schedule.cxx at line 1609 [21.531]

B:BD[16.11144] → [16.11144:11198]

            groupdata.valid.at(tl).at(vi).valid_bnd =

[16.11144]

[16.11198]

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

Replacement in CarpetX/src/schedule.cxx at line 1642 [21.531]

B:BD[4.220] → [4.220:297]

                           !coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&

[4.220]

[4.297]

                           !coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                           !coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&

Replacement in CarpetX/src/schedule.cxx at line 1650 [21.531]

B:BD[4.521] → [4.521:584]

              groupdata.valid.at(tl).at(vi).valid_bnd = false;

[4.521]

[4.584]

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

Replacement in CarpetX/src/schedule.cxx at line 1658 [21.531]

B:BD[32.386] → [32.386:456]

                     coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&

[32.386]

[32.456]

                     coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                     coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&

Replacement in CarpetX/src/schedule.cxx at line 1662 [21.531]

B:BD[32.578] → [32.578:641]

              groupdata.valid.at(tl).at(vi).valid_bnd = false;

[32.578]

[32.641]

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

Replacement in CarpetX/src/schedule.cxx at line 1679 [21.531]

B:BD[32.947] → [32.947:1003]

              groupdata.valid.at(tl).at(vi).valid_bnd =

[32.947]

[32.1003]

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

Replacement in CarpetX/src/schedule.cxx at line 1681 [21.531]

B:BD[32.1070] → [32.1070:1137]

                  coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&

[32.1070]

[32.1137]

                  coarsegroupdata.valid.at(tl).at(vi).valid_outer &&
                  coarsegroupdata.valid.at(tl).at(vi).valid_ghosts &&

Replacement in CarpetX/src/schedule.cxx at line 1829 [21.531]

B:BD[12.9112] → [6.13727:13782]

∅:D[6.13782] → [12.9228:9287]

B:BD[12.9228] → [12.9228:9287]

        for (int vi = 0; vi < groupdata.numvars; ++vi)
          groupdata.valid.at(tl).at(vi).valid_bnd = false;

[12.9112]

[12.9297]

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

Replacement in CarpetX/src/schedule.cxx at line 1879 [21.531]

∅:D[15.1001] → [12.10851:10910]

∅:D[22.3937] → [12.10851:10910]

B:BD[12.10851] → [12.10851:10910]

          groupdata.valid.at(tl).at(vi).valid_bnd = false;

[15.1001]

[33.1247]

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