eschnett/cactusamrex - Change KCIWCVZOHG44WBOLKI2XK33WPHPRI5FWCETF4AOGTPZISKCW3CLQC

More work on poisoning

Created by Erik Schnetter on August 27, 2019

KCIWCVZOHG44WBOLKI2XK33WPHPRI5FWCETF4AOGTPZISKCW3CLQC

Dependencies

In channels

master

main

Change contents

Insertion in AMReX/param.ccl at line 123 [6.17918]

[4.119]

[5.483]

CCTK_REAL grid_efficiency "Minimum AMR grid efficiency"
{
  0.0:* :: ""
} 0.7

Insertion in AMReX/param.ccl at line 129 [6.17918]
[4.121]
[4.121]

Insertion in AMReX/src/driver.cxx at line 99 [6.15972]

[7.377]

[8.1846]

    });
    grid.loop_bnd(groupdata.indextype, [&](const Loop::PointDesc &p) {
      tags_array4(grid.cactus_offset.x + p.i, grid.cactus_offset.y + p.j,
                  grid.cactus_offset.z + p.k) = TagBox::CLEAR;

Deletion in AMReX/src/driver.cxx at line 107 [6.15972]
B:BD[7.385] → [7.385:397]
```
namespace {
```
Replacement in AMReX/src/driver.cxx at line 115 [6.15972]
B:BD[7.728] → [7.728:739]
```
  } else {
```
[7.728]
[7.739]
```
  } else if (iret >= 0) {
```
Insertion in AMReX/src/driver.cxx at line 117 [6.15972]
[7.764]
[9.2148]
```
  } else {
    assert(0);
```
Deletion in AMReX/src/driver.cxx at line 125 [6.15972]
B:BD[4.1273] → [7.876:891]
```
} // namespace
```
Insertion in AMReX/src/driver.cxx at line 152 [6.15972]
[10.2097]
[10.2097]
```
    groupdata.groupindex = gi;
```

Replacement in AMReX/src/driver.cxx at line 169 [6.15972]

∅:D[11.379] → [12.91:128]

B:BD[7.1509] → [12.91:128]

∅:D[12.128] → [13.184:353]

B:BD[13.184] → [13.184:353]

∅:D[13.353] → [8.2128:2149]

B:BD[8.2128] → [8.2128:2149]

B:BD[8.2149] → [13.354:820]

∅:D[13.820] → [8.2531:2549]

∅:D[7.1789] → [8.2531:2549]

B:BD[8.2531] → [8.2531:2549]

      if (poison_undefined_values) {
        // Set grid functions to nan
        auto mfitinfo = MFItInfo().SetDynamic(true).EnableTiling(
            {max_tile_size_x, max_tile_size_y, max_tile_size_z});
#pragma omp parallel
        for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {
          GridPtrDesc grid(leveldata, mfi);
          const Array4<CCTK_REAL> &vars = groupdata.mfab.at(tl)->array(mfi);
          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            CCTK_REAL *restrict const ptr = grid.ptr(vars, vi);
            grid.loop_all(groupdata.indextype, [&](const Loop::PointDesc &p) {
              ptr[p.idx] = 0.0 / 0.0;
            });
          }
        }
      }

[11.379]

[8.2549]

      for (int vi = 0; vi < groupdata.numvars; ++vi)
        poison_invalid(leveldata, groupdata, vi, tl);

Replacement in AMReX/src/driver.cxx at line 188 [6.15972]

B:BD[11.513] → [11.513:621]

    // CCTK_Traverse(cctkGH, "CCTK_POSTREGRIDINITIAL");
    CCTK_Traverse(saved_cctkGH, "CCTK_POSTREGRID");

[11.513]

[11.621]

    // CCTK_Traverse(saved_cctkGH, "CCTK_POSTREGRID");

Replacement in AMReX/src/driver.cxx at line 230 [6.15972]

B:BD[11.804] → [11.804:868]

∅:D[11.868] → [10.3730:3851]

B:BD[10.3730] → [10.3730:3851]

#warning "TODO: only interpolate if coarse grid data are valid"
      InterpFromCoarseLevel(*groupdata.mfab.at(tl), 0.0,
                            *coarsegroupdata.mfab.at(tl), 0, 0,

[11.804]

[10.3851]

      // 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).valid_int &&
                       !coarsegroupdata.valid.at(tl).at(vi).valid_bnd;
      if (all_invalid) {
        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          groupdata.valid.at(tl).at(vi).valid_int = false;
          groupdata.valid.at(tl).at(vi).valid_bnd = false;
        }
      } else {
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          assert(coarsegroupdata.valid.at(tl).at(vi).valid_int &&
                 coarsegroupdata.valid.at(tl).at(vi).valid_bnd);
        InterpFromCoarseLevel(
            *groupdata.mfab.at(tl), 0.0, *coarsegroupdata.mfab.at(tl), 0, 0,

Replacement in AMReX/src/driver.cxx at line 247 [6.15972]

B:BD[10.3931] → [10.3931:4081]

                            ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0,
                            reffact, &cell_bilinear_interp, bcs, 0);

[10.3931]

[11.869]

            ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0, reffact,
            &cell_bilinear_interp, bcs, 0);
        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          groupdata.valid.at(tl).at(vi).valid_int =
              coarsegroupdata.valid.at(tl).at(vi).valid_int &&
              coarsegroupdata.valid.at(tl).at(vi).valid_bnd;
          groupdata.valid.at(tl).at(vi).valid_bnd = false;
        }
      }

