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 : }
|