eschnett/cactusamrex - Change JYHNXXG3OJTYBJ2U3WMKUS6N5WHXO773WXVRNSJLBC5FGEYLJP2AC

MaxwellToyAMReX: Rearrange and modernize code

Created by Erik Schnetter on October 21, 2019

JYHNXXG3OJTYBJ2U3WMKUS6N5WHXO773WXVRNSJLBC5FGEYLJP2AC

Dependencies

In channels

master

main

Change contents

Insertion in MaxwellToyAMReX/README at line 8 [3.8298]

[3.8544]


Solve the Maxwell equations.
2. Derivatives, and constraint preservation
We store variables and calculate derivatives in a way that is very
similar to discrete differential forms. Scalars live on vertices,
vectors on edges, fluxes on faces, and densities in cells. This
happens in 4D, leading to a staggered evolution scheme. We have the
following variables:
- electric potential phi: vertex, staggered in time (equivalent to a
  timelike edge)
- magnetic vector potential A^i: (spacelike) edges
- electric field E^i: (spacelike) edges, staggered in time

Replacement in MaxwellToyAMReX/README at line 28 [3.8298]

B:BD[3.8545] → [3.8545:8573]

Solve the Maxwell equations

[3.8545]

- magnetic field B^i: faces
- electric charge density rho: vertex (equivalent to dual cell),
  staggered in time
- electric current density j^i: edges (equivalent to dual face)
- electric constraint div E: vertices (equivalent to dual cell),
  staggered in time
- magnetic constraint div B: cell
When calculating derivatives, we divide by the grid spacing (unlike
from differential forms). This is for convenience only.
In terms of differential forms, our variables correspond to the
following. The notation [phi, A] means that phi and A^i are the time
and space components of a 4-vector.
- A: [phi, A]: 1-form
- F: [E^i, B^i]: 2-form
- j: *[rho, j^i]: 3-form living on dual grid
- *[div E]: 4-form living on dual grid
- *[div B]: 4-form
4d Equations:
- F = dA
- dF = 0
- d*F = 0
3+1 Equations:
- E = dphi
- B = dA
- *d*E = *rho
- *d*B = *j
(TODO: Correct and complete equations)
3. How to calculate consistent derivatives with mesh refinement
Prolongation opterators need to be conservative in cell centred
directions, and interpolating in vertex centred directions. We want
linear accuracy for vertex centred and constant accuracy for cell
centred directions.

Insertion in MaxwellToyAMReX/interface.ccl at line 134 [3.13068]

[4.20274]


CCTK_REAL constraints_dive TYPE=gf TAGS='index={0 0 0} checkpoint="no"'
{
  dive
} "Electric constraint"
CCTK_REAL constraints_divb TYPE=gf TAGS='index={1 1 1} checkpoint="no"'
{
  divb
} "Magnetic constraint"

Deletion in MaxwellToyAMReX/interface.ccl at line 212 [3.13068]
B:BD[5.7601] → [2.12214:12286]
∅:D[2.12286] → [5.7657:7682]
B:BD[5.7657] → [5.7657:7682]
B:BD[5.7682] → [2.12287:12359]
∅:D[2.12359] → [5.7738:7766]
B:BD[5.7738] → [5.7738:7766]
```
CCTK_REAL constraints_dive TYPE=gf TAGS='index={0 0 0} checkpoint="no"'
{
  dive
} "Constraints"
CCTK_REAL constraints_divb TYPE=gf TAGS='index={1 1 1} checkpoint="no"'
{
  divb
} "Constraints"
```
Insertion in MaxwellToyAMReX/schedule.ccl at line 4 [3.15053]
[5.10026]
[5.10026]

Replacement in MaxwellToyAMReX/schedule.ccl at line 9 [3.15053]

