eschnett/cactusamrex - Change YIQN7NJTGEVKW7JZHL6CTH6EPCIXCNBYNURIGXPYZAOUX3VAJQMAC

Staggered grids

Created by Erik Schnetter on August 8, 2019

YIQN7NJTGEVKW7JZHL6CTH6EPCIXCNBYNURIGXPYZAOUX3VAJQMAC

Dependencies

In channels

main

master

Change contents

Insertion in AMReX/par/maxwell.par at line 43 [2.14]
[2.793]
```
# AMReX::out_tsv = yes
```
Insertion in AMReX/src/driver.cxx at line 8 [3.15972]
[3.16090]
[4.181]
```
#include <util_Table.h>
```
Deletion in AMReX/src/driver.cxx at line 83 [3.15972]
B:BD[5.988] → [5.988:1031]
```
  MultiFab &mfab = *groupdata.mfab.at(tl);
```

Replacement in AMReX/src/driver.cxx at line 86 [3.15972]

B:BD[5.1131] → [5.1131:1190]

  for (MFIter mfi(mfab, mfitinfo); mfi.isValid(); ++mfi) {

[5.1131]

[6.1473]

  for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {

Replacement in AMReX/src/driver.cxx at line 93 [3.15972]

B:BD[7.1698] → [6.1616:1846]

    grid.loop_int([&](int i, int j, int k, int idx) {
      tag(grid.cactus_offset.x + i, grid.cactus_offset.y + j,
          grid.cactus_offset.z + k) =
          err[idx] >= regrid_error_threshold ? TagBox::SET : TagBox::CLEAR;

[7.1698]

[6.1846]

    grid.loop_int(groupdata.indextype, [&](const Loop::PointDesc &p) {
      tag(grid.cactus_offset.x + p.i, grid.cactus_offset.y + p.j,
          grid.cactus_offset.z + p.k) =
          err[p.idx] >= regrid_error_threshold ? TagBox::SET : TagBox::CLEAR;

Insertion in AMReX/src/driver.cxx at line 98 [3.15972]

[6.1854]

[5.2148]

  }
}
namespace {
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 {
    assert(iret == dim);

Insertion in AMReX/src/driver.cxx at line 113 [3.15972]

[5.2152]

[8.1271]

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

Insertion in AMReX/src/driver.cxx at line 118 [3.15972]
[8.1273]
[9.1301]
```
} // namespace
```

Insertion in AMReX/src/driver.cxx at line 129 [3.15972]

[9.1645]

[8.1273]

#warning "TODO: Make this an empty MultiFab"
  leveldata.mfab0 = make_unique<MultiFab>(ba, dm, 1, ghost_size);
  assert(ba.ixType() ==
         IndexType(IndexType::CELL, IndexType::CELL, IndexType::CELL));

Insertion in AMReX/src/driver.cxx at line 148 [3.15972]
[9.2191]
[9.2191]
```
    groupdata.indextype = get_group_indextype(gi);
```

Insertion in AMReX/src/driver.cxx at line 151 [3.15972]

[9.2225]

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

Replacement in AMReX/src/driver.cxx at line 159 [3.15972]

B:BD[9.2365] → [9.2365:2437]

          make_unique<MultiFab>(ba, dm, groupdata.numvars, ghost_size);

[9.2365]

[6.1918]

          make_unique<MultiFab>(gba, dm, groupdata.numvars, ghost_size);

Deletion in AMReX/src/driver.cxx at line 161 [3.15972]
B:BD[6.1953] → [6.1953:2000]
```
      MultiFab &mfab = *groupdata.mfab.at(tl);
```

Replacement in AMReX/src/driver.cxx at line 164 [3.15972]

B:BD[6.2149] → [6.2149:2212]

      for (MFIter mfi(mfab, mfitinfo); mfi.isValid(); ++mfi) {

[6.2149]

[6.2212]

      for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {

Replacement in AMReX/src/driver.cxx at line 166 [3.15972]

B:BD[6.2254] → [6.2254:2311]

        const Array4<CCTK_REAL> &vars = mfab.array(mfi);

[6.2254]

[6.2311]

        const Array4<CCTK_REAL> &vars = groupdata.mfab.at(tl)->array(mfi);

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

B:BD[6.2430] → [6.2430:2531]

          grid.loop_all(
              [&](int i, int j, int k, int idx) { ptr[idx] = 0.0 / 0.0; });

[6.2430]

[6.2531]

          grid.loop_all(groupdata.indextype, [&](const Loop::PointDesc &p) {
            ptr[p.idx] = 0.0 / 0.0;
          });

Insertion in AMReX/src/driver.cxx at line 239 [3.15972]

[9.4281]

#warning "TODO: Make this an empty MultiFab"
  leveldata.mfab0 = make_unique<MultiFab>(ba, dm, 1, ghost_size);
  assert(ba.ixType() ==
         IndexType(IndexType::CELL, IndexType::CELL, IndexType::CELL));

Deletion in AMReX/src/driver.cxx at line 252 [3.15972]

B:BD[9.4607] → [9.4607:4905]

B:BD[9.4905] → [6.2556:3166]

∅:D[6.3166] → [9.4905:5195]

B:BD[9.4905] → [9.4905:5195]


    if (leveldata.level == 0) {
      // Coarsest level: Copy from same level
      // This should not happen
      assert(0);
      PhysBCFunctNoOp fphysbc;
      for (int tl = 0; tl < ntls; ++tl) {
        auto mfab =
            make_unique<MultiFab>(ba, dm, groupdata.numvars, ghost_size);
        // 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(*mfab, 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);
            grid.loop_all(
                [&](int i, int j, int k, int idx) { ptr[idx] = 0.0 / 0.0; });
          }
        }
        if (tl < prolongate_tl)
          FillPatchSingleLevel(*mfab, 0.0, {&*groupdata.mfab.at(tl)}, {0.0}, 0,
                               0, groupdata.numvars,
                               ghext->amrcore->Geom(level), fphysbc, 0);
        groupdata.mfab.at(tl) = move(mfab);
      }

Replacement in AMReX/src/driver.cxx at line 253 [3.15972]

B:BD[9.5196] → [9.5196:5305]

    } else {
      // Refined level: copy from same level and/or prolongate from
      // next coarser level

[9.5196]

[9.5305]

    // This must not happen
    assert(leveldata.level > 0);

Replacement in AMReX/src/driver.cxx at line 256 [3.15972]

B:BD[9.5306] → [9.5306:5501]

      auto &coarseleveldata = ghext->leveldata.at(level - 1);
      auto &restrict coarsegroupdata = coarseleveldata.groupdata.at(gi);
      assert(coarsegroupdata.numvars == groupdata.numvars);

[9.5306]

[9.5501]

    // Copy from same level and/or prolongate from next coarser level
    auto &coarseleveldata = ghext->leveldata.at(level - 1);
    auto &restrict coarsegroupdata = coarseleveldata.groupdata.at(gi);
    assert(coarsegroupdata.numvars == groupdata.numvars);

Replacement in AMReX/src/driver.cxx at line 261 [3.15972]

B:BD[9.5502] → [9.5502:5602]

B:BD[9.5602] → [10.1728:2214]

∅:D[10.2214] → [9.5782:5975]

B:BD[9.5782] → [9.5782:5975]

B:BD[9.5975] → [6.3167:3336]

      PhysBCFunctNoOp cphysbc;
      PhysBCFunctNoOp fphysbc;
      const IntVect reffact{2, 2, 2};
      // boundary conditions
      const BCRec bcrec(periodic_x ? BCType::int_dir : BCType::reflect_odd,
                        periodic_y ? BCType::int_dir : BCType::reflect_odd,
                        periodic_z ? BCType::int_dir : BCType::reflect_odd,
                        periodic_x ? BCType::int_dir : BCType::reflect_odd,
                        periodic_y ? BCType::int_dir : BCType::reflect_odd,
                        periodic_z ? BCType::int_dir : BCType::reflect_odd);
      const Vector<BCRec> bcs(groupdata.numvars, bcrec);
      for (int tl = 0; tl < ntls; ++tl) {
        auto mfab =
            make_unique<MultiFab>(ba, dm, groupdata.numvars, ghost_size);
        // Set grid functions to nan
        auto mfitinfo = MFItInfo().SetDynamic(true).EnableTiling(
            {max_tile_size_x, max_tile_size_y, max_tile_size_z});

[9.5502]

[6.3336]

    PhysBCFunctNoOp cphysbc;
    PhysBCFunctNoOp fphysbc;
    const IntVect reffact{2, 2, 2};
    // boundary conditions
    const BCRec bcrec(periodic_x ? BCType::int_dir : BCType::reflect_odd,
                      periodic_y ? BCType::int_dir : BCType::reflect_odd,
                      periodic_z ? BCType::int_dir : BCType::reflect_odd,
                      periodic_x ? BCType::int_dir : BCType::reflect_odd,
                      periodic_y ? BCType::int_dir : BCType::reflect_odd,
                      periodic_z ? BCType::int_dir : BCType::reflect_odd);
    const Vector<BCRec> bcs(groupdata.numvars, bcrec);
    for (int tl = 0; tl < ntls; ++tl) {
      auto mfab = make_unique<MultiFab>(ba, dm, groupdata.numvars, ghost_size);
      // Set grid functions to nan
      auto mfitinfo = MFItInfo().SetDynamic(true).EnableTiling(
          {max_tile_size_x, max_tile_size_y, max_tile_size_z});

Replacement in AMReX/src/driver.cxx at line 278 [3.15972]

B:BD[6.3357] → [6.3357:3767]

        for (MFIter mfi(*mfab, 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);
            grid.loop_all(
                [&](int i, int j, int k, int idx) { ptr[idx] = 0.0 / 0.0; });
          }

[6.3357]

[6.3767]

      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);
          grid.loop_all(groupdata.indextype, [&](const Loop::PointDesc &p) {
            ptr[p.idx] = 0.0 / 0.0;
          });

Deletion in AMReX/src/driver.cxx at line 287 [3.15972]

∅:D[6.3777] → [9.5975:6434]

B:BD[9.5975] → [9.5975:6434]

        if (tl < prolongate_tl)
          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, &cell_bilinear_interp, bcs, 0);
        groupdata.mfab.at(tl) = move(mfab);

Insertion in AMReX/src/driver.cxx at line 288 [3.15972]

[9.6442]

      if (tl < prolongate_tl)
        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, &cell_bilinear_interp, bcs, 0);
      groupdata.mfab.at(tl) = move(mfab);

Replacement in AMReX/src/driver.cxx at line 428 [3.15972]
B:BD[5.2565] → [5.2565:2586]
```
} // namespace AMReX
```
[5.2565]
[5.2586]
```
}
```

Insertion in AMReX/src/driver.hxx at line 69 [3.15275]

[11.33]

    // Empty MultiFab holding a cell-centred BoxArray for iterating
    // over grid functions.
    // TODO: Can we store the BoxArray directly?
    unique_ptr<MultiFab> mfab0;

Insertion in AMReX/src/driver.hxx at line 77 [3.15275]
[11.199]
[12.1601]
```
      array<int,dim> indextype;
```

Insertion in AMReX/src/io.cxx at line 27 [13.107]

[13.489]

[7.3507]


void OutputPlotfile(const cGH *restrict cctkGH) {
  DECLARE_CCTK_ARGUMENTS;
  DECLARE_CCTK_PARAMETERS;
  const int numgroups = CCTK_NumGroups();
  for (int gi = 0; gi < numgroups; ++gi) {
    auto &restrict groupdata0 = ghext->leveldata.at(0).groupdata.at(gi);
    if (groupdata0.mfab.size() > 0) {
      const int tl = 0;
      string groupname = unique_ptr<char>(CCTK_GroupName(gi)).get();
      groupname = regex_replace(groupname, regex("::"), "-");
      for (auto &c : groupname)
        c = tolower(c);
      ostringstream buf;
      buf << out_dir << "/" << groupname;
      buf << ".it" << setw(6) << setfill('0') << cctk_iteration;
      string filename = buf.str();
      Vector<string> varnames(groupdata0.numvars);
      for (int vi = 0; vi < groupdata0.numvars; ++vi) {
        ostringstream buf;
        buf << CCTK_VarName(groupdata0.firstvarindex + vi);
        for (int i = 0; i < tl; ++i)
          buf << "_p";
        varnames.at(vi) = buf.str();
      }
      Vector<const MultiFab *> mfabs(ghext->leveldata.size());
      Vector<Geometry> geoms(ghext->leveldata.size());
      Vector<int> iters(ghext->leveldata.size());
      Vector<IntVect> reffacts(ghext->leveldata.size());
      for (const auto &restrict leveldata : ghext->leveldata) {
        mfabs.at(leveldata.level) = &*leveldata.groupdata.at(gi).mfab.at(tl);
        geoms.at(leveldata.level) = ghext->amrcore->Geom(leveldata.level);
        iters.at(leveldata.level) = cctk_iteration;
        reffacts.at(leveldata.level) = IntVect{2, 2, 2};
      }

Insertion in AMReX/src/io.cxx at line 67 [13.107]

[7.3508]

[7.3680]

      // TODO: Output all groups into a single file
      WriteMultiLevelPlotfile(filename, mfabs.size(), mfabs, varnames, geoms,
                              cctk_time, iters, reffacts);
    }
  }
}

Insertion in AMReX/src/io.cxx at line 118 [13.107]

[7.5354]

#warning "TODO: Get these from schedule.cxx"
struct TileBox {
  array<int, dim> tile_min;
  array<int, dim> tile_max;
};
extern vector<TileBox> thread_local_tilebox;
void enter_level_mode(cGH *restrict cctkGH,
                      const GHExt::LevelData &restrict leveldata);
void leave_level_mode(cGH *restrict cctkGH,
                      const GHExt::LevelData &restrict leveldata);
void enter_local_mode(cGH *restrict cctkGH, TileBox &restrict tilebox,
                      const GHExt::LevelData &restrict leveldata,
                      const MFIter &mfi);
void leave_local_mode(cGH *restrict cctkGH, TileBox &restrict tilebox,
                      const GHExt::LevelData &restrict leveldata,
                      const MFIter &mfi);

Replacement in AMReX/src/io.cxx at line 149 [13.107]

B:BD[7.5694] → [7.5694:5729]

       << "\t"
       << "isghost"

[7.5694]

[7.5729]

       // << "\t"
       // << "isghost"

Insertion in AMReX/src/io.cxx at line 168 [13.107]

[7.6040]

    enter_level_mode(const_cast<cGH *>(cctkGH), leveldata);

Replacement in AMReX/src/io.cxx at line 171 [13.107]

B:BD[7.6118] → [7.6118:6220]

    const MultiFab &mfab = *groupdata.mfab.at(tl);
    for (MFIter mfi(mfab); mfi.isValid(); ++mfi) {

[7.6118]

[6.5284]

    for (MFIter mfi(*leveldata.mfab0); mfi.isValid(); ++mfi) {
      TileBox &tilebox = thread_local_tilebox.at(omp_get_thread_num());
      enter_local_mode(const_cast<cGH *>(cctkGH), tilebox, leveldata, mfi);

Replacement in AMReX/src/io.cxx at line 179 [13.107]

B:BD[6.5367] → [6.5367:5443]

      write_arrays(file, cctkGH, leveldata.level, mfi.index(), ptrs, grid);

[6.5367]

[7.7563]

      // write_arrays(file, cctkGH, leveldata.level, mfi.index(), ptrs, grid);
      Loop::loop_all(
          cctkGH, groupdata.indextype, [&](const Loop::PointDesc &p) {
            file << cctkGH->cctk_iteration << "\t" << cctkGH->cctk_time << "\t"
                 << leveldata.level << "\t"
                 << mfi.index()
                 // << "\t" << isghost
                 << "\t" << (grid.lbnd[0] + p.i) << "\t" << (grid.lbnd[1] + p.j)
                 << "\t" << (grid.lbnd[2] + p.k) << "\t" << p.x << "\t" << p.y
                 << "\t" << p.z;
            for (const auto &ptr : ptrs)
              file << "\t" << ptr[p.idx];
            file << "\n";
          });
      leave_local_mode(const_cast<cGH *>(cctkGH), tilebox, leveldata, mfi);

Insertion in AMReX/src/io.cxx at line 195 [13.107]

[7.7569]

    leave_level_mode(const_cast<cGH *>(cctkGH), leveldata);

Replacement in AMReX/src/io.cxx at line 200 [13.107]
∅:D[7.7592] → [13.490:533]
B:BD[13.490] → [13.490:533]
```
int OutputGH(const cGH *restrict cctkGH) {
```
[7.7592]
[13.533]
```
void OutputASCII(const cGH *restrict cctkGH) {
```

Deletion in AMReX/src/io.cxx at line 203 [13.107]

B:BD[13.586] → [13.586:587]

B:BD[13.587] → [7.7593:7792]


  const bool is_root = CCTK_MyProc(nullptr) == 0;
  if (is_root)
    cout << "OutputGH: iteration " << cctk_iteration << ", time " << cctk_time
         << ", run time " << CCTK_RunTime() << " s\n";

Replacement in AMReX/src/io.cxx at line 204 [13.107]
∅:D[7.7793] → [14.125:196]
B:BD[13.587] → [14.125:196]
```
  if (out_every <= 0 || cctk_iteration % out_every != 0)
    return 0;
```
[7.7793]
[14.196]
```
  if (!out_tsv)
    return;
```
Deletion in AMReX/src/io.cxx at line 207 [13.107]
∅:D[14.197] → [13.587:609]
B:BD[13.587] → [13.587:609]
```
  int count_vars = 0;
```

Insertion in AMReX/src/io.cxx at line 220 [13.107]

[15.613]

      buf << ".p" << setw(4) << setfill('0') << CCTK_MyProc(nullptr);

Replacement in AMReX/src/io.cxx at line 232 [13.107]

B:BD[15.923] → [15.923:1290]

B:BD[15.1290] → [8.4035:4110]

∅:D[8.4110] → [15.1365:1482]

B:BD[15.1365] → [15.1365:1482]

      Vector<const MultiFab *> mfabs(ghext->leveldata.size());
      Vector<Geometry> geoms(ghext->leveldata.size());
      Vector<int> iters(ghext->leveldata.size());
      Vector<IntVect> reffacts(ghext->leveldata.size());
      for (const auto &restrict leveldata : ghext->leveldata) {
        mfabs.at(leveldata.level) = &*leveldata.groupdata.at(gi).mfab.at(tl);
        geoms.at(leveldata.level) = ghext->amrcore->Geom(leveldata.level);
        iters.at(leveldata.level) = cctk_iteration;
        reffacts.at(leveldata.level) = IntVect{2, 2, 2};
      }

[15.923]

[13.1083]

      WriteASCII(cctkGH, filename, gi, varnames);
    }
  }
}

Replacement in AMReX/src/io.cxx at line 237 [13.107]

B:BD[13.1084] → [15.1483:1672]

B:BD[15.1672] → [7.7837:8130]

      // TODO: Output all groups into a single file
      WriteMultiLevelPlotfile(filename, mfabs.size(), mfabs, varnames, geoms,
                              cctk_time, iters, reffacts);
      if (out_tsv) {
        ostringstream procbuf;
        procbuf << out_dir << "/" << groupname;
        procbuf << ".it" << setw(6) << setfill('0') << cctk_iteration;
        procbuf << ".p" << setw(4) << setfill('0') << CCTK_MyProc(nullptr);
        string procfilename = procbuf.str();

[13.1084]

[16.1090]

void OutputNorms(const cGH *restrict cctkGH) {
  DECLARE_CCTK_ARGUMENTS;
  DECLARE_CCTK_PARAMETERS;

Replacement in AMReX/src/io.cxx at line 241 [13.107]
B:BD[16.1091] → [7.8131:8196]
∅:D[7.8196] → [15.1673:1742]
B:BD[16.1091] → [15.1673:1742]
∅:D[15.1742] → [17.210:216]
B:BD[13.1483] → [17.210:216]
B:BD[17.283] → [17.283:287]
```
        WriteASCII(cctkGH, procfilename, gi, varnames);
      }
      count_vars += ghext->leveldata.at(0).groupdata.at(gi).numvars;
    }
  }
```
[16.1091]
[13.1777]
```
  const bool is_root = CCTK_MyProc(nullptr) == 0;
```
Insertion in AMReX/src/io.cxx at line 243 [13.107]
[13.1778]
[17.288]
```
  const int numgroups = CCTK_NumGroups();
```
Insertion in AMReX/src/io.cxx at line 267 [13.107]
[16.1354]
[13.1819]
```
}
```

Replacement in AMReX/src/io.cxx at line 269 [13.107]

B:BD[13.1820] → [13.1820:1841]

  return count_vars;

[13.1820]

[13.1841]

int OutputGH(const cGH *restrict cctkGH) {
  DECLARE_CCTK_ARGUMENTS;
  DECLARE_CCTK_PARAMETERS;
  const bool is_root = CCTK_MyProc(nullptr) == 0;
  if (is_root)
    cout << "OutputGH: iteration " << cctk_iteration << ", time " << cctk_time
         << ", run time " << CCTK_RunTime() << " s\n";
  if (out_every <= 0 || cctk_iteration % out_every != 0)
    return 0;
  OutputPlotfile(cctkGH);
  OutputASCII(cctkGH);
  OutputNorms(cctkGH);
  // TODO: This should be the number of variables output
  return 0;

Insertion in AMReX/src/loop.hxx at line 21 [6.5481]

[6.5654]


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

Insertion in AMReX/src/loop.hxx at line 24 [6.5481]

[6.5655]

template <typename T, int CI, int CJ, int CK> struct GF3D {
  static_assert(CI == 0 || CI == 1, "");
  static_assert(CJ == 0 || CJ == 1, "");
  static_assert(CK == 0 || CK == 1, "");
  typedef T value_type;
  T *restrict ptr;
  static constexpr int di = 1;
  int dj, dk;
  int ni, nj, nk;
  constexpr array<int, dim> indextype() const { return {CI, CJ, CK}; }
  inline GF3D(const cGH *restrict cctkGH, T *restrict ptr)
      : ptr(ptr), dj(di * (cctkGH->cctk_ash[0] + 1 - CI)),
        dk(dj * (cctkGH->cctk_ash[1] + 1 - CJ)),
        ni(cctkGH->cctk_lsh[0] + 1 - CI), nj(cctkGH->cctk_lsh[1] + 1 - CJ),
        nk(cctkGH->cctk_lsh[2] + 1 - CK) {}
  inline int offset(int i, int j, int k) const {
    assert(i >= 0 && i < ni);
    assert(j >= 0 && j < nj);
    assert(k >= 0 && k < nk);
    return i * di + j * dj + k * dk;
  }
  inline T &restrict operator()(int i, int j, int k) const {
    return ptr[offset(i, j, k)];
  }
};
////////////////////////////////////////////////////////////////////////////////
struct PointDesc {
  int idx;
  int i, j, k;
  CCTK_REAL x, y, z;
  static constexpr int di = 1;
  int dj, dk;
  CCTK_REAL dx, dy, dz;
};

Insertion in AMReX/src/loop.hxx at line 69 [6.5481]
[6.5865]
[6.5865]
```
  array<CCTK_REAL, dim> x0;
  array<CCTK_REAL, dim> dx;
```
Replacement in AMReX/src/loop.hxx at line 104 [6.5481]
B:BD[6.6650] → [6.6650:6674]
```
  template <typename F>
```
[6.6650]
[6.6674]
```
  template <int CI, int CJ, int CK, typename F>
```

Replacement in AMReX/src/loop.hxx at line 107 [6.5481]

B:BD[6.6802] → [6.6802:6917]

    // cout << *this;
    // output(cout, ",imin", imin);
    // output(cout, ",imax", imax);
    // cout << "\n";

[6.6802]

[6.6917]

    static_assert(CI == 0 || CI == 1, "");
    static_assert(CJ == 0 || CJ == 1, "");
    static_assert(CK == 0 || CK == 1, "");

Replacement in AMReX/src/loop.hxx at line 116 [6.5481]

B:BD[6.7025] → [6.7025:7089]

    const int dj = di * ash[0];
    const int dk = dj * ash[1];

[6.7025]

[6.7089]

    const int dj = di * (ash[0] + 1 - CI);
    const int dk = dj * (ash[1] + 1 - CJ);

Insertion in AMReX/src/loop.hxx at line 123 [6.5481]

[6.7251]

          CCTK_REAL x = x0[0] + (lbnd[0] + i + CCTK_REAL(CI - 1) / 2) * dx[0];
          CCTK_REAL y = x0[1] + (lbnd[1] + j + CCTK_REAL(CJ - 1) / 2) * dx[1];
          CCTK_REAL z = x0[2] + (lbnd[2] + k + CCTK_REAL(CK - 1) / 2) * dx[2];

Replacement in AMReX/src/loop.hxx at line 127 [6.5481]

B:BD[6.7297] → [6.7297:7324]

          f(i, j, k, idx);

[6.7297]

[6.7324]

          const PointDesc p{idx, i, j, k, x, y, z, dj, dk, dx[0], dx[1], dx[2]};
          f(p);

Replacement in AMReX/src/loop.hxx at line 135 [6.5481]

B:BD[6.7379] → [6.7379:7437]

  template <typename F> void loop_all(const F &f) const {

[6.7379]

[6.7437]

  template <int CI, int CJ, int CK, typename F>
  void loop_all(const F &f) const {
    constexpr array<int, dim> offset{!CI, !CJ, !CK};

Replacement in AMReX/src/loop.hxx at line 141 [6.5481]

B:BD[6.7538] → [6.7538:7576]

      imax[d] = min(tmax[d], lsh[d]);

[6.7538]

[6.7576]

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

Replacement in AMReX/src/loop.hxx at line 145 [6.5481]
B:BD[6.7583] → [6.7583:7612]
```
    loop_box(f, imin, imax);
```
[6.7583]
[6.7612]
```
    loop_box<CI, CJ, CK>(f, imin, imax);
```

Replacement in AMReX/src/loop.hxx at line 149 [6.5481]

B:BD[6.7652] → [6.7652:7710]

  template <typename F> void loop_int(const F &f) const {

[6.7652]

[6.7710]

  template <int CI, int CJ, int CK, typename F>
  void loop_int(const F &f) const {
    constexpr array<int, dim> offset{!CI, !CJ, !CK};

Replacement in AMReX/src/loop.hxx at line 155 [6.5481]

B:BD[6.7824] → [6.7824:7879]

      imax[d] = min(tmax[d], lsh[d] - nghostzones[d]);

[6.7824]

[6.7879]

      imax[d] = min(tmax[d] + (tmax[d] >= lsh[d] ? offset[d] : 0),
                    lsh[d] + offset[d] - nghostzones[d]);

Replacement in AMReX/src/loop.hxx at line 159 [6.5481]
B:BD[6.7886] → [6.7886:7915]
```
    loop_box(f, imin, imax);
```
[6.7886]
[6.7915]
```
    loop_box<CI, CJ, CK>(f, imin, imax);
```

Replacement in AMReX/src/loop.hxx at line 164 [6.5481]

B:BD[6.8047] → [6.8047:8105]

  template <typename F> void loop_bnd(const F &f) const {

[6.8047]

[6.8105]

  template <int CI, int CJ, int CK, typename F>
  void loop_bnd(const F &f) const {
    constexpr array<int, dim> offset{!CI, !CJ, !CK};

Replacement in AMReX/src/loop.hxx at line 176 [6.5481]
B:BD[6.8410] → [6.8410:8440]
```
            imax[d] = lsh[d];
```
[6.8410]
[6.8440]
```
            imax[d] = lsh[d] + offset[d];
```

Replacement in AMReX/src/loop.hxx at line 183 [6.5481]

B:BD[6.8656] → [6.8656:8724]

                imax[d] = lsh[d] - nghostzones[d]; // only interior

[6.8656]

[6.8724]

                imax[d] = lsh[d] + offset[d] - nghostzones[d]; // only interior

Replacement in AMReX/src/loop.hxx at line 190 [6.5481]

B:BD[6.8877] → [6.8877:8930]

            imin[dir] = lsh[dir] - nghostzones[dir];

[6.8877]

[6.8930]

            imin[dir] = lsh[dir] + offset[dir] - nghostzones[dir];

Replacement in AMReX/src/loop.hxx at line 194 [6.5481]

B:BD[6.9018] → [6.9018:9063]

            imax[d] = min(tmax[d], imax[d]);

[6.9018]

[6.9063]

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

Replacement in AMReX/src/loop.hxx at line 198 [6.5481]

B:BD[6.9076] → [6.9076:9111]

          loop_box(f, imin, imax);

[6.9076]

[6.9111]

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

Insertion in AMReX/src/loop.hxx at line 201 [6.5481]

[6.9129]

    }
  }
  template <typename F>
  void loop_all(const array<int, dim> &indextype, const F &f) const {
    // typedef void (GridDescBase::*funptr)(const F &f) const;
    // constexpr array<funptr, 8> funptrs{
    //     &GridDescBase::loop_all<0, 0, 0, F>,
    //     &GridDescBase::loop_all<1, 0, 0, F>,
    //     &GridDescBase::loop_all<0, 1, 0, F>,
    //     &GridDescBase::loop_all<1, 1, 0, F>,
    //     &GridDescBase::loop_all<0, 0, 1, F>,
    //     &GridDescBase::loop_all<1, 0, 1, F>,
    //     &GridDescBase::loop_all<0, 1, 1, F>,
    //     &GridDescBase::loop_all<1, 1, 1, F>,
    // };
    // return (this->*funptrs[indextype[0] + 2 * indextype[1] + 4 *
    // indextype[2]])(
    //     f);
    switch (indextype[0] + 2 * indextype[1] + 4 * indextype[2]) {
    case 0b000:
      return loop_all<0, 0, 0>(f);
    case 0b001:
      return loop_all<1, 0, 0>(f);
    case 0b010:
      return loop_all<0, 1, 0>(f);
    case 0b011:
      return loop_all<1, 1, 0>(f);
    case 0b100:
      return loop_all<0, 0, 1>(f);
    case 0b101:
      return loop_all<1, 0, 1>(f);
    case 0b110:
      return loop_all<0, 1, 1>(f);
    case 0b111:
      return loop_all<1, 1, 1>(f);
    default:
      assert(0);
    }
  }
  template <typename F>
  void loop_int(const array<int, dim> &indextype, const F &f) const {
    switch (indextype[0] + 2 * indextype[1] + 4 * indextype[2]) {
    case 0b000:
      return loop_int<0, 0, 0>(f);
    case 0b001:
      return loop_int<1, 0, 0>(f);
    case 0b010:
      return loop_int<0, 1, 0>(f);
    case 0b011:
      return loop_int<1, 1, 0>(f);
    case 0b100:
      return loop_int<0, 0, 1>(f);
    case 0b101:
      return loop_int<1, 0, 1>(f);
    case 0b110:
      return loop_int<0, 1, 1>(f);
    case 0b111:
      return loop_int<1, 1, 1>(f);
    default:
      assert(0);
    }
  }
  template <typename F>
  void loop_bnd(const array<int, dim> &indextype, const F &f) const {
    switch (indextype[0] + 2 * indextype[1] + 4 * indextype[2]) {
    case 0b000:
      return loop_bnd<0, 0, 0>(f);
    case 0b001:
      return loop_bnd<1, 0, 0>(f);
    case 0b010:
      return loop_bnd<0, 1, 0>(f);
    case 0b011:
      return loop_bnd<1, 1, 0>(f);
    case 0b100:
      return loop_bnd<0, 0, 1>(f);
    case 0b101:
      return loop_bnd<1, 0, 1>(f);
    case 0b110:
      return loop_bnd<0, 1, 1>(f);
    case 0b111:
      return loop_bnd<1, 1, 1>(f);
    default:
      assert(0);

Replacement in AMReX/src/loop.hxx at line 292 [6.5481]

B:BD[6.9143] → [6.9143:9248]

template <typename F> void loop_all(const cGH *cctkGH, const F &f) {
  GridDescBase(cctkGH).loop_all(f);

[6.9143]

[6.9248]

template <int CI, int CJ, int CK, typename F>
void loop_all(const cGH *cctkGH, const F &f) {
  GridDescBase(cctkGH).loop_all<CI, CJ, CK>(f);
}
template <int CI, int CJ, int CK, typename F>
void loop_int(const cGH *cctkGH, const F &f) {
  GridDescBase(cctkGH).loop_int<CI, CJ, CK>(f);

Replacement in AMReX/src/loop.hxx at line 302 [6.5481]

B:BD[6.9251] → [6.9251:9356]

template <typename F> void loop_int(const cGH *cctkGH, const F &f) {
  GridDescBase(cctkGH).loop_int(f);

[6.9251]

[6.9356]

template <int CI, int CJ, int CK, typename F>
void loop_bnd(const cGH *cctkGH, const F &f) {
  GridDescBase(cctkGH).loop_bnd<CI, CJ, CK>(f);

Replacement in AMReX/src/loop.hxx at line 307 [6.5481]

B:BD[6.9359] → [6.9359:9464]

template <typename F> void loop_bnd(const cGH *cctkGH, const F &f) {
  GridDescBase(cctkGH).loop_bnd(f);

[6.9359]

[6.9464]

template <typename F>
void loop_all(const cGH *cctkGH, const array<int, dim> &indextype, const F &f) {
  GridDescBase(cctkGH).loop_all(indextype, f);

Insertion in AMReX/src/loop.hxx at line 312 [6.5481]

[6.9467]

template <typename F>
void loop_int(const cGH *cctkGH, const array<int, dim> &indextype, const F &f) {
  GridDescBase(cctkGH).loop_int(indextype, f);
}
template <typename F>
void loop_bnd(const cGH *cctkGH, const array<int, dim> &indextype, const F &f) {
  GridDescBase(cctkGH).loop_bnd(indextype, f);
}

Replacement in AMReX/src/reduction.cxx at line 14 [17.870]

B:BD[17.1208] → [7.8425:8496]

B:BD[7.8496] → [6.9588:9638]

reduction<T> reduce_array(const Geometry &geom, const T *restrict ptr,
                          const GridDesc &grid) {

[17.1208]

[18.4011]

reduction<T> reduce_array(const Geometry &geom,
                          const GHExt::LevelData::GroupData &groupdata,
                          const T *restrict ptr, const GridDesc &grid) {

Replacement in AMReX/src/reduction.cxx at line 23 [17.870]

B:BD[17.1355] → [6.9641:9750]

  grid.loop_int([&](int i, int j, int k, int idx) {
    red = reduction<T>(red, reduction<T>(dV, ptr[idx]));

[17.1355]

[6.9750]

  grid.loop_int(groupdata.indextype, [&](const Loop::PointDesc &p) {
    red = reduction<T>(red, reduction<T>(dV, ptr[p.idx]));

Deletion in AMReX/src/reduction.cxx at line 39 [17.870]
B:BD[17.1960] → [17.1960:2007]
```
      MultiFab &mfab = *groupdata.mfab.at(tl);
```

Replacement in AMReX/src/reduction.cxx at line 41 [17.870]

∅:D[7.8716] → [17.2100:2163]

B:BD[17.2100] → [17.2100:2163]

      for (MFIter mfi(mfab, mfitinfo); mfi.isValid(); ++mfi) {

[7.8716]

[6.9758]

      for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {

Replacement in AMReX/src/reduction.cxx at line 48 [17.870]

B:BD[7.8905] → [6.9862:9908]

        red += reduce_array(geom, ptr, grid);

[7.8905]

[17.2705]

        red += reduce_array(geom, groupdata, ptr, grid);

Replacement in AMReX/src/schedule.cxx at line 44 [4.531]
B:BD[6.10669] → [6.10669:10711]
```
  int tile_min[dim];
  int tile_max[dim];
```
[6.10669]
[6.10711]
```
  array<int, dim> tile_min;
  array<int, dim> tile_max;
```
Insertion in AMReX/src/schedule.cxx at line 63 [4.531]
[6.10813]
[6.10813]

Replacement in AMReX/src/schedule.cxx at line 86 [4.531]

B:BD[6.11545] → [6.11545:11705]

  const cGH *restrict threadGH = &AMReX::thread_local_cctkGH.at(thread_num);
  // Check whether this is the correct cGH structure
  assert(cctkGH == threadGH);

[6.11545]

[6.11705]

  if (omp_in_parallel()) {
    const cGH *restrict threadGH = &AMReX::thread_local_cctkGH.at(thread_num);
    // Check whether this is the correct cGH structure
    assert(cctkGH == threadGH);
  }

Insertion in AMReX/src/schedule.cxx at line 98 [4.531]

[6.11907]


  for (int d = 0; d < dim; ++d) {
    dx[d] = cctkGH->cctk_delta_space[d] / cctkGH->cctk_levfac[d];
    x0[d] = cctkGH->cctk_origin_space[d] +
            dx[d] * cctkGH->cctk_levoff[d] / cctkGH->cctk_levoffdenom[d];
  }

Insertion in AMReX/src/schedule.cxx at line 105 [4.531]
[6.11909]
[6.11909]

Replacement in AMReX/src/schedule.cxx at line 123 [4.531]

B:BD[6.12570] → [6.12570:12648]

        domain[orient(d, 1)] - domain[orient(d, 0)] + 1 + 2 * nghostzones[d];

[6.12570]

[6.12648]

        domain[orient(d, 1)] + 1 - domain[orient(d, 0)] + 2 * nghostzones[d];

Insertion in AMReX/src/schedule.cxx at line 150 [4.531]

[6.13340]

  const Geometry &geom = ghext->amrcore->Geom(0);
  const CCTK_REAL *restrict const global_x0 = geom.ProbLo();
  const CCTK_REAL *restrict const global_dx = geom.CellSize();
  for (int d = 0; d < dim; ++d) {
    const int levfac = 1 << leveldata.level;
    const int levoff = 1 - 2 * nghostzones[d];
    const int levoffdenom = 2;
    const CCTK_REAL origin_space = global_x0[d];
    const CCTK_REAL delta_space = global_dx[d];
    dx[d] = delta_space / levfac;
    x0[d] = origin_space + dx[d] * levoff / levoffdenom;
  }

Insertion in AMReX/src/schedule.cxx at line 194 [4.531]

[6.14085]


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

Insertion in AMReX/src/schedule.cxx at line 352 [4.531]
[17.4374]
[6.14892]
```
#warning "TODO: IndexType"
```

Replacement in AMReX/src/schedule.cxx at line 416 [4.531]

B:BD[6.16359] → [6.16359:16512]

  const cGH *restrict threadGH = &thread_local_cctkGH.at(thread_num);
  // Check whether this is the correct cGH structure
  assert(cctkGH == threadGH);

[6.16359]

[4.4061]

  if (omp_in_parallel()) {
    const cGH *restrict threadGH = &thread_local_cctkGH.at(thread_num);
    // Check whether this is the correct cGH structure
    assert(cctkGH == threadGH);
  }

Deletion in AMReX/src/schedule.cxx at line 719 [4.531]
∅:D[5.6162] → [19.2828:2892]
∅:D[6.17374] → [19.2828:2892]
B:BD[19.2828] → [19.2828:2892]
```
        MultiFab &mfab = *leveldata.groupdata.at(0).mfab.at(0);
```

Replacement in AMReX/src/schedule.cxx at line 722 [4.531]

∅:D[7.10768] → [11.3713:3778]

B:BD[11.3713] → [11.3713:3778]

        for (MFIter mfi(mfab, mfitinfo); mfi.isValid(); ++mfi) {

[7.10768]

[6.17375]

        for (MFIter mfi(*leveldata.mfab0, mfitinfo); mfi.isValid(); ++mfi) {

Deletion in HydroToyAMReX/src/hydrotoy.cxx at line 24 [2.6253]

B:BD[2.6748] → [2.6748:6883]

  CCTK_REAL x0[dim], dx[dim];
  for (int d = 0; d < dim; ++d) {
    x0[d] = CCTK_ORIGIN_SPACE(d);
    dx[d] = CCTK_DELTA_SPACE(d);
  }

Replacement in HydroToyAMReX/src/hydrotoy.cxx at line 25 [2.6253]

B:BD[2.6884] → [2.6884:7049]

  Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
    rho[idx] = 1.0;
    momx[idx] = 0.0;
    momy[idx] = 0.0;
    momz[idx] = 0.0;
    etot[idx] = 1.0;

[2.6884]

[2.7049]

  Loop::loop_all<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    rho[p.idx] = 1.0;
    momx[p.idx] = 0.0;
    momy[p.idx] = 0.0;
    momz[p.idx] = 0.0;
    etot[p.idx] = 1.0;

Deletion in HydroToyAMReX/src/hydrotoy.cxx at line 39 [2.6253]

B:BD[2.7207] → [2.7207:7339]

  const CCTK_REAL dx = CCTK_DELTA_SPACE(0);
  const CCTK_REAL dy = CCTK_DELTA_SPACE(1);
  const CCTK_REAL dz = CCTK_DELTA_SPACE(2);

Replacement in HydroToyAMReX/src/hydrotoy.cxx at line 44 [2.6253]

B:BD[2.7435] → [2.7435:7496]

  Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {

[2.7435]

[2.7496]

  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {

Replacement in HydroToyAMReX/src/hydrotoy.cxx at line 46 [2.6253]

B:BD[2.7532] → [2.7532:7754]

    rho[idx] = rho_p[idx] - dt * ((momx_p[idx + di] - momx_p[idx]) / dx +
                                  (momy_p[idx + dj] - momy_p[idx]) / dy +
                                  (momz_p[idx + dk] - momz_p[idx]) / dz);

[2.7532]

[2.7754]

    rho[p.idx] =
        rho_p[p.idx] - dt * ((momx_p[p.idx + di] - momx_p[p.idx]) / p.dx +
                             (momy_p[p.idx + dj] - momy_p[p.idx]) / p.dy +
                             (momz_p[p.idx + dk] - momz_p[p.idx]) / p.dz);

Replacement in HydroToyAMReX/src/hydrotoy.cxx at line 52 [2.6253]

B:BD[2.7802] → [2.7802:7879]

    //     momx[idx] = momx_p[idx] - dt * (
    // momx_p[idx] * momx_p[idx]

[2.7802]

[2.7879]

    //     momx[p.idx] = momx_p[p.idx] - dt * (
    // momx_p[p.idx] * momx_p[p.idx]

Replacement in HydroToyAMReX/src/hydrotoy.cxx at line 56 [2.6253]

B:BD[2.7926] → [2.7926:8055]

    CCTK_REAL velx = momx[idx] / rho[idx];
    CCTK_REAL vely = momy[idx] / rho[idx];
    CCTK_REAL velz = momz[idx] / rho[idx];

[2.7926]

[2.8055]

    CCTK_REAL velx = momx[p.idx] / rho[p.idx];
    CCTK_REAL vely = momy[p.idx] / rho[p.idx];
    CCTK_REAL velz = momz[p.idx] / rho[p.idx];

Replacement in MaxwellToyAMReX/interface.ccl at line 15 [2.13068]

B:BD[2.13268] → [2.13268:13388]

CCTK_REAL potential TYPE=gf TIMELEVELS=2
{
  # d*dA = mu J   A^a,^b_b - A^b,^a_b = mu J^a
  # d*A  = 0      A^a,a   = 0

[2.13268]

[2.13388]

# d*dA = mu J   A^a,^b_b - A^b,^a_b = mu J^a
# d*A  = 0      A^a,a   = 0
# -d*(dphi + A,t)      = rho/epsilon
# d*dA + dt*(dphi+A,t) = mu J
# *phi,t + d*A         = 0             phi,t + A^i,i = 0
# F   = dA     F_ab                     = A_a,b - A_b,a
# dF  = 0      F_ab,c + F_bc,a + F_ca,b = 0
# d*F = mu J   F^ab,a                   = mu J^b

Replacement in MaxwellToyAMReX/interface.ccl at line 26 [2.13068]

B:BD[2.13389] → [2.13389:13519]

  # -d*(dphi + A,t)      = rho/epsilon
  # d*dA + dt*(dphi+A,t) = mu J
  # *phi,t + d*A         = 0             phi,t + A^i,i = 0

[2.13389]

[2.13519]

# E          = -dphi - A,t   E_i                     = - phi,i - A_i,t
# B          = dA            B_ij                    = A_j,i - A_i,j
# dE + B,t   = 0             E_j,i - E_i,j + B_ij,t  = 0
# dB         = 0             B_jk,i + B_ki,j + B_ijk = 0
# d*E        = rho/epsilon   E^i,i                   = rho/epsilon
# d*B - dt*E = mu J          - B^ij,i - E^j,t        = mu J^j
# CCTK_REAL potential TYPE=gf TIMELEVELS=2a
# {
#   phi
#   ax ay az
# } "Electromagnetic potential"
# 
# CCTK_REAL field TYPE=gf TIMELEVELS=2
# {
#   ex ey ez
#   bx by bz   # B_yz B_zx B_xy
# } "Electromagnetic field"
# 
# CCTK_REAL current TYPE=gf TIMELEVELS=2
# {
#   rho
#   jx jy jz
# } "Electric charge current"
# 
# CCTK_REAL errors TYPE=gf
# {
#   phierr
#   axerr ayerr azerr
#   exerr eyerr ezerr
#   bxerr byerr bzerr
#   rhoerr
#   jxerr jyerr jzerr
# } "Errors"

Insertion in MaxwellToyAMReX/interface.ccl at line 63 [2.13068]
[2.13520]
[2.13520]
```
CCTK_REAL potential_phi TYPE=gf TIMELEVELS=2 TAGS='index={0 0 0}'
{
```
Deletion in MaxwellToyAMReX/interface.ccl at line 66 [2.13068]
B:BD[2.13526] → [2.13526:13537]
```
  ax ay az
```

Replacement in MaxwellToyAMReX/interface.ccl at line 68 [2.13068]

B:BD[2.13568] → [2.13568:13605]

CCTK_REAL field TYPE=gf TIMELEVELS=2

[2.13568]

[2.13605]

CCTK_REAL potential_ax TYPE=gf TIMELEVELS=2 TAGS='index={1 0 0}'
{
  ax
} "Electromagnetic potential"
CCTK_REAL potential_ay TYPE=gf TIMELEVELS=2 TAGS='index={0 1 0}'
{
  ay
} "Electromagnetic potential"
CCTK_REAL potential_az TYPE=gf TIMELEVELS=2 TAGS='index={0 0 1}'

Replacement in MaxwellToyAMReX/interface.ccl at line 78 [2.13068]

B:BD[2.13607] → [2.13607:13762]

  # F   = dA     F_ab                     = A_a,b - A_b,a
  # dF  = 0      F_ab,c + F_bc,a + F_ca,b = 0
  # d*F = mu J   F^ab,a                   = mu J^b

[2.13607]

[2.13762]

  az
} "Electromagnetic potential"

Replacement in MaxwellToyAMReX/interface.ccl at line 81 [2.13068]

B:BD[2.13763] → [2.13763:14158]

  # E          = -dphi - A,t   E_i                     = - phi,i - A_i,t
  # B          = dA            B_ij                    = A_j,i - A_i,j
  # dE + B,t   = 0             E_j,i - E_i,j + B_ij,t  = 0
  # dB         = 0             B_jk,i + B_ki,j + B_ijk = 0
  # d*E        = rho/epsilon   E^i,i                   = rho/epsilon
  # d*B - dt*E = mu J          - B^ij,i - E^j,t        = mu J^j

[2.13763]

[2.14158]

CCTK_REAL field_ex TYPE=gf TIMELEVELS=2 TAGS='index={1 0 0}'
{
  ex
} "Electromagnetic field"
CCTK_REAL field_ey TYPE=gf TIMELEVELS=2 TAGS='index={0 1 0}'
{
  ey
} "Electromagnetic field"
CCTK_REAL field_ez TYPE=gf TIMELEVELS=2 TAGS='index={0 0 1}'
{
  ez
} "Electromagnetic field"

Replacement in MaxwellToyAMReX/interface.ccl at line 94 [2.13068]

B:BD[2.14159] → [2.14159:14200]

  ex ey ez
  bx by bz   # B_yz B_zx B_xy

[2.14159]

[2.14200]

CCTK_REAL field_bx TYPE=gf TIMELEVELS=2 TAGS='index={0 1 1}'
{
  bx
} "Electromagnetic field"
CCTK_REAL field_by TYPE=gf TIMELEVELS=2 TAGS='index={1 0 1}'
{
  by
} "Electromagnetic field"
CCTK_REAL field_bz TYPE=gf TIMELEVELS=2 TAGS='index={1 1 0}'
{
  bz

Replacement in MaxwellToyAMReX/interface.ccl at line 107 [2.13068]
B:BD[2.14227] → [2.14227:14266]
```
CCTK_REAL current TYPE=gf TIMELEVELS=2
```
[2.14227]
[2.14266]
```
CCTK_REAL current_rho TYPE=gf TIMELEVELS=2 TAGS='index={0 0 0}'
```
Deletion in MaxwellToyAMReX/interface.ccl at line 110 [2.13068]
B:BD[2.14274] → [2.14274:14285]
```
  jx jy jz
```

Replacement in MaxwellToyAMReX/interface.ccl at line 112 [2.13068]

B:BD[2.14314] → [2.14314:14339]

CCTK_REAL errors TYPE=gf

[2.14314]

[2.14339]

CCTK_REAL current_jx TYPE=gf TIMELEVELS=2 TAGS='index={1 0 0}'
{
  jx
} "Electric charge current"
CCTK_REAL current_jy TYPE=gf TIMELEVELS=2 TAGS='index={0 1 0}'
{
  jy
} "Electric charge current"
CCTK_REAL current_jz TYPE=gf TIMELEVELS=2 TAGS='index={0 0 1}'
{
  jz
} "Electric charge current"
CCTK_REAL errors_potential_phi TYPE=gf TAGS='index={0 0 0}'

Replacement in MaxwellToyAMReX/interface.ccl at line 130 [2.13068]

B:BD[2.14350] → [2.14350:14410]

  axerr ayerr azerr
  exerr eyerr ezerr
  bxerr byerr bzerr

[2.14350]

[2.14410]

} "Electromagnetic potential"
CCTK_REAL errors_potential_ax TYPE=gf TAGS='index={1 0 0}'
{
  axerr
} "Electromagnetic potential"
CCTK_REAL errors_potential_ay TYPE=gf TAGS='index={0 1 0}'
{
  ayerr
} "Electromagnetic potential"
CCTK_REAL errors_potential_az TYPE=gf TAGS='index={0 0 1}'
{
  azerr
} "Electromagnetic potential"
CCTK_REAL errors_field_ex TYPE=gf TAGS='index={1 0 0}'
{
  exerr
} "Electromagnetic field"
CCTK_REAL errors_field_ey TYPE=gf TAGS='index={0 1 0}'
{
  eyerr
} "Electromagnetic field"
CCTK_REAL errors_field_ez TYPE=gf TAGS='index={0 0 1}'
{
  ezerr
} "Electromagnetic field"
CCTK_REAL errors_field_bx TYPE=gf TAGS='index={0 1 1}'
{
  bxerr
} "Electromagnetic field"
CCTK_REAL errors_field_by TYPE=gf TAGS='index={1 0 1}'
{
  byerr
} "Electromagnetic field"
CCTK_REAL errors_field_bz TYPE=gf TAGS='index={1 1 0}'
{
  bzerr
} "Electromagnetic field"
CCTK_REAL errors_current_rho TYPE=gf TAGS='index={0 0 0}'
{

Replacement in MaxwellToyAMReX/interface.ccl at line 174 [2.13068]

B:BD[2.14419] → [2.14419:14450]

  jxerr jyerr jzerr
} "Errors"

[2.14419]

[2.14450]

} "Electric charge current"
CCTK_REAL errors_current_jx TYPE=gf TAGS='index={1 0 0}'
{
  jxerr
} "Electric charge current"
CCTK_REAL errors_current_jy TYPE=gf TAGS='index={0 1 0}'
{
  jyerr
} "Electric charge current"
CCTK_REAL errors_current_jz TYPE=gf TAGS='index={0 0 1}'
{
  jzerr
} "Electric charge current"

Replacement in MaxwellToyAMReX/schedule.ccl at line 19 [2.15053]

B:BD[2.15402] → [2.15402:15434]

  SYNC: potential field current

[2.15402]

[2.15434]

  SYNC: potential_ax potential_ay potential_az
  SYNC: field_bx field_by field_bz
  SYNC: current_jx current_jy current_jz

Replacement in MaxwellToyAMReX/schedule.ccl at line 27 [2.15053]
B:BD[2.15559] → [2.15559:15591]
```
  SYNC: potential field current
```
[2.15559]
[2.15591]
```
  SYNC: potential_phi
  SYNC: field_ex field_ey field_ez
  SYNC: current_rho
```
Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 9 [2.16301]
[2.16435]
[2.16435]
```
#include <functional>
#include <initializer_list>
```

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 22 [2.16301]

B:BD[2.16674] → [2.16674:16724]

  potential operator-(const potential &y) const {

[2.16674]

[2.16724]


  static potential pure(T a) { return {.phi = a, .ax = a, .ay = a, .az = a}; }
  template <typename F> potential map1(const F &f) const {

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 26 [2.16301]

B:BD[2.16751] → [2.16751:16879]

    return {.phi = x.phi - y.phi,
            .ax = x.ax - y.ax,
            .ay = x.ay - y.ay,
            .az = x.az - y.az};

[2.16751]

[2.16879]

    return {.phi = f(x.phi), .ax = f(x.ax), .ay = f(x.ay), .az = f(x.az)};

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 28 [2.16301]
B:BD[2.16883] → [2.16883:16918]
```
  potential operator/(T a) const {
```
[2.16883]
[2.16918]
```
  template <typename F> potential map2(const F &f, const potential &y) const {
```

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 30 [2.16301]

B:BD[2.16945] → [2.16945:17024]

    return {.phi = x.phi / a, .ax = x.ax / a, .ay = x.ay / a, .az = x.az / a};

[2.16945]

[2.17024]

    return {.phi = f(x.phi, y.phi),
            .ax = f(x.ax, y.ax),
            .ay = f(x.ay, y.ay),
            .az = f(x.az, y.az)};
  }
  potential operator+() const { return *this; }
  potential operator-() const { return map1(std::negate<T>()); }
  potential operator+(const potential &y) const {
    return map2(std::plus<T>(), y);
  }
  potential operator-(const potential &y) const {
    return map2(std::minus<T>(), y);
  }
  potential operator*(const potential &y) const {
    return map2(std::multiplies<T>(), y);
  }
  potential operator/(const potential &y) const {
    return map2(std::divides<T>(), y);

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 50 [2.16301]

[2.17028]

  potential operator+(T a) const { return *this + pure(a); }
  potential operator-(T a) const { return *this - pure(a); }
  potential operator*(T a) const { return *this * pure(a); }
  potential operator/(T a) const { return *this / pure(a); }

Deletion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 99 [2.16301]

B:BD[2.18560] → [2.18560:18695]

  const CCTK_REAL x0 = CCTK_ORIGIN_SPACE(0);
  const CCTK_REAL y0 = CCTK_ORIGIN_SPACE(1);
  const CCTK_REAL z0 = CCTK_ORIGIN_SPACE(2);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 100 [2.16301]

B:BD[2.18735] → [2.18735:18867]

  const CCTK_REAL dx = CCTK_DELTA_SPACE(0);
  const CCTK_REAL dy = CCTK_DELTA_SPACE(1);
  const CCTK_REAL dz = CCTK_DELTA_SPACE(2);

[2.18735]

[2.18867]


  const Loop::GF3D<CCTK_REAL, 0, 0, 0> phi_(cctkGH, phi);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> ax_(cctkGH, ax);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> ay_(cctkGH, ay);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> az_(cctkGH, az);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> ex_(cctkGH, ex);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> ey_(cctkGH, ey);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> ez_(cctkGH, ez);
  const Loop::GF3D<CCTK_REAL, 0, 1, 1> bx_(cctkGH, bx);
  const Loop::GF3D<CCTK_REAL, 1, 0, 1> by_(cctkGH, by);
  const Loop::GF3D<CCTK_REAL, 1, 1, 0> bz_(cctkGH, bz);
  const Loop::GF3D<CCTK_REAL, 0, 0, 0> rho_(cctkGH, rho);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> jx_(cctkGH, jx);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> jy_(cctkGH, jy);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> jz_(cctkGH, jz);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 123 [2.16301]

B:BD[2.18923] → [2.18923:19136]

    Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0 + (cctk_lbnd[0] + i) * dx;
      CCTK_REAL y = y0 + (cctk_lbnd[1] + j) * dy;
      CCTK_REAL z = z0 + (cctk_lbnd[2] + k) * dz;

[2.18923]

[2.19136]

    Loop::loop_all<0, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      phi_(p.i, p.j, p.k) = plane_wave(t + dt / 2, p.x, p.y, p.z).phi;
    });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 127 [2.16301]

B:BD[2.19137] → [2.19137:19347]

      phi[idx] = plane_wave(t + dt / 2, x, y, z).phi;
      ax[idx] = plane_wave(t, x + dx / 2, y, z).ax;
      ay[idx] = plane_wave(t, x, y + dy / 2, z).ay;
      az[idx] = plane_wave(t, x, y, z + dz / 2).az;

[2.19137]

[2.19347]

    Loop::loop_all<1, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      ax_(p.i, p.j, p.k) = plane_wave(t, p.x, p.y, p.z).ax;
    });
    Loop::loop_all<0, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      ay_(p.i, p.j, p.k) = plane_wave(t, p.x, p.y, p.z).ay;
    });
    Loop::loop_all<0, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      az_(p.i, p.j, p.k) = plane_wave(t, p.x, p.y, p.z).az;
    });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 137 [2.16301]

B:BD[2.19348] → [2.19348:20392]

      ex[idx] =
          -xderiv(plane_wave<CCTK_REAL>, dx)(t + dt / 2, x + dx / 2, y, z).phi -
          tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, x + dx / 2, y, z).ax;
      ey[idx] =
          -yderiv(plane_wave<CCTK_REAL>, dy)(t + dt / 2, x, y + dy / 2, z).phi -
          tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, x, y + dy / 2, z).ay;
      ez[idx] =
          -zderiv(plane_wave<CCTK_REAL>, dz)(t + dt / 2, x, y, z + dz / 2).phi -
          tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, x, y, z + dz / 2).az;
      bx[idx] =
          yderiv(plane_wave<CCTK_REAL>, dy)(t, x, y + dy / 2, z + dz / 2).az -
          zderiv(plane_wave<CCTK_REAL>, dz)(t, x, y + dy / 2, z + dz / 2).ay;
      by[idx] =
          zderiv(plane_wave<CCTK_REAL>, dz)(t, x + dx / 2, y, z + dz / 2).ax -
          xderiv(plane_wave<CCTK_REAL>, dx)(t, x + dx / 2, y, z + dz / 2).az;
      bz[idx] =
          xderiv(plane_wave<CCTK_REAL>, dx)(t, x, y + dy / 2, z + dz / 2).ay -
          yderiv(plane_wave<CCTK_REAL>, dy)(t, x, y + dy / 2, z + dz / 2).ax;

[2.19348]

[2.20392]

    Loop::loop_all<1, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      ex_(p.i, p.j, p.k) =
          -xderiv(plane_wave<CCTK_REAL>, p.dx)(t + dt / 2, p.x, p.y, p.z).phi -
          tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, p.x, p.y, p.z).ax;
    });
    Loop::loop_all<0, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      ey_(p.i, p.j, p.k) =
          -yderiv(plane_wave<CCTK_REAL>, p.dy)(t + dt / 2, p.x, p.y, p.z).phi -
          tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, p.x, p.y, p.z).ay;
    });
    Loop::loop_all<0, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      ez_(p.i, p.j, p.k) =
          -zderiv(plane_wave<CCTK_REAL>, p.dz)(t + dt / 2, p.x, p.y, p.z).phi -
          tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, p.x, p.y, p.z).az;
    });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 153 [2.16301]

B:BD[2.20393] → [2.20393:20478]

      rho[idx] = 0.0;
      jx[idx] = 0.0;
      jy[idx] = 0.0;
      jz[idx] = 0.0;

[2.20393]

[2.20478]

    Loop::loop_all<0, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      bx_(p.i, p.j, p.k) =
          yderiv(plane_wave<CCTK_REAL>, p.dy)(t, p.x, p.y, p.z).az -
          zderiv(plane_wave<CCTK_REAL>, p.dz)(t, p.x, p.y, p.z).ay;
    });
    Loop::loop_all<1, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      by_(p.i, p.j, p.k) =
          zderiv(plane_wave<CCTK_REAL>, p.dz)(t, p.x, p.y, p.z).ax -
          xderiv(plane_wave<CCTK_REAL>, p.dx)(t, p.x, p.y, p.z).az;
    });
    Loop::loop_all<1, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      bz_(p.i, p.j, p.k) =
          xderiv(plane_wave<CCTK_REAL>, p.dx)(t, p.x, p.y, p.z).ay -
          yderiv(plane_wave<CCTK_REAL>, p.dy)(t, p.x, p.y, p.z).ax;

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 168 [2.16301]

[2.20486]


    Loop::loop_all<0, 0, 0>(
        cctkGH, [&](const Loop::PointDesc &p) { rho_(p.i, p.j, p.k) = 0.0; });

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 172 [2.16301]

[2.20487]

    Loop::loop_all<1, 0, 0>(
        cctkGH, [&](const Loop::PointDesc &p) { jx_(p.i, p.j, p.k) = 0.0; });
    Loop::loop_all<0, 1, 0>(
        cctkGH, [&](const Loop::PointDesc &p) { jy_(p.i, p.j, p.k) = 0.0; });
    Loop::loop_all<0, 0, 1>(
        cctkGH, [&](const Loop::PointDesc &p) { jz_(p.i, p.j, p.k) = 0.0; });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 189 [2.16301]

B:BD[2.20672] → [2.20672:20804]

  const CCTK_REAL dx = CCTK_DELTA_SPACE(0);
  const CCTK_REAL dy = CCTK_DELTA_SPACE(1);
  const CCTK_REAL dz = CCTK_DELTA_SPACE(2);

[2.20672]

[2.20804]


  const Loop::GF3D<const CCTK_REAL, 0, 0, 0> phi_p_(cctkGH, phi_p);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 192 [2.16301]

B:BD[2.20805] → [2.20805:20899]

  constexpr int di = 1;
  const int dj = di * cctk_ash[0];
  const int dk = dj * cctk_ash[1];

[2.20805]

[2.20899]

  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> ax_p_(cctkGH, ax_p);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> ay_p_(cctkGH, ay_p);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> az_p_(cctkGH, az_p);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 196 [2.16301]

B:BD[2.20900] → [2.20900:21036]

  Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
    jx[idx] = jx_p[idx];
    jy[idx] = jy_p[idx];
    jz[idx] = jz_p[idx];

[2.20900]

[2.21036]

  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> ex_p_(cctkGH, ex_p);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> ey_p_(cctkGH, ey_p);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> ez_p_(cctkGH, ez_p);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 200 [2.16301]

B:BD[2.21037] → [2.21037:21445]

    bx[idx] = bx_p[idx] + dt * ((ey_p[idx + dk] - ey_p[idx]) / dz -
                                (ez_p[idx + dj] - ez_p[idx]) / dy);
    by[idx] = by_p[idx] + dt * ((ez_p[idx + di] - ez_p[idx]) / dx -
                                (ex_p[idx + dk] - ex_p[idx]) / dz);
    bz[idx] = bz_p[idx] + dt * ((ex_p[idx + dj] - ex_p[idx]) / dy -
                                (ey_p[idx + di] - ey_p[idx]) / dx);

[2.21037]

[2.21445]

  const Loop::GF3D<const CCTK_REAL, 0, 1, 1> bx_p_(cctkGH, bx_p);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 1> by_p_(cctkGH, by_p);
  const Loop::GF3D<const CCTK_REAL, 1, 1, 0> bz_p_(cctkGH, bz_p);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 204 [2.16301]

B:BD[2.21446] → [2.21446:21716]

    ax[idx] =
        ax_p[idx] - dt * ((phi_p[idx + di] - phi_p[idx]) / dx + ex_p[idx]);
    ay[idx] =
        ay_p[idx] - dt * ((phi_p[idx + dj] - phi_p[idx]) / dy + ey_p[idx]);
    az[idx] =
        az_p[idx] - dt * ((phi_p[idx + dk] - phi_p[idx]) / dz + ez_p[idx]);

[2.21446]

[2.21716]

  const Loop::GF3D<const CCTK_REAL, 0, 0, 0> rho_p_(cctkGH, rho_p);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> jx_p_(cctkGH, jx_p);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> jy_p_(cctkGH, jy_p);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> jz_p_(cctkGH, jz_p);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> ax_(cctkGH, ax);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> ay_(cctkGH, ay);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> az_(cctkGH, az);
  const Loop::GF3D<CCTK_REAL, 0, 1, 1> bx_(cctkGH, bx);
  const Loop::GF3D<CCTK_REAL, 1, 0, 1> by_(cctkGH, by);
  const Loop::GF3D<CCTK_REAL, 1, 1, 0> bz_(cctkGH, bz);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> jx_(cctkGH, jx);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> jy_(cctkGH, jy);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> jz_(cctkGH, jz);
  Loop::loop_int<1, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    jx_(p.i, p.j, p.k) = jx_p_(p.i, p.j, p.k);
  });
  Loop::loop_int<0, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    jy_(p.i, p.j, p.k) = jy_p_(p.i, p.j, p.k);
  });
  Loop::loop_int<0, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    jz_(p.i, p.j, p.k) = jz_p_(p.i, p.j, p.k);
  });
  Loop::loop_int<0, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    bx_(p.i, p.j, p.k) =
        bx_p_(p.i, p.j, p.k) +
        dt * ((ey_p_(p.i, p.j, p.k + 1) - ey_p_(p.i, p.j, p.k)) / p.dz -
              (ez_p_(p.i, p.j + 1, p.k) - ez_p_(p.i, p.j, p.k)) / p.dy);
  });
  Loop::loop_int<1, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    by_(p.i, p.j, p.k) =
        by_p_(p.i, p.j, p.k) +
        dt * ((ez_p_(p.i + 1, p.j, p.k) - ez_p_(p.i, p.j, p.k)) / p.dx -
              (ex_p_(p.i, p.j, p.k + 1) - ex_p_(p.i, p.j, p.k)) / p.dz);
  });
  Loop::loop_int<1, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    bz_(p.i, p.j, p.k) =
        bz_p_(p.i, p.j, p.k) +
        dt * ((ex_p_(p.i, p.j + 1, p.k) - ex_p_(p.i, p.j, p.k)) / p.dy -
              (ey_p_(p.i + 1, p.j, p.k) - ey_p_(p.i, p.j, p.k)) / p.dx);
  });
  Loop::loop_int<1, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    ax_(p.i, p.j, p.k) =
        ax_p_(p.i, p.j, p.k) -
        dt * ((phi_p_(p.i + 1, p.j, p.k) - phi_p_(p.i, p.j, p.k)) / p.dx +
              ex_p_(p.i, p.j, p.k));
  });
  Loop::loop_int<0, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    ay_(p.i, p.j, p.k) =
        ay_p_(p.i, p.j, p.k) -
        dt * ((phi_p_(p.i, p.j + 1, p.k) - phi_p_(p.i, p.j, p.k)) / p.dy +
              ey_p_(p.i, p.j, p.k));
  });
  Loop::loop_int<0, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    az_(p.i, p.j, p.k) =
        az_p_(p.i, p.j, p.k) -
        dt * ((phi_p_(p.i, p.j, p.k + 1) - phi_p_(p.i, p.j, p.k)) / p.dz +
              ez_p_(p.i, p.j, p.k));

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 276 [2.16301]

