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

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

Generated by: LCOV version 2.0-1