B:BD[6.13388] → [6.13388:13780]

    WRITES: potential_phi(everywhere)
    WRITES: potential_ax(everywhere) potential_ay(everywhere) potential_az(everywhere)
    WRITES: field_ex(everywhere) field_ey(everywhere) field_ez(everywhere)
    WRITES: field_bx(everywhere) field_by(everywhere) field_bz(everywhere)
    WRITES: current_rho(everywhere)
    WRITES: current_jx(everywhere) current_jy(everywhere) current_jz(everywhere)

[6.13388]

[6.13780]

    WRITES: potential_phi(interior)
    WRITES: potential_ax(interior) potential_ay(interior) potential_az(interior)
    WRITES: field_ex(interior) field_ey(interior) field_ez(interior)
    WRITES: field_bx(interior) field_by(interior) field_bz(interior)
    WRITES: current_rho(interior)
    WRITES: current_jx(interior) current_jy(interior) current_jz(interior)

Insertion in MaxwellToyAMReX/schedule.ccl at line 23 [3.15053]
[5.10361]
[5.10361]
Insertion in MaxwellToyAMReX/schedule.ccl at line 25 [3.15053]
[5.10370]
[5.10370]

Replacement in MaxwellToyAMReX/schedule.ccl at line 30 [3.15053]

B:BD[6.13783] → [6.13783:14100]

    WRITES: potential_phi(everywhere)
    WRITES: potential_ax(everywhere) potential_ay(everywhere) potential_az(everywhere)
    WRITES: field_ex(everywhere) field_ey(everywhere) field_ez(everywhere)
    WRITES: current_rho(everywhere)
    WRITES: current_jx(everywhere) current_jy(everywhere) current_jz(everywhere)

[6.13783]

[6.14100]

    WRITES: potential_phi(interior)
    WRITES: potential_ax(interior) potential_ay(interior) potential_az(interior)
    WRITES: field_ex(interior) field_ey(interior) field_ez(interior)
    WRITES: current_rho(interior)
    WRITES: current_jx(interior) current_jy(interior) current_jz(interior)

Replacement in MaxwellToyAMReX/schedule.ccl at line 47 [3.15053]

B:BD[6.14104] → [6.14104:14179]

    WRITES: field_bx(everywhere) field_by(everywhere) field_bz(everywhere)

[6.14104]

[6.14179]

    READS: potential_ax(interior) potential_ay(interior) potential_az(interior)
    WRITES: field_bx(interior) field_by(interior) field_bz(interior)

Insertion in MaxwellToyAMReX/schedule.ccl at line 52 [3.15053]
[5.10840]
[5.10840]

Insertion in MaxwellToyAMReX/schedule.ccl at line 69 [3.15053]

[3.15348]

[7.2099]

SCHEDULE MaxwellToyAMReX_EstimateError AT poststep
{
  LANG: C
  READS: potential_phi(everywhere)
  READS: potential_ax(everywhere) potential_ay(everywhere) potential_az(everywhere)
  READS: field_ex(everywhere) field_ey(everywhere) field_ez(everywhere)
  READS: field_bx(everywhere) field_by(everywhere) field_bz(everywhere)
  WRITES: AMReX::regrid_error(interior)
} "Estimate local error for regridding during evolution"

Insertion in MaxwellToyAMReX/schedule.ccl at line 95 [3.15053]
[7.2418]
[5.10843]
Insertion in MaxwellToyAMReX/schedule.ccl at line 98 [3.15053]
[5.10859]
[5.10859]
Insertion in MaxwellToyAMReX/schedule.ccl at line 118 [3.15053]
[5.11090]
[5.11090]
Insertion in MaxwellToyAMReX/schedule.ccl at line 120 [3.15053]
[5.11099]
[5.11099]

Insertion in MaxwellToyAMReX/schedule.ccl at line 142 [3.15053]

[6.15682]

    READS: potential_ax(interior) potential_ay(interior) potential_az(interior)

