LCOV - code coverage report
Current view: top level - solvers/turbulence/avx2 - turbulence_solver_avx2.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 0.0 % 124 0
Test Date: 2026-10-05 04:47:18 Functions: 0.0 % 4 0

            Line data    Source code
       1              : /**
       2              :  * @file turbulence_solver_avx2.c
       3              :  * @brief AVX2-vectorized RANS turbulence transport step
       4              :  *
       5              :  * Same numerics as the scalar reference (turbulence/cpu/). The k-epsilon
       6              :  * interior stencil is vectorized along the unit-stride i direction (4 doubles
       7              :  * per AVX2 register, upwind selection via blendv) with a scalar remainder
       8              :  * tail; the j loop is parallelized with OpenMP. The Spalart-Allmaras kernel is
       9              :  * dominated by pow()-heavy closure functions (fw, fv1) that do not vectorize
      10              :  * profitably without a vector libm, so it is processed with OMP-parallel
      11              :  * scalar rows — numerically identical to the scalar backend by construction.
      12              :  * When AVX2 is unavailable at compile time the whole interior is processed
      13              :  * with the scalar path, so this file always provides a correct implementation.
      14              :  */
      15              : 
      16              : #include "../turbulence_solver_internal.h"
      17              : 
      18              : #include "cfd/core/indexing.h"
      19              : #include "cfd/core/memory.h"
      20              : 
      21              : #include <math.h>
      22              : #include <stddef.h>
      23              : #include <string.h>
      24              : 
      25              : #ifdef _OPENMP
      26              : #include <omp.h>
      27              : #endif
      28              : 
      29              : #if defined(CFD_HAS_AVX2)
      30              : #include <immintrin.h>
      31              : #define USE_AVX 1
      32              : #else
      33              : #define USE_AVX 0
      34              : #endif
      35              : 
      36              : /* Scalar k-epsilon update for one point (vector-loop tail and non-AVX builds).
      37              :  * Must remain numerically identical to turb_kepsilon_step_scalar. */
      38            0 : static inline void kepsilon_point(const flow_field* field,
      39              :                                   const ns_solver_params_t* params,
      40              :                                   size_t idx, size_t nx, double dt,
      41              :                                   double inv_dx, double inv_dy,
      42              :                                   double inv_2dx, double inv_2dy,
      43              :                                   double inv_dx2, double inv_dy2,
      44              :                                   double* k_new, double* eps_new) {
      45            0 :     const double* u = field->u;
      46            0 :     const double* v = field->v;
      47            0 :     const double* k = field->turb_k;
      48            0 :     const double* eps = field->turb_eps;
      49            0 :     const double* nu_t = field->nu_t;
      50              : 
      51            0 :     double nu = params->mu / fmax(field->rho[idx], 1e-10);
      52            0 :     double u_c = u[idx];
      53            0 :     double v_c = v[idx];
      54            0 :     double k_c = fmax(k[idx], TURB_K_MIN);
      55            0 :     double eps_c = fmax(eps[idx], TURB_EPS_MIN);
      56              : 
      57            0 :     double adv_k = (u_c > 0.0 ? u_c * (k[idx] - k[idx - 1]) * inv_dx
      58            0 :                               : u_c * (k[idx + 1] - k[idx]) * inv_dx) +
      59            0 :                    (v_c > 0.0 ? v_c * (k[idx] - k[idx - nx]) * inv_dy
      60            0 :                               : v_c * (k[idx + nx] - k[idx]) * inv_dy);
      61            0 :     double adv_e = (u_c > 0.0 ? u_c * (eps[idx] - eps[idx - 1]) * inv_dx
      62            0 :                               : u_c * (eps[idx + 1] - eps[idx]) * inv_dx) +
      63            0 :                    (v_c > 0.0 ? v_c * (eps[idx] - eps[idx - nx]) * inv_dy
      64            0 :                               : v_c * (eps[idx + nx] - eps[idx]) * inv_dy);
      65              : 
      66            0 :     double gam_e_k = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]) / TURB_SIGMA_K;
      67            0 :     double gam_w_k = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]) / TURB_SIGMA_K;
      68            0 :     double gam_n_k = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]) / TURB_SIGMA_K;
      69            0 :     double gam_s_k = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]) / TURB_SIGMA_K;
      70            0 :     double diff_k = (gam_e_k * (k[idx + 1] - k[idx]) -
      71            0 :                      gam_w_k * (k[idx] - k[idx - 1])) * inv_dx2 +
      72            0 :                     (gam_n_k * (k[idx + nx] - k[idx]) -
      73            0 :                      gam_s_k * (k[idx] - k[idx - nx])) * inv_dy2;
      74              : 
      75            0 :     double gam_e_e = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]) / TURB_SIGMA_EPS;
      76            0 :     double gam_w_e = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]) / TURB_SIGMA_EPS;
      77            0 :     double gam_n_e = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]) / TURB_SIGMA_EPS;
      78            0 :     double gam_s_e = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]) / TURB_SIGMA_EPS;
      79            0 :     double diff_e = (gam_e_e * (eps[idx + 1] - eps[idx]) -
      80            0 :                      gam_w_e * (eps[idx] - eps[idx - 1])) * inv_dx2 +
      81            0 :                     (gam_n_e * (eps[idx + nx] - eps[idx]) -
      82            0 :                      gam_s_e * (eps[idx] - eps[idx - nx])) * inv_dy2;
      83              : 
      84            0 :     double du_dx = (u[idx + 1] - u[idx - 1]) * inv_2dx;
      85            0 :     double du_dy = (u[idx + nx] - u[idx - nx]) * inv_2dy;
      86            0 :     double dv_dx = (v[idx + 1] - v[idx - 1]) * inv_2dx;
      87            0 :     double dv_dy = (v[idx + nx] - v[idx - nx]) * inv_2dy;
      88            0 :     double S2 = 2.0 * du_dx * du_dx + 2.0 * dv_dy * dv_dy +
      89            0 :                 (du_dy + dv_dx) * (du_dy + dv_dx);
      90            0 :     double P_k = fmin(nu_t[idx] * S2, TURB_PROD_LIMIT_FACTOR * eps_c);
      91              : 
      92            0 :     double eps_over_k = eps_c / k_c;
      93            0 :     double k_upd = (k[idx] + dt * (-adv_k + diff_k + P_k)) /
      94            0 :                    (1.0 + dt * eps_over_k);
      95            0 :     double e_upd = (eps[idx] + dt * (-adv_e + diff_e +
      96            0 :                                      TURB_C1_EPS * eps_over_k * P_k)) /
      97            0 :                    (1.0 + dt * TURB_C2_EPS * eps_over_k);
      98              : 
      99            0 :     k_new[idx] = fmax(k_upd, TURB_K_MIN);
     100            0 :     eps_new[idx] = fmax(e_upd, TURB_EPS_MIN);
     101            0 : }
     102              : 
     103              : #if USE_AVX
     104              : /* Vector helpers: upwind advection term c * d(phi) using blendv selection */
     105              : static inline __m256d avx2_upwind(__m256d c, __m256d phi_m, __m256d phi_c,
     106              :                                   __m256d phi_p, __m256d inv_d) {
     107              :     __m256d zero = _mm256_setzero_pd();
     108              :     __m256d pos = _mm256_mul_pd(_mm256_mul_pd(c, _mm256_sub_pd(phi_c, phi_m)), inv_d);
     109              :     __m256d neg = _mm256_mul_pd(_mm256_mul_pd(c, _mm256_sub_pd(phi_p, phi_c)), inv_d);
     110              :     __m256d mask = _mm256_cmp_pd(c, zero, _CMP_GT_OQ);
     111              :     return _mm256_blendv_pd(neg, pos, mask);
     112              : }
     113              : 
     114              : /* Face-averaged diffusion coefficient nu + 0.5*(a+b)/sigma */
     115              : static inline __m256d avx2_gamma(__m256d nu, __m256d a, __m256d b, __m256d sigma) {
     116              :     __m256d half = _mm256_set1_pd(0.5);
     117              :     return _mm256_add_pd(nu, _mm256_div_pd(
     118              :         _mm256_mul_pd(half, _mm256_add_pd(a, b)), sigma));
     119              : }
     120              : #endif
     121              : 
     122              : /* AVX2 k-epsilon transport kernel: i-vectorized with scalar tail, OMP over j */
     123            0 : static void turb_kepsilon_step_avx2(const flow_field* field, const grid* grid,
     124              :                                     const ns_solver_params_t* params, double dt,
     125              :                                     double* k_new, double* eps_new) {
     126            0 :     size_t nx = field->nx;
     127            0 :     size_t ny = field->ny;
     128              : 
     129            0 :     const double dx = grid->dx[0];
     130            0 :     const double dy = grid->dy[0];
     131            0 :     const double inv_dx = 1.0 / dx;
     132            0 :     const double inv_dy = 1.0 / dy;
     133            0 :     const double inv_2dx = 0.5 * inv_dx;
     134            0 :     const double inv_2dy = 0.5 * inv_dy;
     135            0 :     const double inv_dx2 = inv_dx * inv_dx;
     136            0 :     const double inv_dy2 = inv_dy * inv_dy;
     137              : 
     138              : #if USE_AVX
     139              :     const double* u = field->u;
     140              :     const double* v = field->v;
     141              :     const double* k = field->turb_k;
     142              :     const double* eps = field->turb_eps;
     143              :     const double* nu_t = field->nu_t;
     144              :     const double* rho = field->rho;
     145              : 
     146              :     const __m256d v_mu = _mm256_set1_pd(params->mu);
     147              :     const __m256d v_rho_min = _mm256_set1_pd(1e-10);
     148              :     const __m256d v_k_min = _mm256_set1_pd(TURB_K_MIN);
     149              :     const __m256d v_eps_min = _mm256_set1_pd(TURB_EPS_MIN);
     150              :     const __m256d v_prod_lim = _mm256_set1_pd(TURB_PROD_LIMIT_FACTOR);
     151              :     const __m256d v_sigma_k = _mm256_set1_pd(TURB_SIGMA_K);
     152              :     const __m256d v_sigma_e = _mm256_set1_pd(TURB_SIGMA_EPS);
     153              :     const __m256d v_c1 = _mm256_set1_pd(TURB_C1_EPS);
     154              :     const __m256d v_c2 = _mm256_set1_pd(TURB_C2_EPS);
     155              :     const __m256d v_dt = _mm256_set1_pd(dt);
     156              :     const __m256d v_one = _mm256_set1_pd(1.0);
     157              :     const __m256d v_two = _mm256_set1_pd(2.0);
     158              :     const __m256d v_inv_dx = _mm256_set1_pd(inv_dx);
     159              :     const __m256d v_inv_dy = _mm256_set1_pd(inv_dy);
     160              :     const __m256d v_inv_2dx = _mm256_set1_pd(inv_2dx);
     161              :     const __m256d v_inv_2dy = _mm256_set1_pd(inv_2dy);
     162              :     const __m256d v_inv_dx2 = _mm256_set1_pd(inv_dx2);
     163              :     const __m256d v_inv_dy2 = _mm256_set1_pd(inv_dy2);
     164              : 
     165              :     int j;
     166              : #ifdef _OPENMP
     167              : #pragma omp parallel for schedule(static)
     168              : #endif
     169              :     for (j = 1; j < (int)ny - 1; j++) {
     170              :         size_t row = (size_t)j * nx;
     171              :         size_t i = 1;
     172              :         for (; i + 4 <= nx - 1; i += 4) {
     173              :             size_t idx = row + i;
     174              : 
     175              :             __m256d v_u = _mm256_loadu_pd(&u[idx]);
     176              :             __m256d v_v = _mm256_loadu_pd(&v[idx]);
     177              :             __m256d k_c0 = _mm256_loadu_pd(&k[idx]);
     178              :             __m256d k_w = _mm256_loadu_pd(&k[idx - 1]);
     179              :             __m256d k_e = _mm256_loadu_pd(&k[idx + 1]);
     180              :             __m256d k_s = _mm256_loadu_pd(&k[idx - nx]);
     181              :             __m256d k_n = _mm256_loadu_pd(&k[idx + nx]);
     182              :             __m256d e_c0 = _mm256_loadu_pd(&eps[idx]);
     183              :             __m256d e_w = _mm256_loadu_pd(&eps[idx - 1]);
     184              :             __m256d e_e = _mm256_loadu_pd(&eps[idx + 1]);
     185              :             __m256d e_s = _mm256_loadu_pd(&eps[idx - nx]);
     186              :             __m256d e_n = _mm256_loadu_pd(&eps[idx + nx]);
     187              :             __m256d nt_c = _mm256_loadu_pd(&nu_t[idx]);
     188              :             __m256d nt_w = _mm256_loadu_pd(&nu_t[idx - 1]);
     189              :             __m256d nt_e = _mm256_loadu_pd(&nu_t[idx + 1]);
     190              :             __m256d nt_s = _mm256_loadu_pd(&nu_t[idx - nx]);
     191              :             __m256d nt_n = _mm256_loadu_pd(&nu_t[idx + nx]);
     192              : 
     193              :             __m256d v_nu = _mm256_div_pd(v_mu,
     194              :                 _mm256_max_pd(_mm256_loadu_pd(&rho[idx]), v_rho_min));
     195              :             __m256d k_fl = _mm256_max_pd(k_c0, v_k_min);
     196              :             __m256d e_fl = _mm256_max_pd(e_c0, v_eps_min);
     197              : 
     198              :             /* Upwind advection */
     199              :             __m256d adv_k = _mm256_add_pd(
     200              :                 avx2_upwind(v_u, k_w, k_c0, k_e, v_inv_dx),
     201              :                 avx2_upwind(v_v, k_s, k_c0, k_n, v_inv_dy));
     202              :             __m256d adv_e = _mm256_add_pd(
     203              :                 avx2_upwind(v_u, e_w, e_c0, e_e, v_inv_dx),
     204              :                 avx2_upwind(v_v, e_s, e_c0, e_n, v_inv_dy));
     205              : 
     206              :             /* Conservative face-averaged diffusion */
     207              :             __m256d diff_k = _mm256_add_pd(
     208              :                 _mm256_mul_pd(_mm256_sub_pd(
     209              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_e, v_sigma_k),
     210              :                                   _mm256_sub_pd(k_e, k_c0)),
     211              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_w, v_sigma_k),
     212              :                                   _mm256_sub_pd(k_c0, k_w))), v_inv_dx2),
     213              :                 _mm256_mul_pd(_mm256_sub_pd(
     214              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_n, v_sigma_k),
     215              :                                   _mm256_sub_pd(k_n, k_c0)),
     216              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_s, v_sigma_k),
     217              :                                   _mm256_sub_pd(k_c0, k_s))), v_inv_dy2));
     218              :             __m256d diff_e = _mm256_add_pd(
     219              :                 _mm256_mul_pd(_mm256_sub_pd(
     220              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_e, v_sigma_e),
     221              :                                   _mm256_sub_pd(e_e, e_c0)),
     222              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_w, v_sigma_e),
     223              :                                   _mm256_sub_pd(e_c0, e_w))), v_inv_dx2),
     224              :                 _mm256_mul_pd(_mm256_sub_pd(
     225              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_n, v_sigma_e),
     226              :                                   _mm256_sub_pd(e_n, e_c0)),
     227              :                     _mm256_mul_pd(avx2_gamma(v_nu, nt_c, nt_s, v_sigma_e),
     228              :                                   _mm256_sub_pd(e_c0, e_s))), v_inv_dy2));
     229              : 
     230              :             /* Production from central velocity gradients, limited */
     231              :             __m256d du_dx = _mm256_mul_pd(_mm256_sub_pd(
     232              :                 _mm256_loadu_pd(&u[idx + 1]), _mm256_loadu_pd(&u[idx - 1])), v_inv_2dx);
     233              :             __m256d du_dy = _mm256_mul_pd(_mm256_sub_pd(
     234              :                 _mm256_loadu_pd(&u[idx + nx]), _mm256_loadu_pd(&u[idx - nx])), v_inv_2dy);
     235              :             __m256d dv_dx = _mm256_mul_pd(_mm256_sub_pd(
     236              :                 _mm256_loadu_pd(&v[idx + 1]), _mm256_loadu_pd(&v[idx - 1])), v_inv_2dx);
     237              :             __m256d dv_dy = _mm256_mul_pd(_mm256_sub_pd(
     238              :                 _mm256_loadu_pd(&v[idx + nx]), _mm256_loadu_pd(&v[idx - nx])), v_inv_2dy);
     239              :             __m256d shear = _mm256_add_pd(du_dy, dv_dx);
     240              :             __m256d S2 = _mm256_add_pd(
     241              :                 _mm256_add_pd(
     242              :                     _mm256_mul_pd(v_two, _mm256_mul_pd(du_dx, du_dx)),
     243              :                     _mm256_mul_pd(v_two, _mm256_mul_pd(dv_dy, dv_dy))),
     244              :                 _mm256_mul_pd(shear, shear));
     245              :             __m256d P_k = _mm256_min_pd(_mm256_mul_pd(nt_c, S2),
     246              :                                         _mm256_mul_pd(v_prod_lim, e_fl));
     247              : 
     248              :             /* Patankar semi-implicit updates */
     249              :             __m256d eok = _mm256_div_pd(e_fl, k_fl);
     250              :             __m256d k_rhs = _mm256_add_pd(k_c0, _mm256_mul_pd(v_dt,
     251              :                 _mm256_add_pd(_mm256_sub_pd(diff_k, adv_k), P_k)));
     252              :             __m256d k_upd = _mm256_div_pd(k_rhs,
     253              :                 _mm256_add_pd(v_one, _mm256_mul_pd(v_dt, eok)));
     254              :             __m256d e_src = _mm256_mul_pd(v_c1, _mm256_mul_pd(eok, P_k));
     255              :             __m256d e_rhs = _mm256_add_pd(e_c0, _mm256_mul_pd(v_dt,
     256              :                 _mm256_add_pd(_mm256_sub_pd(diff_e, adv_e), e_src)));
     257              :             __m256d e_upd = _mm256_div_pd(e_rhs,
     258              :                 _mm256_add_pd(v_one, _mm256_mul_pd(v_dt, _mm256_mul_pd(v_c2, eok))));
     259              : 
     260              :             _mm256_storeu_pd(&k_new[idx], _mm256_max_pd(k_upd, v_k_min));
     261              :             _mm256_storeu_pd(&eps_new[idx], _mm256_max_pd(e_upd, v_eps_min));
     262              :         }
     263              :         /* Scalar remainder tail */
     264              :         for (; i < nx - 1; i++) {
     265              :             kepsilon_point(field, params, row + i, nx, dt, inv_dx, inv_dy,
     266              :                            inv_2dx, inv_2dy, inv_dx2, inv_dy2, k_new, eps_new);
     267              :         }
     268              :     }
     269              : #else
     270            0 :     int j;
     271              : #ifdef _OPENMP
     272            0 : #pragma omp parallel for schedule(static)
     273              : #endif
     274              :     for (j = 1; j < (int)ny - 1; j++) {
     275              :         for (size_t i = 1; i < nx - 1; i++) {
     276              :             kepsilon_point(field, params, (size_t)j * nx + i, nx, dt, inv_dx, inv_dy,
     277              :                            inv_2dx, inv_2dy, inv_dx2, inv_dy2, k_new, eps_new);
     278              :         }
     279              :     }
     280              : #endif
     281            0 : }
     282              : 
     283              : /* SA transport: OMP-parallel scalar rows (see file header for rationale).
     284              :  * Numerics identical to turb_sa_step_scalar. */
     285            0 : static void turb_sa_step_avx2(const flow_field* field, const grid* grid,
     286              :                               const ns_solver_params_t* params, double dt,
     287              :                               double* nt_new) {
     288            0 :     size_t nx = field->nx;
     289            0 :     size_t ny = field->ny;
     290              : 
     291            0 :     const double dx = grid->dx[0];
     292            0 :     const double dy = grid->dy[0];
     293            0 :     const double inv_dx = 1.0 / dx;
     294            0 :     const double inv_dy = 1.0 / dy;
     295            0 :     const double inv_2dx = 0.5 * inv_dx;
     296            0 :     const double inv_2dy = 0.5 * inv_dy;
     297            0 :     const double inv_dx2 = inv_dx * inv_dx;
     298            0 :     const double inv_dy2 = inv_dy * inv_dy;
     299              : 
     300            0 :     const double* u = field->u;
     301            0 :     const double* v = field->v;
     302            0 :     const double* nt = field->turb_nu_tilde;
     303            0 :     const double cv1_3 = SA_CV1 * SA_CV1 * SA_CV1;
     304              : 
     305            0 :     int j;
     306              : #ifdef _OPENMP
     307            0 : #pragma omp parallel for schedule(static)
     308              : #endif
     309              :     for (j = 1; j < (int)ny - 1; j++) {
     310              :         for (int i = 1; i < (int)nx - 1; i++) {
     311              :             size_t idx = IDX_2D((size_t)i, (size_t)j, nx);
     312              : 
     313              :             double nu = params->mu / fmax(field->rho[idx], 1e-10);
     314              :             double u_c = u[idx];
     315              :             double v_c = v[idx];
     316              :             double nt_c = fmax(nt[idx], 0.0);
     317              : 
     318              :             double chi = nt_c / nu;
     319              :             double chi3 = chi * chi * chi;
     320              :             double fv1 = chi3 / (chi3 + cv1_3);
     321              :             double fv2 = 1.0 - chi / (1.0 + chi * fv1);
     322              : 
     323              :             double du_dy = (u[idx + nx] - u[idx - nx]) * inv_2dy;
     324              :             double dv_dx = (v[idx + 1] - v[idx - 1]) * inv_2dx;
     325              :             double omega = fabs(dv_dx - du_dy);
     326              : 
     327              :             int has_wall = 0;
     328              :             double d = turb_wall_distance(grid, &params->turb_bc, (size_t)i, (size_t)j,
     329              :                                           &has_wall);
     330              :             double s_tilde = omega;
     331              :             double destr_rate = 0.0;
     332              :             if (has_wall && d > 1e-12) {
     333              :                 double inv_kd2 = 1.0 / (SA_KAPPA * SA_KAPPA * d * d);
     334              :                 s_tilde = fmax(omega + nt_c * fv2 * inv_kd2, 0.3 * omega);
     335              : 
     336              :                 double r = fmin(nt_c / (s_tilde * SA_KAPPA * SA_KAPPA * d * d + 1e-16),
     337              :                                 10.0);
     338              :                 double r6 = pow(r, 6.0);
     339              :                 double g = r + SA_CW2 * (r6 - r);
     340              :                 double g6 = pow(g, 6.0);
     341              :                 double cw3_6 = pow(SA_CW3, 6.0);
     342              :                 double fw = g * pow((1.0 + cw3_6) / (g6 + cw3_6), 1.0 / 6.0);
     343              : 
     344              :                 destr_rate = SA_CW1 * fw * nt_c / (d * d);
     345              :             }
     346              : 
     347              :             double adv = (u_c > 0.0 ? u_c * (nt[idx] - nt[idx - 1]) * inv_dx
     348              :                                     : u_c * (nt[idx + 1] - nt[idx]) * inv_dx) +
     349              :                          (v_c > 0.0 ? v_c * (nt[idx] - nt[idx - nx]) * inv_dy
     350              :                                     : v_c * (nt[idx + nx] - nt[idx]) * inv_dy);
     351              : 
     352              :             double gam_e = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx + 1], 0.0))) / SA_SIGMA;
     353              :             double gam_w = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx - 1], 0.0))) / SA_SIGMA;
     354              :             double gam_n = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx + nx], 0.0))) / SA_SIGMA;
     355              :             double gam_s = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx - nx], 0.0))) / SA_SIGMA;
     356              :             double diff = (gam_e * (nt[idx + 1] - nt[idx]) -
     357              :                            gam_w * (nt[idx] - nt[idx - 1])) * inv_dx2 +
     358              :                           (gam_n * (nt[idx + nx] - nt[idx]) -
     359              :                            gam_s * (nt[idx] - nt[idx - nx])) * inv_dy2;
     360              : 
     361              :             double dnt_dx = (nt[idx + 1] - nt[idx - 1]) * inv_2dx;
     362              :             double dnt_dy = (nt[idx + nx] - nt[idx - nx]) * inv_2dy;
     363              :             double grad2 = (SA_CB2 / SA_SIGMA) * (dnt_dx * dnt_dx + dnt_dy * dnt_dy);
     364              : 
     365              :             double prod = SA_CB1 * s_tilde * nt_c;
     366              : 
     367              :             double nt_upd = (nt[idx] + dt * (-adv + diff + grad2 + prod)) /
     368              :                             (1.0 + dt * destr_rate);
     369              : 
     370              :             nt_new[idx] = fmax(nt_upd, 0.0);
     371              :         }
     372              :     }
     373            0 : }
     374              : 
     375            0 : cfd_status_t turbulence_step_explicit_avx2_with_workspace(
     376              :     flow_field* field, const grid* grid,
     377              :     const ns_solver_params_t* params,
     378              :     double dt, double time,
     379              :     double* workspace, size_t workspace_size) {
     380            0 :     (void)time;
     381              : 
     382            0 :     if (!params) {
     383            0 :         cfd_set_error(CFD_ERROR_INVALID,
     384              :                       "turbulence_solver_avx2: params must be non-NULL");
     385            0 :         return CFD_ERROR_INVALID;
     386              :     }
     387              :     /* Checked before the disabled-model exit below: a correction configured
     388              :      * against no turbulence model is refused here exactly as it is at solver
     389              :      * init, rather than silently skipped because the step has nothing to do. */
     390            0 :     cfd_status_t status = turb_check_closure_config(params);
     391            0 :     if (status != CFD_SUCCESS) {
     392              :         return status;
     393              :     }
     394            0 :     if (params->turb_model == TURB_MODEL_NONE) {
     395              :         return CFD_SUCCESS;
     396              :     }
     397              : 
     398            0 :     status = turb_validate_step_args(field, grid, params);
     399            0 :     if (status != CFD_SUCCESS) {
     400              :         return status;
     401              :     }
     402              : 
     403            0 :     size_t total = field->nx * field->ny * field->nz;
     404              : 
     405            0 :     int owns_buffer = 0;
     406            0 :     double* buf;
     407            0 :     if (workspace && workspace_size >= TURB_WORKSPACE_SIZE(total)) {
     408              :         buf = workspace;
     409              :     } else {
     410            0 :         buf = (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double));
     411            0 :         if (!buf) {
     412              :             return CFD_ERROR_NOMEM;
     413              :         }
     414              :         owns_buffer = 1;
     415              :     }
     416              : 
     417            0 :     if (params->turb_model == TURB_MODEL_K_EPSILON) {
     418            0 :         double* k_new = buf;
     419            0 :         double* eps_new = buf + total;
     420            0 :         memcpy(k_new, field->turb_k, total * sizeof(double));
     421            0 :         memcpy(eps_new, field->turb_eps, total * sizeof(double));
     422              : 
     423            0 :         turb_kepsilon_step_avx2(field, grid, params, dt, k_new, eps_new);
     424              : 
     425            0 :         for (size_t n = 0; n < total; n++) {
     426            0 :             if (!isfinite(k_new[n]) || !isfinite(eps_new[n])) {
     427            0 :                 cfd_set_error(CFD_ERROR_DIVERGED,
     428              :                               "NaN/Inf detected in turbulence_step_explicit_avx2 (k-epsilon)");
     429            0 :                 if (owns_buffer) cfd_free(buf);
     430            0 :                 return CFD_ERROR_DIVERGED;
     431              :             }
     432              :         }
     433            0 :         memcpy(field->turb_k, k_new, total * sizeof(double));
     434            0 :         memcpy(field->turb_eps, eps_new, total * sizeof(double));
     435              :     } else {
     436            0 :         double* nt_new = buf;
     437            0 :         memcpy(nt_new, field->turb_nu_tilde, total * sizeof(double));
     438              : 
     439            0 :         turb_sa_step_avx2(field, grid, params, dt, nt_new);
     440              : 
     441            0 :         for (size_t n = 0; n < total; n++) {
     442            0 :             if (!isfinite(nt_new[n])) {
     443            0 :                 cfd_set_error(CFD_ERROR_DIVERGED,
     444              :                               "NaN/Inf detected in turbulence_step_explicit_avx2 (SA)");
     445            0 :                 if (owns_buffer) cfd_free(buf);
     446            0 :                 return CFD_ERROR_DIVERGED;
     447              :             }
     448              :         }
     449            0 :         memcpy(field->turb_nu_tilde, nt_new, total * sizeof(double));
     450              :     }
     451              : 
     452            0 :     turb_update_nu_t(field, params);
     453            0 :     cfd_status_t closure_status = turb_apply_nu_t_correction(field, grid, params);
     454              : 
     455            0 :     if (owns_buffer) cfd_free(buf);
     456              :     return closure_status;
     457              : }
        

Generated by: LCOV version 2.0-1