B:BD[2.21877] → [2.21877:22009]

  const CCTK_REAL dx = CCTK_DELTA_SPACE(0);
  const CCTK_REAL dy = CCTK_DELTA_SPACE(1);
  const CCTK_REAL dz = CCTK_DELTA_SPACE(2);

[2.21877]

[2.22009]


  const Loop::GF3D<const CCTK_REAL, 0, 0, 0> phi_p_(cctkGH, phi_p);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> ex_p_(cctkGH, ex_p);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> ey_p_(cctkGH, ey_p);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> ez_p_(cctkGH, ez_p);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 0> rho_p_(cctkGH, rho_p);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> ax_(cctkGH, ax);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> ay_(cctkGH, ay);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> az_(cctkGH, az);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 289 [2.16301]

B:BD[2.22010] → [2.22010:22104]

  constexpr int di = 1;
  const int dj = di * cctk_ash[0];
  const int dk = dj * cctk_ash[1];

[2.22010]

[2.22104]

  const Loop::GF3D<const CCTK_REAL, 0, 1, 1> bx_(cctkGH, bx);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 1> by_(cctkGH, by);
  const Loop::GF3D<const CCTK_REAL, 1, 1, 0> bz_(cctkGH, bz);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> jx_(cctkGH, jx);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> jy_(cctkGH, jy);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> jz_(cctkGH, jz);
  const Loop::GF3D<CCTK_REAL, 0, 0, 0> phi_(cctkGH, phi);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> ex_(cctkGH, ex);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> ey_(cctkGH, ey);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> ez_(cctkGH, ez);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 303 [2.16301]

