PoPS/doxygen/condensed__schur__source__stepper_8hpp_source.html

#pragma once


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

#include <pops/core/state/variables.hpp>

#include <pops/coupling/schur/core/schur_condensation.hpp>  // ElectrostaticLorentzCondensation (builder #124)

#include <pops/coupling/schur/core/schur_source_kernels.hpp>  // shared geometry-free kernels + validate_krylov_params (#263)

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

#include <pops/mesh/geometry/geometry.hpp>

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

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

#include <pops/mesh/boundary/physical_bc.hpp>

#include <pops/numerics/elliptic/mg/geometric_mg.hpp>   // operator + preconditioner (#120)

#include <pops/numerics/elliptic/linear/krylov_solver.hpp>  // TensorKrylovSolver (BiCGStab, #122)

#include <pops/numerics/linalg/lorentz_eliminator.hpp>      // closed-form B^{-1} (#118)


#include <stdexcept>


namespace pops {


namespace detail {


struct SchurReconstructKernel {

  ConstArray4 phi;

  ConstArray4 vx, vy;

  ConstArray4 bz;

  Array4 st;

  Array4 nvx, nvy;

  Real th_dt;

  Real half_idx, half_idy;

  int c_rho, c_mx, c_my;


  POPS_HD void operator()(int i, int j) const {

    const Real gx = (phi(i + 1, j, 0) - phi(i - 1, j, 0)) * half_idx;  // d_x phi^{n+theta}

    const Real gy = (phi(i, j + 1, 0) - phi(i, j - 1, 0)) * half_idy;  // d_y phi^{n+theta}

    const Real rhsx = vx(i, j, 0) - th_dt * gx;  // (v^n - theta dt grad phi)_x

    const Real rhsy = vy(i, j, 0) - th_dt * gy;

    const LorentzEliminator le(th_dt, Real(1), bz(i, j, 0));  // w = th_dt * B_z

    Real nx, ny;

    le.apply_Binv(rhsx, rhsy, nx, ny);  // v^{n+theta} = B^{-1}(v^n - theta dt grad phi)

    nvx(i, j, 0) = nx;

    nvy(i, j, 0) = ny;

    const Real rho = st(i, j, c_rho);  // rho^n (frozen in the source)

    st(i, j, c_mx) = rho * nx;         // mom^{n+theta} = rho^n v^{n+theta}

    st(i, j, c_my) = rho * ny;

  }


};


// The 5 geometry-free source kernels (extrapolate-scalar/velocity, energy, extract-velocity, copy-Bz)

// live in <pops/coupling/schur/schur_source_kernels.hpp> and are shared with the polar / AMR steppers (#263).

// Only SchurReconstructKernel stays local: it carries the discretization-specific centered gradient.


}  // namespace detail


class CondensedSchurSourceStepper {

 public:


  CondensedSchurSourceStepper(const VariableSet& vars, const Geometry& geom, const BoxArray& ba,

                              const BCRec& bcPhi, Real alpha, int n_precond_vcycles = 1)

      : CondensedSchurSourceStepper(

            vars, vars.index_of(VariableRole::Density), vars.index_of(VariableRole::MomentumX),

            vars.index_of(VariableRole::MomentumY), vars.index_of(VariableRole::Energy), geom, ba,

            bcPhi, alpha, n_precond_vcycles) {}


  CondensedSchurSourceStepper(const VariableSet& vars, int c_rho, int c_mx, int c_my, int c_E,

                              const Geometry& geom, const BoxArray& ba, const BCRec& bcPhi,

                              Real alpha, int n_precond_vcycles = 1)

      : vars_(vars),

        c_rho_(c_rho),

        c_mx_(c_mx),

        c_my_(c_my),

        c_E_(c_E),

        alpha_(alpha),

        geom_(geom),

        bcPhi_(bcPhi),

        n_precond_(n_precond_vcycles),

        ba_(ba),

        dm_(ba.size(), n_ranks()),

        // FULL operator (BiCGStab matvec) + SYMMETRIC preconditioner (without cross terms).

        op_(geom, ba, bcPhi),

        precond_(geom, ba, bcPhi),

        // reused buffers (allocated ONCE):

        eps_x_(ba, dm_, 1, 1),

        eps_y_(ba, dm_, 1, 1),