Replacement in AMReX/src/driver.cxx at line 257 [6.15972]

B:BD[11.922] → [11.922:1100]

        if (coarsegroupdata.valid.at(tl).at(vi).valid_int &&
            coarsegroupdata.valid.at(tl).at(vi).valid_bnd)
          groupdata.valid.at(tl).at(vi).valid_int = true;

[11.922]

[11.1100]

        poison_invalid(leveldata, groupdata, vi, tl);

Deletion in AMReX/src/driver.cxx at line 265 [6.15972]
B:BD[11.1240] → [11.1240:1296]
```
    // CCTK_Traverse(cctkGH, "CCTK_POSTREGRIDINITIAL");
```
Replacement in AMReX/src/driver.cxx at line 321 [6.15972]
∅:D[12.166] → [13.858:895]
B:BD[13.858] → [13.858:895]
```
        // Set grid functions to nan
```
[12.166]
[13.895]
```
        // Set new grid functions to nan
```

Insertion in AMReX/src/driver.cxx at line 337 [6.15972]

[11.1465]

[7.3678]

        // 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).valid_int &&
                         !coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&
                         !groupdata.valid.at(tl).at(vi).valid_int &&
                         !groupdata.valid.at(tl).at(vi).valid_bnd;
        if (all_invalid) {
          valid.at(tl).valid_int = false;
          valid.at(tl).valid_bnd = false;
        } else {
          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            const bool cond = coarsegroupdata.valid.at(tl).at(vi).valid_int &&
                              coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&
                              groupdata.valid.at(tl).at(vi).valid_int &&
                              groupdata.valid.at(tl).at(vi).valid_bnd;
            if (!cond)
              CCTK_VERROR("Found invalid input data: RemakeLevel level %d, "
                          "variable %s%s: need everything defined, have coarse "
                          "%s, have current %s",
                          leveldata.level,
                          CCTK_FullVarName(groupdata.firstvarindex + vi),
                          string("_p", tl).c_str(),
                          string(coarsegroupdata.valid.at(tl).at(vi)).c_str(),
                          string(groupdata.valid.at(tl).at(vi)).c_str());
          }

Replacement in AMReX/src/driver.cxx at line 368 [6.15972]

B:BD[7.3903] → [7.3903:4051]

                           ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0,
                           reffact, &cell_bilinear_interp, bcs, 0);

[7.3903]

[11.1466]

                             ghext->amrcore->Geom(level), cphysbc, 0, fphysbc,
                             0, reffact, &cell_bilinear_interp, bcs, 0);

Insertion in AMReX/src/driver.cxx at line 380 [6.15972]
[11.1856]
[7.4051]
```
      }
```