B:BD[2.22105] → [2.22105:22364]

  Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
    rho[idx] = rho_p[idx] - dt * ((jx[idx] - jx[idx - di]) / dx +
                                  (jy[idx] - jy[idx - dj]) / dy +
                                  (jz[idx] - jz[idx - dk]) / dz);

[2.22105]

[2.22364]

  const Loop::GF3D<CCTK_REAL, 0, 0, 0> rho_(cctkGH, rho);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 305 [2.16301]

B:BD[2.22365] → [2.22365:22779]

    ex[idx] = ex_p[idx] - dt * ((by[idx] - by[idx - dk]) / dz -
                                (bz[idx] - bz[idx - dj]) / dy + jx[idx]);
    ey[idx] = ey_p[idx] - dt * ((bz[idx] - bz[idx - di]) / dx -
                                (bx[idx] - bx[idx - dk]) / dz + jy[idx]);
    ez[idx] = ez_p[idx] - dt * ((bx[idx] - bx[idx - dj]) / dy -
                                (by[idx] - by[idx - di]) / dx + jz[idx]);

[2.22365]

[2.22779]

  Loop::loop_int<0, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    rho_(p.i, p.j, p.k) =
        rho_p_(p.i, p.j, p.k) -
        dt * ((jx_(p.i, p.j, p.k) - jx_(p.i - 1, p.j, p.k)) / p.dx +
              (jy_(p.i, p.j, p.k) - jy_(p.i, p.j - 1, p.k)) / p.dy +
              (jz_(p.i, p.j, p.k) - jz_(p.i, p.j, p.k - 1)) / p.dz);
  });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 313 [2.16301]