Insertion in MaxwellToyAMReX/schedule.ccl at line 170 [3.15053]
[3.15632]
[7.2419]
Deletion in MaxwellToyAMReX/schedule.ccl at line 184 [3.15053]
B:BD[7.2740] → [7.2740:2803]
```
SCHEDULE MaxwellToyAMReX_EstimateError AT poststep
{
  LANG: C
```

Deletion in MaxwellToyAMReX/schedule.ccl at line 185 [3.15053]

B:BD[6.16278] → [6.16278:16582]

∅:D[6.16582] → [7.2803:2860]

B:BD[7.2803] → [7.2803:2860]

  READS: potential_phi(everywhere)
  READS: potential_ax(everywhere) potential_ay(everywhere) potential_az(everywhere)
  READS: field_ex(everywhere) field_ey(everywhere) field_ez(everywhere)
  READS: field_bx(everywhere) field_by(everywhere) field_bz(everywhere)
  WRITES: AMReX::regrid_error(interior)
} "Estimate local error for regridding during evolution"

Deletion in MaxwellToyAMReX/schedule.ccl at line 234 [3.15053]

B:BD[3.16095] → [8.0:91]


SCHEDULE MaxwellToyAMReX_NaNCheck AT analysis AS zzz_MaxwellToyAMReX_NaNCheck
{
  LANG: C

Replacement in MaxwellToyAMReX/schedule.ccl at line 235 [3.15053]

B:BD[6.17664] → [6.17664:18038]

∅:D[6.18038] → [8.91:110]

B:BD[8.91] → [8.91:110]

  READS: potential_phi(everywhere)
  READS: potential_ax(everywhere) potential_ay(everywhere) potential_az(everywhere)
  READS: field_ex(everywhere) field_ey(everywhere) field_ez(everywhere)
  READS: field_bx(everywhere) field_by(everywhere) field_bz(everywhere)
  READS: current_rho(everywhere)
  READS: current_jx(everywhere) current_jy(everywhere) current_jz(everywhere)
} "Check for NaNs"

[6.17664]

# SCHEDULE MaxwellToyAMReX_NaNCheck AT analysis AS zzz_MaxwellToyAMReX_NaNCheck
# {
#   LANG: C
# 
#   READS: potential_phi(everywhere)
#   READS: potential_ax(everywhere) potential_ay(everywhere) potential_az(everywhere)
#   READS: field_ex(everywhere) field_ey(everywhere) field_ez(everywhere)
#   READS: field_bx(everywhere) field_by(everywhere) field_bz(everywhere)
#   READS: current_rho(everywhere)
#   READS: current_jx(everywhere) current_jy(everywhere) current_jz(everywhere)
#   READS: dive(everywhere)
#   READS: divb(everywhere)
# } "Check for NaNs"

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 4 [3.16301]
B:BD[3.16320] → [3.16320:16348]
```
#include <cctk_Arguments.h>
```
[3.16320]
[3.16348]
```
#include <cctk_Arguments_Checked.h>
```
Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 118 [3.16301]
B:BD[3.18473] → [3.18473:18499]
```
  DECLARE_CCTK_ARGUMENTS;
```
[3.18473]
[3.18499]
```
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_Initialize;
```
Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 333 [3.16301]
B:BD[5.16565] → [5.16565:16591]
```
  DECLARE_CCTK_ARGUMENTS;
```
[5.16565]
[5.16591]
```
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_Dependents1;
```

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 361 [3.16301]

[3.20519]


extern "C" void MaxwellToyAMReX_EstimateError(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_EstimateError;
  DECLARE_CCTK_PARAMETERS;
  const Loop::GF3D<const 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);
#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    regrid_error[p.idx] = fabs(p.x) < 0.5 && fabs(p.y) < 0.5 && fabs(p.z) <
    0.5;
  });