Insertion in AMReX/src/driver.cxx at line 383 [6.15972]

[11.1901]

[10.6442]

      for (int vi = 0; vi < groupdata.numvars; ++vi)
        poison_invalid(leveldata, groupdata, vi, tl);

Deletion in AMReX/src/driver.cxx at line 392 [6.15972]
B:BD[11.2035] → [11.2035:2091]
```
    // CCTK_Traverse(cctkGH, "CCTK_POSTREGRIDINITIAL");
```
Insertion in AMReX/src/driver.cxx at line 504 [6.15972]
[14.2870]
[14.2870]
```
  pp.add("amr.grid_eff", grid_efficiency);
```
Insertion in AMReX/src/driver.hxx at line 97 [6.15275]
[15.155]
[15.155]
```
      int groupindex;
```
Insertion in AMReX/src/schedule.cxx at line 12 [17.531]
[16.1302]
[17.680]
```
#include <util_Table.h>
```
Insertion in AMReX/src/schedule.cxx at line 28 [17.531]
[11.3493]
[8.10577]
```
#include <map>
```
Deletion in AMReX/src/schedule.cxx at line 34 [17.531]
B:BD[17.808] → [2.0:25]
```
#include <unordered_map>
```

Insertion in AMReX/src/schedule.cxx at line 202 [17.531]

[8.14085]

[7.16689]


// Set grid functions to nan
void poison_invalid(const GHExt::LevelData &leveldata,
                    const GHExt::LevelData::GroupData &groupdata, int vi,
                    int tl) {
  DECLARE_CCTK_PARAMETERS;
  if (!poison_undefined_values)
    return;
  const valid_t &valid = groupdata.valid.at(tl).at(vi);
  if (valid.valid_int && valid.valid_bnd)
    return;
  auto mfitinfo = MFItInfo().SetDynamic(true).EnableTiling(
      {max_tile_size_x, max_tile_size_y, max_tile_size_z});
#pragma omp parallel
  for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {
    GridPtrDesc grid(leveldata, mfi);
    const Array4<CCTK_REAL> &vars = groupdata.mfab.at(tl)->array(mfi);
    CCTK_REAL *restrict const ptr = grid.ptr(vars, vi);

Insertion in AMReX/src/schedule.cxx at line 223 [17.531]

[7.16690]

    if (!valid.valid_int) {
      if (!valid.valid_bnd) {
        grid.loop_all(groupdata.indextype, [&](const Loop::PointDesc &p) {
          ptr[p.idx] = 0.0 / 0.0;
        });
      } else {
        grid.loop_int(groupdata.indextype, [&](const Loop::PointDesc &p) {
          ptr[p.idx] = 0.0 / 0.0;
        });
      }
    } else {
      if (!valid.valid_bnd) {
        grid.loop_bnd(groupdata.indextype, [&](const Loop::PointDesc &p) {
          ptr[p.idx] = 0.0 / 0.0;
        });
      } else {
        assert(0);
      }
    }
  }
}

Insertion in AMReX/src/schedule.cxx at line 796 [17.531]

[16.4940]

}
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);
  }
}
void InvalidateTimelevels(cGH *restrict const cctkGH) {
  DECLARE_CCTK_PARAMETERS;
  for (auto &restrict leveldata : ghext->leveldata) {
    for (auto &restrict groupdata : leveldata.groupdata) {
      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) = valid_t();
            poison_invalid(leveldata, groupdata, vi, tl);
          }
        }
      }
    }
  }

Insertion in AMReX/src/schedule.cxx at line 848 [17.531]
[18.1816]
[18.1816]
```
      // Rotate time levels and invalidate current time level
```

Insertion in AMReX/src/schedule.cxx at line 854 [17.531]

[18.2063]

[11.8134]

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

Replacement in AMReX/src/schedule.cxx at line 857 [17.531]

B:BD[11.8249] → [11.8249:8317]

∅:D[11.8317] → [13.1478:1479]

B:BD[18.2063] → [13.1478:1479]

B:BD[13.1479] → [12.167:206]

∅:D[12.206] → [13.1518:1721]

