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