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, ¶ms->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 : }
|