B:BD[2.22780] → [2.22780:22978]

    phi[idx] = phi_p[idx] - dt * ((ax[idx] - ax[idx - di]) / dx +
                                  (ay[idx] - ay[idx - dj]) / dy +
                                  (ay[idx] - az[idx - dk]) / dz);

[2.22780]

[2.22978]

  Loop::loop_int<1, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    ex_(p.i, p.j, p.k) =
        ex_p_(p.i, p.j, p.k) -
        dt * ((by_(p.i, p.j, p.k) - by_(p.i, p.j, p.k - 1)) / p.dz -
              (bz_(p.i, p.j, p.k) - bz_(p.i, p.j - 1, p.k)) / p.dy +
              jx_(p.i, p.j, p.k));
  });
  Loop::loop_int<0, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    ey_(p.i, p.j, p.k) =
        ey_p_(p.i, p.j, p.k) -
        dt * ((bz_(p.i, p.j, p.k) - bz_(p.i - 1, p.j, p.k)) / p.dx -
              (bx_(p.i, p.j, p.k) - bx_(p.i, p.j, p.k - 1)) / p.dz +
              jy_(p.i, p.j, p.k));
  });
  Loop::loop_int<0, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    ez_(p.i, p.j, p.k) =
        ez_p_(p.i, p.j, p.k) -
        dt * ((bx_(p.i, p.j, p.k) - bx_(p.i, p.j - 1, p.k)) / p.dy -
              (by_(p.i, p.j, p.k) - by_(p.i - 1, p.j, p.k)) / p.dx +
              jz_(p.i, p.j, p.k));

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 334 [2.16301]

