CCTK_REAL refinement_level TYPE=gf
{
  refinement_level
} "Refinement level"

  1:*

  1:* :: ""

  1:*

  1:* :: ""

  1:*

  1:* :: ""

CCTK_INT max_num_levels "Maximum number of refinement levels"
{
  1:* :: ""
} 1

SCHEDULE AMReX_SetLevel AT basegrid
{
  LANG: C
} "Set refinemenet level grid function"

CactusAmrMesh::CactusAmrMesh() {}
CactusAmrMesh::CactusAmrMesh(const RealBox *rb, int max_level_in,

CactusAmrCore::CactusAmrCore() {}
CactusAmrCore::CactusAmrCore(const RealBox *rb, int max_level_in,

    : AmrMesh(rb, max_level_in, n_cell_in, coord, ref_ratios, is_per) {}
CactusAmrMesh::CactusAmrMesh(const RealBox &rb, int max_level_in,

    : AmrCore(rb, max_level_in, n_cell_in, coord, ref_ratios, is_per) {}
CactusAmrCore::CactusAmrCore(const RealBox &rb, int max_level_in,

    : AmrMesh(rb, max_level_in, n_cell_in, coord, ref_ratios, is_per) {}

    : AmrCore(rb, max_level_in, n_cell_in, coord, ref_ratios, is_per) {}

CactusAmrMesh::~CactusAmrMesh() {}

CactusAmrCore::~CactusAmrCore() {}

void CactusAmrMesh::ErrorEst(const int level, TagBoxArray &tags, Real time,

void CactusAmrCore::ErrorEst(const int level, TagBoxArray &tags, Real time,

  // 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 << "nbx: " << nbx << "\n";
  const BoxArray &ba = boxArray(level);
  tags.setVal(intersect(ba, nbx), TagBox::SET);
  return;

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

}
void CactusAmrCore::MakeNewLevelFromScratch(int lev, Real time,
                                            const BoxArray &ba,
                                            const DistributionMapping &dm) {
  CCTK_VINFO("MakeNewLevelFromScratch level %d", lev);
}
void CactusAmrCore::MakeNewLevelFromCoarse(int lev, Real time,
                                           const BoxArray &ba,
                                           const DistributionMapping &dm) {
  CCTK_VINFO("MakeNewLevelFromCoarse level %d", lev);

void CactusAmrCore::RemakeLevel(int lev, Real time, const BoxArray &ba,
                                const DistributionMapping &dm) {
  CCTK_VINFO("RemakeLevel level %d", lev);
}
void CactusAmrCore::ClearLevel(int lev) {
  CCTK_VINFO("ClearLevel level %d", lev);
}

  // Maximum number of levels
  const int maxnumlevels = 3;

  ghext->amrmesh = make_unique<CactusAmrMesh>(domain, maxnumlevels - 1, ncells,
                                              coord, reffacts, periodic);

  ghext->amrcore = make_unique<CactusAmrCore>(
      domain, max_num_levels - 1, ncells, coord, reffacts, periodic);

  // const int blocking_factor = 8;
  const int blocking_factor = 1;
  ghext->amrmesh->SetBlockingFactor(blocking_factor);

  const int blocking_factor = 8;
  // const int blocking_factor = 1;
  ghext->amrcore->SetBlockingFactor(blocking_factor);

  ghext->amrmesh->SetMaxGridSize(max_grid_size);

  ghext->amrcore->SetMaxGridSize(max_grid_size);

  int maxnumlevels = ghext->amrcore->maxLevel() + 1;

    cout << ghext->amrmesh->Geom(level) << "\n";

    cout << ghext->amrcore->Geom(level) << "\n";

  ghext->amrmesh->MakeNewGrids(time);

  ghext->amrcore->MakeNewGrids(time);

  // cout << ghext->amrmesh->boxArray(level) << "\n";

  // cout << ghext->amrcore->boxArray(level) << "\n";

  // cout << ghext->amrmesh->DistributionMap(level) << "\n";

  // cout << ghext->amrcore->DistributionMap(level) << "\n";

  if (level > ghext->amrcore->maxLevel())
    return;

  int new_finest = -999;
  Vector<BoxArray> new_grids;
  ghext->amrmesh->MakeNewGrids(0, time, new_finest, new_grids);
  cout << "level=" << level << "\n";
  cout << "new_finest=" << new_finest << "\n";
  assert(new_finest == level - 1 || new_finest == level);
  ghext->amrmesh->SetFinestLevel(new_finest);
  ghext->amrMesh->SetBoxArray(level, new_grids.at(level));
  ghext->amrMesh->SetDistributionMap(...);

  ghext->amrcore->regrid(0, time);
  int numlevels = ghext->amrcore->finestLevel() + 1;
  int maxnumlevels = ghext->amrcore->maxLevel() + 1;
  cout << "CRG numlevels=" << numlevels << "\n";
  cout << "CRG maxnumlevels=" << maxnumlevels << "\n";
  assert(numlevels >= 0 && numlevels <= maxnumlevels);
  assert(numlevels <= level + 1);

  if (new_finest == level)

  if (numlevels == level + 1)

          ghext->amrmesh->boxArray(leveldata.level),
          ghext->amrmesh->DistributionMap(leveldata.level), groupdata.numvars,

          ghext->amrcore->boxArray(leveldata.level),
          ghext->amrcore->DistributionMap(leveldata.level), groupdata.numvars,

#include <AMReX_AmrMesh.H>

#include <AMReX_AmrCore.H>

class CactusAmrMesh : public AmrMesh {

class CactusAmrCore : public AmrCore {

  CactusAmrMesh();
  CactusAmrMesh(const RealBox *rb, int max_level_in,

  CactusAmrCore();
  CactusAmrCore(const RealBox *rb, int max_level_in,

  CactusAmrMesh(const RealBox &rb, int max_level_in,

  CactusAmrCore(const RealBox &rb, int max_level_in,

  CactusAmrMesh(const AmrMesh &rhs) = delete;
  CactusAmrMesh &operator=(const AmrMesh &rhs) = delete;

  CactusAmrCore(const AmrCore &rhs) = delete;
  CactusAmrCore &operator=(const AmrCore &rhs) = delete;

  virtual ~CactusAmrMesh();

  virtual ~CactusAmrCore();

  // virtual void MakeNewLevelFromScratch(int lev, Real time, const BoxArray
  // &ba,
  //                                      const DistributionMapping &dm)
  //                                      override;

  // virtual void ManualTagsPlacement(int lev, TagBoxArray &tags,
  //                                  const Vector<IntVect> &bf_lev) override;
  // virtual BoxArray GetAreaNotToTag(int lev) override;

  virtual void MakeNewLevelFromScratch(int lev, Real time, const BoxArray &ba,
                                       const DistributionMapping &dm) override;
  virtual void MakeNewLevelFromCoarse(int lev, Real time, const BoxArray &ba,
                                      const DistributionMapping &dm) override;
  virtual void RemakeLevel(int lev, Real time, const BoxArray &ba,
                           const DistributionMapping &dm) override;
  virtual void ClearLevel(int lev) override;

  unique_ptr<CactusAmrMesh> amrmesh;

  unique_ptr<CactusAmrCore> amrcore;

        geoms.at(leveldata.level) = ghext->amrmesh->Geom(leveldata.level);

        geoms.at(leveldata.level) = ghext->amrcore->Geom(leveldata.level);

#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
namespace AMReX {
using namespace std;
extern "C" void AMReX_SetLevel(CCTK_ARGUMENTS) {
  DECLARE_CCTK_ARGUMENTS;
  DECLARE_CCTK_PARAMETERS;
  int levfac = cctk_levfac[0];
  int lev = 0;
  while (levfac > 1) {
    levfac >>= 1;
    lev += 1;
  }
  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);
        refinement_level[idx] = lev;
      }
    }
  }
}
} // namespace AMReX

SRCS = driver.cxx io.cxx reduction.cxx schedule.cxx

SRCS = driver.cxx io.cxx level.cxx reduction.cxx schedule.cxx

      const auto &restrict geom = ghext->amrmesh->Geom(leveldata.level);

      const auto &restrict geom = ghext->amrcore->Geom(leveldata.level);

  const Geometry &geom = ghext->amrmesh->Geom(0);

  const Geometry &geom = ghext->amrcore->Geom(0);

  const int numlevels = ghext->amrmesh->finestLevel() + 1;

  const int numlevels = ghext->amrcore->finestLevel() + 1;

    const Geometry &geom = ghext->amrmesh->Geom(level);

    const Geometry &geom = ghext->amrcore->Geom(level);

  const Box &domain = ghext->amrmesh->Geom(leveldata.level).Domain();

  const Box &domain = ghext->amrcore->Geom(leveldata.level).Domain();

      current_level = ghext->amrmesh->finestLevel();

      current_level = ghext->amrcore->finestLevel();

      const int old_numlevels = ghext->amrmesh->finestLevel() + 1;

      const int old_numlevels = ghext->amrcore->finestLevel() + 1;

      const int new_numlevels = ghext->amrmesh->finestLevel() + 1;

      const int new_numlevels = ghext->amrcore->finestLevel() + 1;

      cout << "old_numlevels=" << old_numlevels << "\n";
      cout << "new_numlevels=" << new_numlevels << "\n";
      cout << "max_numlevels=" << int(ghext->amrmesh->maxLevel() + 1) << "\n";

      cout << "I old_numlevels=" << old_numlevels << "\n";
      cout << "I new_numlevels=" << new_numlevels << "\n";
      cout << "I max_numlevels=" << int(ghext->amrcore->maxLevel() + 1) << "\n";

      if (new_numlevels == old_numlevels)

      if (new_numlevels <= old_numlevels)

      // Did we create all possible levels?
      if (new_numlevels == int(ghext->amrmesh->maxLevel() + 1))
        break;

              ghext->amrmesh->Geom(leveldata.level).periodicity());

              ghext->amrcore->Geom(leveldata.level).periodicity());

              groupdata.numvars, ghext->amrmesh->Geom(level - 1),
              ghext->amrmesh->Geom(level), cphysbc, 0, fphysbc, 0, reffact,

              groupdata.numvars, ghext->amrcore->Geom(level - 1),
              ghext->amrcore->Geom(level), cphysbc, 0, fphysbc, 0, reffact,

        tag[idx] = r <= 0.5;

        tag[idx] = r <= 0.5 / cctk_levfac[0];

AMReX::ncells_x = 16 # 128
AMReX::ncells_y = 16 # 128
AMReX::ncells_z = 16 # 128

AMReX::ncells_x = 128
AMReX::ncells_y = 128
AMReX::ncells_z = 128

Cactus::cctk_itlast = 0   #TODO 128

AMReX::max_num_levels = 3
Cactus::cctk_itlast = 128