B:BD[13.1518] → [13.1518:1721]

∅:D[13.1721] → [19.169:190]

B:BD[19.169] → [19.169:190]

B:BD[19.190] → [13.1722:2206]

∅:D[13.2206] → [19.672:694]

B:BD[19.672] → [19.672:694]

        groupdata.valid.at(0) = vector<valid_t>(groupdata.numvars);
        if (poison_undefined_values) {
          // Set grid functions to nan
          const int tl = 0;
          auto mfitinfo = MFItInfo().SetDynamic(true).EnableTiling(
              {max_tile_size_x, max_tile_size_y, max_tile_size_z});
#pragma omp parallel
          for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {
            GridPtrDesc grid(leveldata, mfi);
            const Array4<CCTK_REAL> &vars = groupdata.mfab.at(tl)->array(mfi);
            for (int vi = 0; vi < groupdata.numvars; ++vi) {
              CCTK_REAL *restrict const ptr = grid.ptr(vars, vi);
              grid.loop_all(groupdata.indextype, [&](const Loop::PointDesc &p) {
                ptr[p.idx] = 0.0 / 0.0;
              });
            }
          }
        }

[11.8249]

[18.2063]

        groupdata.valid.at(0) = move(vtmp);
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          groupdata.valid.at(0).at(vi) = valid_t();
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          poison_invalid(leveldata, groupdata, vi, 0);

Insertion in AMReX/src/schedule.cxx at line 881 [17.531]
[16.5482]
[10.7804]
```
    InvalidateTimelevels(cctkGH);
```

Replacement in AMReX/src/schedule.cxx at line 997 [17.531]

B:BD[11.10166] → [11.10166:10242]

#warning "TODO: poison those output variables that are not input variables"

[11.10166]

[11.10242]

  // Poison those output variables that are not input variables
  if (poison_undefined_values) {
    map<clause_t, valid_t> isread;
    const vector<clause_t> &reads = decode_clauses(
        attribute, attribute->n_ReadsClauses, attribute->ReadsClauses);
    for (const auto &rd : reads) {
      clause_t cl = rd;
      cl.valid = valid_t();
      assert(isread.count(cl) == 0);
      isread[cl] = rd.valid;
    }
    const vector<clause_t> &writes = decode_clauses(
        attribute, attribute->n_WritesClauses, attribute->WritesClauses);
    for (const auto &wr : writes) {
      clause_t cl = wr;
      cl.valid = valid_t();
      valid_t need;
      if (isread.count(cl) > 0)
        need = isread[cl];
      const valid_t &provided = wr.valid;
      for (int level = min_level; level < max_level; ++level) {
        auto &restrict leveldata = ghext->leveldata.at(level);
        auto &restrict groupdata = leveldata.groupdata.at(wr.gi);
        valid_t &have = groupdata.valid.at(wr.tl).at(wr.vi);
        have.valid_int &= need.valid_int || !provided.valid_int;
        have.valid_bnd &= need.valid_bnd || !provided.valid_bnd;
      }
    }
  }

Insertion in AMReX/src/schedule.cxx at line 1127 [17.531]

[11.11086]

[20.621]

          for (int vi = 0; vi < groupdata.numvars; ++vi)
            assert(groupdata.valid.at(tl).at(vi).valid_int);
          for (int vi = 0; vi < groupdata.numvars; ++vi)
            groupdata.valid.at(tl).at(vi).valid_bnd = false;
          for (int vi = 0; vi < groupdata.numvars; ++vi)
            poison_invalid(leveldata, groupdata, vi, tl);

Insertion in AMReX/src/schedule.cxx at line 1160 [17.531]

[11.11313]

[14.11380]

          for (int vi = 0; vi < groupdata.numvars; ++vi)
            assert(coarsegroupdata.valid.at(tl).at(vi).valid_int &&
                   coarsegroupdata.valid.at(tl).at(vi).valid_bnd &&
                   groupdata.valid.at(tl).at(vi).valid_int);
          for (int vi = 0; vi < groupdata.numvars; ++vi)
            groupdata.valid.at(tl).at(vi).valid_bnd = false;
          for (int vi = 0; vi < groupdata.numvars; ++vi)
            poison_invalid(leveldata, groupdata, vi, tl);

