eschnett/cactusamrex - Change KRJ4HPEPBBQQ6SF4D5R7SHIEC5W6IOQSE4YTEECMOCPTILKO3ZZQC

CarpetX: Allow specifying the grid functions when solving linear systems

Created by Erik Schnetter on June 8, 2020

KRJ4HPEPBBQQ6SF4D5R7SHIEC5W6IOQSE4YTEECMOCPTILKO3ZZQC

Dependencies

In channels

master

main

Change contents

Replacement in CarpetX/interface.ccl at line 29 [6.17976]

B:BD[4.2] → [5.0:29]

void FUNCTION SolvePoisson()

[4.2]

[5.29]

void FUNCTION SolvePoisson(
  CCTK_INT IN gi_sol,
  CCTK_INT IN gi_rhs,
  CCTK_INT IN gi_res)

Replacement in CarpetX/src/linsolve.cxx at line 16 [5.115]

B:BD[5.378] → [5.378:419]

extern "C" void CarpetX_SolvePoisson() {

[5.378]

[5.419]

extern "C" void CarpetX_SolvePoisson(const CCTK_INT gi_sol,
                                     const CCTK_INT gi_rhs,
                                     const CCTK_INT gi_res) {
  assert(gi_rhs >= 0);
  assert(gi_sol >= 0);
  const bool have_res = gi_res >= 0;
  if (have_res)
    assert(gi_res >= 0);
  const int tl = 0;
  const int vi = 0;

Deletion in CarpetX/src/linsolve.cxx at line 61 [5.115]
∅:D[7.13536] → [5.1523:1524]
B:BD[5.1523] → [5.1523:1524]
B:BD[5.1524] → [7.13537:13591]
∅:D[7.13591] → [5.1579:1602]
B:BD[5.1579] → [5.1579:1602]
B:BD[5.1602] → [7.13592:13646]
∅:D[7.13646] → [5.1657:1680]
B:BD[5.1657] → [5.1657:1680]
B:BD[5.1680] → [7.13647:13701]
∅:D[7.13701] → [5.1736:1799]
B:BD[5.1736] → [5.1736:1799]
```
  const int gi_rhs = CCTK_GroupIndex("Poisson::rhs");
  assert(gi_rhs >= 0);
  const int gi_sol = CCTK_GroupIndex("Poisson::phi");
  assert(gi_sol >= 0);
  const int gi_res = CCTK_GroupIndex("Poisson::res");
  assert(gi_res >= 0);
  const int tl = 0;
  const int vi = 0;
```

Replacement in CarpetX/src/linsolve.cxx at line 71 [5.115]

B:BD[5.2352] → [8.1414:1488]

∅:D[8.1488] → [5.2425:2479]

B:BD[5.2425] → [5.2425:2479]

    const auto &restrict groupdata_res = *leveldata.groupdata.at(gi_res);
    ress.at(level) = groupdata_res.mfab.at(tl).get();

[5.2352]

[5.2479]

    if (have_res) {
      const auto &restrict groupdata_res = *leveldata.groupdata.at(gi_res);
      ress.at(level) = groupdata_res.mfab.at(tl).get();
    }

Replacement in CarpetX/src/linsolve.cxx at line 82 [5.115]
B:BD[5.2682] → [5.2682:2721]
```
  mlmg.compResidual(ress, sols, rhss);
```
[5.2682]
[9.590]
```
  if (have_res)
    mlmg.compResidual(ress, sols, rhss);
```

Replacement in CarpetX/src/linsolve.cxx at line 98 [5.115]

∅:D[2.614] → [9.993:1112]

B:BD[9.993] → [9.993:1112]

B:BD[9.1112] → [2.615:686]

    for (int level = 0; level < int(ghext->leveldata.size()); ++level)
      CCTK_VINFO("norm_inf res[%d]: %g", level,
                 double(ress.at(level)->norminf(vi, 0, false, true)));

[2.614]

[9.1182]

    if (have_res)
      for (int level = 0; level < int(ghext->leveldata.size()); ++level)
        CCTK_VINFO("norm_inf res[%d]: %g", level,
                   double(ress.at(level)->norminf(vi, 0, false, true)));

Replacement in CarpetX/src/linsolve.cxx at line 110 [5.115]

B:BD[2.835] → [2.835:874]

  mlmg.compResidual(ress, sols, rhss);

[2.835]

[2.874]

  if (have_res)
    mlmg.compResidual(ress, sols, rhss);

Replacement in CarpetX/src/linsolve.cxx at line 126 [5.115]

B:BD[2.1492] → [2.1492:1682]

    for (int level = 0; level < int(ghext->leveldata.size()); ++level)
      CCTK_VINFO("norm_inf res[%d]: %g", level,
                 double(ress.at(level)->norminf(vi, 0, false, true)));

[2.1492]

[2.1682]

    if (have_res)
      for (int level = 0; level < int(ghext->leveldata.size()); ++level)
        CCTK_VINFO("norm_inf res[%d]: %g", level,
                   double(ress.at(level)->norminf(vi, 0, false, true)));

Replacement in Poisson/interface.ccl at line 10 [3.371]

B:BD[3.468] → [3.468:497]

void FUNCTION SolvePoisson()

[3.468]

[3.497]

void FUNCTION SolvePoisson(
  CCTK_INT IN gi_sol,
  CCTK_INT IN gi_rhs,
  CCTK_INT IN gi_res)

Replacement in Poisson/src/poisson.cxx at line 119 [3.3160]

B:BD[3.5622] → [3.5622:5640]

  SolvePoisson();

[3.5622]

[3.5640]

  const int gi_sol = CCTK_GroupIndex("Poisson::phi");
  assert(gi_sol >= 0);
  const int gi_rhs = CCTK_GroupIndex("Poisson::rhs");
  assert(gi_rhs >= 0);
  const int gi_res = CCTK_GroupIndex("Poisson::res");
  assert(gi_res >= 0);
  SolvePoisson(gi_sol, gi_rhs, gi_res);