eschnett/cactusamrex - Change WNYN6LX3FYXXW3TKGRA7GRLFMIR4YXQMFAWJCB76QAXLY6JR4Q7AC

CarpetX: More progress towards subcycling

Created by Erik Schnetter on June 11, 2020

WNYN6LX3FYXXW3TKGRA7GRLFMIR4YXQMFAWJCB76QAXLY6JR4Q7AC

Dependencies

In channels

master

main

Change contents

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

B:BD[6.403] → [6.403:463]

    assert(current_level == -1);
    current_level = level;

[6.403]

[6.463]

    assert(!active_levels);
    active_levels = make_optional<active_levels_t>(level, level + 1);

Replacement in CarpetX/src/driver.cxx at line 814 [7.15972]
∅:D[8.549] → [6.621:645]
B:BD[6.621] → [6.621:645]
```
    current_level = -1;
```
[8.549]
[6.645]
```
    active_levels = optional<active_levels_t>();
```

Replacement in CarpetX/src/driver.cxx at line 904 [7.15972]

B:BD[6.1130] → [6.1130:1190]

    assert(current_level == -1);
    current_level = level;

[6.1130]

[6.1190]

    assert(!active_levels);
    active_levels = make_optional<active_levels_t>(level, level + 1);

Replacement in CarpetX/src/driver.cxx at line 908 [7.15972]
B:BD[6.1348] → [6.1348:1372]
```
    current_level = -1;
```
[6.1348]
[6.1372]
```
    active_levels = optional<active_levels_t>();
```

Replacement in CarpetX/src/driver.cxx at line 1040 [7.15972]

B:BD[6.1925] → [6.1925:1985]

    assert(current_level == -1);
    current_level = level;

[6.1925]

[6.1985]

    assert(!active_levels);
    active_levels = make_optional<active_levels_t>(level, level + 1);

Replacement in CarpetX/src/driver.cxx at line 1044 [7.15972]
B:BD[6.2143] → [6.2143:2167]
```
    current_level = -1;
```
[6.2143]
[6.2167]
```
    active_levels = optional<active_levels_t>();
```

Insertion in CarpetX/src/schedule.cxx at line 77 [9.531]

[6.3511]

// Used to pass cctkGH into the callbacks for AMReX's regridding functions

Replacement in CarpetX/src/schedule.cxx at line 79 [9.531]

B:BD[6.3540] → [6.3540:3564]

int current_level = -1;

[6.3540]

[10.4579]


// Used to pass active levels from AMReX's regridding functions
optional<active_levels_t> active_levels;

Replacement in CarpetX/src/schedule.cxx at line 610 [9.531]

B:BD[11.1804] → [11.1804:1941]