Insertion in AMReX/src/schedule.cxx at line 1180 [17.531]

[20.1800]

[15.4311]


      for (int tl = 0; tl < sync_tl; ++tl)
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          poison_invalid(leveldata, groupdata, vi, tl);

Replacement in AMReX/src/schedule.cxx at line 1217 [17.531]

B:BD[21.161] → [11.11623:12646]

      if (groupdata.indextype == array<int, dim>{0, 0, 0})
        average_down_nodal(*fine_groupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                           reffact);
      else if (groupdata.indextype == array<int, dim>{1, 0, 0} ||
               groupdata.indextype == array<int, dim>{0, 1, 0} ||
               groupdata.indextype == array<int, dim>{0, 0, 1})
        average_down_edges(*fine_groupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                           reffact);
      else if (groupdata.indextype == array<int, dim>{1, 1, 0} ||
               groupdata.indextype == array<int, dim>{1, 0, 1} ||
               groupdata.indextype == array<int, dim>{0, 1, 1})
        average_down_faces(*fine_groupdata.mfab.at(tl), *groupdata.mfab.at(tl),
                           reffact);
      else if (groupdata.indextype == array<int, dim>{1, 1, 1})
        average_down(*fine_groupdata.mfab.at(tl), *groupdata.mfab.at(tl), 0,
                     groupdata.numvars, reffact);
      else
        assert(0);

[21.161]

[11.12646]

      // Only restrict valid grid functions
      bool all_invalid = true;
      for (int vi = 0; vi < groupdata.numvars; ++vi)
        all_invalid &= !fine_groupdata.valid.at(tl).at(vi).valid_int &&
                       !fine_groupdata.valid.at(tl).at(vi).valid_bnd &&
                       !groupdata.valid.at(tl).at(vi).valid_int;

Replacement in AMReX/src/schedule.cxx at line 1224 [17.531]

B:BD[11.12647] → [11.12647:12936]

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

[11.12647]