[2.22984]


  Loop::loop_int<0, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    phi_(p.i, p.j, p.k) =
        phi_p_(p.i, p.j, p.k) -
        dt * ((ax_(p.i, p.j, p.k) - ax_(p.i - 1, p.j, p.k)) / p.dx +
              (ay_(p.i, p.j, p.k) - ay_(p.i, p.j - 1, p.k)) / p.dy +
              (ay_(p.i, p.j, p.k) - az_(p.i, p.j, p.k - 1)) / p.dz);
  });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 348 [2.16301]

B:BD[2.23105] → [2.23105:23210]

  Loop::loop_int(cctkGH,
                 [&](int i, int j, int k, int idx) { regrid_error[idx] = 0; });

[2.23105]

[2.23210]

  Loop::loop_int<1, 1, 1>(
      cctkGH, [&](const Loop::PointDesc &p) { regrid_error[p.idx] = 0; });

Deletion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 357 [2.16301]

B:BD[2.23356] → [2.23356:23491]

  const CCTK_REAL x0 = CCTK_ORIGIN_SPACE(0);
  const CCTK_REAL y0 = CCTK_ORIGIN_SPACE(1);
  const CCTK_REAL z0 = CCTK_ORIGIN_SPACE(2);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 358 [2.16301]

B:BD[2.23531] → [2.23531:23663]

  const CCTK_REAL dx = CCTK_DELTA_SPACE(0);
  const CCTK_REAL dy = CCTK_DELTA_SPACE(1);
  const CCTK_REAL dz = CCTK_DELTA_SPACE(2);

