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 */
|