calculate_checksums(const vector<vector<vector<valid_t> > > &will_write,
                    const int min_level, const int max_level) {

[11.1804]

[11.1941]

calculate_checksums(const vector<vector<vector<valid_t> > > &will_write) {

Replacement in CarpetX/src/schedule.cxx at line 618 [9.531]

B:BD[11.2050] → [11.2050:2169]

  for (int level = min_level; level < max_level; ++level) {
    auto &restrict leveldata = ghext->leveldata.at(level);

[11.2050]

[5.20429]

  assert(active_levels);
  active_levels->loop([&](auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 634 [9.531]

B:BD[11.2686] → [11.2686:2811]

            const tiletag_t tiletag{level, mfi.tilebox(), groupdata.groupindex,
                                    vi, tl};

[11.2686]

[11.2811]

            const tiletag_t tiletag{leveldata.level, mfi.tilebox(),
                                    groupdata.groupindex, vi, tl};

Replacement in CarpetX/src/schedule.cxx at line 676 [9.531]
B:BD[11.4166] → [11.4166:4170]
```
  }
```
[11.4166]
[11.4170]
```
  });
```

Replacement in CarpetX/src/schedule.cxx at line 680 [9.531]

B:BD[11.4193] → [11.4193:4308]

void check_checksums(const checksums_t checksums, const int min_level,
                     const int max_level) {

[11.4193]

[11.4308]

void check_checksums(const checksums_t checksums) {

Replacement in CarpetX/src/schedule.cxx at line 688 [9.531]

B:BD[11.4418] → [11.4418:4537]

  for (int level = min_level; level < max_level; ++level) {
    auto &restrict leveldata = ghext->leveldata.at(level);

[11.4418]

[5.20636]

  assert(active_levels);
  active_levels->loop([&](auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 704 [9.531]

B:BD[11.5054] → [11.5054:5179]

            const tiletag_t tiletag{level, mfi.tilebox(), groupdata.groupindex,
                                    vi, tl};

[11.5054]

[11.5179]

            const tiletag_t tiletag{leveldata.level, mfi.tilebox(),
                                    groupdata.groupindex, vi, tl};

Replacement in CarpetX/src/schedule.cxx at line 747 [9.531]
B:BD[11.6689] → [11.6689:6693]
```
  }
```
[11.6689]
[11.6693]
```
  });
```

Insertion in CarpetX/src/schedule.cxx at line 1215 [9.531]

[12.12879]

[13.945]


  assert(ghext->leveldata.empty());
  assert(!active_levels);
  active_levels = make_optional<active_levels_t>(0, 0);

Insertion in CarpetX/src/schedule.cxx at line 1223 [9.531]
[14.2502]
[14.2502]
```
  active_levels = optional<active_levels_t>();
```

Insertion in CarpetX/src/schedule.cxx at line 1297 [9.531]

[10.5155]

[15.17823]

      assert(!active_levels);
      active_levels = make_optional<active_levels_t>(0, level + 1);

Insertion in CarpetX/src/schedule.cxx at line 1305 [9.531]
[10.5349]
[6.7537]
```
      active_levels = optional<active_levels_t>();
```

Insertion in CarpetX/src/schedule.cxx at line 1358 [9.531]

[14.3123]

[4.7]

  assert(!active_levels);
  active_levels = make_optional<active_levels_t>(0, ghext->leveldata.size());

Replacement in CarpetX/src/schedule.cxx at line 1363 [9.531]

B:BD[4.54] → [4.54:186]

    assert(current_level == -1);
    for (int level = int(ghext->leveldata.size()) - 2; level >= 0; --level)
      Restrict(level);

[4.54]

[4.186]

    assert(active_levels);
    active_levels->loop_reverse([&](const auto &leveldata) {
      if (leveldata.level != int(ghext->leveldata.size()) - 1)
        Restrict(leveldata.level);
    });

Insertion in CarpetX/src/schedule.cxx at line 1376 [9.531]
[14.3267]
[14.3267]
```
  active_levels = optional<active_levels_t>();
```

Replacement in CarpetX/src/schedule.cxx at line 1438 [9.531]

∅:D[16.7832] → [17.9347:9348]

B:BD[17.9347] → [17.9347:9348]

B:BD[17.9348] → [16.7833:7926]


      assert(current_level == -1);
      for (auto &restrict leveldata : ghext->leveldata) {

[16.7832]

[16.7926]

      assert(active_levels);
      active_levels->loop([&](const auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 1454 [9.531]
B:BD[8.6149] → [8.6149:6157]
```
      }
```
[8.6149]
[8.6157]
```
      });
```

Replacement in CarpetX/src/schedule.cxx at line 1495 [9.531]

B:BD[17.10504] → [16.8892:8985]

      assert(current_level == -1);
      for (auto &restrict leveldata : ghext->leveldata) {

[17.10504]

[16.8985]

      assert(active_levels);
      active_levels->loop([&](auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 1515 [9.531]
∅:D[18.694] → [19.2063:2071]
∅:D[20.3393] → [19.2063:2071]
∅:D[8.6560] → [19.2063:2071]
∅:D[16.9904] → [19.2063:2071]
B:BD[19.2063] → [19.2063:2071]
```
      }
```
[20.3393]
[21.3462]
```
      });
```
Replacement in CarpetX/src/schedule.cxx at line 1562 [9.531]
B:BD[8.6562] → [8.6562:6596]
```
    InvalidateTimelevels(cctkGH);
```
[8.6562]
[22.7804]
```
    assert(!active_levels);
```
Replacement in CarpetX/src/schedule.cxx at line 1586 [9.531]
∅:D[23.1980] → [24.4351:4388]
B:BD[24.4351] → [24.4351:4388]
```
        assert(current_level == -1);
```
[23.1980]
[24.4388]
```
        assert(!active_levels);
```

Replacement in CarpetX/src/schedule.cxx at line 1607 [9.531]

∅:D[22.8282] → [14.5566:5595]

B:BD[14.5566] → [14.5566:5595]

    CycleTimelevels(cctkGH);

[22.8282]

[14.5595]

    // Find smallest iteration number. Levels at this iteration will
    // be evolved.
    rat64 iteration = ghext->leveldata.at(0).iteration;
    for (const auto &leveldata : ghext->leveldata)
      iteration = min(iteration, leveldata.iteration);

Replacement in CarpetX/src/schedule.cxx at line 1613 [9.531]

B:BD[14.5596] → [14.5596:5679]

    CCTK_Traverse(cctkGH, "CCTK_PRESTEP");
    CCTK_Traverse(cctkGH, "CCTK_EVOL");

[14.5596]

[25.2949]

    // Loop over all levels, in batches that combine levels that don't
    // subcycle. The level range is [min_level, max_level).
    int min_level = 0;
    while (min_level < int(ghext->leveldata.size())) {
      // Find end of batch
      int max_level = min_level + 1;
      while (max_level < int(ghext->leveldata.size()) &&
             !ghext->leveldata.at(max_level).is_subcycling_level)
        ++max_level;
      // Skip this batch of levels if it is not active at the current
      // iteration
      if (ghext->leveldata.at(min_level).iteration > iteration)
        break;

Replacement in CarpetX/src/schedule.cxx at line 1628 [9.531]

B:BD[25.2950] → [25.2950:3094]

    // Reflux
    assert(current_level == -1);
    for (int level = int(ghext->leveldata.size()) - 2; level >= 0; --level)
      Reflux(level);

[25.2950]

[26.270]

      active_levels = make_optional<active_levels_t>(min_level, max_level);
      // Advance iteration number on this batch of levels
      active_levels->loop([&](auto &restrict leveldata) {
        leveldata.iteration += leveldata.delta_iteration;
      });
      InvalidateTimelevels(cctkGH);

Replacement in CarpetX/src/schedule.cxx at line 1637 [9.531]

B:BD[26.271] → [4.239:325]

    if (!restrict_during_sync) {
      // Restrict
      assert(current_level == -1);

[26.271]

[4.325]

      CycleTimelevels(cctkGH);
      CCTK_Traverse(cctkGH, "CCTK_PRESTEP");
      CCTK_Traverse(cctkGH, "CCTK_EVOL");
      // Reflux
      assert(active_levels);

Replacement in CarpetX/src/schedule.cxx at line 1645 [9.531]

B:BD[4.403] → [4.403:478]

        Restrict(level);
      CCTK_Traverse(cctkGH, "CCTK_POSTRESTRICT");

[4.403]

[4.478]

        Reflux(level);
      if (!restrict_during_sync) {
        // Restrict
        for (int level = int(ghext->leveldata.size()) - 2; level >= 0; --level)
          Restrict(level);
        CCTK_Traverse(cctkGH, "CCTK_POSTRESTRICT");
      }
      CCTK_Traverse(cctkGH, "CCTK_POSTSTEP");
      CCTK_Traverse(cctkGH, "CCTK_CHECKPOINT");
      CCTK_Traverse(cctkGH, "CCTK_ANALYSIS");
      CCTK_OutputGH(cctkGH);
      active_levels = optional<active_levels_t>();

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

B:BD[14.5724] → [26.384:428]

∅:D[26.428] → [14.5724:5845]

B:BD[14.5724] → [14.5724:5845]

    CCTK_Traverse(cctkGH, "CCTK_POSTSTEP");
    CCTK_Traverse(cctkGH, "CCTK_CHECKPOINT");
    CCTK_Traverse(cctkGH, "CCTK_ANALYSIS");
    CCTK_OutputGH(cctkGH);
  }

[14.5724]

[14.5845]

  } // main loop

Insertion in CarpetX/src/schedule.cxx at line 1679 [9.531]

[14.6002]

  assert(!active_levels);
  active_levels =
      make_optional<active_levels_t>(0, int(ghext->leveldata.size()));

Insertion in CarpetX/src/schedule.cxx at line 1684 [9.531]

[14.6045]


  active_levels = optional<active_levels_t>();
  active_levels = make_optional<active_levels_t>(0, 0);

Insertion in CarpetX/src/schedule.cxx at line 1689 [9.531]
[14.6087]
[14.6087]
```
  active_levels = optional<active_levels_t>();
  assert(!ghext);
```

Replacement in CarpetX/src/schedule.cxx at line 1712 [9.531]

B:BD[9.5066] → [6.8823:8985]

  const int min_level = current_level == -1 ? 0 : current_level;
  const int max_level =
      current_level == -1 ? ghext->leveldata.size() : current_level + 1;

[9.5066]

[6.8985]

  assert(active_levels);

Replacement in CarpetX/src/schedule.cxx at line 1720 [9.531]

B:BD[17.11964] → [27.196:333]

        for (int level = min_level; level < max_level; ++level) {
          const auto &restrict leveldata = ghext->leveldata.at(level);

[17.11964]

[28.2187]

        active_levels->loop([&](const auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 1737 [9.531]
B:BD[27.1529] → [27.1529:1539]
```
        }
```
[27.1529]
[27.1539]
```
        });
```

Replacement in CarpetX/src/schedule.cxx at line 1782 [9.531]

B:BD[27.2585] → [27.2585:2716]

        for (int level = min_level; level < max_level; ++level) {
          auto &restrict leveldata = ghext->leveldata.at(level);

[27.2585]

[28.2322]

        active_levels->loop([&](auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 1796 [9.531]
∅:D[20.3564] → [27.3089:3099]
B:BD[27.3089] → [27.3089:3099]
```
        }
```
[20.3564]
[27.3099]
```
        });
```

Replacement in CarpetX/src/schedule.cxx at line 1838 [9.531]

B:BD[29.709] → [11.7404:7468]

    checksums = calculate_checksums(gfs, min_level, max_level);

[29.709]

[8.7747]

    checksums = calculate_checksums(gfs);

Replacement in CarpetX/src/schedule.cxx at line 1858 [9.531]

B:BD[30.2229] → [31.1022:1085]

       TileBox &restrict thread_tilebox = thread_info.tilebox;

[30.2229]

[10.6107]

      TileBox &restrict thread_tilebox = thread_info.tilebox;

Replacement in CarpetX/src/schedule.cxx at line 1860 [9.531]

B:BD[10.6108] → [31.1086:1179]

∅:D[31.1179] → [6.10244:10377]

B:BD[32.17316] → [6.10244:10377]

                   // Loop over all levels
                   // TODO: parallelize this loop
      for (int level = min_level; level < max_level; ++level) {
        const auto &restrict leveldata = ghext->leveldata.at(level);

[10.6108]

[33.2892]

      // Loop over all levels
      // TODO: parallelize this loop
      active_levels->loop([&](const auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 1866 [9.531]

B:BD[34.10768] → [5.21224:21306]

        for (amrex::MFIter mfi(*leveldata.fab, mfitinfo); mfi.isValid(); ++mfi) {

[34.10768]

[31.1180]

        for (amrex::MFIter mfi(*leveldata.fab, mfitinfo); mfi.isValid();
             ++mfi) {

Replacement in CarpetX/src/schedule.cxx at line 1878 [9.531]
B:BD[33.3097] → [32.17517:17525]
```
      }
```
[33.3097]
[9.5558]
```
      });
```

Replacement in CarpetX/src/schedule.cxx at line 1884 [9.531]

B:BD[31.1622] → [31.1622:1751]

    for (int level = min_level; level < max_level; ++level) {
      const auto &restrict leveldata = ghext->leveldata.at(level);

[31.1622]

[5.21307]

    active_levels->loop([&](const auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 1891 [9.531]

B:BD[31.2165] → [31.2165:2225]

        const auto task{[level, mfp, function, attribute] {

[31.2165]

[31.2225]

        const auto task{[level = leveldata.level, mfp, function, attribute] {

Replacement in CarpetX/src/schedule.cxx at line 1910 [9.531]
B:BD[31.3016] → [31.3016:3022]
```
    }
```
[31.3016]
[31.3022]
```
    });
```

Replacement in CarpetX/src/schedule.cxx at line 1948 [9.531]

B:BD[11.7490] → [11.7490:7581]

  if (poison_undefined_values) {
    check_checksums(checksums, min_level, max_level);
  }

[11.7490]

[11.7581]

  if (poison_undefined_values)
    check_checksums(checksums);

Replacement in CarpetX/src/schedule.cxx at line 1957 [9.531]

B:BD[27.3445] → [27.3445:3576]

        for (int level = min_level; level < max_level; ++level) {
          auto &restrict leveldata = ghext->leveldata.at(level);

[27.3445]

[28.2451]

        active_levels->loop([&](auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 1977 [9.531]
B:BD[27.4201] → [27.4201:4211]
```
        }
```
[27.4201]
[27.4211]
```
        });
```

Replacement in CarpetX/src/schedule.cxx at line 2012 [9.531]

B:BD[27.4795] → [27.4795:4926]

        for (int level = min_level; level < max_level; ++level) {
          auto &restrict leveldata = ghext->leveldata.at(level);

[27.4795]

[28.2580]

        active_levels->loop([&](auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 2032 [9.531]
B:BD[27.5559] → [27.5559:5569]
```
        }
```
[27.5559]
[27.5569]
```
        });
```

Replacement in CarpetX/src/schedule.cxx at line 2104 [9.531]

B:BD[35.992] → [35.992:1022]

∅:D[36.35] → [16.10323:10354]

B:BD[35.1022] → [16.10323:10354]

∅:D[16.10354] → [37.0:78]

B:BD[35.1051] → [37.0:78]

∅:D[2.78] → [35.1124:1157]

∅:D[37.78] → [35.1124:1157]

B:BD[35.1124] → [35.1124:1157]

B:BD[35.1157] → [16.10355:10428]

∅:D[16.10428] → [38.73:114]

B:BD[38.73] → [38.73:114]

B:BD[38.122] → [38.122:128]

∅:D[35.1205] → [32.17770:17774]

∅:D[38.128] → [32.17770:17774]

B:BD[32.17770] → [32.17770:17774]

  if (restrict_during_sync) {
    if (current_level == -1) {
      for (int level = int(ghext->leveldata.size()) - 2; level >= 0; --level)
        Restrict(level, groups);
    } else {
      if (current_level < int(ghext->leveldata.size()) - 1)
        Restrict(current_level, groups);
    }
  }

[35.992]

[39.267]

  if (restrict_during_sync)
    active_levels->loop_reverse([&](const auto &leveldata) {
      if (leveldata.level < int(ghext->leveldata.size()) - 1)
        Restrict(leveldata.level, groups);
    });

Replacement in CarpetX/src/schedule.cxx at line 2110 [9.531]

B:BD[39.268] → [40.456:737]

  const int min_level = current_level == -1 ? 0 : current_level;
  const int max_level =
      current_level == -1 ? ghext->leveldata.size() : current_level + 1;
  for (int level = min_level; level < max_level; ++level) {
    auto &restrict leveldata = ghext->leveldata.at(level);

[39.268]

[35.1206]

  active_levels->loop([&](auto &restrict leveldata) {

Replacement in CarpetX/src/schedule.cxx at line 2149 [9.531]

B:BD[41.30912] → [41.30912:31173]

            FillPatchSingleLevel(*groupdata.mfab.at(tl), 0.0,
                                 {&*groupdata.mfab.at(tl)}, {0.0}, 0, 0,
                                 groupdata.numvars, ghext->amrcore->Geom(level),
                                 physbc, 0);

[41.30912]

[41.31173]

            FillPatchSingleLevel(
                *groupdata.mfab.at(tl), 0.0, {&*groupdata.mfab.at(tl)}, {0.0},
                0, 0, groupdata.numvars, ghext->amrcore->Geom(leveldata.level),
                physbc, 0);

Replacement in CarpetX/src/schedule.cxx at line 2222 [9.531]
B:BD[21.4317] → [19.2516:2520]
```
  }
```
[21.4317]
[39.613]
```
  });
```
Insertion in CarpetX/src/schedule.hxx at line 12 [9.5992]
[32.17903]
[32.17903]
```
#include <cassert>
#include <optional>
```

Insertion in CarpetX/src/schedule.hxx at line 41 [9.5992]

[6.13190]

[32.18063]


struct active_levels_t {
  int min_level, max_level;
  active_levels_t() = delete;
  active_levels_t(const int min_level, const int max_level)
      : min_level(min_level), max_level(max_level) {
    assert(min_level >= 0);
    assert(max_level <= int(ghext->leveldata.size()));
  }

Replacement in CarpetX/src/schedule.hxx at line 53 [9.5992]

B:BD[32.18064] → [6.13191:13303]

// Whether CallFunction traverses all levels (-1) or just one specific level
// (>=0)
extern int current_level;

[32.18064]

[6.13303]

  template <typename F> void loop(F f) {
    for (int level = min_level; level < max_level; ++level)
      assert(ghext->leveldata.at(level).iteration ==
             ghext->leveldata.at(min_level).iteration);
    for (int level = min_level; level < max_level; ++level)
      f(ghext->leveldata.at(level));
  }
  template <typename F> void loop_reverse(F f) {
    for (int level = min_level; level < max_level; ++level)
      assert(ghext->leveldata.at(level).iteration ==
             ghext->leveldata.at(min_level).iteration);
    for (int level = max_level - 1; level >= min_level; --level)
      f(ghext->leveldata.at(level));
  }
};
// The levels CallFunction should traverse
extern optional<active_levels_t> active_levels;

Replacement in ODESolvers/src/solve.cxx at line 51 [44.541]

∅:D[42.117] → [43.438:502]

B:BD[43.438] → [43.438:502]

      for (const auto &leveldata : CarpetX::ghext->leveldata) {

[42.117]

[42.118]

      assert(CarpetX::active_levels);
      CarpetX::active_levels->loop([&](const auto &leveldata) {

Replacement in ODESolvers/src/solve.cxx at line 60 [44.541]
∅:D[42.426] → [43.722:730]
B:BD[43.722] → [43.722:730]
```
      }
```
[42.426]
[43.730]
```
      });
```

Replacement in ODESolvers/src/solve.cxx at line 204 [44.541]

∅:D[45.17] → [44.3691:3751]

B:BD[44.3691] → [44.3691:3751]

  for (const auto &leveldata : CarpetX::ghext->leveldata) {

[45.17]

[43.949]

  assert(CarpetX::active_levels);
  CarpetX::active_levels->loop([&](const auto &leveldata) {

Replacement in ODESolvers/src/solve.cxx at line 222 [44.541]
B:BD[42.1933] → [42.1933:1967]
```
        if (leveldata.level == 0)
```
[42.1933]
[42.1967]
```
        if (leveldata.level == active_levels->min_level)
```
Replacement in ODESolvers/src/solve.cxx at line 226 [44.541]
B:BD[44.4225] → [44.4225:4229]
```
  }
```
[44.4225]
[3.191]
```
  });
```

CarpetX: More progress towards subcycling

Dependencies

In channels

Change contents

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

Replacement in CarpetX/src/driver.cxx at line 814 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 904 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 908 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 1040 [7.15972]

Replacement in CarpetX/src/driver.cxx at line 1044 [7.15972]

Insertion in CarpetX/src/schedule.cxx at line 77 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 79 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 610 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 618 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 634 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 676 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 680 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 688 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 704 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 747 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1215 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1223 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1297 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1305 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1358 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1363 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1376 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1438 [9.531]

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

Replacement in CarpetX/src/schedule.cxx at line 1495 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1515 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1562 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1586 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1607 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1613 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1628 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1637 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1645 [9.531]

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

Insertion in CarpetX/src/schedule.cxx at line 1679 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1684 [9.531]

Insertion in CarpetX/src/schedule.cxx at line 1689 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1712 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1720 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1737 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1782 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1796 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1838 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1858 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1860 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1866 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1878 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1884 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1891 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1910 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1948 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1957 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 1977 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 2012 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 2032 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 2104 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 2110 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 2149 [9.531]

Replacement in CarpetX/src/schedule.cxx at line 2222 [9.531]

Insertion in CarpetX/src/schedule.hxx at line 12 [9.5992]

Insertion in CarpetX/src/schedule.hxx at line 41 [9.5992]

Replacement in CarpetX/src/schedule.hxx at line 53 [9.5992]

Replacement in ODESolvers/src/solve.cxx at line 51 [44.541]

Replacement in ODESolvers/src/solve.cxx at line 60 [44.541]

Replacement in ODESolvers/src/solve.cxx at line 204 [44.541]

Replacement in ODESolvers/src/solve.cxx at line 222 [44.541]

Replacement in ODESolvers/src/solve.cxx at line 226 [44.541]