[2.23531]

[2.23663]


  const Loop::GF3D<CCTK_REAL, 0, 0, 0> phi_(cctkGH, phi);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> ax_(cctkGH, ax);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> ay_(cctkGH, ay);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> az_(cctkGH, az);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> ex_(cctkGH, ex);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> ey_(cctkGH, ey);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> ez_(cctkGH, ez);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 1> bx_(cctkGH, bx);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 1> by_(cctkGH, by);
  const Loop::GF3D<const CCTK_REAL, 1, 1, 0> bz_(cctkGH, bz);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 0> rho_(cctkGH, rho);
  const Loop::GF3D<const CCTK_REAL, 1, 0, 0> jx_(cctkGH, jx);
  const Loop::GF3D<const CCTK_REAL, 0, 1, 0> jy_(cctkGH, jy);
  const Loop::GF3D<const CCTK_REAL, 0, 0, 1> jz_(cctkGH, jz);
  const Loop::GF3D<CCTK_REAL, 0, 0, 0> phierr_(cctkGH, phierr);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> axerr_(cctkGH, axerr);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> ayerr_(cctkGH, ayerr);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> azerr_(cctkGH, azerr);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> exerr_(cctkGH, exerr);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> eyerr_(cctkGH, eyerr);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> ezerr_(cctkGH, ezerr);
  const Loop::GF3D<CCTK_REAL, 0, 1, 1> bxerr_(cctkGH, bxerr);
  const Loop::GF3D<CCTK_REAL, 1, 0, 1> byerr_(cctkGH, byerr);
  const Loop::GF3D<CCTK_REAL, 1, 1, 0> bzerr_(cctkGH, bzerr);
  const Loop::GF3D<CCTK_REAL, 0, 0, 0> rhoerr_(cctkGH, rhoerr);
  const Loop::GF3D<CCTK_REAL, 1, 0, 0> jxerr_(cctkGH, jxerr);
  const Loop::GF3D<CCTK_REAL, 0, 1, 0> jyerr_(cctkGH, jyerr);
  const Loop::GF3D<CCTK_REAL, 0, 0, 1> jzerr_(cctkGH, jzerr);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 401 [2.16301]

B:BD[2.23719] → [2.23719:23932]

    Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0 + (cctk_lbnd[0] + i) * dx;
      CCTK_REAL y = y0 + (cctk_lbnd[1] + j) * dy;
      CCTK_REAL z = z0 + (cctk_lbnd[2] + k) * dz;

[2.23719]

[2.23932]

    Loop::loop_all<0, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      phierr_(p.i, p.j, p.k) =
          phi_(p.i, p.j, p.k) - plane_wave(t + dt / 2, p.x, p.y, p.z).phi;
    });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 406 [2.16301]

B:BD[2.23933] → [2.23933:24196]

      phierr[idx] = phi[idx] - plane_wave(t + dt / 2, x, y, z).phi;
      axerr[idx] = ax[idx] - plane_wave(t, x + dx / 2, y, z).ax;
      ayerr[idx] = ay[idx] - plane_wave(t, x, y + dy / 2, z).ay;
      azerr[idx] = az[idx] - plane_wave(t, x, y, z + dz / 2).az;