        a_xy_(ba, dm_, 1, 1),

        a_yx_(ba, dm_, 1, 1),

        rhs_schur_(ba, dm_, 1, 0),

        bz_(ba, dm_, 1, 1),

        vx_n_(ba, dm_, 1, 0),

        vy_n_(ba, dm_, 1, 0),

        vx_t_(ba, dm_, 1, 0),

        vy_t_(ba, dm_, 1, 0),

        phi_n_(ba, dm_, 1, 1),

        kry_(op_, precond_, n_precond_) {

    if (c_rho_ < 0 || c_mx_ < 0 || c_my_ < 0)

      throw std::runtime_error(

          "CondensedSchurSourceStepper: the fluid block must expose the Density, MomentumX "

          "and MomentumY roles (VariableSet.roles populated).");

  }


  bool has_energy() const { return c_E_ >= 0; }


  void step(MultiFab& state, MultiFab& phi, const MultiFab& bz_field, int c_bz, Real theta,

            Real dt) {

    const Real th_dt = theta * dt;


    // -1) freeze phi^n (for the final extrapolation; op_'s phi() will be overwritten by the solve).

    copy_comp0(phi_n_, phi);


    // 0) extract v^n = (mx, my)/rho and copy B_z into the internal buffer (1 ghost filled afterwards).

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

      const ConstArray4 s = state.fab(li).const_array();

      for_each_cell(state.box(li),

                    detail::ExtractVelocityKernel{s, vx_n_.fab(li).array(), vy_n_.fab(li).array(),

                                                  c_rho_, c_mx_, c_my_});

      for_each_cell(bz_.box(li), detail::CopyBzKernel{bz_field.fab(li).const_array(),

                                                      bz_.fab(li).array(), c_bz});

    }

    const BCRec ebc = coeff_bc(bcPhi_);

    fill_ghosts(bz_, geom_.domain, ebc);  // B_z read at (i,j) only here, but 1 ghost = MPI-clean


    // 1) ASSEMBLE A_op = I + c rho B^{-1} + condensed RHS (#124). phi gets its ghosts filled (BC).

    ElectrostaticLorentzCondensation builder(vars_, alpha_, theta, dt);

    builder.assemble_operator(state, bz_, geom_, bcPhi_, eps_x_, eps_y_, a_xy_, a_yx_);

    builder.assemble_rhs(phi, state, bz_, geom_, bcPhi_, rhs_schur_);


    // 2) configure the FULL operator (op_) and the SYMMETRIC preconditioner (precond_), then

    //    SOLVE L_int(phi) = -rhs_schur (cf. the sign convention of the header) by BiCGStab.

    op_.set_epsilon_anisotropic(eps_x_, eps_y_);

    op_.set_cross_terms(a_xy_, a_yx_);

    precond_.set_epsilon_anisotropic(eps_x_, eps_y_);  // symmetric part: cross terms DROPPED.

    // warm start: phi^n -> op_.phi(); rhs = -rhs_schur.

    copy_comp0(op_.phi(), phi);

    negate_into(op_.rhs(), rhs_schur_);

    // kry_ is a persistent MEMBER (its ~10 MultiFab are allocated ONCE at construction, not

    // per call): solve() recomputes the entirety of its state per solve (prepare_solve, r0, directions),

    // so the result is BIT-IDENTICAL to the old per-call construction of a local TensorKrylovSolver here.

    // Tolerances configurable via set_krylov (audit 2026-06); defaults = historical 1e-10/400.

    last_result_ = kry_.solve(krylov_tol_, krylov_max_iters_);

    copy_comp0(phi, op_.phi());  // phi <- phi^{n+theta}


    // 3) RECONSTRUCT v^{n+theta} = B^{-1}(v^n - theta dt grad phi^{n+theta}); mom = rho v.

    device_fence();

    fill_ghosts(phi, geom_.domain, bcPhi_);  // centered grad reads phi(i+-1), phi(j+-1)

    const Real half_idx = Real(1) / (Real(2) * geom_.dx());

    const Real half_idy = Real(1) / (Real(2) * geom_.dy());

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

      for_each_cell(

          state.box(li),

          detail::SchurReconstructKernel{

              phi.fab(li).const_array(), vx_n_.fab(li).const_array(), vy_n_.fab(li).const_array(),

              bz_.fab(li).const_array(), state.fab(li).array(), vx_t_.fab(li).array(),

              vy_t_.fab(li).array(), th_dt, half_idx, half_idy, c_rho_, c_mx_, c_my_});

    }

