LCOV - code coverage report
Current view: top level - solvers/navier_stokes/cpu - solver_rk2.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 89.3 % 103 92
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 1 1

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

Generated by: LCOV version 2.0-1