#endif
#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    CCTK_REAL err = 0;
    for (int b = 0; b < 2; ++b)
      for (int a = 0; a < 2; ++a)
        err += fabs(ax_(p.i - 1, p.j + a, p.k + b) -
                    2 * ax_(p.i, p.j + a, p.k + b) +
                    ax_(p.i + 1, p.j + a, p.k + b)) +
               fabs(ay_(p.i + a, p.j - 1, p.k + b) -
                    2 * ay_(p.i + a, p.j, p.k + b) +
                    ay_(p.i + a, p.j + 1, p.k + b)) +
               fabs(az_(p.i + a, p.j + b, p.k - 1) -
                    2 * az_(p.i + a, p.j + b, p.k) +
                    az_(p.i + a, p.j + b, p.k + 1));
    regrid_error[p.idx] = err;
  });
#endif
#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    auto closeto = [&](CCTK_REAL x, CCTK_REAL y, CCTK_REAL z, CCTK_REAL r) {
      return fabs(p.x - x) <= r && fabs(p.y - y) <= r && fabs(p.z - z) <= r;
    };
    constexpr CCTK_REAL x = 0.25;
    constexpr CCTK_REAL y = 0.25;
    constexpr CCTK_REAL z = 0.25;
    constexpr CCTK_REAL r = 0.2;
    regrid_error[p.idx] = // closeto(-x, -y, -z, r) ||
        closeto(+x, -y, -z, r) || closeto(-x, +y, -z, r) ||
        closeto(+x, +y, -z, r) || closeto(-x, -y, +z, r) ||
        closeto(+x, -y, +z, r) || closeto(-x, +y, +z, r) ||
        closeto(+x, +y, +z, r);
  });
#endif

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 422 [3.16301]

[3.20520]

#if 1
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    CCTK_REAL err = 0;
    const auto accum = [&](CCTK_REAL x) { err += fabs(x); };
    const auto diffx = [&](const auto &var_, int i, int j, int k) {
      for (int b = 0; b < 2; ++b)
        for (int a = 0; a < 2; ++a)
          accum(var_(i + 1, j + a, k + b) - var_(i, j + a, k + b));
    };
    const auto diffy = [&](const auto &var_, int i, int j, int k) {
      for (int b = 0; b < 2; ++b)
        for (int a = 0; a < 2; ++a)
          accum(var_(i + a, j + 1, k + b) - var_(i + a, j, k + b));
    };
    const auto diffz = [&](const auto &var_, int i, int j, int k) {
      for (int b = 0; b < 2; ++b)
        for (int a = 0; a < 2; ++a)
          accum(var_(i + a, j + b, k + 1) - var_(i + a, j + b, k));
    };
    const auto diff000 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff100 = [&](const auto &var_) {
      diffx(var_, p.i - 1, p.j, p.k);
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff010 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j - 1, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff001 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k - 1);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff011 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j - 1, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k - 1);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff101 = [&](const auto &var_) {
      diffx(var_, p.i - 1, p.j, p.k);
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k - 1);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff110 = [&](const auto &var_) {
      diffx(var_, p.i - 1, p.j, p.k);
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j - 1, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    diff000(phi_);
    diff100(ax_);
    diff010(ay_);
    diff001(az_);
    diff100(ex_);
    diff010(ey_);
    diff001(ez_);
    diff011(bx_);
    diff101(by_);
    diff110(bz_);
    regrid_error[p.idx] = err;
  });
#endif
}
extern "C" void MaxwellToyAMReX_Boundaries(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_Boundaries;
  DECLARE_CCTK_PARAMETERS;
  // Do nothing; boundary conditions consist of synchronization only
}

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 508 [3.16301]
B:BD[3.20578] → [3.20578:20604]
```
  DECLARE_CCTK_ARGUMENTS;
```
[3.20578]
[3.20604]
```
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_Evolve1;
```
Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 638 [3.16301]
B:BD[3.21783] → [3.21783:21809]
```
  DECLARE_CCTK_ARGUMENTS;
```
[3.21783]
[3.21809]
```
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_Evolve2;
```

