eschnett/cactusamrex - Change 33IC3UHCEPZLGS5ACS2JXHGT6CRU5LXU6PM6RDHCERPOIELVRVXQC

AMR is now adaptive

Created by Erik Schnetter on July 25, 2019

33IC3UHCEPZLGS5ACS2JXHGT6CRU5LXU6PM6RDHCERPOIELVRVXQC

Dependencies

In channels

master

main

Change contents

Replacement in AMReX/interface.ccl at line 11 [4.17976]
B:BD[3.12] → [3.12:41]
```
CCTK_REAL regrid_tag TYPE=gf
```
[3.12]
[3.41]
```
CCTK_REAL regrid_error TYPE=gf
```
Replacement in AMReX/interface.ccl at line 13 [4.17976]
B:BD[3.43] → [3.43:69]
```
  tag
} "Regridding tags"
```
[3.43]
[5.0]
```
  regrid_error
} "Regridding condition"
```

File addition: planewave.par (-rw-r--r--)

[2.6]

ActiveThorns = "
    AMReX
    IOUtil
    WaveToyAMReX
"
 
$nlevels = 4
$ncells = 16
Cactus::cctk_show_schedule = no
Cactus::cctk_itlast = $ncells * 2 ** ($nlevels - 1) * 2
AMReX::verbose = yes
AMReX::ncells_x = $ncells
AMReX::ncells_y = $ncells
AMReX::ncells_z = $ncells
AMReX::max_num_levels = $nlevels
AMReX::regrid_every = 16
AMReX::regrid_error_threshold = 0.02   # 0.05   # 0.1
AMReX::dtfac = 0.5
WaveToyAMReX::initial_condition = "periodic Gaussian"
WaveToyAMReX::spatial_frequency_x = 0.5
WaveToyAMReX::spatial_frequency_y = 0.0
WaveToyAMReX::spatial_frequency_z = 0.0
IO::out_dir = "planewave"
IO::out_every = 1   #TODO $ncells * 2 ** ($nlevels - 1) / 2

Insertion in AMReX/param.ccl at line 110 [4.17918]

[6.485]

CCTK_INT regrid_every "Regridding interval" STEERABLE=always
{
  0 :: "never"
  1:* :: "every that many iterations"
} 0

Insertion in AMReX/param.ccl at line 116 [4.17918]

[6.486]

[7.948]

CCTK_REAL regrid_error_threshold "Regridding error threshold" STEERABLE=always
{
  0.0:* :: ""
} 1.0

Insertion in AMReX/param.ccl at line 121 [4.17918]
[7.949]
[6.486]
Insertion in AMReX/src/driver.cxx at line 11 [4.15972]
[8.46]
[7.1194]
```
#include <AMReX_FillPatchUtil.H>
#include <AMReX_Interpolater.H>
```
Insertion in AMReX/src/driver.cxx at line 14 [4.15972]
[7.1223]
[4.16090]
```
#include <AMReX_PhysBCFunct.H>
```

Replacement in AMReX/src/driver.cxx at line 82 [4.15972]

∅:D[3.506] → [9.804:830]

B:BD[9.804] → [9.804:830]

B:BD[9.830] → [3.507:555]

∅:D[3.555] → [9.876:877]

B:BD[9.876] → [9.876:877]

B:BD[9.877] → [5.720:1270]

∅:D[5.1270] → [3.758:814]

B:BD[3.758] → [3.758:814]

  // // refine everywhere
  // tags.setVal(boxArray(level), TagBox::SET);
  // // refine centre
  // const Box &dom = Geom(level).Domain();
  // Box nbx;
  // for (int d = 0; d < dim; ++d) {
  //   int md = (dom.bigEnd(d) + dom.smallEnd(d) + 1) / 2;
  //   int rd = (dom.bigEnd(d) - dom.smallEnd(d) + 1) / 2;
  //   // mark one fewer cells; AMReX seems to add one cell
  //   nbx.setSmall(d, md - rd / (1 << (level + 1)) + 1);
  //   nbx.setBig(d, md + rd / (1 << (level + 1)) - 2);
  // }
  // cout << "EE nbx: " << nbx << "\n";
  // const BoxArray &ba = boxArray(level);
  // tags.setVal(intersect(ba, nbx), TagBox::SET);
  const int gi = CCTK_GroupIndex("AMReX::regrid_tag");

[3.506]

[3.814]

  const int gi = CCTK_GroupIndex("AMReX::regrid_error");

Replacement in AMReX/src/driver.cxx at line 106 [4.15972]

B:BD[7.1572] → [7.1572:1646]

    const CCTK_REAL *restrict ptr = vars.ptr(imin.x, imin.y, imin.z, vi);

[7.1572]

[7.1646]

    const CCTK_REAL *restrict err = vars.ptr(imin.x, imin.y, imin.z, vi);

Replacement in AMReX/src/driver.cxx at line 119 [4.15972]

B:BD[7.1754] → [7.1754:1815]

              ptr[idx] == 0.0 ? TagBox::CLEAR : TagBox::SET;

[7.1754]