[2.23933]

[2.24196]

    Loop::loop_all<1, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      axerr_(p.i, p.j, p.k) =
          ax_(p.i, p.j, p.k) - plane_wave(t, p.x, p.y, p.z).ax;
    });
    Loop::loop_all<0, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      ayerr_(p.i, p.j, p.k) =
          ay_(p.i, p.j, p.k) - plane_wave(t, p.x, p.y, p.z).ay;
    });
    Loop::loop_all<0, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      azerr_(p.i, p.j, p.k) =
          az_(p.i, p.j, p.k) - plane_wave(t, p.x, p.y, p.z).az;
    });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 419 [2.16301]

B:BD[2.24197] → [2.24197:25448]

      exerr[idx] =
          ex[idx] -
          (-xderiv(plane_wave<CCTK_REAL>, dx)(t + dt / 2, x + dx / 2, y, z)
                .phi -
           tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, x + dx / 2, y, z).ax);
      eyerr[idx] =
          ey[idx] -
          (-yderiv(plane_wave<CCTK_REAL>, dy)(t + dt / 2, x, y + dy / 2, z)
                .phi -
           tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, x, y + dy / 2, z).ay);
      ezerr[idx] =
          ez[idx] -
          (-zderiv(plane_wave<CCTK_REAL>, dz)(t + dt / 2, x, y, z + dz / 2)
                .phi -
           tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, x, y, z + dz / 2).az);
      bxerr[idx] =
          bx[idx] -
          (yderiv(plane_wave<CCTK_REAL>, dy)(t, x, y + dy / 2, z + dz / 2).az -
           zderiv(plane_wave<CCTK_REAL>, dz)(t, x, y + dy / 2, z + dz / 2).ay);
      byerr[idx] =
          by[idx] -
          (zderiv(plane_wave<CCTK_REAL>, dz)(t, x + dx / 2, y, z + dz / 2).ax -
           xderiv(plane_wave<CCTK_REAL>, dx)(t, x + dx / 2, y, z + dz / 2).az);
      bzerr[idx] =
          bz[idx] -
          (xderiv(plane_wave<CCTK_REAL>, dx)(t, x, y + dy / 2, z + dz / 2).ay -
           yderiv(plane_wave<CCTK_REAL>, dy)(t, x, y + dy / 2, z + dz / 2).ax);

[2.24197]

[2.25448]

    Loop::loop_all<1, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      exerr_(p.i, p.j, p.k) =
          ex_(p.i, p.j, p.k) -
          (-xderiv(plane_wave<CCTK_REAL>, p.dx)(t + dt / 2, p.x, p.y, p.z).phi -
           tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, p.x, p.y, p.z).ax);
    });
    Loop::loop_all<0, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      eyerr_(p.i, p.j, p.k) =
          ey_(p.i, p.j, p.k) -
          (-yderiv(plane_wave<CCTK_REAL>, p.dy)(t + dt / 2, p.x, p.y, p.z).phi -
           tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, p.x, p.y, p.z).ay);
    });
    Loop::loop_all<0, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      ezerr_(p.i, p.j, p.k) =
          ez_(p.i, p.j, p.k) -
          (-zderiv(plane_wave<CCTK_REAL>, p.dz)(t + dt / 2, p.x, p.y, p.z).phi -
           tderiv(plane_wave<CCTK_REAL>, dt)(t + dt / 2, p.x, p.y, p.z).az);
    });
    Loop::loop_all<0, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      bxerr_(p.i, p.j, p.k) =
          bx_(p.i, p.j, p.k) -
          (yderiv(plane_wave<CCTK_REAL>, p.dy)(t, p.x, p.y, p.z).az -
           zderiv(plane_wave<CCTK_REAL>, p.dz)(t, p.x, p.y, p.z).ay);
    });
    Loop::loop_all<1, 0, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      byerr_(p.i, p.j, p.k) =
          by_(p.i, p.j, p.k) -
          (zderiv(plane_wave<CCTK_REAL>, p.dz)(t, p.x, p.y, p.z).ax -
           xderiv(plane_wave<CCTK_REAL>, p.dx)(t, p.x, p.y, p.z).az);
    });
    Loop::loop_all<1, 1, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      bzerr_(p.i, p.j, p.k) =
          bz_(p.i, p.j, p.k) -
          (xderiv(plane_wave<CCTK_REAL>, p.dx)(t, p.x, p.y, p.z).ay -
           yderiv(plane_wave<CCTK_REAL>, p.dy)(t, p.x, p.y, p.z).ax);
    });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 457 [2.16301]

B:BD[2.25449] → [2.25449:25546]

      rhoerr[idx] = 0.0;
      jxerr[idx] = 0.0;
      jyerr[idx] = 0.0;
      jzerr[idx] = 0.0;

[2.25449]

[2.25546]

    Loop::loop_all<0, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
      rhoerr_(p.i, p.j, p.k) = 0.0;

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 461 [2.16301]

[2.25555]

    Loop::loop_all<1, 0, 0>(
        cctkGH, [&](const Loop::PointDesc &p) { jxerr_(p.i, p.j, p.k) = 0.0; });
    Loop::loop_all<0, 1, 0>(
        cctkGH, [&](const Loop::PointDesc &p) { jyerr_(p.i, p.j, p.k) = 0.0; });
    Loop::loop_all<0, 0, 1>(
        cctkGH, [&](const Loop::PointDesc &p) { jzerr_(p.i, p.j, p.k) = 0.0; });

Deletion in WaveToyAMReX/src/wavetoy.cxx at line 133 [3.37]

B:BD[18.6311] → [18.6311:6446]

  CCTK_REAL x0[dim], dx[dim];
  for (int d = 0; d < dim; ++d) {
    x0[d] = CCTK_ORIGIN_SPACE(d);
    dx[d] = CCTK_DELTA_SPACE(d);
  }

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 136 [3.37]

B:BD[9.10478] → [6.23150:23523]

    Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phi[idx] = standing(t, x, y, z);
      // phi_p[idx] = standing(t - dt, x, y, z);
      psi[idx] = timederiv(standing, dt)(t, x, y, z);

[9.10478]

[6.23523]

    Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phi[p.idx] = standing(t, p.x, p.y, p.z);
      // phi_p[p.idx] = standing(t - dt, p.x, p.y, p.z);
      psi[p.idx] = timederiv(standing, dt)(t, p.x, p.y, p.z);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 144 [3.37]

B:BD[9.11110] → [6.23532:23932]

    Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phi[idx] = periodic_gaussian(t, x, y, z);
      // phi_p[idx] = periodic_gaussian(t - dt, x, y, z);
      psi[idx] = timederiv(periodic_gaussian, dt)(t, x, y, z);

[9.11110]

[6.23932]

    Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phi[p.idx] = periodic_gaussian(t, p.x, p.y, p.z);
      // phi_p[p.idx] = periodic_gaussian(t - dt, p.x, p.y, p.z);
      psi[p.idx] = timederiv(periodic_gaussian, dt)(t, p.x, p.y, p.z);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 152 [3.37]

B:BD[6.24001] → [6.24001:24374]

    Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phi[idx] = gaussian(t, x, y, z);
      // phi_p[idx] = gaussian(t - dt, x, y, z);
      psi[idx] = timederiv(gaussian, dt)(t, x, y, z);

[6.24001]

[6.24374]

    Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phi[p.idx] = gaussian(t, p.x, p.y, p.z);
      // phi_p[p.idx] = gaussian(t - dt, p.x, p.y, p.z);
      psi[p.idx] = timederiv(gaussian, dt)(t, p.x, p.y, p.z);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 160 [3.37]

B:BD[6.24452] → [6.24452:24852]

    Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phi[idx] = central_potential(t, x, y, z);
      // phi_p[idx] = central_potential(t - dt, x, y, z);
      psi[idx] = timederiv(central_potential, dt)(t, x, y, z);

[6.24452]

[6.24852]

    Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phi[p.idx] = central_potential(t, p.x, p.y, p.z);
      // phi_p[p.idx] = central_potential(t - dt, p.x, p.y, p.z);
      psi[p.idx] = timederiv(central_potential, dt)(t, p.x, p.y, p.z);

Deletion in WaveToyAMReX/src/wavetoy.cxx at line 191 [3.37]
∅:D[5.6724] → [3.5451:5452]
B:BD[3.5451] → [3.5451:5452]
B:BD[3.5452] → [9.11765:11859]
```
  constexpr int di = 1;
  const int dj = di * cctk_ash[0];
  const int dk = dj * cctk_ash[1];
```

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 192 [3.37]

B:BD[5.6861] → [6.24861:24979]

  Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
    CCTK_REAL base_phi = fabs(phi[idx]) + fabs(phi_abs);

[5.6861]

[6.24979]

  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    CCTK_REAL base_phi = fabs(phi[p.idx]) + fabs(phi_abs);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 195 [3.37]

B:BD[6.25004] → [6.25004:25075]

        fabs(phi[idx - di] - 2 * phi[idx] + phi[idx + di]) / base_phi;

[6.25004]

[6.25075]

        fabs(phi[p.idx - p.di] - 2 * phi[p.idx] + phi[p.idx + p.di]) / base_phi;

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 197 [3.37]

B:BD[6.25100] → [6.25100:25171]

        fabs(phi[idx - dj] - 2 * phi[idx] + phi[idx + dj]) / base_phi;

[6.25100]

[6.25171]

        fabs(phi[p.idx - p.dj] - 2 * phi[p.idx] + phi[p.idx + p.dj]) / base_phi;

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 199 [3.37]

B:BD[6.25196] → [6.25196:25324]

        fabs(phi[idx - dk] - 2 * phi[idx] + phi[idx + dk]) / base_phi;
    CCTK_REAL base_psi = fabs(psi[idx]) + fabs(psi_abs);

[6.25196]

[6.25324]

        fabs(phi[p.idx - p.dk] - 2 * phi[p.idx] + phi[p.idx + p.dk]) / base_phi;
    CCTK_REAL base_psi = fabs(psi[p.idx]) + fabs(psi_abs);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 202 [3.37]

B:BD[6.25349] → [6.25349:25420]

        fabs(psi[idx - di] - 2 * psi[idx] + psi[idx + di]) / base_psi;

[6.25349]

[6.25420]

        fabs(psi[p.idx - p.di] - 2 * psi[p.idx] + psi[p.idx + p.di]) / base_psi;

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 204 [3.37]

B:BD[6.25445] → [6.25445:25516]

        fabs(psi[idx - dj] - 2 * psi[idx] + psi[idx + dj]) / base_psi;

[6.25445]

[6.25516]

        fabs(psi[p.idx - p.dj] - 2 * psi[p.idx] + psi[p.idx + p.dj]) / base_psi;

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 206 [3.37]

B:BD[6.25541] → [6.25541:25636]

        fabs(psi[idx - dk] - 2 * psi[idx] + psi[idx + dk]) / base_psi;
    regrid_error[idx] =

[6.25541]

[6.25636]

        fabs(psi[p.idx - p.dk] - 2 * psi[p.idx] + psi[p.idx + p.dk]) / base_psi;
    regrid_error[p.idx] =

Deletion in WaveToyAMReX/src/wavetoy.cxx at line 218 [3.37]
B:BD[6.25866] → [6.25866:25997]
∅:D[6.25997] → [5.7338:7342]
B:BD[5.7338] → [5.7338:7342]
```
  CCTK_REAL x0[dim], dx[dim];
  for (int d = 0; d < dim; ++d) {
    x0[d] = CCTK_ORIGIN_SPACE(d);
    dx[d] = CCTK_DELTA_SPACE(d);
  }
```

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 219 [3.37]

B:BD[6.25999] → [6.25999:26317]

  constexpr int di = 1;
  const int dj = di * cctk_ash[0];
  const int dk = dj * cctk_ash[1];
  Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {
    CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
    CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
    CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];

[6.25999]

[6.26376]

  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 221 [3.37]

B:BD[6.26400] → [6.26400:26478]

        (phi_p[idx - di] - 2 * phi_p[idx] + phi_p[idx + di]) / pow(dx[0], 2);

[6.26400]

[6.26478]

        (phi_p[p.idx - p.di] - 2 * phi_p[p.idx] + phi_p[p.idx + p.di]) /
        pow(p.dx, 2);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 224 [3.37]

B:BD[6.26502] → [6.26502:26580]

        (phi_p[idx - dj] - 2 * phi_p[idx] + phi_p[idx + dj]) / pow(dx[1], 2);

[6.26502]

[6.26580]

        (phi_p[p.idx - p.dj] - 2 * phi_p[p.idx] + phi_p[p.idx + p.dj]) /
        pow(p.dy, 2);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 227 [3.37]

B:BD[6.26604] → [6.26604:26732]

        (phi_p[idx - dk] - 2 * phi_p[idx] + phi_p[idx + dk]) / pow(dx[2], 2);
    // phi[idx] = 2 * phi_p[idx] - phi_p_p[idx] +