    // vx_t_/vy_t_ now carry v^{n+theta}.


    // 5) EXTRAPOLATE phi and v from the theta-stage to the full step: f^{n+1} = f^n + (1/theta)(f^{n+theta}-f^n).

    //    theta = 1 -> identity. phi^n is frozen in phi_n_ (step -1), v^n in vx_n_/vy_n_.

    const Real inv_theta = Real(1) / theta;

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

      for_each_cell(phi.box(li), detail::SchurExtrapolateScalarKernel{

                                     phi_n_.fab(li).const_array(), phi.fab(li).array(), inv_theta});

    // v + mom: linear extrapolation, recompose mom = rho v^{n+1}. vx_t_/vy_t_ then carry v^{n+1}.

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

      for_each_cell(state.box(li), detail::SchurExtrapolateVelocityKernel{

                                       vx_n_.fab(li).const_array(), vy_n_.fab(li).const_array(),

                                       vx_t_.fab(li).array(), vy_t_.fab(li).array(),

                                       state.fab(li).array(), inv_theta, c_rho_, c_mx_, c_my_});


    // 4) ENERGY (if role present): E^{n+1} = E^n + (1/2) rho (|v^{n+1}|^2 - |v^n|^2).

    if (c_E_ >= 0)

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

        for_each_cell(state.box(li), detail::SchurEnergyKernel{

                                         vx_n_.fab(li).const_array(), vy_n_.fab(li).const_array(),

                                         vx_t_.fab(li).const_array(), vy_t_.fab(li).const_array(),

                                         state.fab(li).array(), c_rho_, c_E_});


    // 6) FILL the ghosts of the state and of the potential (MPI halos / physical BC) before returning control.

    device_fence();

    fill_ghosts(state, geom_.domain, bcU_default());

    fill_ghosts(phi, geom_.domain, bcPhi_);

  }


  const KrylovResult& last_solve() const { return last_result_; }


  void set_krylov(Real tol, int max_iters) {

    detail::validate_krylov_params(tol, max_iters, "CondensedSchurSourceStepper::set_krylov");

    krylov_tol_ = tol;

    krylov_max_iters_ = max_iters;

  }


  int density_comp() const { return c_rho_; }

  int momentum_x_comp() const { return c_mx_; }

  int momentum_y_comp() const { return c_my_; }

  int energy_comp() const { return c_E_; }


 private:

  BCRec bcU_default() const { return coeff_bc(bcPhi_); }


  static BCRec coeff_bc(const BCRec& bc) {

    auto fo = [](BCType t) { return t == BCType::Periodic ? t : BCType::Foextrap; };

    BCRec b;

    b.xlo = fo(bc.xlo);

    b.xhi = fo(bc.xhi);

    b.ylo = fo(bc.ylo);

    b.yhi = fo(bc.yhi);

    return b;

  }


  void copy_comp0(MultiFab& dst, const MultiFab& src) {

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

      for_each_cell(dst.box(li),

                    detail::CopyComp0Kernel{dst.fab(li).array(), src.fab(li).const_array()});

  }


  void negate_into(MultiFab& dst, const MultiFab& src) {

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

      for_each_cell(dst.box(li),

                    detail::NegateKernel{src.fab(li).const_array(), dst.fab(li).array()});

  }


  VariableSet vars_;

  int c_rho_, c_mx_, c_my_, c_E_;

  Real alpha_;

  Geometry geom_;

  BCRec bcPhi_;

  int n_precond_;

  BoxArray ba_;

  DistributionMapping dm_;

  GeometricMG op_, precond_;

  MultiFab eps_x_, eps_y_, a_xy_, a_yx_;

  MultiFab rhs_schur_;

  MultiFab bz_;

  MultiFab vx_n_, vy_n_;

  MultiFab vx_t_, vy_t_;

  MultiFab

      phi_n_;

  KrylovResult last_result_;

  Real krylov_tol_ = Real(1e-10);

  int krylov_max_iters_ = 400;

  // PERSISTENT Krylov solver (BiCGStab + MG precond). Allocates its buffers (r/rhat/p/v/s/t/phat/

  // shat + BC offsets) ONCE; step() reuses kry_ without reallocation. MUST be declared AFTER

  // op_/precond_/n_precond_ (which it references): init order (after them) and destruction order (before them)

  // correct. Bit-identical to the old per-call construction (solve() reinitializes its entire state).

  TensorKrylovSolver kry_;

};


}  // namespace pops

