Line data Source code
1 : /**
2 : * Optimized Explicit Euler NSSolver with SIMD + OpenMP
3 : *
4 : * This implementation combines SIMD vectorization (AVX2) with OpenMP
5 : * parallelization for maximum performance on multi-core CPUs.
6 : *
7 : * - Outer loops are parallelized with OpenMP
8 : * - Inner loops use AVX2 SIMD intrinsics for vectorization
9 : *
10 : * Note: When AVX2 is not enabled at compile time (CFD_ENABLE_AVX2=OFF),
11 : * this solver uses scalar code paths. Use the base explicit_euler solver
12 : * for guaranteed scalar-only execution.
13 : */
14 :
15 : // Enable C11 features for aligned_alloc
16 : #define _POSIX_C_SOURCE 200809L
17 : #define _ISOC11_SOURCE
18 :
19 : #include "cfd/core/cfd_status.h"
20 : #include "cfd/core/grid.h"
21 : #include "cfd/core/indexing.h"
22 : #include "cfd/core/logging.h"
23 : #include "cfd/core/memory.h"
24 : #include "cfd/solvers/navier_stokes_solver.h"
25 : #include "cfd/solvers/energy_solver.h"
26 : #include "cfd/solvers/turbulence_solver.h"
27 : #include "../../energy/energy_solver_internal.h"
28 : #include "../../turbulence/turbulence_solver_internal.h"
29 :
30 : #include "../boundary_copy_utils.h"
31 : #include "../ns_convection_internal.h"
32 : #include "../ns_simd_backend_internal.h"
33 : #include "upwind_avx2.h"
34 :
35 : #include <math.h>
36 : #include <stdio.h>
37 : #include <stdlib.h>
38 : #include <string.h>
39 :
40 : #ifdef _OPENMP
41 : #include <omp.h>
42 : #endif
43 :
44 : /* AVX2 detection
45 : * CFD_HAS_AVX2 is set by CMake when -DCFD_ENABLE_AVX2=ON.
46 : * This works consistently across all compilers (GCC, Clang, MSVC).
47 : */
48 : #if defined(CFD_HAS_AVX2)
49 : #include <immintrin.h>
50 : #define USE_AVX 1
51 : #else
52 : #define USE_AVX 0
53 : #endif
54 :
55 : // Physical stability limits
56 : #define MAX_DERIVATIVE_LIMIT 100.0
57 : #define MAX_SECOND_DERIVATIVE_LIMIT 1000.0
58 : #define MAX_VELOCITY_LIMIT 100.0
59 : #define MAX_DIVERGENCE_LIMIT 10.0
60 : /* One definition lives in navier_stokes_solver.h (NS_EULER_DT_LIMIT). */
61 : #define DT_CONSERVATIVE_LIMIT NS_EULER_DT_LIMIT
62 : #define UPDATE_LIMIT 1.0
63 : #define PRESSURE_UPDATE_FACTOR 0.1
64 :
65 : typedef struct {
66 : double* u_new;
67 : double* v_new;
68 : double* w_new;
69 : double* p_new;
70 : double* T_ws; /* Reusable scratch for the energy step (avoids per-step alloc) */
71 : double* turb_ws; /* Reusable scratch for the turbulence step; always allocated */
72 : double* dx_inv;
73 : double* dy_inv;
74 : size_t nx;
75 : size_t ny;
76 : size_t nz;
77 : size_t stride_z;
78 : size_t k_start;
79 : size_t k_end;
80 : double inv_2dz;
81 : double inv_dz2;
82 : int initialized;
83 : int iter_count; /* Step counter for advancing time-dependent thermal terms */
84 : } explicit_euler_simd_context;
85 :
86 : // Public API functions
87 : cfd_status_t explicit_euler_simd_init(struct NSSolver* solver, const grid* grid,
88 : const ns_solver_params_t* params);
89 : void explicit_euler_simd_destroy(struct NSSolver* solver);
90 : cfd_status_t explicit_euler_simd_step(struct NSSolver* solver, flow_field* field, const grid* grid,
91 : const ns_solver_params_t* params, ns_solver_stats_t* stats);
92 :
93 23 : cfd_status_t explicit_euler_simd_init(struct NSSolver* solver, const grid* grid,
94 : const ns_solver_params_t* params) {
95 23 : if (!solver || !grid) {
96 : return CFD_ERROR_INVALID;
97 : }
98 23 : cfd_status_t scheme_status = ns_check_convection_scheme(params, 1);
99 23 : if (scheme_status != CFD_SUCCESS) {
100 : return scheme_status;
101 : }
102 :
103 : /* No scalar fallback: a SIMD solver that quietly runs scalar kernels turns a
104 : * configuration error into a performance mystery. Fail so the caller can pick
105 : * the scalar "explicit_euler" deliberately. */
106 22 : cfd_status_t simd_status = ns_check_simd_backend();
107 22 : if (simd_status != CFD_SUCCESS) {
108 : return simd_status;
109 : }
110 :
111 0 : cfd_status_t turb_status = ns_check_turbulence_model(params, 1);
112 0 : if (turb_status != CFD_SUCCESS) {
113 : return turb_status;
114 : }
115 :
116 0 : cfd_status_t pressure_bc_status = ns_check_pressure_bc(params, 0);
117 0 : if (pressure_bc_status != CFD_SUCCESS) {
118 : return pressure_bc_status;
119 : }
120 :
121 0 : cfd_status_t pressure_solver_status = ns_check_pressure_solver(params, 0);
122 0 : if (pressure_solver_status != CFD_SUCCESS) {
123 : return pressure_solver_status;
124 : }
125 0 : if (grid->nx < 3 || grid->ny < 3 || (grid->nz > 1 && grid->nz < 3)) {
126 : return CFD_ERROR_INVALID;
127 : }
128 :
129 0 : explicit_euler_simd_context* ctx =
130 0 : (explicit_euler_simd_context*)cfd_calloc(1, sizeof(explicit_euler_simd_context));
131 0 : if (!ctx) {
132 : return CFD_ERROR_NOMEM;
133 : }
134 :
135 0 : ctx->nx = grid->nx;
136 0 : ctx->ny = grid->ny;
137 0 : ctx->nz = grid->nz;
138 0 : size_t field_size = ctx->nx * ctx->ny * ctx->nz * sizeof(double);
139 :
140 : /* Reject non-uniform z-spacing (solver uses constant inv_2dz/inv_dz2) */
141 0 : if (grid->nz > 1 && grid->dz) {
142 0 : for (size_t kk = 1; kk < grid->nz - 1; kk++) {
143 0 : if (fabs(grid->dz[kk] - grid->dz[0]) > 1e-14) {
144 0 : cfd_free(ctx);
145 0 : return CFD_ERROR_INVALID;
146 : }
147 : }
148 : }
149 :
150 0 : size_t plane = ctx->nx * ctx->ny;
151 0 : ctx->stride_z = (grid->nz > 1) ? plane : 0;
152 0 : ctx->k_start = (grid->nz > 1) ? 1 : 0;
153 0 : ctx->k_end = (grid->nz > 1) ? (grid->nz - 1) : 1;
154 0 : ctx->inv_2dz = (grid->nz > 1 && grid->dz) ? 1.0 / (2.0 * grid->dz[0]) : 0.0;
155 0 : ctx->inv_dz2 = (grid->nz > 1 && grid->dz) ? 1.0 / (grid->dz[0] * grid->dz[0]) : 0.0;
156 :
157 0 : size_t n_total = ctx->nx * ctx->ny * ctx->nz;
158 0 : ctx->u_new = (double*)cfd_aligned_malloc(field_size);
159 0 : ctx->v_new = (double*)cfd_aligned_malloc(field_size);
160 0 : ctx->w_new = (double*)cfd_aligned_malloc(field_size);
161 0 : ctx->p_new = (double*)cfd_aligned_malloc(field_size);
162 0 : ctx->T_ws = (double*)cfd_aligned_malloc(field_size);
163 0 : ctx->turb_ws = (double*)cfd_calloc(TURB_WORKSPACE_SIZE(n_total), sizeof(double));
164 0 : ctx->dx_inv = (double*)cfd_aligned_malloc(ctx->nx * sizeof(double));
165 0 : ctx->dy_inv = (double*)cfd_aligned_malloc(ctx->ny * sizeof(double));
166 :
167 0 : if (!ctx->u_new || !ctx->v_new || !ctx->w_new || !ctx->p_new || !ctx->T_ws ||
168 0 : !ctx->turb_ws || !ctx->dx_inv || !ctx->dy_inv) {
169 0 : if (ctx->u_new) { cfd_aligned_free(ctx->u_new); }
170 0 : if (ctx->v_new) { cfd_aligned_free(ctx->v_new); }
171 0 : if (ctx->w_new) { cfd_aligned_free(ctx->w_new); }
172 0 : if (ctx->p_new) { cfd_aligned_free(ctx->p_new); }
173 0 : if (ctx->T_ws) { cfd_aligned_free(ctx->T_ws); }
174 0 : if (ctx->turb_ws) { cfd_free(ctx->turb_ws); }
175 0 : if (ctx->dx_inv) { cfd_aligned_free(ctx->dx_inv); }
176 0 : if (ctx->dy_inv) { cfd_aligned_free(ctx->dy_inv); }
177 0 : cfd_free(ctx);
178 0 : return CFD_ERROR_NOMEM;
179 : }
180 :
181 : // Pre-compute inverses
182 0 : for (size_t i = 0; i < ctx->nx; i++) {
183 0 : ctx->dx_inv[i] = (i < ctx->nx - 1) ? 1.0 / (2.0 * grid->dx[i]) : 0.0;
184 : }
185 0 : for (size_t j = 0; j < ctx->ny; j++) {
186 0 : ctx->dy_inv[j] = (j < ctx->ny - 1) ? 1.0 / (2.0 * grid->dy[j]) : 0.0;
187 : }
188 :
189 0 : ctx->initialized = 1;
190 0 : solver->context = ctx;
191 :
192 : #ifdef _OPENMP
193 0 : CFD_LOG_INFO("solver", "Explicit Euler SIMD: AVX2 + OpenMP enabled (%d threads)", omp_get_max_threads());
194 : #else
195 : CFD_LOG_INFO("solver", "Explicit Euler SIMD: AVX2 enabled (OpenMP disabled)");
196 : #endif
197 :
198 0 : return CFD_SUCCESS;
199 : }
200 :
201 30 : void explicit_euler_simd_destroy(struct NSSolver* solver) {
202 30 : if (solver && solver->context) {
203 0 : explicit_euler_simd_context* ctx = (explicit_euler_simd_context*)solver->context;
204 0 : if (ctx->initialized) {
205 0 : cfd_aligned_free(ctx->u_new);
206 0 : cfd_aligned_free(ctx->v_new);
207 0 : cfd_aligned_free(ctx->w_new);
208 0 : cfd_aligned_free(ctx->p_new);
209 0 : cfd_aligned_free(ctx->T_ws);
210 0 : cfd_free(ctx->turb_ws);
211 0 : cfd_aligned_free(ctx->dx_inv);
212 0 : cfd_aligned_free(ctx->dy_inv);
213 : }
214 0 : cfd_free(ctx);
215 0 : solver->context = NULL;
216 : }
217 30 : }
218 :
219 : /* Momentum source terms at column i of row j, shared by the vector lanes and
220 : * the scalar row. Iteration 0 matches the scalar explicit_euler step, which
221 : * runs every step as a one-iteration solve. */
222 : static void cell_source_terms(const grid* grid, const ns_solver_params_t* params, size_t i,
223 : size_t j, double z_coord, double dt, double* source_u,
224 : double* source_v, double* source_w) {
225 : compute_source_terms(grid->x[i], grid->y[j], z_coord, 0, dt, params,
226 : source_u, source_v, source_w);
227 : }
228 :
229 : #if USE_AVX
230 : static inline __m256d vector_fmax(__m256d a, __m256d b) {
231 : return _mm256_max_pd(a, b);
232 : }
233 : static inline __m256d vector_fmin(__m256d a, __m256d b) {
234 : return _mm256_min_pd(a, b);
235 : }
236 :
237 : typedef struct {
238 : double dt;
239 : __m256d dt_vec;
240 : __m256d max_deriv;
241 : __m256d min_deriv;
242 : __m256d max_diverg;
243 : __m256d min_diverg;
244 : __m256d max_vel_limit;
245 : __m256d min_vel_limit;
246 : __m256d one_vec;
247 : __m256d neg_one_vec;
248 : __m256d pressure_factor;
249 : __m256d two;
250 : __m256d four;
251 : __m256d epsilon;
252 : __m256d mu_vec;
253 : __m256d zero;
254 : __m256d inv_2dz_vec;
255 : __m256d inv_dz_vec;
256 : __m256d inv_dz2_vec;
257 : /* Boussinesq buoyancy: accel = -beta*(T - T_ref)*g. Zero beta -> no-op. */
258 : __m256d neg_beta_vec;
259 : __m256d t_ref_vec;
260 : __m256d gx_vec;
261 : __m256d gy_vec;
262 : __m256d gz_vec;
263 : int upwind; /* First-order upwind convective derivatives */
264 : int has_source; /* Momentum sources can be nonzero; skips per-lane evaluation otherwise */
265 : } simd_constants;
266 :
267 : static void init_simd_constants(simd_constants* c, const ns_solver_params_t* params,
268 : double conservative_dt, double inv_2dz, double inv_dz2) {
269 : c->dt = conservative_dt;
270 : c->dt_vec = _mm256_set1_pd(conservative_dt);
271 : c->max_deriv = _mm256_set1_pd(MAX_DERIVATIVE_LIMIT);
272 : c->min_deriv = _mm256_set1_pd(-MAX_DERIVATIVE_LIMIT);
273 : c->max_diverg = _mm256_set1_pd(MAX_DIVERGENCE_LIMIT);
274 : c->min_diverg = _mm256_set1_pd(-MAX_DIVERGENCE_LIMIT);
275 : c->max_vel_limit = _mm256_set1_pd(MAX_VELOCITY_LIMIT);
276 : c->min_vel_limit = _mm256_set1_pd(-MAX_VELOCITY_LIMIT);
277 : c->one_vec = _mm256_set1_pd(UPDATE_LIMIT);
278 : c->neg_one_vec = _mm256_set1_pd(-UPDATE_LIMIT);
279 : c->pressure_factor = _mm256_set1_pd(-PRESSURE_UPDATE_FACTOR);
280 : c->two = _mm256_set1_pd(2.0);
281 : c->four = _mm256_set1_pd(4.0);
282 : c->epsilon = _mm256_set1_pd(1e-10);
283 : c->mu_vec = _mm256_set1_pd(params->mu);
284 : c->zero = _mm256_setzero_pd();
285 : c->inv_2dz_vec = _mm256_set1_pd(inv_2dz);
286 : c->inv_dz_vec = _mm256_set1_pd(2.0 * inv_2dz);
287 : c->inv_dz2_vec = _mm256_set1_pd(inv_dz2);
288 : c->neg_beta_vec = _mm256_set1_pd(-params->beta);
289 : c->t_ref_vec = _mm256_set1_pd(params->T_ref);
290 : c->gx_vec = _mm256_set1_pd(params->gravity[0]);
291 : c->gy_vec = _mm256_set1_pd(params->gravity[1]);
292 : c->gz_vec = _mm256_set1_pd(params->gravity[2]);
293 : c->upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
294 : c->has_source = (params->source_func != NULL || params->source_amplitude_u != 0.0 ||
295 : params->source_amplitude_v != 0.0);
296 : }
297 :
298 : static inline __m256d clamp_deriv(const simd_constants* sc, __m256d x) {
299 : return vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, x));
300 : }
301 :
302 : /* Vectorized update of row j in 4-wide groups. Returns the first interior
303 : * column not processed (1-3 columns remain when (nx-2) % 4 != 0); the caller
304 : * finishes the row with the scalar row path. */
305 : static size_t process_simd_row(explicit_euler_simd_context* ctx, flow_field* field, const grid* grid,
306 : const ns_solver_params_t* params, size_t j,
307 : const simd_constants* sc, double z_coord,
308 : size_t stride_z, size_t k_offset) {
309 : double dy2 = grid->dy[j] * grid->dy[j];
310 : __m256d dy_inv_val = _mm256_set1_pd(ctx->dy_inv[j]);
311 : __m256d dy2_val = _mm256_set1_pd(dy2);
312 : __m256d dy2_recip = _mm256_div_pd(sc->one_vec, dy2_val);
313 :
314 : size_t i = 1;
315 : for (; i + 3 < ctx->nx - 1; i += 4) {
316 : size_t idx = k_offset + IDX_2D(i, j, ctx->nx);
317 :
318 : __m256d u = _mm256_loadu_pd(&field->u[idx]);
319 : __m256d v = _mm256_loadu_pd(&field->v[idx]);
320 : __m256d rho = _mm256_loadu_pd(&field->rho[idx]);
321 : __m256d rho_inv = _mm256_div_pd(sc->one_vec, _mm256_max_pd(rho, sc->epsilon));
322 : __m256d dx_inv_val = _mm256_loadu_pd(&ctx->dx_inv[i]);
323 :
324 : __m256d u_xp = _mm256_loadu_pd(&field->u[idx + 1]);
325 : __m256d u_xm = _mm256_loadu_pd(&field->u[idx - 1]);
326 : __m256d u_yp = _mm256_loadu_pd(&field->u[idx + ctx->nx]);
327 : __m256d u_ym = _mm256_loadu_pd(&field->u[idx - ctx->nx]);
328 : __m256d u_zp = _mm256_loadu_pd(&field->u[idx + stride_z]);
329 : __m256d u_zm = _mm256_loadu_pd(&field->u[idx - stride_z]);
330 :
331 : __m256d du_dx = _mm256_mul_pd(_mm256_sub_pd(u_xp, u_xm), dx_inv_val);
332 : __m256d du_dy = _mm256_mul_pd(_mm256_sub_pd(u_yp, u_ym), dy_inv_val);
333 : __m256d du_dz = _mm256_mul_pd(_mm256_sub_pd(u_zp, u_zm), sc->inv_2dz_vec);
334 :
335 : du_dx = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, du_dx));
336 : du_dy = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, du_dy));
337 : du_dz = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, du_dz));
338 :
339 : __m256d v_xp = _mm256_loadu_pd(&field->v[idx + 1]);
340 : __m256d v_xm = _mm256_loadu_pd(&field->v[idx - 1]);
341 : __m256d v_yp = _mm256_loadu_pd(&field->v[idx + ctx->nx]);
342 : __m256d v_ym = _mm256_loadu_pd(&field->v[idx - ctx->nx]);
343 : __m256d v_zp = _mm256_loadu_pd(&field->v[idx + stride_z]);
344 : __m256d v_zm = _mm256_loadu_pd(&field->v[idx - stride_z]);
345 :
346 : __m256d dv_dx = _mm256_mul_pd(_mm256_sub_pd(v_xp, v_xm), dx_inv_val);
347 : __m256d dv_dy = _mm256_mul_pd(_mm256_sub_pd(v_yp, v_ym), dy_inv_val);
348 : __m256d dv_dz = _mm256_mul_pd(_mm256_sub_pd(v_zp, v_zm), sc->inv_2dz_vec);
349 :
350 : dv_dx = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dv_dx));
351 : dv_dy = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dv_dy));
352 : dv_dz = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dv_dz));
353 :
354 : __m256d p_xp = _mm256_loadu_pd(&field->p[idx + 1]);
355 : __m256d p_xm = _mm256_loadu_pd(&field->p[idx - 1]);
356 : __m256d p_yp = _mm256_loadu_pd(&field->p[idx + ctx->nx]);
357 : __m256d p_ym = _mm256_loadu_pd(&field->p[idx - ctx->nx]);
358 : __m256d p_zp = _mm256_loadu_pd(&field->p[idx + stride_z]);
359 : __m256d p_zm = _mm256_loadu_pd(&field->p[idx - stride_z]);
360 :
361 : __m256d dp_dx = _mm256_mul_pd(_mm256_sub_pd(p_xp, p_xm), dx_inv_val);
362 : __m256d dp_dy = _mm256_mul_pd(_mm256_sub_pd(p_yp, p_ym), dy_inv_val);
363 : __m256d dp_dz = _mm256_mul_pd(_mm256_sub_pd(p_zp, p_zm), sc->inv_2dz_vec);
364 :
365 : dp_dx = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dp_dx));
366 : dp_dy = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dp_dy));
367 : dp_dz = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dp_dz));
368 :
369 : __m256d w = _mm256_loadu_pd(&field->w[idx]);
370 : __m256d w_xp = _mm256_loadu_pd(&field->w[idx + 1]);
371 : __m256d w_xm = _mm256_loadu_pd(&field->w[idx - 1]);
372 : __m256d w_yp = _mm256_loadu_pd(&field->w[idx + ctx->nx]);
373 : __m256d w_ym = _mm256_loadu_pd(&field->w[idx - ctx->nx]);
374 : __m256d w_zp = _mm256_loadu_pd(&field->w[idx + stride_z]);
375 : __m256d w_zm = _mm256_loadu_pd(&field->w[idx - stride_z]);
376 :
377 : __m256d dw_dx = _mm256_mul_pd(_mm256_sub_pd(w_xp, w_xm), dx_inv_val);
378 : __m256d dw_dy = _mm256_mul_pd(_mm256_sub_pd(w_yp, w_ym), dy_inv_val);
379 : __m256d dw_dz = _mm256_mul_pd(_mm256_sub_pd(w_zp, w_zm), sc->inv_2dz_vec);
380 :
381 : dw_dx = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dw_dx));
382 : dw_dy = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dw_dy));
383 : dw_dz = vector_fmax(sc->min_deriv, vector_fmin(sc->max_deriv, dw_dz));
384 :
385 : /* Convective derivatives: the clamped central ones, or first-order
386 : * upwind. The divergence below stays central. */
387 : __m256d cdu_dx = du_dx, cdu_dy = du_dy, cdu_dz = du_dz;
388 : __m256d cdv_dx = dv_dx, cdv_dy = dv_dy, cdv_dz = dv_dz;
389 : __m256d cdw_dx = dw_dx, cdw_dy = dw_dy, cdw_dz = dw_dz;
390 : if (sc->upwind) {
391 : /* dx_inv and dy_inv hold 1/(2h); upwind differences need 1/h */
392 : __m256d inv_dx = _mm256_add_pd(dx_inv_val, dx_inv_val);
393 : __m256d inv_dy = _mm256_add_pd(dy_inv_val, dy_inv_val);
394 : cdu_dx = clamp_deriv(sc, upwind_deriv_avx2(u, u_xm, u, u_xp, inv_dx));
395 : cdu_dy = clamp_deriv(sc, upwind_deriv_avx2(v, u_ym, u, u_yp, inv_dy));
396 : cdu_dz = clamp_deriv(sc, upwind_deriv_avx2(w, u_zm, u, u_zp, sc->inv_dz_vec));
397 : cdv_dx = clamp_deriv(sc, upwind_deriv_avx2(u, v_xm, v, v_xp, inv_dx));
398 : cdv_dy = clamp_deriv(sc, upwind_deriv_avx2(v, v_ym, v, v_yp, inv_dy));
399 : cdv_dz = clamp_deriv(sc, upwind_deriv_avx2(w, v_zm, v, v_zp, sc->inv_dz_vec));
400 : cdw_dx = clamp_deriv(sc, upwind_deriv_avx2(u, w_xm, w, w_xp, inv_dx));
401 : cdw_dy = clamp_deriv(sc, upwind_deriv_avx2(v, w_ym, w, w_yp, inv_dy));
402 : cdw_dz = clamp_deriv(sc, upwind_deriv_avx2(w, w_zm, w, w_zp, sc->inv_dz_vec));
403 : }
404 :
405 : __m256d inv_dx_sq = _mm256_mul_pd(sc->four, _mm256_mul_pd(dx_inv_val, dx_inv_val));
406 :
407 : __m256d d2u_dx2 = _mm256_mul_pd(
408 : _mm256_sub_pd(_mm256_add_pd(u_xp, u_xm), _mm256_mul_pd(sc->two, u)), inv_dx_sq);
409 : __m256d d2u_dy2 = _mm256_mul_pd(
410 : _mm256_sub_pd(_mm256_add_pd(u_yp, u_ym), _mm256_mul_pd(sc->two, u)), dy2_recip);
411 : __m256d d2u_dz2 = _mm256_mul_pd(
412 : _mm256_sub_pd(_mm256_add_pd(u_zp, u_zm), _mm256_mul_pd(sc->two, u)), sc->inv_dz2_vec);
413 :
414 : __m256d d2v_dx2 = _mm256_mul_pd(
415 : _mm256_sub_pd(_mm256_add_pd(v_xp, v_xm), _mm256_mul_pd(sc->two, v)), inv_dx_sq);
416 : __m256d d2v_dy2 = _mm256_mul_pd(
417 : _mm256_sub_pd(_mm256_add_pd(v_yp, v_ym), _mm256_mul_pd(sc->two, v)), dy2_recip);
418 : __m256d d2v_dz2 = _mm256_mul_pd(
419 : _mm256_sub_pd(_mm256_add_pd(v_zp, v_zm), _mm256_mul_pd(sc->two, v)), sc->inv_dz2_vec);
420 :
421 : __m256d d2w_dx2 = _mm256_mul_pd(
422 : _mm256_sub_pd(_mm256_add_pd(w_xp, w_xm), _mm256_mul_pd(sc->two, w)), inv_dx_sq);
423 : __m256d d2w_dy2 = _mm256_mul_pd(
424 : _mm256_sub_pd(_mm256_add_pd(w_yp, w_ym), _mm256_mul_pd(sc->two, w)), dy2_recip);
425 : __m256d d2w_dz2 = _mm256_mul_pd(
426 : _mm256_sub_pd(_mm256_add_pd(w_zp, w_zm), _mm256_mul_pd(sc->two, w)), sc->inv_dz2_vec);
427 :
428 : __m256d nu = _mm256_min_pd(sc->one_vec, _mm256_mul_pd(sc->mu_vec, rho_inv));
429 :
430 : __m256d term_pres_x = _mm256_mul_pd(dp_dx, rho_inv);
431 : __m256d term_visc_u = _mm256_mul_pd(nu, _mm256_add_pd(_mm256_add_pd(d2u_dx2, d2u_dy2), d2u_dz2));
432 : __m256d conv_u = _mm256_add_pd(
433 : _mm256_add_pd(_mm256_mul_pd(u, cdu_dx), _mm256_mul_pd(v, cdu_dy)),
434 : _mm256_mul_pd(w, cdu_dz));
435 : __m256d du =
436 : _mm256_mul_pd(sc->dt_vec, _mm256_add_pd(_mm256_sub_pd(term_visc_u, term_pres_x),
437 : _mm256_sub_pd(sc->zero, conv_u)));
438 :
439 : __m256d term_pres_y = _mm256_mul_pd(dp_dy, rho_inv);
440 : __m256d term_visc_v = _mm256_mul_pd(nu, _mm256_add_pd(_mm256_add_pd(d2v_dx2, d2v_dy2), d2v_dz2));
441 : __m256d conv_v = _mm256_add_pd(
442 : _mm256_add_pd(_mm256_mul_pd(u, cdv_dx), _mm256_mul_pd(v, cdv_dy)),
443 : _mm256_mul_pd(w, cdv_dz));
444 : __m256d dv =
445 : _mm256_mul_pd(sc->dt_vec, _mm256_add_pd(_mm256_sub_pd(term_visc_v, term_pres_y),
446 : _mm256_sub_pd(sc->zero, conv_v)));
447 :
448 : __m256d term_pres_z = _mm256_mul_pd(dp_dz, rho_inv);
449 : __m256d term_visc_w = _mm256_mul_pd(nu, _mm256_add_pd(_mm256_add_pd(d2w_dx2, d2w_dy2), d2w_dz2));
450 : __m256d conv_w = _mm256_add_pd(
451 : _mm256_add_pd(_mm256_mul_pd(u, cdw_dx), _mm256_mul_pd(v, cdw_dy)),
452 : _mm256_mul_pd(w, cdw_dz));
453 : __m256d dw =
454 : _mm256_mul_pd(sc->dt_vec, _mm256_add_pd(_mm256_sub_pd(term_visc_w, term_pres_z),
455 : _mm256_sub_pd(sc->zero, conv_w)));
456 :
457 : /* Momentum sources: dvel += dt * source, evaluated per lane */
458 : if (sc->has_source) {
459 : double src_u[4] = {0.0, 0.0, 0.0, 0.0};
460 : double src_v[4] = {0.0, 0.0, 0.0, 0.0};
461 : double src_w[4] = {0.0, 0.0, 0.0, 0.0};
462 : for (size_t lane = 0; lane < 4; lane++) {
463 : cell_source_terms(grid, params, i + lane, j, z_coord, sc->dt,
464 : &src_u[lane], &src_v[lane], &src_w[lane]);
465 : }
466 : du = _mm256_add_pd(du, _mm256_mul_pd(sc->dt_vec, _mm256_loadu_pd(src_u)));
467 : dv = _mm256_add_pd(dv, _mm256_mul_pd(sc->dt_vec, _mm256_loadu_pd(src_v)));
468 : dw = _mm256_add_pd(dw, _mm256_mul_pd(sc->dt_vec, _mm256_loadu_pd(src_w)));
469 : }
470 :
471 : /* Boussinesq buoyancy: dvel += dt * (-beta*(T - T_ref)) * g.
472 : * When beta == 0 this adds exactly 0.0, matching the scalar path. */
473 : __m256d Tcell = _mm256_loadu_pd(&field->T[idx]);
474 : __m256d buoy = _mm256_mul_pd(sc->neg_beta_vec, _mm256_sub_pd(Tcell, sc->t_ref_vec));
475 : __m256d dt_buoy = _mm256_mul_pd(sc->dt_vec, buoy);
476 : du = _mm256_add_pd(du, _mm256_mul_pd(dt_buoy, sc->gx_vec));
477 : dv = _mm256_add_pd(dv, _mm256_mul_pd(dt_buoy, sc->gy_vec));
478 : dw = _mm256_add_pd(dw, _mm256_mul_pd(dt_buoy, sc->gz_vec));
479 :
480 : du = vector_fmin(sc->one_vec, vector_fmax(sc->neg_one_vec, du));
481 : dv = vector_fmin(sc->one_vec, vector_fmax(sc->neg_one_vec, dv));
482 : dw = vector_fmin(sc->one_vec, vector_fmax(sc->neg_one_vec, dw));
483 :
484 : __m256d u_next = _mm256_add_pd(u, du);
485 : __m256d v_next = _mm256_add_pd(v, dv);
486 : __m256d w_next = _mm256_add_pd(w, dw);
487 :
488 : u_next = vector_fmin(sc->max_vel_limit, vector_fmax(sc->min_vel_limit, u_next));
489 : v_next = vector_fmin(sc->max_vel_limit, vector_fmax(sc->min_vel_limit, v_next));
490 : w_next = vector_fmin(sc->max_vel_limit, vector_fmax(sc->min_vel_limit, w_next));
491 :
492 : __m256d divergence = _mm256_add_pd(_mm256_add_pd(du_dx, dv_dy), dw_dz);
493 : divergence = vector_fmin(sc->max_diverg, vector_fmax(sc->min_diverg, divergence));
494 : __m256d p = _mm256_loadu_pd(&field->p[idx]);
495 : __m256d dp = _mm256_mul_pd(
496 : sc->dt_vec, _mm256_mul_pd(sc->pressure_factor, _mm256_mul_pd(rho, divergence)));
497 : dp = vector_fmin(sc->one_vec, vector_fmax(sc->neg_one_vec, dp));
498 : __m256d p_next = _mm256_add_pd(p, dp);
499 :
500 : _mm256_storeu_pd(&ctx->u_new[idx], u_next);
501 : _mm256_storeu_pd(&ctx->v_new[idx], v_next);
502 : _mm256_storeu_pd(&ctx->w_new[idx], w_next);
503 : _mm256_storeu_pd(&ctx->p_new[idx], p_next);
504 : }
505 : return i;
506 : }
507 : #endif
508 :
509 : /* Scalar update of row j for interior columns i_start..nx-2 */
510 : static void process_scalar_row_turb(explicit_euler_simd_context* ctx, flow_field* field,
511 : const grid* grid, const ns_solver_params_t* params, size_t j,
512 : double conservative_dt, double z_coord, size_t stride_z,
513 : size_t k_offset, int turb_on_flag, size_t i_start) {
514 : for (size_t i = i_start; i < ctx->nx - 1; i++) {
515 : size_t idx = k_offset + IDX_2D(i, j, ctx->nx);
516 :
517 : double du_dx = (field->u[idx + 1] - field->u[idx - 1]) / (2.0 * grid->dx[i]);
518 : double du_dy = (field->u[idx + ctx->nx] - field->u[idx - ctx->nx]) / (2.0 * grid->dy[j]);
519 : double du_dz = (field->u[idx + stride_z] - field->u[idx - stride_z]) * ctx->inv_2dz;
520 : double dv_dx = (field->v[idx + 1] - field->v[idx - 1]) / (2.0 * grid->dx[i]);
521 : double dv_dy = (field->v[idx + ctx->nx] - field->v[idx - ctx->nx]) / (2.0 * grid->dy[j]);
522 : double dv_dz = (field->v[idx + stride_z] - field->v[idx - stride_z]) * ctx->inv_2dz;
523 : double dw_dx = (field->w[idx + 1] - field->w[idx - 1]) / (2.0 * grid->dx[i]);
524 : double dw_dy = (field->w[idx + ctx->nx] - field->w[idx - ctx->nx]) / (2.0 * grid->dy[j]);
525 : double dw_dz = (field->w[idx + stride_z] - field->w[idx - stride_z]) * ctx->inv_2dz;
526 :
527 : double dp_dx = (field->p[idx + 1] - field->p[idx - 1]) / (2.0 * grid->dx[i]);
528 : double dp_dy = (field->p[idx + ctx->nx] - field->p[idx - ctx->nx]) / (2.0 * grid->dy[j]);
529 : double dp_dz = (field->p[idx + stride_z] - field->p[idx - stride_z]) * ctx->inv_2dz;
530 :
531 : double d2u_dx2 = (field->u[idx + 1] - 2.0 * field->u[idx] + field->u[idx - 1]) /
532 : (grid->dx[i] * grid->dx[i]);
533 : double d2u_dy2 = (field->u[idx + ctx->nx] - 2.0 * field->u[idx] + field->u[idx - ctx->nx]) /
534 : (grid->dy[j] * grid->dy[j]);
535 : double d2u_dz2 = (field->u[idx + stride_z] - 2.0 * field->u[idx] + field->u[idx - stride_z]) *
536 : ctx->inv_dz2;
537 : double d2v_dx2 = (field->v[idx + 1] - 2.0 * field->v[idx] + field->v[idx - 1]) /
538 : (grid->dx[i] * grid->dx[i]);
539 : double d2v_dy2 = (field->v[idx + ctx->nx] - 2.0 * field->v[idx] + field->v[idx - ctx->nx]) /
540 : (grid->dy[j] * grid->dy[j]);
541 : double d2v_dz2 = (field->v[idx + stride_z] - 2.0 * field->v[idx] + field->v[idx - stride_z]) *
542 : ctx->inv_dz2;
543 : double d2w_dx2 = (field->w[idx + 1] - 2.0 * field->w[idx] + field->w[idx - 1]) /
544 : (grid->dx[i] * grid->dx[i]);
545 : double d2w_dy2 = (field->w[idx + ctx->nx] - 2.0 * field->w[idx] + field->w[idx - ctx->nx]) /
546 : (grid->dy[j] * grid->dy[j]);
547 : double d2w_dz2 = (field->w[idx + stride_z] - 2.0 * field->w[idx] + field->w[idx - stride_z]) *
548 : ctx->inv_dz2;
549 :
550 : double rho = fmax(field->rho[idx], 1e-10);
551 : double nu = fmin(params->mu / rho, 1.0);
552 :
553 : du_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, du_dx));
554 : du_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, du_dy));
555 : du_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, du_dz));
556 : dv_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dv_dx));
557 : dv_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dv_dy));
558 : dv_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dv_dz));
559 : dw_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dw_dx));
560 : dw_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dw_dy));
561 : dw_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dw_dz));
562 : dp_dx = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dp_dx));
563 : dp_dy = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dp_dy));
564 : dp_dz = fmax(-MAX_DERIVATIVE_LIMIT, fmin(MAX_DERIVATIVE_LIMIT, dp_dz));
565 :
566 : /* Convective derivatives: the clamped central ones, or first-order
567 : * upwind. The divergence below stays central. */
568 : ns_conv_derivs_t cd = {du_dx, du_dy, du_dz, dv_dx, dv_dy, dv_dz, dw_dx, dw_dy, dw_dz};
569 : if (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND) {
570 : ns_upwind_conv_derivs(field->u, field->v, field->w, idx, idx - 1, idx + 1,
571 : idx - ctx->nx, idx + ctx->nx, idx - stride_z, idx + stride_z,
572 : grid->dx[i], grid->dy[j], 2.0 * ctx->inv_2dz, &cd);
573 : ns_clamp_conv_derivs(&cd, MAX_DERIVATIVE_LIMIT);
574 : }
575 :
576 : double source_u = 0.0;
577 : double source_v = 0.0;
578 : double source_w = 0.0;
579 : cell_source_terms(grid, params, i, j, z_coord, conservative_dt,
580 : &source_u, &source_v, &source_w);
581 :
582 : /* Boussinesq buoyancy source (no-op when beta == 0) */
583 : energy_compute_buoyancy(field->T[idx], params, &source_u, &source_v, &source_w);
584 :
585 : double u_c = field->u[idx];
586 : double v_c = field->v[idx];
587 : double w_c = field->w[idx];
588 :
589 : double visc_u, visc_v, visc_w;
590 : if (!turb_on_flag) {
591 : visc_u = nu * (d2u_dx2 + d2u_dy2 + d2u_dz2);
592 : visc_v = nu * (d2v_dx2 + d2v_dy2 + d2v_dz2);
593 : visc_w = nu * (d2w_dx2 + d2w_dy2 + d2w_dz2);
594 : } else {
595 : const double* nu_t = field->nu_t;
596 : double dx2 = grid->dx[i] * grid->dx[i];
597 : double dy2 = grid->dy[j] * grid->dy[j];
598 : /* Face-averaged nu_eff = nu + nu_t (nu_t is bounded by the
599 : * realizability clamp) */
600 : double nu_xp = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]);
601 : double nu_xm = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]);
602 : double nu_yp = nu + 0.5 * (nu_t[idx] + nu_t[idx + ctx->nx]);
603 : double nu_ym = nu + 0.5 * (nu_t[idx] + nu_t[idx - ctx->nx]);
604 : visc_u = (nu_xp * (field->u[idx + 1] - u_c) -
605 : nu_xm * (u_c - field->u[idx - 1])) / dx2 +
606 : (nu_yp * (field->u[idx + ctx->nx] - u_c) -
607 : nu_ym * (u_c - field->u[idx - ctx->nx])) / dy2 +
608 : nu * d2u_dz2;
609 : visc_v = (nu_xp * (field->v[idx + 1] - v_c) -
610 : nu_xm * (v_c - field->v[idx - 1])) / dx2 +
611 : (nu_yp * (field->v[idx + ctx->nx] - v_c) -
612 : nu_ym * (v_c - field->v[idx - ctx->nx])) / dy2 +
613 : nu * d2v_dz2;
614 : visc_w = (nu_xp * (field->w[idx + 1] - w_c) -
615 : nu_xm * (w_c - field->w[idx - 1])) / dx2 +
616 : (nu_yp * (field->w[idx + ctx->nx] - w_c) -
617 : nu_ym * (w_c - field->w[idx - ctx->nx])) / dy2 +
618 : nu * d2w_dz2;
619 : visc_u = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_u));
620 : visc_v = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_v));
621 : visc_w = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_w));
622 : }
623 :
624 : double du = conservative_dt * (-u_c * cd.du_dx - v_c * cd.du_dy - w_c * cd.du_dz -
625 : dp_dx / rho + visc_u + source_u);
626 : double dv = conservative_dt * (-u_c * cd.dv_dx - v_c * cd.dv_dy - w_c * cd.dv_dz -
627 : dp_dy / rho + visc_v + source_v);
628 : double dw = conservative_dt * (-u_c * cd.dw_dx - v_c * cd.dw_dy - w_c * cd.dw_dz -
629 : dp_dz / rho + visc_w + source_w);
630 :
631 : du = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, du));
632 : dv = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dv));
633 : dw = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dw));
634 :
635 : ctx->u_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, u_c + du));
636 : ctx->v_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, v_c + dv));
637 : ctx->w_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, w_c + dw));
638 :
639 : double divergence = du_dx + dv_dy + dw_dz;
640 : divergence = fmax(-MAX_DIVERGENCE_LIMIT, fmin(MAX_DIVERGENCE_LIMIT, divergence));
641 : double dp = -PRESSURE_UPDATE_FACTOR * conservative_dt * rho * divergence;
642 : dp = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dp));
643 : ctx->p_new[idx] = field->p[idx] + dp;
644 : }
645 : }
646 :
647 1 : cfd_status_t explicit_euler_simd_step(struct NSSolver* solver, flow_field* field, const grid* grid,
648 : const ns_solver_params_t* params, ns_solver_stats_t* stats) {
649 1 : if (!solver || !solver->context || !field || !grid || !params) {
650 : return CFD_ERROR_INVALID;
651 : }
652 :
653 0 : explicit_euler_simd_context* ctx = (explicit_euler_simd_context*)solver->context;
654 0 : const int turb_on = (params->turb_model != TURB_MODEL_NONE);
655 :
656 0 : if (field->nx < 3 || field->ny < 3 || (field->nz > 1 && field->nz < 3)) {
657 : return CFD_ERROR_INVALID;
658 : }
659 :
660 0 : if (field->nx != ctx->nx || field->ny != ctx->ny || field->nz != ctx->nz) {
661 : return CFD_ERROR_INVALID;
662 : }
663 :
664 : // Use conservative time step to match basic solver stability
665 0 : double conservative_dt = fmin(params->dt, DT_CONSERVATIVE_LIMIT);
666 :
667 : // Copy current state to temp buffers
668 0 : size_t size = ctx->nx * ctx->ny * ctx->nz;
669 0 : memcpy(ctx->u_new, field->u, size * sizeof(double));
670 0 : memcpy(ctx->v_new, field->v, size * sizeof(double));
671 0 : memcpy(ctx->w_new, field->w, size * sizeof(double));
672 0 : memcpy(ctx->p_new, field->p, size * sizeof(double));
673 :
674 0 : size_t nx = ctx->nx;
675 0 : size_t ny = ctx->ny;
676 :
677 : #if USE_AVX
678 : int ny_int = (int)(ctx->ny);
679 : int j;
680 : if (!turb_on) {
681 : simd_constants sc;
682 : init_simd_constants(&sc, params, conservative_dt, ctx->inv_2dz, ctx->inv_dz2);
683 : for (size_t k = ctx->k_start; k < ctx->k_end; k++) {
684 : size_t k_offset = k * ctx->stride_z;
685 : double z_coord = (ctx->nz > 1 && grid->z) ? grid->z[k] : 0.0;
686 : #ifdef _OPENMP
687 : #pragma omp parallel for schedule(static)
688 : #endif
689 : for (j = 1; j < ny_int - 1; j++) {
690 : size_t i_tail = process_simd_row(ctx, field, grid, params, (size_t)j, &sc,
691 : z_coord, ctx->stride_z, k_offset);
692 : process_scalar_row_turb(ctx, field, grid, params, (size_t)j, conservative_dt,
693 : z_coord, ctx->stride_z, k_offset, 0, i_tail);
694 : }
695 : }
696 : } else {
697 : for (size_t k = ctx->k_start; k < ctx->k_end; k++) {
698 : size_t k_offset = k * ctx->stride_z;
699 : double z_coord = (ctx->nz > 1 && grid->z) ? grid->z[k] : 0.0;
700 : #ifdef _OPENMP
701 : #pragma omp parallel for schedule(static)
702 : #endif
703 : for (j = 1; j < ny_int - 1; j++) {
704 : process_scalar_row_turb(ctx, field, grid, params, (size_t)j, conservative_dt,
705 : z_coord, ctx->stride_z, k_offset, 1, 1);
706 : }
707 : }
708 : }
709 : #endif
710 :
711 : // Apply boundary, check NaNs, etc.
712 0 : memcpy(field->u, ctx->u_new, size * sizeof(double));
713 0 : memcpy(field->v, ctx->v_new, size * sizeof(double));
714 0 : memcpy(field->w, ctx->w_new, size * sizeof(double));
715 0 : memcpy(field->p, ctx->p_new, size * sizeof(double));
716 :
717 : // Energy equation: advance temperature using updated velocity
718 : {
719 0 : cfd_status_t energy_status = energy_step_explicit_avx2_with_workspace(
720 : field, grid, params, conservative_dt,
721 0 : ctx->iter_count * conservative_dt, ctx->T_ws, size);
722 0 : if (energy_status != CFD_SUCCESS) {
723 : return energy_status;
724 : }
725 : }
726 :
727 : // Store caller-set boundary values before apply_boundary_conditions overwrites them,
728 : // then restore them. Then apply configured thermal BCs.
729 0 : copy_boundary_velocities_3d(ctx->u_new, ctx->v_new, ctx->w_new,
730 0 : field->u, field->v, field->w, nx, ny, ctx->nz);
731 0 : apply_boundary_conditions(field, grid);
732 0 : copy_boundary_velocities_3d(field->u, field->v, field->w,
733 0 : ctx->u_new, ctx->v_new, ctx->w_new, nx, ny, ctx->nz);
734 : {
735 0 : cfd_status_t bc_status = energy_apply_thermal_bcs(field, params);
736 0 : if (bc_status != CFD_SUCCESS) {
737 : return bc_status;
738 : }
739 : }
740 :
741 : /* Turbulence transport: advance k-eps/SA with the updated velocity,
742 : * then apply turbulence BCs. nu_t is updated once per step. */
743 : {
744 0 : cfd_status_t turb_status = turbulence_step_explicit_avx2_with_workspace(
745 : field, grid, params, conservative_dt,
746 0 : ctx->iter_count * conservative_dt, ctx->turb_ws,
747 : turb_on ? TURB_WORKSPACE_SIZE(size) : 0);
748 0 : if (turb_status == CFD_SUCCESS) {
749 0 : turb_status = turbulence_apply_bcs(field, grid, params);
750 : }
751 0 : if (turb_status != CFD_SUCCESS) {
752 0 : return turb_status;
753 : }
754 : }
755 :
756 0 : if (stats) {
757 0 : stats->iterations = 1;
758 : }
759 :
760 : // NaN/Inf check
761 0 : int has_nan = 0;
762 0 : for (size_t n = 0; n < size; n++) {
763 0 : if (!isfinite(field->u[n]) || !isfinite(field->v[n]) ||
764 0 : !isfinite(field->w[n]) || !isfinite(field->p[n])) {
765 : has_nan = 1;
766 : break;
767 : }
768 : }
769 0 : if (has_nan) {
770 0 : cfd_set_error(CFD_ERROR_DIVERGED,
771 : "NaN/Inf detected in explicit_euler_simd step");
772 0 : return CFD_ERROR_DIVERGED;
773 : }
774 :
775 0 : ctx->iter_count++;
776 0 : return CFD_SUCCESS;
777 : }
|