PoPS/doxygen/regrid_8hpp_source.html

#pragma once


#include <pops/amr/hierarchy/amr_hierarchy.hpp>

#include <pops/amr/tagging/cluster.hpp>

#include <pops/amr/tagging/tag_box.hpp>

#include <pops/mesh/index/box2d.hpp>

#include <pops/mesh/layout/box_array.hpp>

#include <pops/mesh/layout/distribution_mapping.hpp>

#include <pops/mesh/storage/fab2d.hpp>

#include <pops/mesh/storage/multifab.hpp>

#include <pops/mesh/layout/refinement.hpp>

#include <pops/parallel/comm.hpp>


#include <utility>

#include <vector>


namespace pops {


template <class Crit>


TagBox tag_cells(const MultiFab& mf, const Box2D& domain, Crit crit) {

  TagBox tb(domain);

  for (int li = 0; li < mf.local_size(); ++li) {

    const Fab2D& f = mf.fab(li);

    const ConstArray4 a = f.const_array();

    const Box2D v = f.box();

    for (int j = v.lo[1]; j <= v.hi[1]; ++j)

      for (int i = v.lo[0]; i <= v.hi[0]; ++i)

        if (crit(a, i, j))

          tb(i, j) = 1;

  }

  return tb;

}


inline TagBox grow_tags(const TagBox& in, int n, const Box2D& domain) {

  TagBox out(in.box);

  const Box2D& b = in.box;

  for (int j = b.lo[1]; j <= b.hi[1]; ++j)

    for (int i = b.lo[0]; i <= b.hi[0]; ++i)

      if (in(i, j))

        for (int dj = -n; dj <= n; ++dj)

          for (int di = -n; di <= n; ++di) {

            const int ii = i + di, jj = j + dj;

            if (b.contains(ii, jj) && domain.contains(ii, jj))

              out(ii, jj) = 1;

          }

  return out;

}


struct RegridParams {

  int n_buffer = 1;

  ClusterParams cluster{};

};


template <class Crit>


void regrid_level(AmrHierarchy& h, int coarse_lev, Crit crit, const RegridParams& rp = {}) {

  const Box2D cdom = h.domain(coarse_lev);

  TagBox tags = tag_cells(h.data(coarse_lev), cdom, crit);

  TagBox grown = grow_tags(tags, rp.n_buffer, cdom);


  if (grown.count() == 0) {  // nothing left to refine

    h.clear_above(coarse_lev);

    return;

  }


  // coarse boxes -> fine boxes (index space of level coarse_lev+1)

  std::vector<Box2D> cboxes = berger_rigoutsos(grown, rp.cluster);

  std::vector<Box2D> fboxes;

  fboxes.reserve(cboxes.size());

  for (const auto& b : cboxes)

    fboxes.push_back(b.refine(h.ref_ratio()));

  BoxArray fba(std::move(fboxes));


  MultiFab newfine(fba, DistributionMapping(fba.size(), n_ranks()), h.ncomp(), h.n_grow());

  interpolate(h.data(coarse_lev), newfine, h.ref_ratio());

  if (h.num_levels() > coarse_lev + 1)

    parallel_copy(newfine, h.data(coarse_lev + 1));  // preserve the old fine level


  h.install_level(coarse_lev + 1, fba, std::move(newfine));

}


}  // namespace pops

amr_hierarchy.hpp
AmrHierarchy: the stack of refinement levels (container of the AMR hierarchy).

box2d.hpp
Box2D: the integer index space of a 2D cell-centered Cartesian grid.

box_array.hpp
BoxArray: the set of boxes tiling a level (disjoint, covering).

pops::AmrHierarchy
Stack of refined levels (domain + BoxArray + MultiFab per level), level 0 the coarsest.
Definition amr_hierarchy.hpp:38

pops::AmrHierarchy::clear_above
void clear_above(int lev)
Removes all levels strictly finer than lev (no-op if lev is already the finest).
Definition amr_hierarchy.hpp:90

pops::AmrHierarchy::data
MultiFab & data(int lev)
Field of level lev (mutable access).
Definition amr_hierarchy.hpp:112

pops::AmrHierarchy::ncomp
int ncomp() const
Number of field components per cell.
Definition amr_hierarchy.hpp:103

pops::AmrHierarchy::n_grow
int n_grow() const
Number of ghost layers of the MultiFab.
Definition amr_hierarchy.hpp:105

pops::AmrHierarchy::ref_ratio
int ref_ratio() const
Integer refinement ratio between consecutive levels.
Definition amr_hierarchy.hpp:101

pops::AmrHierarchy::domain
const Box2D & domain(int lev) const
Domain of level lev in index space (INCLUSIVE lo/hi corners).
Definition amr_hierarchy.hpp:108