[11.12936]

      if (all_invalid) {
        for (int vi = 0; vi < groupdata.numvars; ++vi) {
          groupdata.valid.at(tl).at(vi).valid_int = false;
          groupdata.valid.at(tl).at(vi).valid_bnd = false;
        }
      } else {
        for (int vi = 0; vi < groupdata.numvars; ++vi)
          assert(fine_groupdata.valid.at(tl).at(vi).valid_int &&
                 fine_groupdata.valid.at(tl).at(vi).valid_bnd &&
                 groupdata.valid.at(tl).at(vi).valid_int);
        if (groupdata.indextype == array<int, dim>{0, 0, 0})
          average_down_nodal(*fine_groupdata.mfab.at(tl),
                             *groupdata.mfab.at(tl), reffact);
        else if (groupdata.indextype == array<int, dim>{1, 0, 0} ||
                 groupdata.indextype == array<int, dim>{0, 1, 0} ||
                 groupdata.indextype == array<int, dim>{0, 0, 1})
          average_down_edges(*fine_groupdata.mfab.at(tl),
                             *groupdata.mfab.at(tl), reffact);
        else if (groupdata.indextype == array<int, dim>{1, 1, 0} ||
                 groupdata.indextype == array<int, dim>{1, 0, 1} ||
                 groupdata.indextype == array<int, dim>{0, 1, 1})
          average_down_faces(*fine_groupdata.mfab.at(tl),
                             *groupdata.mfab.at(tl), reffact);
        else if (groupdata.indextype == array<int, dim>{1, 1, 1})
          average_down(*fine_groupdata.mfab.at(tl), *groupdata.mfab.at(tl), 0,
                       groupdata.numvars, reffact);
        else
          assert(0);

Replacement in AMReX/src/schedule.cxx at line 1257 [17.531]

∅:D[11.12937] → [21.161:724]

B:BD[21.161] → [21.161:724]

B:BD[21.787] → [21.787:969]

B:BD[22.1603] → [22.1603:1715]

B:BD[22.1715] → [11.12938:12976]

∅:D[11.12976] → [22.1755:1771]

B:BD[22.1755] → [22.1755:1771]

∅:D[22.1771] → [21.1235:1247]

B:BD[21.1235] → [21.1235:1247]

      if (poison_undefined_values) {
        MultiFab &mfab = *groupdata.mfab.at(tl);
        const MultiFab &fine_mfab = *fine_groupdata.mfab.at(tl);
        const IntVect reffact{2, 2, 2};
        const iMultiFab finemask =
            makeFineMask(mfab, fine_mfab.boxArray(), reffact);
        auto mfitinfo = MFItInfo().SetDynamic(true).EnableTiling(
            {max_tile_size_x, max_tile_size_y, max_tile_size_z});
#pragma omp parallel
        for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {
          GridPtrDesc grid(leveldata, mfi);
          const Array4<CCTK_REAL> &vars = mfab.array(mfi);
          for (int vi = 0; vi < groupdata.numvars; ++vi) {
            CCTK_REAL *restrict const ptr = grid.ptr(vars, vi);
            // Poison boundaries
            grid.loop_bnd(groupdata.indextype, [&](const Loop::PointDesc &p) {
              ptr[p.idx] = 0.0 / 0.0;
            });
          }

[11.12937]

[21.1247]

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

Insertion in AMReX/src/schedule.cxx at line 1264 [17.531]

[21.1265]

[23.1809]


      for (int vi = 0; vi < groupdata.numvars; ++vi)
        poison_invalid(leveldata, groupdata, vi, tl);

Insertion in AMReX/src/schedule.hxx at line 70 [17.5992]

[8.18748]


void poison_invalid(const GHExt::LevelData &leveldata,
                    const GHExt::LevelData::GroupData &groupdata, int vi,
                    int tl);

Replacement in MaxwellToyAMReX/interface.ccl at line 137 [24.13068]

B:BD[7.20277] → [7.20277:20337]

CCTK_REAL errors_potential_phi TYPE=gf TAGS='index={0 0 0}'

[7.20277]

[24.14339]

CCTK_REAL errors_potential_phi TYPE=gf TAGS='index={0 0 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 142 [24.13068]

B:BD[7.20369] → [7.20369:20428]

CCTK_REAL errors_potential_ax TYPE=gf TAGS='index={1 0 0}'

[7.20369]

[7.20428]

CCTK_REAL errors_potential_ax TYPE=gf TAGS='index={1 0 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 146 [24.13068]

B:BD[7.20468] → [7.20468:20527]

CCTK_REAL errors_potential_ay TYPE=gf TAGS='index={0 1 0}'

[7.20468]

[7.20527]

CCTK_REAL errors_potential_ay TYPE=gf TAGS='index={0 1 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 150 [24.13068]

B:BD[7.20567] → [7.20567:20626]

CCTK_REAL errors_potential_az TYPE=gf TAGS='index={0 0 1}'

[7.20567]

[7.20626]

CCTK_REAL errors_potential_az TYPE=gf TAGS='index={0 0 1} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 155 [24.13068]

B:BD[7.20667] → [7.20667:20722]

CCTK_REAL errors_field_ex TYPE=gf TAGS='index={1 0 0}'

[7.20667]

[7.20722]

CCTK_REAL errors_field_ex TYPE=gf TAGS='index={1 0 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 159 [24.13068]

B:BD[7.20758] → [7.20758:20813]

CCTK_REAL errors_field_ey TYPE=gf TAGS='index={0 1 0}'

[7.20758]

[7.20813]

CCTK_REAL errors_field_ey TYPE=gf TAGS='index={0 1 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 163 [24.13068]

B:BD[7.20849] → [7.20849:20904]

CCTK_REAL errors_field_ez TYPE=gf TAGS='index={0 0 1}'

[7.20849]

[7.20904]

CCTK_REAL errors_field_ez TYPE=gf TAGS='index={0 0 1} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 168 [24.13068]

B:BD[7.20941] → [7.20941:20996]

CCTK_REAL errors_field_bx TYPE=gf TAGS='index={0 1 1}'

[7.20941]

[7.20996]

CCTK_REAL errors_field_bx TYPE=gf TAGS='index={0 1 1} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 172 [24.13068]

B:BD[7.21032] → [7.21032:21087]

CCTK_REAL errors_field_by TYPE=gf TAGS='index={1 0 1}'

[7.21032]

[7.21087]

CCTK_REAL errors_field_by TYPE=gf TAGS='index={1 0 1} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 176 [24.13068]

B:BD[7.21123] → [7.21123:21178]

CCTK_REAL errors_field_bz TYPE=gf TAGS='index={1 1 0}'

[7.21123]

[7.21178]

CCTK_REAL errors_field_bz TYPE=gf TAGS='index={1 1 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 181 [24.13068]

B:BD[7.21215] → [7.21215:21273]

CCTK_REAL errors_current_rho TYPE=gf TAGS='index={0 0 0}'

[7.21215]

[7.21273]

CCTK_REAL errors_current_rho TYPE=gf TAGS='index={0 0 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 186 [24.13068]

B:BD[7.21305] → [7.21305:21362]

CCTK_REAL errors_current_jx TYPE=gf TAGS='index={1 0 0}'

[7.21305]

[7.21362]

CCTK_REAL errors_current_jx TYPE=gf TAGS='index={1 0 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 190 [24.13068]

B:BD[7.21400] → [7.21400:21457]

CCTK_REAL errors_current_jy TYPE=gf TAGS='index={0 1 0}'

[7.21400]

[7.21457]

CCTK_REAL errors_current_jy TYPE=gf TAGS='index={0 1 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 194 [24.13068]

B:BD[7.21495] → [7.21495:21552]

CCTK_REAL errors_current_jz TYPE=gf TAGS='index={0 0 1}'

[7.21495]

[7.21552]

CCTK_REAL errors_current_jz TYPE=gf TAGS='index={0 0 1} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 201 [24.13068]

B:BD[25.7601] → [25.7601:7657]

CCTK_REAL constraints_dive TYPE=gf TAGS='index={0 0 0}'

[25.7601]

[25.7657]

CCTK_REAL constraints_dive TYPE=gf TAGS='index={0 0 0} checkpoint="no"'

Replacement in MaxwellToyAMReX/interface.ccl at line 205 [24.13068]

B:BD[25.7682] → [25.7682:7738]

CCTK_REAL constraints_divb TYPE=gf TAGS='index={1 1 1}'

[25.7682]

[25.7738]

CCTK_REAL constraints_divb TYPE=gf TAGS='index={1 1 1} checkpoint="no"'

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 666 [24.16301]

B:BD[26.3041] → [26.3041:3156]

  Loop::loop_all<0, 0, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(dive, p); });

[26.3041]

[26.3156]

  // Loop::loop_all<0, 0, 0>(cctkGH,
  //                         [&](const Loop::PointDesc &p) { nancheck(dive, p);
  //                         });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 670 [24.16301]

B:BD[26.3157] → [26.3157:3272]

  Loop::loop_all<1, 1, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(divb, p); });

