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

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

Generated by: LCOV version 2.0-1