LCOV - code coverage report
Current view: top level - solvers/navier_stokes/cpu - solver_rk4.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 89.6 % 134 120
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 2 2

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

Generated by: LCOV version 2.0-1