Deletion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 735 [3.16301]

B:BD[5.20491] → [7.2862:3022]

}
extern "C" void MaxwellToyAMReX_Boundaries(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS;
  // Do nothing; boundary conditions consist of synchronization only

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 737 [3.16301]

B:BD[8.112] → [8.112:197]

extern "C" void MaxwellToyAMReX_NaNCheck(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS;

[8.112]

[8.197]

extern "C" void MaxwellToyAMReX_Constraints(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_Constraints;

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 741 [3.16301]

B:BD[8.225] → [8.225:289]

  const Loop::GF3D<const CCTK_REAL, 0, 0, 0> phi_(cctkGH, phi);

[8.225]

[8.289]

  if (analyse_every <= 0 || cctk_iteration % analyse_every != 0)
    return;

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 744 [3.16301]

B:BD[8.290] → [8.290:476]

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

[8.290]

[8.476]

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

Deletion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 757 [3.16301]

B:BD[8.915] → [8.915:1169]

∅:D[8.1169] → [3.22986:22987]

B:BD[3.22986] → [3.22986:22987]

B:BD[3.22987] → [8.1170:2585]


  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<const CCTK_REAL, 0, 0, 0> dive_(cctkGH, dive);
  const Loop::GF3D<const CCTK_REAL, 1, 1, 1> divb_(cctkGH, divb);
  const auto nancheck = [&](const CCTK_REAL *restrict var,
                            const Loop::PointDesc &p) {
    if (CCTK_isnan(var[p.idx]))
      CCTK_VERROR("Found nan at [%d,%d,%d]", p.i, p.j, p.k);
  };
  Loop::loop_all<0, 0, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(phi, p); });
  Loop::loop_all<1, 0, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ax, p); });
  Loop::loop_all<0, 1, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ay, p); });
  Loop::loop_all<0, 0, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(az, p); });
  Loop::loop_all<1, 0, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ex, p); });
  Loop::loop_all<0, 1, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ey, p); });
  Loop::loop_all<0, 0, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ez, p); });
  Loop::loop_all<0, 1, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(bx, p); });
  Loop::loop_all<1, 0, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(by, p); });
  Loop::loop_all<1, 1, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(bz, p); });

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 758 [3.16301]

B:BD[8.2586] → [8.2586:2700]

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

[8.2586]

[8.2700]

  const Loop::GF3D<CCTK_REAL, 0, 0, 0> dive_(cctkGH, dive);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 760 [3.16301]

B:BD[8.2701] → [8.2701:3040]

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

[8.2701]

[8.3040]

  const Loop::GF3D<CCTK_REAL, 1, 1, 1> divb_(cctkGH, divb);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 762 [3.16301]

B:BD[8.3041] → [2.12360:12510]

∅:D[2.12510] → [8.3156:3157]

B:BD[8.3156] → [8.3156:3157]

B:BD[8.3157] → [2.12511:12661]

∅:D[2.12661] → [8.3272:3275]

B:BD[8.3272] → [8.3272:3275]

∅:D[8.3275] → [3.22987:23104]

B:BD[3.22987] → [3.22987:23104]

B:BD[3.23104] → [5.20492:20557]

∅:D[5.20557] → [3.23104:23105]

B:BD[3.23104] → [3.23104:23105]

B:BD[3.23105] → [9.8155:8341]

B:BD[9.8341] → [5.20558:20933]

B:BD[5.20933] → [2.12662:13504]

  // Loop::loop_all<0, 0, 0>(cctkGH,
  //                         [&](const Loop::PointDesc &p) { nancheck(dive, p);
  //                         });
  // Loop::loop_all<1, 1, 1>(cctkGH,
  //                         [&](const Loop::PointDesc &p) { nancheck(divb, p);
  //                         });
}
extern "C" void MaxwellToyAMReX_EstimateError(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS;
  DECLARE_CCTK_PARAMETERS;
  const Loop::GF3D<const 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);
