eschnett/cactusamrex - Change 6OFN2SJK2MPLZQWYF4RBKSVAZ6BX3LINXR3OXUJED6CWLDTAU7UQC

CarpetX: Merged scalar and array code

Created by Samuel Cupp on October 12, 2020

6OFN2SJK2MPLZQWYF4RBKSVAZ6BX3LINXR3OXUJED6CWLDTAU7UQC

Dependencies

In channels

main

Change contents

Deletion in CarpetX/src/driver.cxx at line 631 [5.15972]
B:BD[4.3272] → [4.3272:3320]
```
  globaldata.scalargroupdata.resize(numgroups);
```

Deletion in CarpetX/src/driver.cxx at line 640 [5.15972]

B:BD[4.3594] → [6.200:878]

∅:D[6.878] → [4.3594:3595]

B:BD[4.3594] → [4.3594:3595]

B:BD[4.3595] → [6.879:2089]

    } else if (group.grouptype == CCTK_SCALAR) {
      assert(group.vartype == CCTK_VARIABLE_REAL);
      assert(group.disttype == CCTK_DISTRIB_CONSTANT);
      assert(group.dim == 0);
      globaldata.scalargroupdata.at(gi) =
          make_unique<GHExt::GlobalData::ScalarGroupData>();
      GHExt::GlobalData::ScalarGroupData &scalargroupdata =
          *globaldata.scalargroupdata.at(gi);
      scalargroupdata.groupindex = gi;
      scalargroupdata.firstvarindex = CCTK_FirstVarIndexI(gi);
      scalargroupdata.numvars = group.numvars;
      scalargroupdata.do_checkpoint = get_group_checkpoint_flag(gi);
      scalargroupdata.do_restrict = get_group_restrict_flag(gi);
      // Set up dynamic data
      scalargroupdata.dimension = 0;
      scalargroupdata.activetimelevels = 1;
      // Allocate data
      scalargroupdata.data.resize(group.numtimelevels);
      scalargroupdata.valid.resize(group.numtimelevels);
      for (int tl = 0; tl < int(scalargroupdata.data.size()); ++tl) {
        scalargroupdata.data.at(tl).resize(scalargroupdata.numvars);
        why_valid_t why([] { return "SetupGlobals"; });
        scalargroupdata.valid.at(tl).resize(scalargroupdata.numvars, why);
        for (int vi = 0; vi < scalargroupdata.numvars; ++vi) {
          // TODO: decide that valid_bnd == false always and rely on
          // initialization magic?
          valid_t valid;
          valid.valid_int = false;
          valid.valid_outer = true;
          valid.valid_ghosts = true;
          scalargroupdata.valid.at(tl).at(vi).set(valid,
                                                  [] { return "SetupGlobals"; });
          // TODO: make poison_invalid and check_invalid virtual members of
          // CommonGroupData
          poison_invalid(scalargroupdata, vi, tl);
          check_valid(scalargroupdata, vi, tl, [] { return "SetupGlobals"; });
        }
      }

Replacement in CarpetX/src/driver.cxx at line 641 [5.15972]

B:BD[6.2102] → [6.2102:2147]

      assert(group.grouptype == CCTK_ARRAY);

[6.2102]

[6.2147]

      assert(group.grouptype == CCTK_ARRAY || group.grouptype == CCTK_SCALAR);

Replacement in CarpetX/src/driver.cxx at line 644 [5.15972]
B:BD[6.2253] → [6.2253:2302]
```
      assert(group.dim > 0 && group.dim <= dim);
```
[6.2253]
[6.2302]
```
      assert(group.dim >= 0);
```

Deletion in CarpetX/src/driver.cxx at line 1127 [5.15972]

B:BD[7.870] → [7.870:1238]

B:BD[7.1238] → [6.4595:4643]

           const GHExt::GlobalData::ScalarGroupData &scalargroupdata) {
  yaml << YAML::LocalTag("scalargroupdata-1.0.0");
  yaml << YAML::BeginMap;
  yaml << YAML::Key << "commongroupdata" << YAML::Value
       << (GHExt::CommonGroupData)scalargroupdata;
  yaml << YAML::Key << "data" << YAML::Value << scalargroupdata.data;
  yaml << YAML::EndMap;
  return yaml;
}
YAML::Emitter &
operator<<(YAML::Emitter &yaml,

Replacement in CarpetX/src/driver.cxx at line 1141 [5.15972]

B:BD[7.1422] → [7.1422:1619]

  yaml << YAML::Key << "scalargroupdata" << YAML::Value << YAML::BeginSeq;
  for (const auto &scalargroupdata : globaldata.scalargroupdata)
    if (scalargroupdata)
      yaml << *scalargroupdata;

[7.1422]

[7.1619]

  yaml << YAML::Key << "arraygroupdata" << YAML::Value << YAML::BeginSeq;
  for (const auto &arraygroupdata : globaldata.arraygroupdata)
    if (arraygroupdata)
      yaml << *arraygroupdata;

Replacement in CarpetX/src/driver.cxx at line 1625 [5.15972]

B:BD[6.5982] → [6.5982:6598]

  } else if (group.grouptype == CCTK_SCALAR) {
    GHExt::GlobalData &globaldata = ghext->globaldata;
    GHExt::GlobalData::ScalarGroupData &scalargroupdata =
        *globaldata.scalargroupdata.at(gi);
    data->dim = scalargroupdata.dimension;
    data->lsh = scalargroupdata.lsh;
    data->ash = scalargroupdata.ash;
    data->gsh = scalargroupdata.gsh;
    data->lbnd = scalargroupdata.lbnd;
    data->ubnd = scalargroupdata.ubnd;
    data->bbox = scalargroupdata.bbox;
    data->nghostzones = scalargroupdata.nghostzones;
    data->activetimelevels = scalargroupdata.activetimelevels;
  } else { // CCTK_ARRAY

[6.5982]

[6.6598]

  } else { // CCTK_ARRAY or CCTK_SCALAR

Replacement in CarpetX/src/io.cxx at line 301 [9.107]

B:BD[8.5119] → [8.5119:5192]

B:BD[8.5192] → [10.1219:1263]

    const GHExt::GlobalData::ScalarGroupData &restrict scalargroupdata =
        *globaldata.scalargroupdata.at(gi);

[8.5119]

[8.5235]

    const GHExt::GlobalData::ArrayGroupData &restrict arraygroupdata =
        *globaldata.arraygroupdata.at(gi);

Replacement in CarpetX/src/io.cxx at line 305 [9.107]

∅:D[11.2223] → [8.5322:5381]

B:BD[8.5322] → [8.5322:5381]

B:BD[8.5381] → [11.2224:2281]

    for (int vi = 0; vi < scalargroupdata.numvars; ++vi) {
      file << sep << scalargroupdata.data.at(tl).at(vi);

[11.2223]

[12.2278]

    for (int vi = 0; vi < arraygroupdata.numvars; ++vi) {
      file << sep << arraygroupdata.data.at(tl).at(vi);

Replacement in CarpetX/src/io_tsv.cxx at line 132 [13.36]

B:BD[2.713] → [2.713:788]

  const auto &scalargroupdata = *ghext->globaldata.scalargroupdata.at(gi);

[2.713]

[2.788]

  const auto &arraygroupdata = *ghext->globaldata.arraygroupdata.at(gi);

Replacement in CarpetX/src/io_tsv.cxx at line 135 [13.36]

B:BD[2.816] → [2.816:945]

  for (int vi = 0; vi < scalargroupdata.numvars; ++vi)
    varnames.push_back(CCTK_VarName(scalargroupdata.firstvarindex + vi));

[2.816]

[2.945]

  for (int vi = 0; vi < arraygroupdata.numvars; ++vi)
    varnames.push_back(CCTK_VarName(arraygroupdata.firstvarindex + vi));

Replacement in CarpetX/src/io_tsv.cxx at line 154 [13.36]

B:BD[2.1452] → [2.1452:1562]

  for (int vi = 0; vi < scalargroupdata.numvars; ++vi)
    file << sep << scalargroupdata.data.at(tl).at(vi);

[2.1452]

[2.1562]

  for (int vi = 0; vi < arraygroupdata.numvars; ++vi)
    file << sep << arraygroupdata.data.at(tl).at(vi);

Replacement in CarpetX/src/io_tsv.cxx at line 371 [13.36]

B:BD[2.8686] → [2.8686:8742]

        assert(0); // Grid ararys are not yet supported

[2.8686]

[2.8742]

        assert(0); // Grid arrays are not yet supported

Deletion in CarpetX/src/schedule.cxx at line 480 [16.531]

∅:D[14.2972] → [15.2169:2173]

B:BD[17.6904] → [15.2169:2173]

∅:D[15.2173] → [17.6904:6907]

B:BD[17.6904] → [17.6904:6907]

B:BD[17.6907] → [6.8696:8729]

∅:D[6.8729] → [18.2683:2876]

B:BD[17.6942] → [18.2683:2876]

∅:D[18.2876] → [17.7101:7228]

B:BD[17.7101] → [17.7101:7228]

B:BD[17.7228] → [6.8730:8801]

∅:D[6.8801] → [17.7301:7533]

B:BD[17.7301] → [17.7301:7533]

B:BD[17.7533] → [18.2877:3067]

∅:D[18.3067] → [17.7690:7849]

B:BD[17.7690] → [17.7690:7849]

B:BD[17.7849] → [6.8802:8872]

∅:D[6.8872] → [17.7921:8147]

B:BD[17.7921] → [17.7921:8147]

∅:D[17.8147] → [8.5606:5636]

∅:D[19.8925] → [8.5606:5636]

B:BD[8.5606] → [8.5606:5636]

B:BD[8.5636] → [21.486:603]

∅:D[21.603] → [8.5753:5825]

B:BD[8.5753] → [8.5753:5825]

B:BD[8.5825] → [17.8148:8216]

∅:D[17.8216] → [22.3483:3508]

B:BD[8.5887] → [22.3483:3508]

∅:D[22.3508] → [8.5929:5941]

∅:D[23.68] → [8.5929:5941]

∅:D[19.8992] → [8.5929:5941]

B:BD[8.5929] → [8.5929:5941]

∅:D[19.9044] → [8.6032:6059]

B:BD[8.6032] → [8.6032:6059]

B:BD[8.6059] → [24.126:232]

∅:D[24.232] → [8.6131:6153]

B:BD[8.6131] → [8.6131:6153]

  }
}
// Ensure grid scalars are valid
void error_if_invalid(const GHExt::GlobalData::ScalarGroupData &groupdata,
                      int vi, int tl, const valid_t &required,
                      const function<string()> &msg) {
  const valid_t &have = groupdata.valid.at(tl).at(vi).get();
  if (CCTK_BUILTIN_EXPECT((required & ~have).valid_any(), false))
    CCTK_VERROR("%s: Grid Scalar \"%s\" is invalid on time level %d; "
                "required %s, found %s",
                msg().c_str(), CCTK_FullVarName(groupdata.firstvarindex + vi),
                tl, string(required).c_str(),
                string(groupdata.valid.at(tl).at(vi)).c_str());
}
void warn_if_invalid(const GHExt::GlobalData::ScalarGroupData &groupdata,
                     int vi, int tl, const valid_t &required,
                     const function<string()> &msg) {
  const valid_t &have = groupdata.valid.at(tl).at(vi).get();
  if (CCTK_BUILTIN_EXPECT((required & ~have).valid_any(), false))
    CCTK_VWARN(CCTK_WARN_ALERT,
               "%s: Grid Scalar \"%s\" is invalid on time level %d; "
               "required %s, found %s",
               msg().c_str(), CCTK_FullVarName(groupdata.firstvarindex + vi),
               tl, string(required).c_str(),
               string(groupdata.valid.at(tl).at(vi)).c_str());
}
// Set grid scalars to nan
void poison_invalid(const GHExt::GlobalData::ScalarGroupData &scalargroupdata,
                    int vi, int tl) {
  DECLARE_CCTK_PARAMETERS;
  if (!poison_undefined_values)
    return;
  const valid_t &valid = scalargroupdata.valid.at(tl).at(vi).get();
  if (valid.valid_all())
    return;
  if (!valid.valid_int) {
    CCTK_REAL *restrict const ptr =
        const_cast<CCTK_REAL *>(&scalargroupdata.data.at(tl).at(vi));
    *ptr = 0.0 / 0.0;

Deletion in CarpetX/src/schedule.cxx at line 483 [16.531]

B:BD[8.6157] → [8.6157:6192]

B:BD[8.6192] → [21.604:746]

∅:D[20.326] → [8.6303:6374]

∅:D[21.746] → [8.6303:6374]

B:BD[8.6303] → [8.6303:6374]

// Ensure grid scalars are not nan
void check_valid(const GHExt::GlobalData::ScalarGroupData &scalargroupdata,
                 int vi, int tl, const function<string()> &msg) {
  DECLARE_CCTK_PARAMETERS;
  if (!poison_undefined_values)
    return;

Replacement in CarpetX/src/schedule.cxx at line 484 [16.531]

B:BD[8.6375] → [17.8217:8285]

∅:D[17.8285] → [22.3509:3535]

B:BD[8.6437] → [22.3509:3535]

∅:D[22.3535] → [8.6481:6494]

∅:D[23.89] → [8.6481:6494]

∅:D[19.9114] → [8.6481:6494]

B:BD[8.6481] → [8.6481:6494]

B:BD[8.6494] → [26.67:133]

B:BD[26.133] → [19.9115:9166]

∅:D[19.9166] → [8.6584:6585]

B:BD[8.6584] → [8.6584:6585]

B:BD[8.6585] → [27.2606:2637]

∅:D[27.2637] → [8.6618:6643]

B:BD[8.6618] → [8.6618:6643]

B:BD[8.6643] → [24.233:312]

B:BD[24.312] → [14.2973:3033]

∅:D[14.3033] → [27.2638:2657]

B:BD[19.9223] → [27.2638:2657]

∅:D[27.2657] → [8.6790:6801]

B:BD[8.6790] → [8.6790:6801]

B:BD[8.6801] → [27.2658:2957]

B:BD[27.2957] → [28.4815:4885]

B:BD[28.4885] → [6.8873:8908]

  const valid_t &valid = scalargroupdata.valid.at(tl).at(vi).get();
  if (!valid.valid_any())
    return;
  // scalars have no boundary so we expect them to alway be valid
  assert(valid.valid_outer && valid.valid_ghosts);
  atomic<size_t> nan_count{0};
  if (valid.valid_int) {
    const CCTK_REAL *restrict const ptr = &scalargroupdata.data.at(tl).at(vi);
    if (CCTK_BUILTIN_EXPECT(!CCTK_isfinite(*ptr), false)) {
      ++nan_count;
    }
  }
  if (CCTK_BUILTIN_EXPECT(nan_count > 0, false))
    CCTK_VERROR("%s: Grid Scalar \"%s\" has %td nans on time level %d; "
                "expected valid %s",
                msg().c_str(),
                CCTK_FullVarName(scalargroupdata.firstvarindex + vi),
                size_t(nan_count), tl,
                string(scalargroupdata.valid.at(tl).at(vi)).c_str());
}
// Ensure grid arrays are valid

[8.6375]

[6.8908]

// Ensure arrays are valid

Replacement in CarpetX/src/schedule.cxx at line 490 [16.531]

B:BD[6.9227] → [6.9227:9297]

    CCTK_VERROR("%s: Grid array \"%s\" is invalid on time level %d; "

[6.9227]

[6.9297]

    CCTK_VERROR("%s: Array \"%s\" is invalid on time level %d; "

Replacement in CarpetX/src/schedule.cxx at line 502 [16.531]

B:BD[6.9877] → [6.9877:9946]

               "%s: Grid array \"%s\" is invalid on time level %d; "

[6.9877]

[6.9946]

               "%s: Array \"%s\" is invalid on time level %d; "

Replacement in CarpetX/src/schedule.cxx at line 509 [16.531]
B:BD[6.10175] → [6.10175:10217]
```
// Set (distrib=const) grid arrays to nan
```
[6.10175]
[6.10217]
```
// Set arrays to nan
```

Replacement in CarpetX/src/schedule.cxx at line 520 [16.531]

B:BD[6.10509] → [3.0:460]

  int dimension = arraygroupdata.dimension;
  atomic<size_t> nan_count{0};
  if (dimension == 0) {
    return;
  } else {
    const int *gsh = arraygroupdata.gsh;
    int n_elems = 1;
    for (int i = 0; i < dimension; i++) n_elems *= gsh[i];
  
    if (valid.valid_int) {
      CCTK_REAL *restrict const ptr =
          const_cast<CCTK_REAL *>(&arraygroupdata.data.at(tl).at(vi));
      for (int i = 0; i < n_elems; i++) {
        ptr[i] = 0.0 / 0.0;
      }

[6.10509]

[29.99]

  if (!valid.valid_int) {
    int dimension = arraygroupdata.dimension;
    atomic<size_t> nan_count{0};
    CCTK_REAL *restrict const ptr =
        const_cast<CCTK_REAL *>(&arraygroupdata.data.at(tl).at(vi));
    if (dimension == 0) {
      *ptr = 0.0 / 0.0;
    } else {
      const int *gsh = arraygroupdata.gsh;
      int n_elems = 1;
      for (int i = 0; i < dimension; i++) n_elems *= gsh[i];
      for (int i = 0; i < n_elems; i++) ptr[i] = 0.0 / 0.0;

Replacement in CarpetX/src/schedule.cxx at line 536 [16.531]
B:BD[6.10741] → [6.10741:10775]
```
// Ensure grid arrays are not nan
```
[6.10741]
[6.10775]
```
// Ensure arrays are not nan
```
Deletion in CarpetX/src/schedule.cxx at line 550 [16.531]
B:BD[3.462] → [3.462:506]
```
  int dimension = arraygroupdata.dimension;
```

Replacement in CarpetX/src/schedule.cxx at line 551 [16.531]

B:BD[6.11346] → [3.507:785]

  if (dimension == 0) {
    return;
  } else {
    const int *gsh = arraygroupdata.gsh;
    int n_elems = 1;
    for (int i = 0; i < dimension; i++) n_elems *= gsh[i];
  
    if (valid.valid_int) {
      const CCTK_REAL *restrict const ptr = &arraygroupdata.data.at(tl).at(vi);

[6.11346]

[3.785]

  if (valid.valid_int) {
    const CCTK_REAL *restrict const ptr = &arraygroupdata.data.at(tl).at(vi);
    int dimension = arraygroupdata.dimension;
    if (dimension == 0) {
      if (CCTK_BUILTIN_EXPECT(!CCTK_isfinite(*ptr), false)) {
        ++nan_count;
      }
    } else {
      const int *gsh = arraygroupdata.gsh;
      int n_elems = 1;
      for (int i = 0; i < dimension; i++) {
        n_elems *= gsh[i];
      }

Replacement in CarpetX/src/schedule.cxx at line 573 [16.531]

B:BD[6.11641] → [6.11641:11713]

    CCTK_VERROR("%s: Grid Array \"%s\" has %td nans on time level %d; "

[6.11641]

[6.11713]

    CCTK_VERROR("%s: Array \"%s\" has %td nans on time level %d; "

Replacement in CarpetX/src/schedule.cxx at line 922 [16.531]

B:BD[8.7540] → [6.12037:12503]

∅:D[24.431] → [8.7891:7901]

∅:D[6.12503] → [8.7891:7901]

B:BD[8.7891] → [8.7891:7901]

B:BD[8.7901] → [6.12504:12533]

      } else if (group.grouptype == CCTK_SCALAR) {
        auto &restrict scalargroupdata = *globaldata.scalargroupdata.at(gi);
        for (int tl = 0; tl < int(scalargroupdata.data.size()); ++tl) {
          const auto &restrict vars = scalargroupdata.data.at(tl);
          for (int vi = 0; vi < scalargroupdata.numvars; ++vi) {
            cctkGH->data[scalargroupdata.firstvarindex + vi][tl] =
                const_cast<CCTK_REAL *>(&vars.at(vi));
          }
        }
      } else { // CCTK_ARRAY

[8.7540]

[6.12533]

      } else { // CCTK_ARRAY or CCTK_SCALAR

Replacement in CarpetX/src/schedule.cxx at line 949 [16.531]

B:BD[8.8239] → [6.13057:13449]

      } else if (group.grouptype == CCTK_SCALAR) {
        auto &restrict scalargroupdata = *globaldata.scalargroupdata.at(gi);
        for (int tl = 0; tl < int(scalargroupdata.data.size()); ++tl) {
          for (int vi = 0; vi < scalargroupdata.numvars; ++vi) {
            cctkGH->data[scalargroupdata.firstvarindex + vi][tl] = nullptr;
          }
        }
      } else { // CCTK_ARRAY

[8.8239]

[6.13449]

      } else { // CCTK_ARRAY or CCTK_SCALAR

Replacement in CarpetX/src/schedule.cxx at line 1555 [16.531]
B:BD[30.1981] → [6.13747:13796]
```
    } else if (group.grouptype == CCTK_SCALAR) {
```
[30.1981]
[8.9728]
```
    } else { // CCTK_ARRAY or CCTK_SCALAR
```

Deletion in CarpetX/src/schedule.cxx at line 1558 [16.531]

∅:D[31.8623] → [10.1972:2047]

B:BD[8.9729] → [10.1972:2047]

B:BD[10.2047] → [31.8624:8668]

∅:D[31.8668] → [8.9913:10114]

B:BD[8.9913] → [8.9913:10114]

B:BD[8.10114] → [32.0:45]

B:BD[32.45] → [17.8611:8808]

∅:D[17.8808] → [8.10175:10228]

∅:D[32.112] → [8.10175:10228]

B:BD[8.10175] → [8.10175:10228]

B:BD[8.10228] → [6.13797:13908]

      auto &restrict scalargroupdata = *globaldata.scalargroupdata.at(gi);
      if (!scalargroupdata.do_checkpoint) {
        // Invalidate all time levels
        const int ntls = scalargroupdata.data.size();
        for (int tl = 0; tl < ntls; ++tl) {
          for (int vi = 0; vi < scalargroupdata.numvars; ++vi) {
            // TODO: handle this more nicely
            scalargroupdata.valid.at(tl).at(vi).set_int(false, [] {
              return "InvalidateTimelevels (invalidate all non-checkpointed "
                     "variables)";
            });
            poison_invalid(scalargroupdata, vi, tl);
          }
        }
      }
    } else { // CCTK_ARRAY
      auto &restrict globaldata = ghext->globaldata;

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

B:BD[30.2080] → [6.14517:14566]

∅:D[6.14566] → [8.10818:10819]

B:BD[8.10818] → [8.10818:10819]

B:BD[8.10880] → [31.9969:10022]

∅:D[31.10022] → [10.2111:2186]

B:BD[8.10880] → [10.2111:2186]

∅:D[10.2186] → [8.10954:11090]

B:BD[8.10954] → [8.10954:11090]

B:BD[8.11090] → [33.893:1138]

B:BD[33.1138] → [31.10023:10086]

∅:D[31.10086] → [17.9199:9348]

B:BD[8.11622] → [17.9199:9348]

B:BD[8.11741] → [8.11741:11791]

B:BD[8.11791] → [31.10087:10097]

∅:D[31.10097] → [8.11791:11799]

B:BD[8.11791] → [8.11791:11799]

B:BD[8.11799] → [31.10098:10246]

B:BD[31.10246] → [6.14567:14654]

    } else if (group.grouptype == CCTK_SCALAR) {
      auto &restrict globaldata = ghext->globaldata;
      auto &restrict scalargroupdata = *globaldata.scalargroupdata.at(gi);
      const int ntls = scalargroupdata.data.size();
      // Rotate time levels and invalidate current time level
      if (ntls > 1) {
        rotate(scalargroupdata.data.begin(), scalargroupdata.data.end() - 1,
               scalargroupdata.data.end());
        rotate(scalargroupdata.valid.begin(), scalargroupdata.valid.end() - 1,
               scalargroupdata.valid.end());
        for (int vi = 0; vi < scalargroupdata.numvars; ++vi) {
          scalargroupdata.valid.at(0).at(vi).set_int(false, [] {
            return "CycletimeLevels (invalidate current time level)";
          });
          poison_invalid(scalargroupdata, vi, 0);
        }
      }
      for (int tl = 0; tl < ntls; ++tl)
        for (int vi = 0; vi < scalargroupdata.numvars; ++vi)
          check_valid(scalargroupdata, vi, tl,
                      [&]() { return "CycleTimelevels"; });
    } else { // CCTK_ARRAY

[30.2080]

[6.14654]

    } else { // CCTK_ARRAY or CCTK_SCALAR

Insertion in CarpetX/src/schedule.cxx at line 1833 [16.531]
[30.4328]
[34.1539]
```
      } else { // CCTK_ARRAY or CCTK_SCALAR
```

Deletion in CarpetX/src/schedule.cxx at line 1835 [16.531]

B:BD[34.1540] → [6.15579:15637]

∅:D[6.15637] → [34.1570:1618]

B:BD[34.1570] → [34.1570:1618]

B:BD[34.1618] → [10.2263:2321]

∅:D[8.12385] → [35.9404:9444]

∅:D[21.2085] → [35.9404:9444]

∅:D[10.2321] → [35.9404:9444]

∅:D[34.1675] → [35.9404:9444]

B:BD[35.9404] → [35.9404:9444]

B:BD[35.9444] → [17.9798:10196]

B:BD[17.10196] → [6.15638:15941]

      } else if (CCTK_GroupTypeI(rd.gi) == CCTK_SCALAR) {
        const auto &restrict scalargroupdata =
            *ghext->globaldata.scalargroupdata.at(rd.gi);
        const valid_t &need = rd.valid;
        error_if_invalid(scalargroupdata, rd.vi, rd.tl, need, [&] {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking input";
          return buf.str();
        });
        check_valid(scalargroupdata, rd.vi, rd.tl, [&] {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking input";
          return buf.str();
        });
      } else { // CCTK_ARRAY

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

∅:D[30.4402] → [34.3099:3100]

B:BD[34.3099] → [34.3099:3100]

B:BD[34.3100] → [6.16481:16539]

∅:D[34.3130] → [8.12893:12894]

∅:D[6.16539] → [8.12893:12894]

B:BD[8.12893] → [8.12893:12894]

B:BD[8.12894] → [34.3131:3172]

B:BD[34.3172] → [10.2392:2450]

∅:D[10.2450] → [34.3229:3273]

B:BD[34.3229] → [34.3229:3273]

B:BD[34.3273] → [17.10737:11262]

∅:D[17.11262] → [34.3341:3396]

∅:D[19.10001] → [34.3341:3396]

B:BD[36.7733] → [34.3341:3396]

B:BD[34.3396] → [6.16540:16570]


      } else if (CCTK_GroupTypeI(wr.gi) == CCTK_SCALAR) {
        auto &restrict scalargroupdata =
            *ghext->globaldata.scalargroupdata.at(wr.gi);
        const valid_t &provided = wr.valid;
        scalargroupdata.valid.at(wr.tl).at(wr.vi).set_and(
            need | ~provided,
            [iteration = cctkGH->cctk_iteration, where = attribute->where,
             thorn = attribute->thorn, routine = attribute->routine] {
              ostringstream buf;
              buf << "CallFunction iteration " << iteration << " " << where
                  << ": " << thorn << "::" << routine
                  << ": Poison output variables that are not input variables";
              return buf.str();
            });
        poison_invalid(scalargroupdata, wr.vi, wr.tl);
      } else { // CCTK_ARRAY

[30.4402]

[6.16570]

      } else { // CCTK_ARRAY or CCTK_SCALAR

Replacement in CarpetX/src/schedule.cxx at line 2070 [16.531]

∅:D[30.5036] → [34.4211:4212]

B:BD[34.4211] → [34.4211:4212]

B:BD[34.4212] → [6.17290:17348]

∅:D[34.4242] → [8.13348:13349]

∅:D[6.17348] → [8.13348:13349]

B:BD[8.13348] → [8.13348:13349]

B:BD[8.13349] → [34.4243:4284]

B:BD[34.4284] → [10.2521:2579]

∅:D[8.13593] → [35.10790:10834]

∅:D[21.3531] → [35.10790:10834]

∅:D[10.2579] → [35.10790:10834]

∅:D[34.4341] → [35.10790:10834]

B:BD[35.10790] → [35.10790:10834]

B:BD[35.10834] → [17.11844:12338]

∅:D[17.12338] → [34.4410:4469]

∅:D[19.10211] → [34.4410:4469]

B:BD[35.11024] → [34.4410:4469]

B:BD[34.4469] → [6.17349:17654]


      } else if (CCTK_GroupTypeI(wr.gi) == CCTK_SCALAR) {
        auto &restrict scalargroupdata =
            *ghext->globaldata.scalargroupdata.at(wr.gi);
        const valid_t &provided = wr.valid;
        scalargroupdata.valid.at(wr.tl).at(wr.vi).set_or(
            provided,
            [iteration = cctkGH->cctk_iteration, where = attribute->where,
             thorn = attribute->thorn, routine = attribute->routine] {
              ostringstream buf;
              buf << "CallFunction iteration " << iteration << " " << where
                  << ": " << thorn << "::" << routine
                  << ": Mark output variables as valid";
              return buf.str();
            });
        check_valid(scalargroupdata, wr.vi, wr.tl, [&]() {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking output";
          return buf.str();
        });
      } else { // CCTK_ARRAY

[30.5036]

[6.17654]

      } else { // CCTK_ARRAY or CCTK_SCALAR

Deletion in CarpetX/src/schedule.cxx at line 2122 [16.531]

B:BD[34.5559] → [30.5098:5110]

∅:D[30.5110] → [34.5569:5570]

B:BD[34.5569] → [34.5569:5570]

B:BD[34.5570] → [6.18347:18406]

∅:D[34.5600] → [20.2166:2167]

∅:D[6.18406] → [20.2166:2167]

B:BD[20.2166] → [20.2166:2167]

B:BD[20.2167] → [34.5601:5642]

B:BD[34.5642] → [10.2651:2710]

∅:D[20.2413] → [37.745:790]

∅:D[21.4759] → [37.745:790]

∅:D[10.2710] → [37.745:790]

∅:D[34.5700] → [37.745:790]

B:BD[37.745] → [37.745:790]

B:BD[37.790] → [17.12855:13356]

∅:D[17.13356] → [34.5771:5832]

∅:D[19.10425] → [34.5771:5832]

B:BD[37.984] → [34.5771:5832]

B:BD[34.5832] → [6.18407:18669]

        });
      } else if (CCTK_GroupTypeI(inv.gi) == CCTK_SCALAR) {
        auto &restrict scalargroupdata =
            *ghext->globaldata.scalargroupdata.at(inv.gi);
        const valid_t &provided = inv.valid;
        scalargroupdata.valid.at(inv.tl).at(inv.vi).set_and(
            ~provided,
            [iteration = cctkGH->cctk_iteration, where = attribute->where,
             thorn = attribute->thorn, routine = attribute->routine] {
              ostringstream buf;
              buf << "CallFunction iteration " << iteration << " " << where
                  << ": " << thorn << "::" << routine
                  << ": Mark invalid variables as invalid";
              return buf.str();
            });
        check_valid(scalargroupdata, inv.vi, inv.tl, [&]() {
          ostringstream buf;
          buf << "CallFunction iteration " << cctkGH->cctk_iteration << " "
              << attribute->where << ": " << attribute->thorn
              << "::" << attribute->routine << " checking output";
          return buf.str();

Replacement in CarpetX/src/schedule.cxx at line 2123 [16.531]
B:BD[6.18681] → [6.18681:18712]
```
      } else { // CCTK_ARRAY
```
[6.18681]
[6.18712]
```
      } else { // CCTK_ARRAY or CCTK_SCALAR
```

Deletion in CarpetX/src/schedule.hxx at line 168 [16.5992]

B:BD[38.18749] → [18.5768:6149]

∅:D[18.6149] → [8.14296:14484]

∅:D[17.18074] → [8.14296:14484]

B:BD[38.18749] → [8.14296:14484]

B:BD[8.14484] → [20.3295:3352]

void error_if_invalid(const GHExt::GlobalData::ScalarGroupData &groupdata,
                      int vi, int tl, const valid_t &required,
                      const function<string()> &msg);
void warn_if_invalid(const GHExt::GlobalData::ScalarGroupData &groupdata,
                     int vi, int tl, const valid_t &required,
                     const function<string()> &msg);
void poison_invalid(const GHExt::GlobalData::ScalarGroupData &groupdata, int vi,
                    int tl);
void check_valid(const GHExt::GlobalData::ScalarGroupData &groupdata, int vi,
                 int tl, const function<string()> &msg);