pops::AmrHierarchy::num_levels
int num_levels() const
Number of levels present (>= 1: level 0 always exists).
Definition amr_hierarchy.hpp:99

pops::AmrHierarchy::install_level
void install_level(int lev, const BoxArray &fine_ba, MultiFab data)
Installs (adds or replaces) a fine level at index lev.
Definition amr_hierarchy.hpp:72

pops::Fab2D
Single-grid data on a Box2D: VALID box + ng ghost layers, ncomp components, component-slow layout.
Definition fab2d.hpp:59

pops::Fab2D::box
const Box2D & box() const
VALID box (without ghosts).
Definition fab2d.hpp:74

pops::Fab2D::const_array
ConstArray4 const_array() const
READ handle (POD device-copyable) over this Fab. Valid as long as the Fab lives.
Definition fab2d.hpp:96

pops::MultiFab
Field distributed over a level: decomposition (BoxArray) + distribution (DistributionMapping) + ncomp...
Definition multifab.hpp:33

pops::MultiFab::fab
Fab2D & fab(int li)
Local fab at index li (0 <= li < local_size()), for writing.
Definition multifab.hpp:67

pops::MultiFab::local_size
int local_size() const
Number of fabs OWNED by this rank (bound on local indices).
Definition multifab.hpp:65

cluster.hpp
Berger-Rigoutsos clustering: tag grid -> small set of boxes covering the tagged cells.

comm.hpp
Parallel seam: minimal MPI abstraction (rank/size + collectives) with serial fallback.

distribution_mapping.hpp
DistributionMapping: maps each box (by global index) to its owning MPI rank.

fab2d.hpp
Fab2D: single-grid data on a Box2D (in-house equivalent of AMReX's FArrayBox); Array4 / ConstArray4: ...

multifab.hpp
MultiFab: a field DISTRIBUTED over a level (equivalent of AMReX's MultiFab).

pops
Definition amr_hierarchy.hpp:29

pops::regrid_level
void regrid_level(AmrHierarchy &h, int coarse_lev, Crit crit, const RegridParams &rp={})
(Re)builds level coarse_lev+1 from the tagging of level coarse_lev.
Definition regrid.hpp:87

pops::n_ranks
int n_ranks()
Definition comm.hpp:139

pops::interpolate
void interpolate(const MultiFab &coarse, MultiFab &fine, int r, MultiFab &cfine)
Interpolation coarse -> fine (ratio r) by piecewise-CONSTANT injection: each fine cell (including the...
Definition refinement.hpp:220

pops::parallel_copy
void parallel_copy(MultiFab &dst, const MultiFab &src)
Copies the valid regions that OVERLAP from src to dst (same indices, no shift).
Definition refinement.hpp:50

pops::berger_rigoutsos
std::vector< Box2D > berger_rigoutsos(const TagBox &tags, const ClusterParams &p={})
Cluster a TagBox into boxes covering the tagged cells (Berger-Rigoutsos), then final chop.
Definition cluster.hpp:185

pops::grow_tags
TagBox grow_tags(const TagBox &in, int n, const Box2D &domain)
Grows the tags by n cells (square neighborhood), staying within the domain.
Definition regrid.hpp:58

pops::tag_cells
TagBox tag_cells(const MultiFab &mf, const Box2D &domain, Crit crit)
Marks the valid cells where the predicate is true, on a TagBox covering the domain.
Definition regrid.hpp:40

refinement.hpp
AMR inter-level transfer operators (integer ratio r) + parallel_copy.

pops::Box2D
2D integer index space, cell-centered.
Definition box2d.hpp:37

pops::Box2D::hi
int hi[2]
Definition box2d.hpp:39

pops::Box2D::contains
bool contains(int i, int j) const
true if cell (i, j) is inside the box (lo/hi bounds inclusive).
Definition box2d.hpp:61

pops::Box2D::lo
int lo[2]
Definition box2d.hpp:38

pops::ClusterParams
Berger-Rigoutsos clustering parameters (configuration object).
Definition cluster.hpp:31

pops::ConstArray4
READ-only handle (const counterpart of Array4): same layout and same contract (POD device-copyable,...
Definition fab2d.hpp:44

pops::RegridParams
Regrid parameters (configuration object).
Definition regrid.hpp:74

pops::RegridParams::cluster
ClusterParams cluster
Berger-Rigoutsos clustering parameters.
Definition regrid.hpp:76

pops::RegridParams::n_buffer
int n_buffer
tag dilation radius (grow_tags) before clustering.
Definition regrid.hpp:75

pops::TagBox
Dense grid of 0/1 markers over a box, input to Berger-Rigoutsos clustering.
Definition tag_box.hpp:35

pops::TagBox::box
Box2D box
Definition tag_box.hpp:36

tag_box.hpp
TagBox: dense grid of markers (0/1) over a region, input to Berger-Rigoutsos clustering.