#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    regrid_error[p.idx] = fabs(p.x) < 0.5 && fabs(p.y) < 0.5 && fabs(p.z) <
    0.5;
  });
#endif
#if 0
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    CCTK_REAL err = 0;
    for (int b = 0; b < 2; ++b)
      for (int a = 0; a < 2; ++a)
        err += fabs(ax_(p.i - 1, p.j + a, p.k + b) -
                    2 * ax_(p.i, p.j + a, p.k + b) +
                    ax_(p.i + 1, p.j + a, p.k + b)) +
               fabs(ay_(p.i + a, p.j - 1, p.k + b) -
                    2 * ay_(p.i + a, p.j, p.k + b) +
                    ay_(p.i + a, p.j + 1, p.k + b)) +
               fabs(az_(p.i + a, p.j + b, p.k - 1) -
                    2 * az_(p.i + a, p.j + b, p.k) +
                    az_(p.i + a, p.j + b, p.k + 1));
    regrid_error[p.idx] = err;

[8.3041]

[2.13504]

  Loop::loop_int<0, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    dive_(p.i, p.j, p.k) = (ex_(p.i, p.j, p.k) - ex_(p.i - 1, p.j, p.k)) / dx +
                           (ey_(p.i, p.j, p.k) - ey_(p.i, p.j - 1, p.k)) / dy +
                           (ez_(p.i, p.j, p.k) - ez_(p.i, p.j, p.k - 1)) / dz -
                           rho_(p.i, p.j, p.k);

Deletion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 768 [3.16301]
B:BD[2.13510] → [2.13510:13517]
```
#endif
```
Deletion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 769 [3.16301]
B:BD[9.8342] → [2.13518:13524]
```
#if 0
```

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 770 [3.16301]

B:BD[2.13590] → [2.13590:14166]

∅:D[2.14166] → [5.21819:21820]

B:BD[5.21819] → [5.21819:21820]

B:BD[5.21820] → [2.14167:14173]

∅:D[5.21820] → [9.8342:8431]

∅:D[2.14173] → [9.8342:8431]

B:BD[9.8342] → [9.8342:8431]

B:BD[9.8431] → [5.21821:24150]

∅:D[5.24150] → [9.8976:9007]

B:BD[9.8976] → [9.8976:9007]

    auto closeto = [&](CCTK_REAL x, CCTK_REAL y, CCTK_REAL z, CCTK_REAL r) {
      return fabs(p.x - x) <= r && fabs(p.y - y) <= r && fabs(p.z - z) <= r;
    };
    constexpr CCTK_REAL x = 0.25;
    constexpr CCTK_REAL y = 0.25;
    constexpr CCTK_REAL z = 0.25;
    constexpr CCTK_REAL r = 0.2;
    regrid_error[p.idx] = // closeto(-x, -y, -z, r) ||
        closeto(+x, -y, -z, r) || closeto(-x, +y, -z, r) ||
        closeto(+x, +y, -z, r) || closeto(-x, -y, +z, r) ||
        closeto(+x, -y, +z, r) || closeto(-x, +y, +z, r) ||
        closeto(+x, +y, +z, r);
  });