pops::BoxArray
Ordered list of boxes tiling a level.
Definition box_array.hpp:22

pops::CondensedSchurSourceStepper
Schur-condensed SOURCE STAGE, STANDALONE (transport frozen), GENERIC over any fluid block that expose...
Definition condensed_schur_source_stepper.hpp:126

pops::CondensedSchurSourceStepper::set_krylov
void set_krylov(Real tol, int max_iters)
Tolerance / iteration budget of the stage Krylov solve (BiCGStab).
Definition condensed_schur_source_stepper.hpp:277

pops::CondensedSchurSourceStepper::density_comp
int density_comp() const
Definition condensed_schur_source_stepper.hpp:283

pops::CondensedSchurSourceStepper::CondensedSchurSourceStepper
CondensedSchurSourceStepper(const VariableSet &vars, const Geometry &geom, const BoxArray &ba, const BCRec &bcPhi, Real alpha, int n_precond_vcycles=1)
vars: descriptor of the fluid block; MUST expose Density / MomentumX / MomentumY (Energy optional).
Definition condensed_schur_source_stepper.hpp:133

pops::CondensedSchurSourceStepper::momentum_x_comp
int momentum_x_comp() const
Definition condensed_schur_source_stepper.hpp:284

pops::CondensedSchurSourceStepper::CondensedSchurSourceStepper
CondensedSchurSourceStepper(const VariableSet &vars, int c_rho, int c_mx, int c_my, int c_E, const Geometry &geom, const BoxArray &ba, const BCRec &bcPhi, Real alpha, int n_precond_vcycles=1)
Variant with EXPLICIT COMPONENTS (audit 2026-06, wave 2: roles/fields carried in the ABI).
Definition condensed_schur_source_stepper.hpp:146

pops::CondensedSchurSourceStepper::has_energy
bool has_energy() const
true if the model carries an Energy role (energy update active).
Definition condensed_schur_source_stepper.hpp:183

pops::CondensedSchurSourceStepper::energy_comp
int energy_comp() const
Definition condensed_schur_source_stepper.hpp:286

pops::CondensedSchurSourceStepper::last_solve
const KrylovResult & last_solve() const
Diagnostic of the last solve (BiCGStab iterations, relative residual, convergence).
Definition condensed_schur_source_stepper.hpp:272

pops::CondensedSchurSourceStepper::step
void step(MultiFab &state, MultiFab &phi, const MultiFab &bz_field, int c_bz, Real theta, Real dt)
Condensed SOURCE STAGE, IN-PLACE on state and phi.
Definition condensed_schur_source_stepper.hpp:190

pops::CondensedSchurSourceStepper::momentum_y_comp
int momentum_y_comp() const
Definition condensed_schur_source_stepper.hpp:285