[26.3157]

[26.3272]

  // Loop::loop_all<1, 1, 1>(cctkGH,
  //                         [&](const Loop::PointDesc &p) { nancheck(divb, p);
  //                         });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 693 [24.16301]

B:BD[25.20933] → [25.20933:21102]

  // Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
  //   regrid_error[p.idx] = fabs(p.x) < 0.5 && fabs(p.y) < 0.5 && fabs(p.z) <
  //   0.5;
  // });

[25.20933]

[23.8341]

#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    regrid_error[p.idx] = fabs(p.x) < 0.5 && fabs(p.y) < 0.5 && fabs(p.z) <
    0.5;
  });
#endif
#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    CCTK_REAL err = 0;
    for (int b = 0; b < 2; ++b)
      for (int a = 0; a < 2; ++a)
        err += fabs(ax_(p.i - 1, p.j + a, p.k + b) -
                    2 * ax_(p.i, p.j + a, p.k + b) +
                    ax_(p.i + 1, p.j + a, p.k + b)) +
               fabs(ay_(p.i + a, p.j - 1, p.k + b) -
                    2 * ay_(p.i + a, p.j, p.k + b) +
                    ay_(p.i + a, p.j + 1, p.k + b)) +
               fabs(az_(p.i + a, p.j + b, p.k - 1) -
                    2 * az_(p.i + a, p.j + b, p.k) +
                    az_(p.i + a, p.j + b, p.k + 1));
    regrid_error[p.idx] = err;
  });