#endif
#if 1
  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    CCTK_REAL err = 0;
    const auto accum = [&](CCTK_REAL x) { err += fabs(x); };
    const auto diffx = [&](const auto &var_, int i, int j, int k) {
      for (int b = 0; b < 2; ++b)
        for (int a = 0; a < 2; ++a)
          accum(var_(i + 1, j + a, k + b) - var_(i, j + a, k + b));
    };
    const auto diffy = [&](const auto &var_, int i, int j, int k) {
      for (int b = 0; b < 2; ++b)
        for (int a = 0; a < 2; ++a)
          accum(var_(i + a, j + 1, k + b) - var_(i + a, j, k + b));
    };
    const auto diffz = [&](const auto &var_, int i, int j, int k) {
      for (int b = 0; b < 2; ++b)
        for (int a = 0; a < 2; ++a)
          accum(var_(i + a, j + b, k + 1) - var_(i + a, j + b, k));
    };
    const auto diff000 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff100 = [&](const auto &var_) {
      diffx(var_, p.i - 1, p.j, p.k);
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff010 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j - 1, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff001 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k - 1);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff011 = [&](const auto &var_) {
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j - 1, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k - 1);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff101 = [&](const auto &var_) {
      diffx(var_, p.i - 1, p.j, p.k);
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k - 1);
      diffz(var_, p.i, p.j, p.k);
    };
    const auto diff110 = [&](const auto &var_) {
      diffx(var_, p.i - 1, p.j, p.k);
      diffx(var_, p.i, p.j, p.k);
      diffy(var_, p.i, p.j - 1, p.k);
      diffy(var_, p.i, p.j, p.k);
      diffz(var_, p.i, p.j, p.k);
    };
    diff000(phi_);
    diff100(ax_);
    diff010(ay_);
    diff001(az_);
    diff100(ex_);
    diff010(ey_);
    diff001(ez_);
    diff011(bx_);
    diff101(by_);
    diff110(bz_);
    regrid_error[p.idx] = err;

[2.13590]

[9.9007]

    divb_(p.i, p.j, p.k) = (bx_(p.i + 1, p.j, p.k) - bx_(p.i, p.j, p.k)) / dx +
                           (by_(p.i, p.j + 1, p.k) - by_(p.i, p.j, p.k)) / dy +
                           (bz_(p.i, p.j, p.k + 1) - bz_(p.i, p.j, p.k)) / dz;

Deletion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 774 [3.16301]
B:BD[9.9013] → [2.14174:14181]
```
#endif
```
Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 777 [3.16301]
B:BD[3.23269] → [3.23269:23295]
```
  DECLARE_CCTK_ARGUMENTS;
```
[3.23269]
[3.23295]
```
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_Error;
```

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1041 [3.16301]

B:BD[5.27089] → [5.27089:27177]

