PoPS/doxygen/amr__diagnostics_8hpp_source.html

#pragma once


#include <pops/core/foundation/types.hpp>

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

#include <pops/mesh/execution/for_each.hpp>  // device_fence

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


#include <algorithm>

#include <cmath>


namespace pops {


// --- MULTI-BOX form (canonical): sum/max over the valid cells of ALL local fabs,

// WITHOUT MPI reduction (the coupler decides whether to all_reduce according to its

// ownership policy). This is the single implementation; the mono-box variants below reduce

// to it (a single fab whose box equals the domain -> bit for bit identical). This removes

// the duplication between AmrCoupler (mono-box) and AmrCouplerMP (multi-box / distributed).


// local sum of u(.,.,0) * dV over the valid cells. dV multiplied INSIDE the kernel.


inline Real amr_mass_mb(const MultiFab& coarse, Real dx, Real dy) {

  const Real dV = dx * dy;

  Real M = 0;

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

    const ConstArray4 u = coarse.fab(li).const_array();

    M += for_each_cell_reduce_sum(coarse.box(li),

                                  [u, dV] POPS_HD(int i, int j) { return u(i, j, 0) * dV; });

  }

  return M;

}


// local max of |grad phi| / B0 (aux comp 1,2 = grad phi). Host loop (std::hypot not

// confirmed device: see the header). WITHOUT floor (applied by the caller).


inline Real amr_max_drift_speed_mb(const MultiFab& aux0, Real B0) {

  device_fence();

  Real v = 0;

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

    const ConstArray4 a = aux0.fab(li).const_array();

    const Box2D b = aux0.box(li);

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

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

        v = std::max(v, std::hypot(a(i, j, 1), a(i, j, 2)) / B0);

  }

  return v;

}


// mass of component 0 on the coarse level (single box): degenerate case of

// amr_mass_mb (one fab covering the domain), bit for bit identical. dom kept for the API.


inline Real amr_mass(const MultiFab& coarse, const Box2D& dom, Real dx, Real dy) {

  (void)dom;

  return amr_mass_mb(coarse, dx, dy);

}


// max drift speed on the coarse level (single box) + floor 1e-12 (CFL guard).


inline Real amr_max_drift_speed(const MultiFab& aux0, const Box2D& dom, Real B0) {

  (void)dom;

  return std::max(amr_max_drift_speed_mb(aux0, B0), Real(1e-12));

}


}  // namespace pops

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

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::box
const Box2D & box(int li) const
VALID box of local fab li.
Definition multifab.hpp:71

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

for_each.hpp
for_each_cell and reductions: the parallelism SEAM over the cells of a Box2D; sync_host / sync_device...

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

pops
Definition amr_hierarchy.hpp:29

pops::for_each_cell_reduce_sum
Real for_each_cell_reduce_sum(const Box2D &b, F f)
SUM reduction of f(i, j) over box b.
Definition for_each.hpp:199

pops::Real
double Real
Definition types.hpp:30

pops::amr_mass
Real amr_mass(const MultiFab &coarse, const Box2D &dom, Real dx, Real dy)
Mono-box mass: degenerate case of amr_mass_mb (bit for bit). dom is ignored (kept for the API).
Definition amr_diagnostics.hpp:64

pops::device_fence
void device_fence()
Device barrier: waits for in-flight kernels to finish before a HOST access to unified memory.
Definition kokkos_env.hpp:43

pops::amr_max_drift_speed_mb
Real amr_max_drift_speed_mb(const MultiFab &aux0, Real B0)
LOCAL max drift speed: max of |grad phi| / B0 (aux comp 1, 2 = grad phi) over the valid cells,...
Definition amr_diagnostics.hpp:48

pops::amr_mass_mb
Real amr_mass_mb(const MultiFab &coarse, Real dx, Real dy)
LOCAL mass: sum of u(.,.,0) * dx * dy over the valid cells of ALL local fabs, WITHOUT MPI reduction (...
Definition amr_diagnostics.hpp:33

pops::amr_max_drift_speed
Real amr_max_drift_speed(const MultiFab &aux0, const Box2D &dom, Real B0)
Mono-box max drift speed + floor 1e-12 (CFL guard). dom ignored (kept for the API).
Definition amr_diagnostics.hpp:71

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

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

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

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

types.hpp
Base scalar types and the POPS_HD macro (host+device portability).

POPS_HD
#define POPS_HD
Definition types.hpp:25