#endif

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 718 [24.16301]

B:BD[23.8342] → [25.21103:21819]

  // Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
  //   CCTK_REAL err = 0;
  //   for (int b = 0; b < 2; ++b)
  //     for (int a = 0; a < 2; ++a)
  //       err += fabs(ax_(p.i - 1, p.j + a, p.k + b) -
  //                   2 * ax_(p.i, p.j + a, p.k + b) +
  //                   ax_(p.i + 1, p.j + a, p.k + b)) +
  //              fabs(ay_(p.i + a, p.j - 1, p.k + b) -
  //                   2 * ay_(p.i + a, p.j, p.k + b) +
  //                   ay_(p.i + a, p.j + 1, p.k + b)) +
  //              fabs(az_(p.i + a, p.j + b, p.k - 1) -
  //                   2 * az_(p.i + a, p.j + b, p.k) +
  //                   az_(p.i + a, p.j + b, p.k + 1));
  //   regrid_error[p.idx] = err;
  // });

[23.8342]

[25.21819]

#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    auto closeto = [&](CCTK_REAL x, CCTK_REAL y, CCTK_REAL z, CCTK_REAL r) {
      return fabs(p.x - x) <= r && fabs(p.y - y) <= r && fabs(p.z - z) <= r;
    };
    constexpr CCTK_REAL x = 0.25;
    constexpr CCTK_REAL y = 0.25;
    constexpr CCTK_REAL z = 0.25;
    constexpr CCTK_REAL r = 0.2;
    regrid_error[p.idx] = // closeto(-x, -y, -z, r) ||
        closeto(+x, -y, -z, r) || closeto(-x, +y, -z, r) ||
        closeto(+x, +y, -z, r) || closeto(-x, -y, +z, r) ||
        closeto(+x, -y, +z, r) || closeto(-x, +y, +z, r) ||
        closeto(+x, +y, +z, r);
  });
#endif

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 735 [24.16301]
[25.21820]
[23.8342]
```
#if 1
```
Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 810 [24.16301]
[23.9013]
[24.23210]
```
#endif
```
Replacement in WaveToyAMReX/interface.ccl at line 19 [6.10196]
B:BD[27.1617] → [14.12617:12642]
```
CCTK_REAL energy TYPE=gf
```
[27.1617]
[14.12642]
```
CCTK_REAL energy TYPE=gf TAGS='checkpoint="no"'
```
Replacement in WaveToyAMReX/interface.ccl at line 24 [6.10196]
∅:D[14.12688] → [16.6956:6978]
B:BD[27.1617] → [16.6956:6978]
```
CCTK_REAL err TYPE=gf
```
[14.12688]
[28.2004]
```
CCTK_REAL err TYPE=gf TAGS='checkpoint="no"'
```
Insertion in WaveToyAMReX/schedule.ccl at line 36 [6.9594]
[3.118]
[10.9732]
```
  WRITES: AMReX::regrid_error(interior)
```

More work on poisoning

Dependencies

In channels

Change contents

Insertion in AMReX/param.ccl at line 123 [6.17918]

Insertion in AMReX/param.ccl at line 129 [6.17918]

Insertion in AMReX/src/driver.cxx at line 99 [6.15972]

Deletion in AMReX/src/driver.cxx at line 107 [6.15972]

Replacement in AMReX/src/driver.cxx at line 115 [6.15972]

Insertion in AMReX/src/driver.cxx at line 117 [6.15972]

Deletion in AMReX/src/driver.cxx at line 125 [6.15972]

Insertion in AMReX/src/driver.cxx at line 152 [6.15972]