LCOV - code coverage report
Current view: top level - solvers/navier_stokes/momentum_rhs - ns_momentum_rhs_scalar.h (source / functions) Coverage Total Hit
Test: coverage.info Lines: 91.9 % 123 113
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 1 1

            Line data    Source code
       1              : /**
       2              :  * @file ns_momentum_rhs_scalar.h
       3              :  * @brief Shared scalar momentum RHS kernel for the explicit RK time integrators.
       4              :  *
       5              :  * Defines the semi-discrete Navier-Stokes right-hand side used identically by
       6              :  * the scalar RK2 (`solver_rk2.c`) and RK4 (`solver_rk4.c`) solvers. Extracted to
       7              :  * a single source of truth so the two integrators cannot drift apart.
       8              :  *
       9              :  * Include requirements (the includer must satisfy these BEFORE #include-ing):
      10              :  *   - <math.h> (fabs/fmax/fmin)
      11              :  *   - "cfd/core/grid.h", "cfd/core/indexing.h" (grid, IDX_2D)
      12              :  *   - "cfd/solvers/navier_stokes_solver.h" (ns_solver_params_t)
      13              :  *   - "../../energy/energy_solver_internal.h" (compute_source_terms,
      14              :  *     energy_compute_buoyancy)
      15              :  *
      16              :  * This header is #include-only and is never compiled as a standalone TU (see the
      17              :  * SIMD template pattern in lib/src/solvers/linear/simd_template/).
      18              :  */
      19              : #ifndef CFD_NS_MOMENTUM_RHS_SCALAR_H
      20              : #define CFD_NS_MOMENTUM_RHS_SCALAR_H
      21              : 
      22              : #include "../ns_convection_internal.h"
      23              : 
      24              : /* Physical stability limits (shared by the RK2/RK4 scalar RHS kernel) */
      25              : #ifndef MAX_DERIVATIVE_LIMIT
      26              : #define MAX_DERIVATIVE_LIMIT        100.0
      27              : #endif
      28              : #ifndef MAX_SECOND_DERIVATIVE_LIMIT
      29              : #define MAX_SECOND_DERIVATIVE_LIMIT 1000.0
      30              : #endif
      31              : #ifndef MAX_DIVERGENCE_LIMIT
      32              : #define MAX_DIVERGENCE_LIMIT        10.0
      33              : #endif
      34              : #ifndef PRESSURE_UPDATE_FACTOR
      35              : #define PRESSURE_UPDATE_FACTOR      0.1
      36              : #endif
      37              : 
      38              : /**
      39              :  * Compute the right-hand side of the semi-discrete Navier-Stokes equations.
      40              :  *
      41              :  * For each interior point, computes:
      42              :  *   du/dt = -u·∇u - (1/ρ)∂p/∂x + ν∇²u + source_u
      43              :  *   dv/dt = -u·∇v - (1/ρ)∂p/∂y + ν∇²v + source_v
      44              :  *   dw/dt = -u·∇w - (1/ρ)∂p/∂z + ν∇²w + source_w
      45              :  *   dp/dt = -0.1 * ρ * (∂u/∂x + ∂v/∂y + ∂w/∂z)
      46              :  *
      47              :  * Uses periodic stencil indices to avoid relying on ghost cells, which is
      48              :  * critical for preserving RK temporal order (ghost cell values may be stale
      49              :  * during intermediate RK stages).
      50              :  */
      51        11786 : static void compute_rhs(const double* u, const double* v, const double* w,
      52              :                          const double* p, const double* rho, const double* T,
      53              :                          const double* nu_t,
      54              :                          double* rhs_u, double* rhs_v, double* rhs_w, double* rhs_p,
      55              :                          const grid* grid, const ns_solver_params_t* params,
      56              :                          size_t nx, size_t ny, size_t nz,
      57              :                          size_t stride_z, size_t k_start, size_t k_end,
      58              :                          double inv_2dz, double inv_dz2,
      59              :                          int iter, double dt) {
      60              :     /* nu_t is frozen across RK stages (updated once per full step) */
      61        11786 :     const int turb_on = (params->turb_model != TURB_MODEL_NONE) && (nu_t != NULL);
      62        11786 :     const int upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
      63        11786 :     const double inv_dz = 2.0 * inv_2dz;
      64              : 
      65        24142 :     for (size_t k = k_start; k < k_end; k++) {
      66       841334 :         for (size_t j = 1; j < ny - 1; j++) {
      67     88789316 :             for (size_t i = 1; i < nx - 1; i++) {
      68     87960338 :                 size_t idx = k * stride_z + IDX_2D(i, j, nx);
      69              : 
      70              :                 /* Safety checks */
      71     87960338 :                 if (rho[idx] <= 1e-10) {
      72            0 :                     rhs_u[idx] = 0.0;
      73            0 :                     rhs_v[idx] = 0.0;
      74            0 :                     rhs_w[idx] = 0.0;
      75            0 :                     rhs_p[idx] = 0.0;
      76            0 :                     continue;
      77              :                 }
      78     87960338 :                 if (fabs(grid->dx[i]) < 1e-10 || fabs(grid->dy[j]) < 1e-10) {
      79            0 :                     rhs_u[idx] = 0.0;
      80            0 :                     rhs_v[idx] = 0.0;
      81            0 :                     rhs_w[idx] = 0.0;
      82            0 :                     rhs_p[idx] = 0.0;
      83            0 :                     continue;
      84              :                 }
      85              : 
      86              :                 /* Periodic stencil indices in x and y — avoids relying on ghost cells,
      87              :                  * which is critical for preserving RK temporal order. */
      88     87960338 :                 size_t il = (i > 1)      ? idx - 1  : k * stride_z + IDX_2D(nx - 2, j, nx);
      89     87960338 :                 size_t ir = (i < nx - 2) ? idx + 1  : k * stride_z + IDX_2D(1, j, nx);
      90     87960338 :                 size_t jd = (j > 1)      ? idx - nx : k * stride_z + IDX_2D(i, ny - 2, nx);
      91     87960338 :                 size_t ju = (j < ny - 2) ? idx + nx : k * stride_z + IDX_2D(i, 1, nx);
      92              : 
      93              :                 /* Periodic stencil indices in z.
      94              :                  * When nz==1: k=0, stride_z=0, so kd=ku=idx → z-terms vanish. */
      95    175920676 :                 size_t kd = (k > 1)      ? idx - stride_z
      96     87960338 :                                          : (nz - 2) * stride_z + IDX_2D(i, j, nx);
      97    175920676 :                 size_t ku = (k < nz - 2) ? idx + stride_z
      98     87960338 :                                          : 1 * stride_z + IDX_2D(i, j, nx);
      99              : 
     100              :                 /* First derivatives (central differences) */
     101     87960338 :                 double du_dx = (u[ir] - u[il]) / (2.0 * grid->dx[i]);
     102     87960338 :                 double du_dy = (u[ju] - u[jd]) / (2.0 * grid->dy[j]);
     103     87960338 :                 double du_dz = (u[ku] - u[kd]) * inv_2dz;
     104              : 
     105     87960338 :                 double dv_dx = (v[ir] - v[il]) / (2.0 * grid->dx[i]);
     106     87960338 :                 double dv_dy = (v[ju] - v[jd]) / (2.0 * grid->dy[j]);
     107     87960338 :                 double dv_dz = (v[ku] - v[kd]) * inv_2dz;
     108              : 
     109     87960338 :                 double dw_dx = (w[ir] - w[il]) / (2.0 * grid->dx[i]);
     110     87960338 :                 double dw_dy = (w[ju] - w[jd]) / (2.0 * grid->dy[j]);
     111     87960338 :                 double dw_dz = (w[ku] - w[kd]) * inv_2dz;
     112              : 
     113              :                 /* Pressure gradients */
     114     87960338 :                 double dp_dx = (p[ir] - p[il]) / (2.0 * grid->dx[i]);
     115     87960338 :                 double dp_dy = (p[ju] - p[jd]) / (2.0 * grid->dy[j]);
     116     87960338 :                 double dp_dz = (p[ku] - p[kd]) * inv_2dz;
     117              : 
     118              :                 /* Second derivatives (viscous terms) */
     119     87960338 :                 double d2u_dx2 = (u[ir] - 2.0 * u[idx] + u[il]) / (grid->dx[i] * grid->dx[i]);
     120     87960338 :                 double d2u_dy2 = (u[ju] - 2.0 * u[idx] + u[jd]) / (grid->dy[j] * grid->dy[j]);
     121     87960338 :                 double d2u_dz2 = (u[ku] - 2.0 * u[idx] + u[kd]) * inv_dz2;
     122              : 
     123     87960338 :                 double d2v_dx2 = (v[ir] - 2.0 * v[idx] + v[il]) / (grid->dx[i] * grid->dx[i]);
     124     87960338 :                 double d2v_dy2 = (v[ju] - 2.0 * v[idx] + v[jd]) / (grid->dy[j] * grid->dy[j]);
     125     87960338 :                 double d2v_dz2 = (v[ku] - 2.0 * v[idx] + v[kd]) * inv_dz2;
     126              : 
     127     87960338 :                 double d2w_dx2 = (w[ir] - 2.0 * w[idx] + w[il]) / (grid->dx[i] * grid->dx[i]);
     128     87960338 :                 double d2w_dy2 = (w[ju] - 2.0 * w[idx] + w[jd]) / (grid->dy[j] * grid->dy[j]);
     129     87960338 :                 double d2w_dz2 = (w[ku] - 2.0 * w[idx] + w[kd]) * inv_dz2;
     130              : 
     131              :                 /* Kinematic viscosity */
     132     87960338 :                 double nu = params->mu / fmax(rho[idx], 1e-10);
     133     87960338 :                 nu = fmin(nu, 1.0);
     134              : 
     135              :                 /* Clamp first derivatives */
     136     87960338 :                 du_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, du_dx));
     137     87960338 :                 du_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, du_dy));
     138     87960338 :                 du_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, du_dz));
     139     87960338 :                 dv_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dv_dx));
     140     87960338 :                 dv_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dv_dy));
     141     87960338 :                 dv_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dv_dz));
     142     87960338 :                 dw_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dw_dx));
     143     87960338 :                 dw_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dw_dy));
     144     87960338 :                 dw_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dw_dz));
     145     87960338 :                 dp_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dp_dx));
     146     87960338 :                 dp_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dp_dy));
     147     87960338 :                 dp_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dp_dz));
     148              : 
     149              :                 /* Clamp second derivatives */
     150     87960338 :                 d2u_dx2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2u_dx2));
     151     87960338 :                 d2u_dy2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2u_dy2));
     152     87960338 :                 d2u_dz2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2u_dz2));
     153     87960338 :                 d2v_dx2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2v_dx2));
     154     87960338 :                 d2v_dy2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2v_dy2));
     155     87960338 :                 d2v_dz2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2v_dz2));
     156     87960338 :                 d2w_dx2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2w_dx2));
     157     87960338 :                 d2w_dy2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2w_dy2));
     158     87960338 :                 d2w_dz2 = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, d2w_dz2));
     159              : 
     160              :                 /* Convective derivatives: the clamped central ones, or first-order
     161              :                  * upwind. The divergence below stays central. */
     162     87960338 :                 ns_conv_derivs_t cd = {du_dx, du_dy, du_dz, dv_dx, dv_dy, dv_dz,
     163              :                                        dw_dx, dw_dy, dw_dz};
     164     87960338 :                 if (upwind) {
     165        80936 :                     ns_upwind_conv_derivs(u, v, w, idx, il, ir, jd, ju, kd, ku,
     166              :                                           grid->dx[i], grid->dy[j], inv_dz, &cd);
     167        80936 :                     ns_clamp_conv_derivs(&cd, MAX_DERIVATIVE_LIMIT);
     168              :                 }
     169              : 
     170              :                 /* Source terms */
     171     87960338 :                 double source_u = 0.0, source_v = 0.0, source_w = 0.0;
     172     87960338 :                 double z_coord = (nz > 1 && grid->z) ? grid->z[k] : 0.0;
     173     87960338 :                 compute_source_terms(grid->x[i], grid->y[j], z_coord, iter, dt,
     174              :                                      params, &source_u, &source_v, &source_w);
     175              : 
     176              :                 /* Boussinesq buoyancy source */
     177     87960338 :                 if (T) {
     178     87960338 :                     energy_compute_buoyancy(T[idx], params,
     179              :                                             &source_u, &source_v, &source_w);
     180              :                 }
     181              : 
     182              :                 /* Viscous terms: laminar constant-nu Laplacian, or conservative
     183              :                  * face-averaged effective viscosity div((nu + nu_t) grad u) when
     184              :                  * a turbulence model is active. The z-term keeps the laminar nu
     185              :                  * (turbulence is 2D-only; it vanishes when nz == 1). */
     186     87960338 :                 double visc_u, visc_v, visc_w;
     187     87960338 :                 if (!turb_on) {
     188     87944560 :                     visc_u = nu * (d2u_dx2 + d2u_dy2 + d2u_dz2);
     189     87944560 :                     visc_v = nu * (d2v_dx2 + d2v_dy2 + d2v_dz2);
     190     87944560 :                     visc_w = nu * (d2w_dx2 + d2w_dy2 + d2w_dz2);
     191              :                 } else {
     192              :                     /* Face-averaged nu_eff = nu + nu_t (nu_t already bounded by
     193              :                      * the realizability clamp; the flux clamp below caps it) */
     194        15778 :                     double nu_xp = nu + 0.5 * (nu_t[idx] + nu_t[ir]);
     195        15778 :                     double nu_xm = nu + 0.5 * (nu_t[idx] + nu_t[il]);
     196        15778 :                     double nu_yp = nu + 0.5 * (nu_t[idx] + nu_t[ju]);
     197        15778 :                     double nu_ym = nu + 0.5 * (nu_t[idx] + nu_t[jd]);
     198        15778 :                     double inv_dxi2 = 1.0 / (grid->dx[i] * grid->dx[i]);
     199        15778 :                     double inv_dyj2 = 1.0 / (grid->dy[j] * grid->dy[j]);
     200              : 
     201        15778 :                     double t_u_x = (nu_xp * (u[ir] - u[idx]) - nu_xm * (u[idx] - u[il])) * inv_dxi2;
     202        15778 :                     double t_u_y = (nu_yp * (u[ju] - u[idx]) - nu_ym * (u[idx] - u[jd])) * inv_dyj2;
     203        15778 :                     double t_v_x = (nu_xp * (v[ir] - v[idx]) - nu_xm * (v[idx] - v[il])) * inv_dxi2;
     204        15778 :                     double t_v_y = (nu_yp * (v[ju] - v[idx]) - nu_ym * (v[idx] - v[jd])) * inv_dyj2;
     205        15778 :                     double t_w_x = (nu_xp * (w[ir] - w[idx]) - nu_xm * (w[idx] - w[il])) * inv_dxi2;
     206        15778 :                     double t_w_y = (nu_yp * (w[ju] - w[idx]) - nu_ym * (w[idx] - w[jd])) * inv_dyj2;
     207              : 
     208              :                     /* Same safety clamp as the laminar second derivatives */
     209        15778 :                     t_u_x = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, t_u_x));
     210        15778 :                     t_u_y = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, t_u_y));
     211        15778 :                     t_v_x = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, t_v_x));
     212        15778 :                     t_v_y = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, t_v_y));
     213        15778 :                     t_w_x = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, t_w_x));
     214        15778 :                     t_w_y = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, t_w_y));
     215              : 
     216        15778 :                     visc_u = t_u_x + t_u_y + nu * d2u_dz2;
     217        15778 :                     visc_v = t_v_x + t_v_y + nu * d2v_dz2;
     218        15778 :                     visc_w = t_w_x + t_w_y + nu * d2w_dz2;
     219              :                 }
     220              : 
     221              :                 /* RHS for u-momentum */
     222     87960338 :                 rhs_u[idx] = -u[idx] * cd.du_dx - v[idx] * cd.du_dy - w[idx] * cd.du_dz
     223     87960338 :                              - dp_dx / rho[idx]
     224     87960338 :                              + visc_u
     225     87960338 :                              + source_u;
     226              : 
     227              :                 /* RHS for v-momentum */
     228     87960338 :                 rhs_v[idx] = -u[idx] * cd.dv_dx - v[idx] * cd.dv_dy - w[idx] * cd.dv_dz
     229     87960338 :                              - dp_dy / rho[idx]
     230     87960338 :                              + visc_v
     231     87960338 :                              + source_v;
     232              : 
     233              :                 /* RHS for w-momentum */
     234     87960338 :                 rhs_w[idx] = -u[idx] * cd.dw_dx - v[idx] * cd.dw_dy - w[idx] * cd.dw_dz
     235     87960338 :                              - dp_dz / rho[idx]
     236     87960338 :                              + visc_w
     237     87960338 :                              + source_w;
     238              : 
     239              :                 /* Simplified pressure RHS (divergence-based) */
     240     87960338 :                 double divergence = du_dx + dv_dy + dw_dz;
     241     87960338 :                 divergence = fmax(-MAX_DIVERGENCE_LIMIT,
     242              :                                   fmin(MAX_DIVERGENCE_LIMIT, divergence));
     243     87960338 :                 rhs_p[idx] = -PRESSURE_UPDATE_FACTOR * rho[idx] * divergence;
     244              :             }
     245              :         }
     246              :     }
     247        11786 : }
     248              : 
     249              : #endif /* CFD_NS_MOMENTUM_RHS_SCALAR_H */
        

Generated by: LCOV version 2.0-1