extern "C" void MaxwellToyAMReX_Constraints(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS;

[5.27089]

[5.27177]

#if 0
extern "C" void MaxwellToyAMReX_NaNCheck(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS_MaxwellToyAMReX_NaNCheck;

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1046 [3.16301]

B:BD[3.25588] → [5.27205:27282]

  if (analyse_every <= 0 || cctk_iteration % analyse_every != 0)
    return;

[3.25588]

[5.27282]

  const Loop::GF3D<const CCTK_REAL, 0, 0, 0> phi_(cctkGH, phi);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1048 [3.16301]

B:BD[5.27283] → [5.27283:27415]

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

[5.27283]

[5.27415]

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

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1061 [3.16301]

[5.27854]

[5.28041]


  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<const CCTK_REAL, 0, 0, 0> dive_(cctkGH, dive);

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1068 [3.16301]

B:BD[5.28042] → [5.28042:28102]

  const Loop::GF3D<CCTK_REAL, 0, 0, 0> dive_(cctkGH, dive);

[5.28042]

[5.28102]

  const Loop::GF3D<const CCTK_REAL, 1, 1, 1> divb_(cctkGH, divb);
  const auto nancheck = [&](const CCTK_REAL *restrict var,
                            const Loop::PointDesc &p) {
    if (CCTK_isnan(var[p.idx]))
      CCTK_VERROR("Found nan at [%d,%d,%d]", p.i, p.j, p.k);
  };

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1076 [3.16301]

B:BD[5.28103] → [5.28103:28163]

  const Loop::GF3D<CCTK_REAL, 1, 1, 1> divb_(cctkGH, divb);

[5.28103]

[5.28163]

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

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1079 [3.16301]

B:BD[5.28164] → [5.28164:28524]

  Loop::loop_int<0, 0, 0>(cctkGH, [&](const Loop::PointDesc &p) {
    dive_(p.i, p.j, p.k) = (ex_(p.i, p.j, p.k) - ex_(p.i - 1, p.j, p.k)) / dx +
                           (ey_(p.i, p.j, p.k) - ey_(p.i, p.j - 1, p.k)) / dy +
                           (ez_(p.i, p.j, p.k) - ez_(p.i, p.j, p.k - 1)) / dz -
                           rho_(p.i, p.j, p.k);
  });

[5.28164]

[5.28524]

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

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1086 [3.16301]

B:BD[5.28525] → [5.28525:28836]

  Loop::loop_int<1, 1, 1>(cctkGH, [&](const Loop::PointDesc &p) {
    divb_(p.i, p.j, p.k) = (bx_(p.i + 1, p.j, p.k) - bx_(p.i, p.j, p.k)) / dx +
                           (by_(p.i, p.j + 1, p.k) - by_(p.i, p.j, p.k)) / dy +
                           (bz_(p.i, p.j, p.k + 1) - bz_(p.i, p.j, p.k)) / dz;
  });

[5.28525]

[5.28836]

  Loop::loop_all<1, 0, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ex, p); });
  Loop::loop_all<0, 1, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ey, p); });
  Loop::loop_all<0, 0, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(ez, p); });
  Loop::loop_all<0, 1, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(bx, p); });
  Loop::loop_all<1, 0, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(by, p); });
  Loop::loop_all<1, 1, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(bz, p); });
  Loop::loop_all<0, 0, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(rho, p); });
  Loop::loop_all<1, 0, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(jx, p); });
  Loop::loop_all<0, 1, 0>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(jy, p); });
  Loop::loop_all<0, 0, 1>(cctkGH,
                          [&](const Loop::PointDesc &p) { nancheck(jz, p); });
  // Loop::loop_all<0, 0, 0>(cctkGH,
  //                         [&](const Loop::PointDesc &p) { nancheck(dive, p);
  //                         });
  // Loop::loop_all<1, 1, 1>(cctkGH,
  //                         [&](const Loop::PointDesc &p) { nancheck(divb, p);
  //                         });

Insertion in MaxwellToyAMReX/src/maxwelltoy.cxx at line 1118 [3.16301]
[5.28838]
[5.28838]
```
#endif
```

MaxwellToyAMReX: Rearrange and modernize code

Dependencies

In channels

Change contents

Insertion in MaxwellToyAMReX/README at line 8 [3.8298]

Replacement in MaxwellToyAMReX/README at line 28 [3.8298]

Insertion in MaxwellToyAMReX/interface.ccl at line 134 [3.13068]

Deletion in MaxwellToyAMReX/interface.ccl at line 212 [3.13068]

Insertion in MaxwellToyAMReX/schedule.ccl at line 4 [3.15053]

Replacement in MaxwellToyAMReX/schedule.ccl at line 9 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 23 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 25 [3.15053]

Replacement in MaxwellToyAMReX/schedule.ccl at line 30 [3.15053]

Replacement in MaxwellToyAMReX/schedule.ccl at line 47 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 52 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 69 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 95 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 98 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 118 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 120 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 142 [3.15053]

Insertion in MaxwellToyAMReX/schedule.ccl at line 170 [3.15053]

Deletion in MaxwellToyAMReX/schedule.ccl at line 184 [3.15053]

Deletion in MaxwellToyAMReX/schedule.ccl at line 185 [3.15053]

Deletion in MaxwellToyAMReX/schedule.ccl at line 234 [3.15053]

Replacement in MaxwellToyAMReX/schedule.ccl at line 235 [3.15053]

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 4 [3.16301]

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 118 [3.16301]

Replacement in MaxwellToyAMReX/src/maxwelltoy.cxx at line 333 [3.16301]