pops::ElectrostaticLorentzCondensation
GENERIC builder of the condensed source stage for the electrostatic + Lorentz source (kind="electrost...
Definition schur_condensation.hpp:153

pops::ElectrostaticLorentzCondensation::assemble_operator
void assemble_operator(const MultiFab &state, const MultiFab &bz, const Geometry &geom, const BCRec &bc, MultiFab &eps_x, MultiFab &eps_y, MultiFab &a_xy, MultiFab &a_yx) const
Assembles ONLY the coefficients of the tensor operator A_op = I + c rho B^{-1} into MultiFab eps_x/ep...
Definition schur_condensation.hpp:185

pops::ElectrostaticLorentzCondensation::assemble_rhs
void assemble_rhs(MultiFab &phi_n, const MultiFab &state, const MultiFab &bz, const Geometry &geom, const BCRec &bc, MultiFab &rhs) const
Assembles ONLY the condensed right-hand side -Lap phi^n - theta dt alpha div(rho B^{-1} v^n).
Definition schur_condensation.hpp:216

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::GeometricMG::rhs
MultiFab & rhs()
Definition geometric_mg.hpp:222

pops::GeometricMG::phi
MultiFab & phi()
Definition geometric_mg.hpp:221

pops::GeometricMG::set_epsilon_anisotropic
void set_epsilon_anisotropic(std::function< Real(Real, Real)> eps_x_fn, std::function< Real(Real, Real)> eps_y_fn)
Definition geometric_mg.hpp:274

pops::GeometricMG::set_cross_terms
void set_cross_terms(std::function< Real(Real, Real)> a_xy_fn, std::function< Real(Real, Real)> a_yx_fn)
Definition geometric_mg.hpp:329

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

pops::TensorKrylovSolver::solve
void solve()
Definition krylov_solver.hpp:92

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

geometric_mg.hpp
GeometricMG: in-house geometric multigrid (V-cycle) for the elliptic operator, Gauss-Seidel smoother ...

geometry.hpp
Geometry: index-space (Box2D) <-> Cartesian physical-space mapping; PolarGeometry: SIBLING for a glob...

krylov_solver.hpp
TensorKrylovSolver: MATRIX-FREE Krylov solver (BiCGStab) with MG preconditioning, for the FULL-TENSOR...

lorentz_eliminator.hpp
LorentzEliminator: 2x2 operator B of the Schur scheme for implicit velocity elimination.

mf_arith.hpp
MultiFab arithmetic (saxpy, lincomb, norm_inf, dot) over VALID cells.

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

pops::detail::validate_krylov_params
void validate_krylov_params(Real tol, int max_iters, const char *who)
Validates the Krylov tolerance / iteration budget shared by the Schur source steppers (historical con...
Definition schur_source_kernels.hpp:103

pops
Definition amr_hierarchy.hpp:29

pops::for_each_cell
void for_each_cell(const Box2D &b, F f)
Applies f to EACH cell (i, j) of box b (bounds inclusive), via Kokkos::parallel_for (Serial / OpenMP ...
Definition for_each.hpp:138

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

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

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::VariableRole
VariableRole
PHYSICAL role of a component.
Definition variables.hpp:27

pops::VariableRole::Energy
@ Energy

pops::VariableRole::Density
@ Density

pops::VariableRole::MomentumX
@ MomentumX

pops::VariableRole::MomentumY
@ MomentumY

pops::BCType
BCType
Boundary condition type for a face: Periodic (handled by fill_boundary), Foextrap (zero gradient,...
Definition physical_bc.hpp:25

pops::BCType::Foextrap
@ Foextrap

pops::BCType::Periodic
@ Periodic

pops::fill_ghosts
void fill_ghosts(MultiFab &mf, const Box2D &domain, const BCRec &bc)
COMPLETE ghost filling: fill_boundary (interior + periodic, periodicity deduced from bc) THEN fill_ph...
Definition physical_bc.hpp:227

physical_bc.hpp
PHYSICAL boundary conditions at the domain edge (BCType, BCRec, fill_physical_bc, fill_ghosts).

schur_condensation.hpp
BUILDER (NOT solver) of the Schur-condensed source stage of the implicit source coupling potential / ...

schur_source_kernels.hpp
Geometry-INDEPENDENT device kernels shared by the Schur SOURCE-STAGE steppers: the Cartesian condense...

pops::Array4
WRITE POD handle (raw pointer + strides) over a Fab2D buffer, indexed by (i, j, c) IN GLOBAL INDICES ...
Definition fab2d.hpp:29

pops::BCRec
Boundary conditions for the FOUR faces of the domain (type + associated Dirichlet value).
Definition physical_bc.hpp:29

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

pops::Geometry
Cartesian geometry of a level: index domain + physical bounds [xlo, xhi] x [ylo, yhi].
Definition geometry.hpp:20

pops::Geometry::dy
POPS_HD Real dy() const
Grid spacing in y (= (yhi - ylo) / domain.ny()). POPS_HD.
Definition geometry.hpp:33

pops::Geometry::dx
POPS_HD Real dx() const
Grid spacing in x (= (xhi - xlo) / domain.nx()). POPS_HD.
Definition geometry.hpp:31

pops::Geometry::domain
Box2D domain
Definition geometry.hpp:21

pops::KrylovResult
Outcome of a Krylov solve: iterations performed, final relative residual, convergence flag.
Definition krylov_result.hpp:16

pops::LorentzEliminator
LorentzEliminator: operator B = [[1,-w],[w,1]] and its analytic inverse.
Definition lorentz_eliminator.hpp:55

pops::LorentzEliminator::apply_Binv
POPS_HD void apply_Binv(Real vx, Real vy, Real &vxp, Real &vyp) const
apply_Binv: applies B^{-1} = (1/det)*[[1,w],[-w,1]] to (vx, vy), writes (vxp, vyp)....
Definition lorentz_eliminator.hpp:73

pops::VariableSet
A model's variable set: kind (cons/prim), names, size, canonical roles (optional, parallel to names; ...
Definition variables.hpp:58

pops::detail::CopyBzKernel
Copies the B_z field (aux channel) into an internal scalar MultiFab (0 ghost is enough,...
Definition schur_source_kernels.hpp:93

pops::detail::ExtractVelocityKernel
Extracts the velocity v = (mx, my) / rho from the state (Density / MomentumX / MomentumY roles) into ...
Definition schur_source_kernels.hpp:79

pops::detail::SchurEnergyKernel
Energy update: E^{n+1} = E^n + (1/2) rho^n (|v^{n+1}|^2 - |v^n|^2).
Definition schur_source_kernels.hpp:62

pops::detail::SchurExtrapolateScalarKernel
Linear extrapolation of a SCALAR field from the theta-stage to the full step: f^{n+1} = f^n + (1/thet...
Definition schur_source_kernels.hpp:32

pops::detail::SchurExtrapolateVelocityKernel
Linear extrapolation of the VELOCITY (vx, vy) from the theta-stage to the full step,...
Definition schur_source_kernels.hpp:43

pops::detail::SchurReconstructKernel
Reconstructs v^{n+theta} = B^{-1}(v^n - theta dt grad phi^{n+theta}) and writes mom = rho^n v^{n+thet...
Definition condensed_schur_source_stepper.hpp:85

pops::detail::SchurReconstructKernel::phi
ConstArray4 phi
phi^{n+theta} (ghosts filled: centered grad reads i+-1, j+-1)
Definition condensed_schur_source_stepper.hpp:86

pops::detail::SchurReconstructKernel::c_mx
int c_mx
Definition condensed_schur_source_stepper.hpp:93

pops::detail::SchurReconstructKernel::vy
ConstArray4 vy
v^n (component 0 of their MultiFab: velocity, NOT momentum)
Definition condensed_schur_source_stepper.hpp:87

pops::detail::SchurReconstructKernel::half_idx
Real half_idx
Definition condensed_schur_source_stepper.hpp:92

pops::detail::SchurReconstructKernel::vx
ConstArray4 vx
Definition condensed_schur_source_stepper.hpp:87

pops::detail::SchurReconstructKernel::st
Array4 st
fluid state (WRITE mx, my; READ rho)
Definition condensed_schur_source_stepper.hpp:89

pops::detail::SchurReconstructKernel::operator()
POPS_HD void operator()(int i, int j) const
Definition condensed_schur_source_stepper.hpp:94

pops::detail::SchurReconstructKernel::c_rho
int c_rho
Definition condensed_schur_source_stepper.hpp:93

pops::detail::SchurReconstructKernel::nvy
Array4 nvy
output: v^{n+theta} (component 0) for the energy / the diagnostic
Definition condensed_schur_source_stepper.hpp:90

pops::detail::SchurReconstructKernel::bz
ConstArray4 bz
B_z field at the center.
Definition condensed_schur_source_stepper.hpp:88

pops::detail::SchurReconstructKernel::half_idy
Real half_idy
1/(2 dx), 1/(2 dy) (centered gradient)
Definition condensed_schur_source_stepper.hpp:92

pops::detail::SchurReconstructKernel::nvx
Array4 nvx
Definition condensed_schur_source_stepper.hpp:90

pops::detail::SchurReconstructKernel::th_dt
Real th_dt
theta * dt (w = th_dt * B_z, and gradient factor)
Definition condensed_schur_source_stepper.hpp:91

pops::detail::SchurReconstructKernel::c_my
int c_my
Density / MomentumX / MomentumY components.
Definition condensed_schur_source_stepper.hpp:93

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

POPS_HD
#define POPS_HD
Definition types.hpp:25

variables.hpp
Descriptor of a model's variables (Vars).