LCOV - code coverage report
Current view: top level - solvers/navier_stokes/avx2 - solver_explicit_euler_avx2.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 9.2 % 120 11
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 3 3

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

Generated by: LCOV version 2.0-1