LCOV - code coverage report
Current view: top level - solvers/navier_stokes/omp - solver_rk2_omp.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 88.2 % 93 82
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 1 1

            Line data    Source code
       1              : /**
       2              :  * @file solver_rk2_omp.c
       3              :  * @brief RK2 (Heun's method) time integration - OpenMP parallelized
       4              :  *
       5              :  * Same algorithm as scalar RK2 but with OpenMP-parallelized loops.
       6              :  * Achieves O(dt^2) temporal accuracy with multi-threaded execution.
       7              :  *
       8              :  * Branch-free 3D: when nz==1, stride_z=0 and inv_2dz/inv_dz2=0.0 cause all
       9              :  * z-terms to vanish, producing bit-identical results to the 2D code path.
      10              :  */
      11              : 
      12              : #include "cfd/core/cfd_status.h"
      13              : #include "cfd/core/grid.h"
      14              : #include "cfd/core/indexing.h"
      15              : #include "cfd/core/memory.h"
      16              : #include "cfd/solvers/energy_solver.h"
      17              : #include "cfd/solvers/navier_stokes_solver.h"
      18              : #include "cfd/solvers/turbulence_solver.h"
      19              : #include "../../energy/energy_solver_internal.h"
      20              : #include "../../turbulence/turbulence_solver_internal.h"
      21              : 
      22              : #include <math.h>
      23              : #include <stddef.h>
      24              : #include <string.h>
      25              : 
      26              : #ifdef CFD_ENABLE_OPENMP
      27              : 
      28              : #include <omp.h>
      29              : 
      30              : /* OpenMP version-gated pragmas */
      31              : #if _OPENMP >= 201307  /* OMP 4.0 */
      32              : #  define OMP_FOR_SIMD _Pragma("omp parallel for simd schedule(static)")
      33              : #else
      34              : #  define OMP_FOR_SIMD _Pragma("omp parallel for schedule(static)")
      35              : #endif
      36              : 
      37              : #ifndef M_PI
      38              : #define M_PI 3.14159265358979323846
      39              : #endif
      40              : 
      41              : /* Velocity clamp used by the time-step update (not the RHS kernel) */
      42              : #define MAX_VELOCITY_LIMIT          100.0
      43              : 
      44              : /* Shared OpenMP momentum RHS kernel (also #include-d by solver_rk4_omp.c).
      45              :  * Included inside the CFD_ENABLE_OPENMP block, after <omp.h>/<math.h>/grid/
      46              :  * energy. Defines the shared clamp constants MAX_DERIVATIVE_LIMIT /
      47              :  * MAX_SECOND_DERIVATIVE_LIMIT / MAX_DIVERGENCE_LIMIT / PRESSURE_UPDATE_FACTOR. */
      48              : #include "../momentum_rhs/ns_momentum_rhs_omp.h"
      49              : 
      50              : 
      51              : /* ============================================================================
      52              :  * RK2 OMP SOLVER
      53              :  * ============================================================================ */
      54              : 
      55          259 : cfd_status_t rk2_omp_impl(flow_field* field, const grid* grid,
      56              :                             const ns_solver_params_t* params) {
      57          259 :     if (field->nx < 3 || field->ny < 3 || (field->nz > 1 && field->nz < 3)) {
      58              :         return CFD_ERROR_INVALID;
      59              :     }
      60              : 
      61          259 :     size_t nx = field->nx;
      62          259 :     size_t ny = field->ny;
      63          259 :     size_t nz = field->nz;
      64              : 
      65              :     /* Reject non-uniform z-spacing (solver uses constant inv_2dz/inv_dz2) */
      66          259 :     if (nz > 1 && grid->dz) {
      67           44 :         for (size_t k = 1; k < nz - 1; k++) {
      68           37 :             if (fabs(grid->dz[k] - grid->dz[0]) > 1e-14) {
      69              :                 return CFD_ERROR_INVALID;
      70              :             }
      71              :         }
      72              :     }
      73              : 
      74          259 :     size_t plane = nx * ny;
      75          259 :     size_t total = plane * nz;
      76          259 :     size_t bytes = total * sizeof(double);
      77              : 
      78              :     /* Branch-free 3D constants */
      79          259 :     size_t stride_z = (nz > 1) ? plane : 0;
      80          259 :     size_t k_start  = (nz > 1) ? 1 : 0;
      81          259 :     size_t k_end    = (nz > 1) ? (nz - 1) : 1;
      82          259 :     double inv_2dz  = (nz > 1 && grid->dz) ? 1.0 / (2.0 * grid->dz[0]) : 0.0;
      83            7 :     double inv_dz2  = (nz > 1 && grid->dz) ? 1.0 / (grid->dz[0] * grid->dz[0]) : 0.0;
      84              : 
      85              :     /* Allocate working arrays:
      86              :      *   k1_u/v/w/p : Stage 1 derivatives
      87              :      *   k2_u/v/w/p : Stage 2 derivatives
      88              :      *   u0/v0/w0/p0 : Saved state Q^n
      89              :      */
      90          259 :     double* k1_u = (double*)cfd_calloc(total, sizeof(double));
      91          259 :     double* k1_v = (double*)cfd_calloc(total, sizeof(double));
      92          259 :     double* k1_w = (double*)cfd_calloc(total, sizeof(double));
      93          259 :     double* k1_p = (double*)cfd_calloc(total, sizeof(double));
      94          259 :     double* k2_u = (double*)cfd_calloc(total, sizeof(double));
      95          259 :     double* k2_v = (double*)cfd_calloc(total, sizeof(double));
      96          259 :     double* k2_w = (double*)cfd_calloc(total, sizeof(double));
      97          259 :     double* k2_p = (double*)cfd_calloc(total, sizeof(double));
      98          259 :     double* u0 = (double*)cfd_calloc(total, sizeof(double));
      99          259 :     double* v0 = (double*)cfd_calloc(total, sizeof(double));
     100          259 :     double* w0 = (double*)cfd_calloc(total, sizeof(double));
     101          259 :     double* p0 = (double*)cfd_calloc(total, sizeof(double));
     102          259 :     int needs_T_ws = (params->alpha > 0.0 || params->beta != 0.0);
     103          259 :     double* T_energy_ws = needs_T_ws
     104            2 :         ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
     105          259 :     const int turb_on = (params->turb_model != TURB_MODEL_NONE);
     106          518 :     double* turb_ws = turb_on
     107          259 :         ? (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double)) : NULL;
     108              : 
     109          259 :     if (!k1_u || !k1_v || !k1_w || !k1_p ||
     110          259 :         !k2_u || !k2_v || !k2_w || !k2_p ||
     111          259 :         !u0 || !v0 || !w0 || !p0 ||
     112          259 :         (needs_T_ws && !T_energy_ws) || (turb_on && !turb_ws)) {
     113            0 :         cfd_free(k1_u); cfd_free(k1_v); cfd_free(k1_w); cfd_free(k1_p);
     114            0 :         cfd_free(k2_u); cfd_free(k2_v); cfd_free(k2_w); cfd_free(k2_p);
     115            0 :         cfd_free(u0); cfd_free(v0); cfd_free(w0); cfd_free(p0);
     116            0 :         cfd_free(T_energy_ws); cfd_free(turb_ws);
     117            0 :         return CFD_ERROR_NOMEM;
     118              :     }
     119              : 
     120          259 :     double dt = params->dt;
     121          259 :     ptrdiff_t total_int = (ptrdiff_t)total;
     122          259 :     cfd_status_t status = CFD_SUCCESS;
     123              : 
     124          556 :     for (int iter = 0; iter < params->max_iter; iter++) {
     125              :         /* Save Q^n */
     126          297 :         memcpy(u0, field->u, bytes);
     127          297 :         memcpy(v0, field->v, bytes);
     128          297 :         memcpy(w0, field->w, bytes);
     129          297 :         memcpy(p0, field->p, bytes);
     130              : 
     131              :         /* ---- Stage 1: k1 = RHS(Q^n) ---- */
     132          297 :         memset(k1_u, 0, bytes);
     133          297 :         memset(k1_v, 0, bytes);
     134          297 :         memset(k1_w, 0, bytes);
     135          297 :         memset(k1_p, 0, bytes);
     136              : 
     137          297 :         compute_rhs_omp(field->u, field->v, field->w, field->p, field->rho, field->T,
     138          297 :                          field->nu_t,
     139              :                          k1_u, k1_v, k1_w, k1_p,
     140              :                          grid, params, nx, ny, nz,
     141              :                          stride_z, k_start, k_end, inv_2dz, inv_dz2,
     142              :                          iter, dt);
     143              : 
     144              :         /* ---- Intermediate: field = Q^n + dt * k1 ---- */
     145              :         {
     146          297 :             ptrdiff_t kk;
     147          297 :             OMP_FOR_SIMD
     148              :             for (kk = 0; kk < total_int; kk++) {
     149              :                 field->u[kk] = u0[kk] + dt * k1_u[kk];
     150              :                 field->v[kk] = v0[kk] + dt * k1_v[kk];
     151              :                 field->w[kk] = w0[kk] + dt * k1_w[kk];
     152              :                 field->p[kk] = p0[kk] + dt * k1_p[kk];
     153              : 
     154              :                 field->u[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->u[kk]));
     155              :                 field->v[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->v[kk]));
     156              :                 field->w[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->w[kk]));
     157              :             }
     158              :         }
     159              : 
     160              :         /* NOTE: Do NOT apply BCs between RK stages. The ghost cells carry
     161              :          * zero-derivative evolution (k1[ghost]=0), which is consistent with
     162              :          * the semi-discrete ODE system. Applying BCs here would reduce RK2
     163              :          * to first-order temporal accuracy. */
     164              : 
     165              :         /* ---- Stage 2: k2 = RHS(Q_pred) ---- */
     166          297 :         memset(k2_u, 0, bytes);
     167          297 :         memset(k2_v, 0, bytes);
     168          297 :         memset(k2_w, 0, bytes);
     169          297 :         memset(k2_p, 0, bytes);
     170              : 
     171          297 :         compute_rhs_omp(field->u, field->v, field->w, field->p, field->rho, field->T,
     172          297 :                          field->nu_t,
     173              :                          k2_u, k2_v, k2_w, k2_p,
     174              :                          grid, params, nx, ny, nz,
     175              :                          stride_z, k_start, k_end, inv_2dz, inv_dz2,
     176              :                          iter, dt);
     177              : 
     178              :         /* ---- Final update: Q^{n+1} = Q^n + (dt/2)*(k1 + k2) ---- */
     179              :         {
     180          297 :             double half_dt = 0.5 * dt;
     181          297 :             ptrdiff_t kk;
     182          297 :             OMP_FOR_SIMD
     183              :             for (kk = 0; kk < total_int; kk++) {
     184              :                 field->u[kk] = u0[kk] + half_dt * (k1_u[kk] + k2_u[kk]);
     185              :                 field->v[kk] = v0[kk] + half_dt * (k1_v[kk] + k2_v[kk]);
     186              :                 field->w[kk] = w0[kk] + half_dt * (k1_w[kk] + k2_w[kk]);
     187              :                 field->p[kk] = p0[kk] + half_dt * (k1_p[kk] + k2_p[kk]);
     188              : 
     189              :                 field->u[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->u[kk]));
     190              :                 field->v[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->v[kk]));
     191              :                 field->w[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->w[kk]));
     192              :             }
     193              :         }
     194              : 
     195              :         /* Energy equation: advance temperature after RK2 velocity update */
     196              :         {
     197          297 :             cfd_status_t energy_status = energy_step_explicit_omp_with_workspace(
     198              :                 field, grid, params, dt, iter * dt, T_energy_ws, total);
     199          297 :             if (energy_status != CFD_SUCCESS) {
     200            0 :                 status = energy_status;
     201            0 :                 goto cleanup;
     202              :             }
     203              :         }
     204              : 
     205              :         /* Apply BCs to final state only (after the full RK2 step).
     206              :          * Then apply configured thermal BCs (overwrites periodic T values). */
     207          297 :         apply_boundary_conditions(field, grid);
     208          297 :         status = energy_apply_thermal_bcs(field, params);
     209          297 :         if (status != CFD_SUCCESS) {
     210            0 :             goto cleanup;
     211              :         }
     212              : 
     213              :         /* Turbulence transport: advance k-eps/SA with the updated velocity,
     214              :          * then apply turbulence BCs (including wall functions). nu_t is
     215              :          * frozen across RK stages and updated once per full step. */
     216          297 :         status = turbulence_step_explicit_omp_with_workspace(
     217              :             field, grid, params, dt, iter * dt, turb_ws,
     218              :             turb_on ? TURB_WORKSPACE_SIZE(total) : 0);
     219          297 :         if (status == CFD_SUCCESS) {
     220          297 :             status = turbulence_apply_bcs(field, grid, params);
     221              :         }
     222          297 :         if (status != CFD_SUCCESS) {
     223            0 :             goto cleanup;
     224              :         }
     225              : 
     226              :         /* NaN / Inf check (parallelized) */
     227              :         {
     228          297 :             int has_nan = 0;
     229          297 :             ptrdiff_t kk;
     230          297 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
     231              :             for (kk = 0; kk < total_int; kk++) {
     232              :                 if (!isfinite(field->u[kk]) || !isfinite(field->v[kk]) ||
     233              :                     !isfinite(field->w[kk]) || !isfinite(field->p[kk])) {
     234              :                     has_nan = 1;
     235              :                 }
     236              :             }
     237          297 :             if (has_nan) {
     238            0 :                 status = CFD_ERROR_DIVERGED;
     239            0 :                 goto cleanup;
     240              :             }
     241              :         }
     242              :     }
     243              : 
     244          259 : cleanup:
     245          259 :     cfd_free(k1_u); cfd_free(k1_v); cfd_free(k1_w); cfd_free(k1_p);
     246          259 :     cfd_free(k2_u); cfd_free(k2_v); cfd_free(k2_w); cfd_free(k2_p);
     247          259 :     cfd_free(u0); cfd_free(v0); cfd_free(w0); cfd_free(p0);
     248          259 :     cfd_free(T_energy_ws); cfd_free(turb_ws);
     249              : 
     250          259 :     return status;
     251              : }
     252              : 
     253              : #endif /* CFD_ENABLE_OPENMP */
        

Generated by: LCOV version 2.0-1