[6.26604]

[6.26732]

        (phi_p[p.idx - p.dk] - 2 * phi_p[p.idx] + phi_p[p.idx + p.dk]) /
        pow(p.dz, 2);
    // phi[p.idx] = 2 * phi_p[p.idx] - phi_p_p[p.idx] +

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 231 [3.37]

B:BD[6.26794] → [6.26794:26822]

B:BD[6.26822] → [20.2756:2835]

B:BD[20.2835] → [2.25620:25684]

∅:D[2.25684] → [6.27075:27118]

∅:D[20.2912] → [6.27075:27118]

B:BD[6.27075] → [6.27075:27118]

    psi[idx] = psi_p[idx] +
               dt * (ddx_phi + ddy_phi + ddz_phi - pow(mass, 2) * phi_p[idx] +
                     4 * M_PI * central_potential(t, x, y, z));
    phi[idx] = phi_p[idx] + dt * psi[idx];

[6.26794]

[6.27118]

    psi[p.idx] =
        psi_p[p.idx] +
        dt * (ddx_phi + ddy_phi + ddz_phi - pow(mass, 2) * phi_p[p.idx] +
              4 * M_PI * central_potential(t, p.x, p.y, p.z));
    phi[p.idx] = phi_p[p.idx] + dt * psi[p.idx];

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 418 [3.37]

B:BD[6.31397] → [6.31397:31525]

              CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
              CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];

[6.31397]

[6.31525]

              CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * p.dy;
              CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * p.dz;

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 426 [3.37]

B:BD[6.31733] → [6.31733:31947]

              //     (phi_p[idx] - phi_p[idx - ndir * ddir]) / dx[dir];
              // phi[idx] =
              //     phi_p[idx] -
              //     dt * phi_vel * (r * gradphi + (phi_p[idx] - phi_inf) / r);

[6.31733]

[6.31947]

              //     (phi_p[p.idx] - phi_p[p.idx - ndir * ddir]) / dx[dir];
              // phi[p.idx] =
              //     phi_p[p.idx] -
              //     dt * phi_vel * (r * gradphi + (phi_p[p.idx] - phi_inf) / r);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 432 [3.37]

B:BD[6.31985] → [6.31985:32199]

              //     (psi_p[idx] - psi_p[idx - ndir * ddir]) / dx[dir];
              // psi[idx] =
              //     psi_p[idx] -
              //     dt * psi_vel * (r * gradpsi + (psi_p[idx] - psi_inf) / r);

[6.31985]

[6.32199]

              //     (psi_p[p.idx] - psi_p[p.idx - ndir * ddir]) / dx[dir];
              // psi[p.idx] =
              //     psi_p[p.idx] -
              //     dt * psi_vel * (r * gradpsi + (psi_p[p.idx] - psi_inf) / r);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 438 [3.37]

B:BD[6.32234] → [6.32234:32436]

                  (phi_p[idx] - phi_p[idx - ndir * ddir]) / dx[dir];
              psi[idx] = -phi_vel * (r * gradphi + (phi_p[idx] - phi_inf) / r);
              phi[idx] = phi_p[idx] + dt * psi[idx];

[6.32234]

[6.32436]

                  (phi_p[p.idx] - phi_p[p.idx - ndir * ddir]) / dx[dir];
              psi[p.idx] = -phi_vel * (r * gradphi + (phi_p[p.idx] - phi_inf) / r);
              phi[p.idx] = phi_p[p.idx] + dt * psi[p.idx];

Deletion in WaveToyAMReX/src/wavetoy.cxx at line 460 [3.37]

B:BD[6.32744] → [6.32744:32879]

  CCTK_REAL x0[dim], dx[dim];
  for (int d = 0; d < dim; ++d) {
    x0[d] = CCTK_ORIGIN_SPACE(d);
    dx[d] = CCTK_DELTA_SPACE(d);
  }

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 469 [3.37]

B:BD[6.33073] → [6.33073:33427]

      Loop::loop_bnd(cctkGH, [&](int i, int j, int k, int idx) {
        CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
        CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
        CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
        phi[idx] = central_potential(t, x, y, z);
        psi[idx] = timederiv(central_potential, dt)(t, x, y, z);

[6.33073]

[6.33427]

      Loop::loop_bnd<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
        phi[p.idx] = central_potential(t, p.x, p.y, p.z);
        psi[p.idx] = timederiv(central_potential, dt)(t, p.x, p.y, p.z);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 487 [3.37]

B:BD[6.33623] → [6.33623:33762]

  Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
    assert(CCTK_isfinite(phi_p[idx]));
    assert(CCTK_isfinite(psi_p[idx]));

[6.33623]

[6.33762]

  Loop::loop_all<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    assert(CCTK_isfinite(phi_p[p.idx]));
    assert(CCTK_isfinite(psi_p[p.idx]));

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 505 [3.37]

B:BD[6.34018] → [6.34018:34334]

  Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
    if (!CCTK_isfinite(phi[idx]) || !CCTK_isfinite(psi[idx])) {
      CCTK_VINFO("level %d idx=[%d,%d,%d] gidx=[%d,%d,%d] (%g,%g)", lev, i, j,
                 k, cctk_lbnd[0] + i, cctk_lbnd[1] + j, cctk_lbnd[2] + k,
                 phi[idx], psi[idx]);

[6.34018]

[6.34334]

  Loop::loop_all<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    if (!CCTK_isfinite(phi[p.idx]) || !CCTK_isfinite(psi[p.idx])) {
      CCTK_VINFO("level %d idx=[%d,%d,%d] gidx=[%d,%d,%d] (%g,%g)", lev, p.i,
                 p.j, p.k, cctk_lbnd[0] + p.i, cctk_lbnd[1] + p.j,
                 cctk_lbnd[2] + p.k, phi[p.idx], psi[p.idx]);

Deletion in WaveToyAMReX/src/wavetoy.cxx at line 522 [3.37]

B:BD[7.14897] → [7.14897:14984]

B:BD[7.15187] → [7.15187:15281]

  CCTK_REAL dx[dim];
  for (int d = 0; d < dim; ++d)
    dx[d] = CCTK_DELTA_SPACE(d);
  constexpr int di = 1;
  const int dj = di * cctk_ash[0];
  const int dk = dj * cctk_ash[1];

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 523 [3.37]

B:BD[7.15282] → [6.34419:34480]

  Loop::loop_int(cctkGH, [&](int i, int j, int k, int idx) {

[7.15282]

[6.34480]

  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 525 [3.37]

B:BD[6.34504] → [6.34504:34576]

        (phi[idx - di] - 2 * phi[idx] + phi[idx + di]) / pow(dx[0], 2);

[6.34504]

[6.34576]

        (phi[p.idx - p.di] - 2 * phi[p.idx] + phi[p.idx + p.di]) / pow(p.dx, 2);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 527 [3.37]

B:BD[6.34600] → [6.34600:34672]

        (phi[idx - dj] - 2 * phi[idx] + phi[idx + dj]) / pow(dx[1], 2);

[6.34600]

[6.34672]

        (phi[p.idx - p.dj] - 2 * phi[p.idx] + phi[p.idx + p.dj]) / pow(p.dy, 2);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 529 [3.37]

B:BD[6.34696] → [6.34696:34837]

        (phi[idx - dk] - 2 * phi[idx] + phi[idx + dk]) / pow(dx[2], 2);
    CCTK_REAL psi_n = psi[idx] + dt * (ddx_phi + ddy_phi + ddz_phi);

[6.34696]

[6.34837]

        (phi[p.idx - p.dk] - 2 * phi[p.idx] + phi[p.idx + p.dk]) / pow(p.dz, 2);
    CCTK_REAL psi_n = psi[p.idx] + dt * (ddx_phi + ddy_phi + ddz_phi);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 532 [3.37]

B:BD[6.34869] → [6.34869:35491]

    CCTK_REAL dt_phi_m = psi_p[idx];
    CCTK_REAL dx_phi_p = (phi[idx + di] - phi[idx]) / dx[0];
    CCTK_REAL dx_phi_m = (phi[idx] - phi[idx - di]) / dx[0];
    CCTK_REAL dy_phi_p = (phi[idx + dj] - phi[idx]) / dx[1];
    CCTK_REAL dy_phi_m = (phi[idx] - phi[idx - dj]) / dx[1];
    CCTK_REAL dz_phi_p = (phi[idx + dk] - phi[idx]) / dx[2];
    CCTK_REAL dz_phi_m = (phi[idx] - phi[idx - dk]) / dx[2];
    eps[idx] = (pow(dt_phi_p, 2) + pow(dt_phi_m, 2) + pow(dx_phi_p, 2) +
                pow(dx_phi_m, 2) + pow(dy_phi_p, 2) + pow(dy_phi_m, 2) +
                pow(dz_phi_p, 2) + pow(dz_phi_m, 2)) /
               4;

[6.34869]

[6.35491]

    CCTK_REAL dt_phi_m = psi_p[p.idx];
    CCTK_REAL dx_phi_p = (phi[p.idx + p.di] - phi[p.idx]) / p.dx;
    CCTK_REAL dx_phi_m = (phi[p.idx] - phi[p.idx - p.di]) / p.dx;
    CCTK_REAL dy_phi_p = (phi[p.idx + p.dj] - phi[p.idx]) / p.dy;
    CCTK_REAL dy_phi_m = (phi[p.idx] - phi[p.idx - p.dj]) / p.dy;
    CCTK_REAL dz_phi_p = (phi[p.idx + p.dk] - phi[p.idx]) / p.dz;
    CCTK_REAL dz_phi_m = (phi[p.idx] - phi[p.idx - p.dk]) / p.dz;
    eps[p.idx] = (pow(dt_phi_p, 2) + pow(dt_phi_m, 2) + pow(dx_phi_p, 2) +
                  pow(dx_phi_m, 2) + pow(dy_phi_p, 2) + pow(dy_phi_m, 2) +
                  pow(dz_phi_p, 2) + pow(dz_phi_m, 2)) /
                 4;

Deletion in WaveToyAMReX/src/wavetoy.cxx at line 552 [3.37]
∅:D[7.15897] → [18.6580:6715]
∅:D[9.13600] → [18.6580:6715]
B:BD[21.3664] → [18.6580:6715]
```
  CCTK_REAL x0[dim], dx[dim];
  for (int d = 0; d < dim; ++d) {
    x0[d] = CCTK_ORIGIN_SPACE(d);
    dx[d] = CCTK_DELTA_SPACE(d);
  }
```

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 555 [3.37]

B:BD[9.13659] → [6.35498:35850]

    Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phierr[idx] = phi[idx] - standing(t, x, y, z);
      psierr[idx] = psi[idx] - timederiv(standing, dt)(t, x, y, z);

[9.13659]

[6.35850]

    Loop::loop_all<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phierr[p.idx] = phi[p.idx] - standing(t, p.x, p.y, p.z);
      psierr[p.idx] = psi[p.idx] - timederiv(standing, dt)(t, p.x, p.y, p.z);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 562 [3.37]

B:BD[9.14247] → [6.35859:36229]

    Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phierr[idx] = phi[idx] - periodic_gaussian(t, x, y, z);
      psierr[idx] = psi[idx] - timederiv(periodic_gaussian, dt)(t, x, y, z);

[9.14247]

[6.36229]

    Loop::loop_all<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phierr[p.idx] = phi[p.idx] - periodic_gaussian(t, p.x, p.y, p.z);
      psierr[p.idx] =
          psi[p.idx] - timederiv(periodic_gaussian, dt)(t, p.x, p.y, p.z);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 570 [3.37]

B:BD[6.36298] → [6.36298:36650]

    Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phierr[idx] = phi[idx] - gaussian(t, x, y, z);
      psierr[idx] = psi[idx] - timederiv(gaussian, dt)(t, x, y, z);

[6.36298]

[6.36650]

    Loop::loop_all<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phierr[p.idx] = phi[p.idx] - gaussian(t, p.x, p.y, p.z);
      psierr[p.idx] = psi[p.idx] - timederiv(gaussian, dt)(t, p.x, p.y, p.z);

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 577 [3.37]

B:BD[6.36728] → [6.36728:37098]

    Loop::loop_all(cctkGH, [&](int i, int j, int k, int idx) {
      CCTK_REAL x = x0[0] + (cctk_lbnd[0] + i) * dx[0];
      CCTK_REAL y = x0[1] + (cctk_lbnd[1] + j) * dx[1];
      CCTK_REAL z = x0[2] + (cctk_lbnd[2] + k) * dx[2];
      phierr[idx] = phi[idx] - central_potential(t, x, y, z);
      psierr[idx] = psi[idx] - timederiv(central_potential, dt)(t, x, y, z);

[6.36728]

[6.37098]

    Loop::loop_all<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
      phierr[p.idx] = phi[p.idx] - central_potential(t, p.x, p.y, p.z);
      psierr[p.idx] =
          psi[p.idx] - timederiv(central_potential, dt)(t, p.x, p.y, p.z);