[3.2124]

              err[idx] >= regrid_error_threshold ? TagBox::SET : TagBox::CLEAR;

Insertion in AMReX/src/driver.cxx at line 125 [4.15972]

[5.1273]


void SetupLevel(int level, const BoxArray &ba, const DistributionMapping &dm) {
  DECLARE_CCTK_PARAMETERS;
  if (verbose)
    CCTK_VINFO("SetupLevel level %d", level);
  assert(level == int(ghext->leveldata.size()));
  ghext->leveldata.resize(level + 1);
  GHExt::LevelData &leveldata = ghext->leveldata.at(level);
  leveldata.level = level;

Replacement in AMReX/src/driver.cxx at line 136 [4.15972]

B:BD[5.1274] → [5.1274:1338]

void CactusAmrCore::MakeNewLevelFromScratch(int lev, Real time,

[5.1274]

[5.1338]

  const int numgroups = CCTK_NumGroups();
  leveldata.groupdata.resize(numgroups);
  for (int gi = 0; gi < numgroups; ++gi) {
    cGroup group;
    int ierr = CCTK_GroupData(gi, &group);
    assert(!ierr);
    assert(group.grouptype == CCTK_GF);
    assert(group.vartype == CCTK_VARIABLE_REAL);
    assert(group.disttype == CCTK_DISTRIB_DEFAULT);
    assert(group.dim == dim);
    GHExt::LevelData::GroupData &groupdata = leveldata.groupdata.at(gi);
    groupdata.firstvarindex = CCTK_FirstVarIndexI(gi);
    groupdata.numvars = group.numvars;
    // Allocate grid hierarchies
    groupdata.mfab.resize(group.numtimelevels);
    for (int tl = 0; tl < int(groupdata.mfab.size()); ++tl) {
      groupdata.mfab.at(tl) =
          make_unique<MultiFab>(ba, dm, groupdata.numvars, ghost_size);
    }
  }
}
void CactusAmrCore::MakeNewLevelFromScratch(int level, Real time,

Replacement in AMReX/src/driver.cxx at line 165 [4.15972]

B:BD[7.1858] → [7.1858:1915]

    CCTK_VINFO("MakeNewLevelFromScratch level %d", lev);

[7.1858]

[5.1534]

    CCTK_VINFO("MakeNewLevelFromScratch level %d", level);
  SetupLevel(level, ba, dm);

Replacement in AMReX/src/driver.cxx at line 170 [4.15972]

B:BD[5.1537] → [5.1537:1600]

void CactusAmrCore::MakeNewLevelFromCoarse(int lev, Real time,

[5.1537]

[5.1600]

void CactusAmrCore::MakeNewLevelFromCoarse(int level, Real time,

Replacement in AMReX/src/driver.cxx at line 175 [4.15972]

B:BD[7.1958] → [7.1958:2014]

    CCTK_VINFO("MakeNewLevelFromCoarse level %d", lev);

[7.1958]

[9.1244]

    CCTK_VINFO("MakeNewLevelFromCoarse level %d", level);
  assert(level > 0);
  SetupLevel(level, ba, dm);
  // Prolongate
  auto &leveldata = ghext->leveldata.at(level);
  auto &coarseleveldata = ghext->leveldata.at(level - 1);
  const int num_groups = CCTK_NumGroups();
  for (int gi = 0; gi < num_groups; ++gi) {
    auto &restrict groupdata = leveldata.groupdata.at(gi);
    auto &restrict coarsegroupdata = coarseleveldata.groupdata.at(gi);
    assert(coarsegroupdata.numvars == groupdata.numvars);
    PhysBCFunctNoOp cphysbc;
    PhysBCFunctNoOp fphysbc;
    const IntVect reffact{2, 2, 2};
    // periodic boundaries
    const BCRec bcrec(BCType::int_dir, BCType::int_dir, BCType::int_dir,
                      BCType::int_dir, BCType::int_dir, BCType::int_dir);
    const Vector<BCRec> bcs(groupdata.numvars, bcrec);
    // If there is more than one time level, then we don't
    // prolongate the oldest.
    int ntls = groupdata.mfab.size();
    int prolongate_tl = ntls > 1 ? ntls - 1 : ntls;
    for (int tl = 0; tl < prolongate_tl; ++tl)
      InterpFromCoarseLevel(*groupdata.mfab.at(tl), 0.0,
                            *coarsegroupdata.mfab.at(tl), 0, 0,
                            groupdata.numvars, ghext->amrcore->Geom(level - 1),
                            ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0,
                            reffact, &cell_bilinear_interp, bcs, 0);
  }

Replacement in AMReX/src/driver.cxx at line 209 [4.15972]

B:BD[9.1247] → [5.1794:1866]

void CactusAmrCore::RemakeLevel(int lev, Real time, const BoxArray &ba,

[9.1247]

[5.1866]

void CactusAmrCore::RemakeLevel(int level, Real time, const BoxArray &ba,

Replacement in AMReX/src/driver.cxx at line 213 [4.15972]

B:BD[7.2057] → [7.2057:2102]

    CCTK_VINFO("RemakeLevel level %d", lev);

[7.2057]

[5.1974]

    CCTK_VINFO("RemakeLevel level %d", level);
  // Copy or prolongate
  auto &leveldata = ghext->leveldata.at(level);
  const int num_groups = CCTK_NumGroups();
  for (int gi = 0; gi < num_groups; ++gi) {
    auto &restrict groupdata = leveldata.groupdata.at(gi);
    // If there is more than one time level, then we don't
    // prolongate the oldest.
    int ntls = groupdata.mfab.size();
    int prolongate_tl = ntls > 1 ? ntls - 1 : ntls;
    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);
        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);
      }
    } else {
      // Refined level: 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);
      PhysBCFunctNoOp cphysbc;
      PhysBCFunctNoOp fphysbc;
      const IntVect reffact{2, 2, 2};
      // periodic boundaries
      const BCRec bcrec(BCType::int_dir, BCType::int_dir, BCType::int_dir,
                        BCType::int_dir, BCType::int_dir, BCType::int_dir);
      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);
        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 274 [4.15972]
B:BD[5.1977] → [5.1977:2019]
```
void CactusAmrCore::ClearLevel(int lev) {
```
[5.1977]
[7.2103]
```
void CactusAmrCore::ClearLevel(int level) {
```

Replacement in AMReX/src/driver.cxx at line 277 [4.15972]

B:BD[7.2145] → [7.2145:2189]

    CCTK_VINFO("ClearLevel level %d", lev);

[7.2145]

[5.2061]

    CCTK_VINFO("ClearLevel level %d", level);
  assert(level == int(ghext->leveldata.size()) - 1);
  ghext->leveldata.resize(level);

Deletion in AMReX/src/driver.cxx at line 285 [4.15972]
B:BD[3.2154] → [3.2154:2182]
∅:D[3.2182] → [9.1328:1329]
B:BD[9.1328] → [9.1328:1329]
```
void SetupLevel(int level);
```
Deletion in AMReX/src/driver.cxx at line 387 [4.15972]
B:BD[3.2207] → [3.2207:2230]
```
  const int level = 0;
```
Deletion in AMReX/src/driver.cxx at line 389 [4.15972]
∅:D[5.2499] → [3.2306:2327]
B:BD[3.2306] → [3.2306:2327]
```
  SetupLevel(level);
```
Deletion in AMReX/src/driver.cxx at line 413 [4.15972]
∅:D[3.3147] → [9.2406:2407]
∅:D[5.3007] → [9.2406:2407]
B:BD[9.2406] → [9.2406:2407]
B:BD[9.2407] → [5.3008:3038]
∅:D[5.3038] → [3.3175:3198]
B:BD[3.3175] → [3.3175:3198]
```
  if (numlevels == level + 1)
    SetupLevel(level);
```
Replacement in AMReX/src/driver.cxx at line 415 [4.15972]
B:BD[9.2630] → [3.3201:3230]
```
void SetupLevel(int level) {
```
[9.2630]
[3.3230]
```
void RegridLevel(int level) {
```
Replacement in AMReX/src/driver.cxx at line 418 [4.15972]
B:BD[7.3217] → [7.3217:3263]
```
    CCTK_VINFO("SetupLevel level %d", level);
```
[7.3217]
[10.827]
```
    CCTK_VINFO("RegridLevel level %d", level);
```

Replacement in AMReX/src/driver.cxx at line 420 [4.15972]

B:BD[10.828] → [3.3302:3389]

  assert(level == int(ghext->leveldata.size()));
  ghext->leveldata.resize(level + 1);

[10.828]

[3.3389]

  assert(level < int(ghext->leveldata.size()));

Deletion in AMReX/src/driver.cxx at line 422 [4.15972]
B:BD[3.3449] → [3.3449:3476]
```
  leveldata.level = level;
```

Replacement in AMReX/src/driver.cxx at line 423 [4.15972]

B:BD[10.1033] → [3.3477:3854]

∅:D[3.3854] → [11.1821:1822]

B:BD[12.292] → [11.1821:1822]

B:BD[11.1822] → [3.3855:4022]

∅:D[3.4022] → [13.415:416]

∅:D[11.1839] → [13.415:416]

B:BD[13.415] → [13.415:416]

B:BD[13.416] → [3.4023:4104]

  const int numgroups = CCTK_NumGroups();
  leveldata.groupdata.resize(numgroups);
  for (int gi = 0; gi < numgroups; ++gi) {
    cGroup group;
    int ierr = CCTK_GroupData(gi, &group);
    assert(!ierr);
    assert(group.grouptype == CCTK_GF);
    assert(group.vartype == CCTK_VARIABLE_REAL);
    assert(group.disttype == CCTK_DISTRIB_DEFAULT);
    assert(group.dim == dim);
    GHExt::LevelData::GroupData &groupdata = leveldata.groupdata.at(gi);
    groupdata.firstvarindex = CCTK_FirstVarIndexI(gi);
    groupdata.numvars = group.numvars;
    // Allocate grid hierarchies
    groupdata.mfab.resize(group.numtimelevels);

[10.1033]

[3.4104]

  for (auto &groupdata : leveldata.groupdata) {

Replacement in AMReX/src/driver.cxx at line 425 [4.15972]

B:BD[3.4166] → [3.4166:4219]

B:BD[3.4219] → [5.3039:3171]

∅:D[5.3171] → [3.4351:4374]

B:BD[3.4351] → [3.4351:4374]

      groupdata.mfab.at(tl) = make_unique<MultiFab>(
          ghext->amrcore->boxArray(leveldata.level),
          ghext->amrcore->DistributionMap(leveldata.level), groupdata.numvars,
          ghost_size);

[3.4166]

[3.4374]

#warning "TODO"
      assert(0);
      groupdata.mfab.at(tl) =
          make_unique<MultiFab>(ghext->amrcore->boxArray(level),
                                ghext->amrcore->DistributionMap(level),
                                groupdata.numvars, ghost_size);

Replacement in AMReX/src/driver.hxx at line 42 [4.15275]

B:BD[9.3509] → [9.3509:3572]

  virtual void ErrorEst(int lev, TagBoxArray &tags, Real time,

[9.3297]

[9.3572]

  virtual void ErrorEst(int level, TagBoxArray &tags, Real time,

Replacement in AMReX/src/driver.hxx at line 44 [4.15275]

B:BD[9.3617] → [5.3500:3579]

  virtual void MakeNewLevelFromScratch(int lev, Real time, const BoxArray &ba,

[9.3617]

[5.3579]

  virtual void MakeNewLevelFromScratch(int level, Real time, const BoxArray &ba,

Replacement in AMReX/src/driver.hxx at line 46 [4.15275]

B:BD[5.3659] → [5.3659:3737]

  virtual void MakeNewLevelFromCoarse(int lev, Real time, const BoxArray &ba,

[5.3659]

[5.3737]

  virtual void MakeNewLevelFromCoarse(int level, Real time, const BoxArray &ba,

Replacement in AMReX/src/driver.hxx at line 48 [4.15275]

B:BD[5.3816] → [5.3816:3883]

  virtual void RemakeLevel(int lev, Real time, const BoxArray &ba,

[5.3816]

[5.3883]

  virtual void RemakeLevel(int level, Real time, const BoxArray &ba,

Replacement in AMReX/src/driver.hxx at line 50 [4.15275]
B:BD[5.3951] → [5.3951:3996]
```
  virtual void ClearLevel(int lev) override;
```
[5.3951]
[9.3819]
```
  virtual void ClearLevel(int level) override;
```

Deletion in AMReX/src/schedule.cxx at line 40 [13.531]

∅:D[14.4207] → [13.1181:1182]

B:BD[13.1181] → [13.1181:1182]

B:BD[13.1182] → [3.4424:4579]


// During initialization, the schedule should traverse only a single
// level. At all other times, all levels should be traversed.
int current_level = -1;

Replacement in AMReX/src/schedule.cxx at line 341 [13.531]

B:BD[3.5101] → [5.5111:5164]

B:BD[5.5164] → [7.10134:10195]

      current_level = ghext->amrcore->finestLevel();
      CCTK_VINFO("Initializing level %d...", current_level);

[3.5101]

[3.5154]

      // TODO: Remove "current_level" mechanism
      // current_level = ghext->amrcore->finestLevel();
      const int level = ghext->amrcore->finestLevel();
      CCTK_VINFO("Initializing level %d...", level);

Replacement in AMReX/src/schedule.cxx at line 352 [13.531]
∅:D[5.5232] → [3.5416:5460]
B:BD[3.5416] → [3.5416:5460]
```
      CreateRefinedGrid(current_level + 1);
```
[5.5232]
[5.5233]
```
      CreateRefinedGrid(level + 1);
```
Replacement in AMReX/src/schedule.cxx at line 361 [13.531]
B:BD[3.6039] → [3.6039:6063]
```
    current_level = -1;
```
[3.6039]
[10.3118]
```
    // current_level = -1;
```

Replacement in AMReX/src/schedule.cxx at line 366 [13.531]

B:BD[15.176] → [15.176:247]

  for (int level = (ghext->leveldata.size()) - 2; level >= 0; --level)

[15.176]

[15.247]

  for (int level = int(ghext->leveldata.size()) - 2; level >= 0; --level)

Insertion in AMReX/src/schedule.cxx at line 445 [13.531]
[10.5362]
[10.5362]
```
  DECLARE_CCTK_PARAMETERS;
```

Insertion in AMReX/src/schedule.cxx at line 454 [13.531]

[10.5482]

[10.5566]


    if (regrid_every > 0 && cctkGH->cctk_iteration % regrid_every == 0) {
      CCTK_VINFO("Regridding...");
      CCTK_REAL time = 0.0; // dummy time
      const int old_numlevels = ghext->amrcore->finestLevel() + 1;
      ghext->amrcore->regrid(0, time);
      const int new_numlevels = ghext->amrcore->finestLevel() + 1;
      CCTK_VINFO("  old levels %d, new levels %d", old_numlevels,
                 new_numlevels);
      CCTK_Traverse(cctkGH, "CCTK_BASEGRID");
    }

Replacement in AMReX/src/schedule.cxx at line 536 [13.531]

B:BD[3.6173] → [3.6173:6486]

      if (current_level < 0) {
        // Loop over all levels
        // TODO: parallelize this loop
        for (auto &restrict leveldata : ghext->leveldata)
          callfunc(leveldata);
      } else {
        // Loop over a single level
        auto &restrict leveldata = ghext->leveldata.at(current_level);

[3.6173]

[3.6486]

      // Loop over all levels
      // TODO: parallelize this loop
      for (auto &restrict leveldata : ghext->leveldata)

Deletion in AMReX/src/schedule.cxx at line 540 [13.531]
∅:D[3.6515] → [16.2391:2399]
∅:D[11.3097] → [16.2391:2399]
∅:D[17.3991] → [16.2391:2399]
B:BD[16.2391] → [16.2391:2399]
```
      }
```
Deletion in AMReX/src/schedule.cxx at line 596 [13.531]
B:BD[18.1187] → [7.10958:10990]
```
        // CellBilinear interp;
```

Deletion in AMReX/src/schedule.cxx at line 601 [13.531]

B:BD[7.11038] → [7.11038:11339]

          // InterpFromCoarseLevel(
          //     *groupdata.mfab.at(tl), 0.0, *coarsegroupdata.mfab.at(tl), 0,
          //     0, groupdata.numvars, ghext->amrcore->Geom(level - 1),
          //     ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0, reffact,
          //     &interp, bcs, 0);

Insertion in AMReX/src/schedule.cxx at line 616 [13.531]

[15.456]

  const int gi_regrid_error = CCTK_GroupIndex("AMReX::regrid_error");
  assert(gi_regrid_error >= 0);
  const int gi_refinement_level = CCTK_GroupIndex("AMReX::refinement_level");
  assert(gi_refinement_level >= 0);

Insertion in AMReX/src/schedule.cxx at line 624 [13.531]

[15.631]

    // Don't restrict the regridding error nor the refinement level
    if (gi == gi_regrid_error || gi == gi_refinement_level)
      continue;

Deletion in WaveToyAMReX/README at line 14 [4.14802]

B:BD[7.11872] → [7.11872:12111]


Scalar wave equation:
  phi,tt = phi,xx
Introduce new variable:
  psi = phi,t
New set of equations:
  phi,t = psi
  psi,t = phi,tt = phi,xx
Discretization:
  phi_0 = phi_1 + dt psi_1
  psi_0 = psi_1 + dt phi_1,xx
3. Fancy equations:

Replacement in WaveToyAMReX/README at line 21 [4.14802]

B:BD[7.12255] → [7.12255:12390]

  psi = phi,t
New set of equations:
  phi,t = psi
  psi,t = phi,tt = phi,xx
New, equivalent discretization:
  phi_0 - phi_1 = dt psi_1

[7.12255]

[7.12390]

  psi_0 = (phi_0 - phi_1) / dt

Replacement in WaveToyAMReX/README at line 23 [4.14802]

B:BD[7.12391] → [7.12391:12503]

  phi_0 - 2 phi_1 + phi_2 = dt^2 phi_1,xx
  dt psi_1 - dt psi_2 = dt^2 phi_1,xx
  psi_1 = psi_2 + dt^2 phi_1,xx

[7.12391]

[7.12503]

Some calculations:
  psi_1 = (phi_1 - phi_2) / dt
  phi_0 = 2 phi_1 - phi_2 + dt^2 phi_1,xx
  phi_0 = phi_1 + phi_1 - phi_2 + dt^2 phi_1,xx

Replacement in WaveToyAMReX/README at line 28 [4.14802]

B:BD[7.12504] → [7.12504:12607]

  phi_0 = phi_1 + dt psi_1
  psi_0 = psi_1 + dt phi_0,xx
        = psi_1 + dt phi_1,xx + dt^2 psi_1,xx

[7.12504]

  phi_0 = phi_1 + dt psi_1 + dt^2 phi_1,xx
  psi_0 = (phi_0 - phi_1) / dt
New set of equations:
  psi_0 = psi_1 + dt phi_1,xx
  phi_0 = phi_1 + dt psi_0

Replacement in WaveToyAMReX/interface.ccl at line 9 [4.10196]
B:BD[19.1526] → [10.6873:6908]
```
CCTK_REAL phi TYPE=gf TIMELEVELS=3
```
[19.1526]
[10.6908]
```
CCTK_REAL phi TYPE=gf TIMELEVELS=2
```
Replacement in WaveToyAMReX/interface.ccl at line 12 [4.10196]
B:BD[10.6916] → [7.12608:12616]
```
  # psi
```
[10.6916]
[10.6916]
```
  psi
```
Replacement in WaveToyAMReX/interface.ccl at line 23 [4.10196]
B:BD[7.12698] → [7.12698:12709]
∅:D[7.12709] → [10.6979:7027]
B:BD[20.2036] → [10.6979:7027]
```
  # psierr
} "Error in scalar potential for wave equation"
```
[7.12698]
```
  psierr
} "Error of wave equation solution"
```

Insertion in WaveToyAMReX/param.ccl at line 2 [4.10131]

[4.10179]


KEYWORD initial_condition "Initial condition"
{
  "standing wave" :: ""
  "periodic Gaussian" :: ""
} "standing wave"
CCTK_REAL spatial_frequency_x "spatial frequency"
{
  *:* :: ""
} 0.5
CCTK_REAL spatial_frequency_y "spatial frequency"
{
  *:* :: ""
} 0.5
CCTK_REAL spatial_frequency_z "spatial frequency"
{
  *:* :: ""
} 0.5
CCTK_REAL width "width"
{
  (0.0:* :: ""
} 0.1
CCTK_REAL phi_abs "Typical value of phi to determine absolute error" STEERABLE=always
{
  (0.0:* :: ""
} 1.0

Replacement in WaveToyAMReX/schedule.ccl at line 9 [4.9594]
B:BD[19.1890] → [3.6534:6575]
```
SCHEDULE WaveToyAMReX_Tag AT postinitial
```
[19.1890]
[3.6575]
```
SCHEDULE WaveToyAMReX_EstimateError AT postinitial
```
Replacement in WaveToyAMReX/schedule.ccl at line 12 [4.9594]
B:BD[3.6587] → [3.6587:6617]
```
} "Tag to-be-refined regions"
```
[3.6587]
[3.6617]
```
} "Estimate local error for regridding initial conditions"
```

Insertion in WaveToyAMReX/schedule.ccl at line 20 [4.9594]

[7.12711]

SCHEDULE WaveToyAMReX_EstimateError AT poststep
{
  LANG: C
} "Estimate local error for regridding during evolution"

Insertion in WaveToyAMReX/src/wavetoy.cxx at line 5 [4.37]
[4.215]
[4.233]
```
#include <cassert>
```
Deletion in WaveToyAMReX/src/wavetoy.cxx at line 25 [4.37]
B:BD[7.12977] → [7.12977:13034]
```
    // return (f(t + dt, x, y, z) - f(t, x, y, z)) / dt;
```

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 31 [4.37]

B:BD[4.632] → [7.13096:13199]

  T kx = 2 * M_PI / 2, ky = 2 * M_PI / 2, kz = 2 * M_PI / 2;
  // T kx = 2 * M_PI / 2, ky = 0, kz = 0;

[4.632]

[4.724]

  DECLARE_CCTK_PARAMETERS;
  T kx = 2 * M_PI * spatial_frequency_x;
  T ky = 2 * M_PI * spatial_frequency_y;
  T kz = 2 * M_PI * spatial_frequency_z;

Insertion in WaveToyAMReX/src/wavetoy.cxx at line 39 [4.37]

[19.2035]

// Standing wave
template <typename T> T gaussian(T t, T x, T y, T z) {
  DECLARE_CCTK_PARAMETERS;
  T kx = M_PI * spatial_frequency_x;
  T ky = M_PI * spatial_frequency_y;
  T kz = M_PI * spatial_frequency_z;
  T omega = sqrt(sqr(kx) + sqr(ky) + sqr(kz));
  return exp(-0.5 * sqr(sin(kx * x + ky * y + kz * z - omega * t) / width));
}

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 69 [4.37]

B:BD[7.13403] → [7.13403:13493]

  for (int k = imin[2]; k < imax[2]; ++k) {
    for (int j = imin[1]; j < imax[1]; ++j) {

[7.13403]

[4.4979]

  if (CCTK_EQUALS(initial_condition, "standing wave")) {
    for (int k = imin[2]; k < imax[2]; ++k) {
      for (int j = imin[1]; j < imax[1]; ++j) {

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 74 [4.37]

B:BD[4.4996] → [7.13494:13542]

∅:D[7.13542] → [20.2959:3279]

B:BD[20.2959] → [20.2959:3279]

B:BD[20.3279] → [7.13543:13602]

      for (int i = imin[0]; i < imax[0]; ++i) {
        const int idx = CCTK_GFINDEX3D(cctkGH, i, j, k);
        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);

[4.4996]

[19.3756]

        for (int i = imin[0]; i < imax[0]; ++i) {
          const int idx = CCTK_GFINDEX3D(cctkGH, i, j, k);
          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);
        }
      }
    }
  } else if (CCTK_EQUALS(initial_condition, "periodic Gaussian")) {
    for (int k = imin[2]; k < imax[2]; ++k) {
      for (int j = imin[1]; j < imax[1]; ++j) {
#pragma omp simd
        for (int i = imin[0]; i < imax[0]; ++i) {
          const int idx = CCTK_GFINDEX3D(cctkGH, i, j, k);
          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);
        }

Insertion in WaveToyAMReX/src/wavetoy.cxx at line 102 [4.37]
[12.2614]
[12.2614]
```
  } else {
    assert(0);
```

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 108 [4.37]

B:BD[3.6620] → [3.6620:6671]

extern "C" void WaveToyAMReX_Tag(CCTK_ARGUMENTS) {

[3.6620]

[3.6671]

extern "C" void WaveToyAMReX_EstimateError(CCTK_ARGUMENTS) {

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 112 [4.37]

B:BD[4.5452] → [3.6725:6860]

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

[4.5452]

[3.6860]

  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 121 [4.37]

B:BD[3.7067] → [3.7067:7295]

B:BD[3.7295] → [7.13603:13637]

∅:D[7.13637] → [15.1267:1327]

B:BD[3.7295] → [15.1267:1327]

        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];
        CCTK_REAL r = sqrt(sqr(x) + sqr(y) + sqr(z));
        // CCTK_REAL r = fabs(x);
        tag[idx] = r <= 0.5 / cctk_levfac[0] - 0.5 * dx[0];

[3.7067]

[3.7324]

        CCTK_REAL base_phi = fabs(phi[idx]) + fabs(phi_abs);
        CCTK_REAL errx_phi =
            fabs(phi[idx - di] - 2 * phi[idx] + phi[idx + di]) / base_phi;
        CCTK_REAL erry_phi =
            fabs(phi[idx - dj] - 2 * phi[idx] + phi[idx + dj]) / base_phi;
        CCTK_REAL errz_phi =
            fabs(phi[idx - dk] - 2 * phi[idx] + phi[idx + dk]) / base_phi;
        regrid_error[idx] = errx_phi + erry_phi + errz_phi;

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 165 [4.37]

B:BD[19.5321] → [7.13982:14727]

∅:D[7.14727] → [19.5373:5433]

B:BD[19.5373] → [19.5373:5433]

        // CCTK_REAL ddx_psi =
        //     (psi_p[idx - di] - 2 * psi_p[idx] + psi_p[idx + di]) /
        //     sqr(dx[0]);
        // CCTK_REAL ddy_psi =
        //     (psi_p[idx - dj] - 2 * psi_p[idx] + psi_p[idx + dj]) /
        //     sqr(dx[1]);
        // CCTK_REAL ddz_psi =
        //     (psi_p[idx - dk] - 2 * psi_p[idx] + psi_p[idx + dk]) /
        //     sqr(dx[2]);
        // phi[idx] = phi_p[idx] + dt * psi_p[idx];
        // psi[idx] = psi_p[idx] + dt * (ddx_phi + ddy_phi + ddz_phi) +
        //            sqr(dt) * (ddx_psi + ddy_psi + ddz_psi);
        // phi[idx] = phi_p[idx] + dt * psi_p[idx];
        // psi[idx] = psi_p[idx] + dt * (ddx_phi + ddy_phi + ddz_phi);
        phi[idx] = 2 * phi_p[idx] - phi_p_p[idx] +
                   sqr(dt) * (ddx_phi + ddy_phi + ddz_phi);

[19.5321]

[7.14728]

        // phi[idx] = 2 * phi_p[idx] - phi_p_p[idx] +
        //            sqr(dt) * (ddx_phi + ddy_phi + ddz_phi);
        psi[idx] = psi_p[idx] + dt * (ddx_phi + ddy_phi + ddz_phi);
        phi[idx] = phi_p[idx] + dt * psi[idx];

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 198 [4.37]

B:BD[7.15494] → [7.15494:15853]

        CCTK_REAL dt_phi = (phi[idx] - phi_p[idx]) / dt;
        CCTK_REAL dx_phi = (phi[idx + di] - phi[idx - di]) / (2 * dx[0]);
        CCTK_REAL dy_phi = (phi[idx + dj] - phi[idx - dj]) / (2 * dx[1]);
        CCTK_REAL dz_phi = (phi[idx + dk] - phi[idx - dk]) / (2 * dx[2]);
        eps[idx] = (sqr(dt_phi) + sqr(dx_phi) + sqr(dy_phi) + sqr(dz_phi)) / 2;

[7.15494]

[19.5433]

        CCTK_REAL ddx_phi =
            (phi[idx - di] - 2 * phi[idx] + phi[idx + di]) / sqr(dx[0]);
        CCTK_REAL ddy_phi =
            (phi[idx - dj] - 2 * phi[idx] + phi[idx + dj]) / sqr(dx[1]);
        CCTK_REAL ddz_phi =
            (phi[idx - dk] - 2 * phi[idx] + phi[idx + dk]) / sqr(dx[2]);
        CCTK_REAL psi_n = psi[idx] + dt * (ddx_phi + ddy_phi + ddz_phi);
        CCTK_REAL dt_phi_p = psi_n;
        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] =
            (sqr(dt_phi_p) + sqr(dt_phi_m) + sqr(dx_phi_p) + sqr(dx_phi_m) +
             sqr(dy_phi_p) + sqr(dy_phi_m) + sqr(dz_phi_p) + sqr(dz_phi_m)) /
            4;

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 227 [4.37]
B:BD[20.3664] → [7.15854:15897]
```
  // const CCTK_REAL dt = CCTK_DELTA_TIME;
```
[20.3664]
[9.6580]
```
  const CCTK_REAL dt = CCTK_DELTA_TIME;
```

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 234 [4.37]

B:BD[4.7715] → [12.2717:2803]

  for (int k = 0; k < cctk_lsh[2]; ++k) {
    for (int j = 0; j < cctk_lsh[1]; ++j) {

[4.7715]

[4.8503]

  if (CCTK_EQUALS(initial_condition, "standing wave")) {
    for (int k = 0; k < cctk_lsh[2]; ++k) {
      for (int j = 0; j < cctk_lsh[1]; ++j) {

Replacement in WaveToyAMReX/src/wavetoy.cxx at line 239 [4.37]

B:BD[4.8520] → [20.3863:4140]

B:BD[20.4140] → [7.15898:16026]

      for (int i = 0; i < cctk_lsh[0]; ++i) {
        const int idx = CCTK_GFINDEX3D(cctkGH, i, j, k);
        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);

[4.8520]

[19.6606]

        for (int i = 0; i < cctk_lsh[0]; ++i) {
          const int idx = CCTK_GFINDEX3D(cctkGH, i, j, k);
          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);
        }

Insertion in WaveToyAMReX/src/wavetoy.cxx at line 249 [4.37]

[12.2810]


  } else if (CCTK_EQUALS(initial_condition, "periodic Gaussian")) {
    for (int k = 0; k < cctk_lsh[2]; ++k) {
      for (int j = 0; j < cctk_lsh[1]; ++j) {
#pragma omp simd
        for (int i = 0; i < cctk_lsh[0]; ++i) {
          const int idx = CCTK_GFINDEX3D(cctkGH, i, j, k);
          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);
        }
      }
    }

AMR is now adaptive

Dependencies

In channels

Change contents

Replacement in AMReX/interface.ccl at line 11 [4.17976]

Replacement in AMReX/interface.ccl at line 13 [4.17976]

File addition: planewave.par (-rw-r--r--)

Insertion in AMReX/param.ccl at line 110 [4.17918]

Insertion in AMReX/param.ccl at line 116 [4.17918]

Insertion in AMReX/param.ccl at line 121 [4.17918]

Insertion in AMReX/src/driver.cxx at line 11 [4.15972]

Insertion in AMReX/src/driver.cxx at line 14 [4.15972]

Replacement in AMReX/src/driver.cxx at line 82 [4.15972]

Replacement in AMReX/src/driver.cxx at line 106 [4.15972]

Replacement in AMReX/src/driver.cxx at line 119 [4.15972]

Insertion in AMReX/src/driver.cxx at line 125 [4.15972]

Replacement in AMReX/src/driver.cxx at line 136 [4.15972]

Replacement in AMReX/src/driver.cxx at line 165 [4.15972]

Replacement in AMReX/src/driver.cxx at line 170 [4.15972]

Replacement in AMReX/src/driver.cxx at line 175 [4.15972]

Replacement in AMReX/src/driver.cxx at line 209 [4.15972]

Replacement in AMReX/src/driver.cxx at line 213 [4.15972]

Replacement in AMReX/src/driver.cxx at line 274 [4.15972]

Replacement in AMReX/src/driver.cxx at line 277 [4.15972]

Deletion in AMReX/src/driver.cxx at line 285 [4.15972]

Deletion in AMReX/src/driver.cxx at line 387 [4.15972]

Deletion in AMReX/src/driver.cxx at line 389 [4.15972]

Deletion in AMReX/src/driver.cxx at line 413 [4.15972]

Replacement in AMReX/src/driver.cxx at line 415 [4.15972]

Replacement in AMReX/src/driver.cxx at line 418 [4.15972]

Replacement in AMReX/src/driver.cxx at line 420 [4.15972]

Deletion in AMReX/src/driver.cxx at line 422 [4.15972]

Replacement in AMReX/src/driver.cxx at line 423 [4.15972]

Replacement in AMReX/src/driver.cxx at line 425 [4.15972]

Replacement in AMReX/src/driver.hxx at line 42 [4.15275]

Replacement in AMReX/src/driver.hxx at line 44 [4.15275]

Replacement in AMReX/src/driver.hxx at line 46 [4.15275]

Replacement in AMReX/src/driver.hxx at line 48 [4.15275]

Replacement in AMReX/src/driver.hxx at line 50 [4.15275]

Deletion in AMReX/src/schedule.cxx at line 40 [13.531]

Replacement in AMReX/src/schedule.cxx at line 341 [13.531]

Replacement in AMReX/src/schedule.cxx at line 352 [13.531]

Replacement in AMReX/src/schedule.cxx at line 361 [13.531]

Replacement in AMReX/src/schedule.cxx at line 366 [13.531]

Insertion in AMReX/src/schedule.cxx at line 445 [13.531]

Insertion in AMReX/src/schedule.cxx at line 454 [13.531]

Replacement in AMReX/src/schedule.cxx at line 536 [13.531]

Deletion in AMReX/src/schedule.cxx at line 540 [13.531]

Deletion in AMReX/src/schedule.cxx at line 596 [13.531]