Line data Source code
1 : /**
2 : * @file turbulence_solver_omp.c
3 : * @brief OpenMP-parallelized RANS turbulence transport step
4 : *
5 : * Same numerics as the scalar reference (turbulence/cpu/turbulence_kepsilon.c
6 : * and turbulence_sa.c); the interior stencil loops are parallelized over j.
7 : * Read/write separation (reads field arrays, writes the workspace buffers)
8 : * makes the loops race-free. Validation, nu_t update, boundary conditions,
9 : * and wall functions are shared with the scalar backend (boundary-only work).
10 : *
11 : * This file is always compiled (like the AVX2 backend). It uses only #pragma
12 : * omp directives — no OpenMP runtime calls — so when OpenMP is unavailable the
13 : * pragmas are ignored and the interior loops run serially. The entry point
14 : * therefore always provides a correct implementation, and the OMP-named symbol
15 : * is present regardless of whether the toolchain supports OpenMP.
16 : */
17 :
18 : #include "../turbulence_solver_internal.h"
19 :
20 : #include "cfd/core/indexing.h"
21 : #include "cfd/core/memory.h"
22 :
23 : #include <math.h>
24 : #include <stddef.h>
25 : #include <string.h>
26 :
27 : #ifdef _OPENMP
28 : #include <omp.h>
29 : #endif
30 :
31 : /* OMP k-epsilon transport kernel — numerics identical to
32 : * turb_kepsilon_step_scalar, j-loop parallelized. */
33 0 : static void turb_kepsilon_step_omp(const flow_field* field, const grid* grid,
34 : const ns_solver_params_t* params, double dt,
35 : double* k_new, double* eps_new) {
36 0 : size_t nx = field->nx;
37 0 : size_t ny = field->ny;
38 :
39 0 : const double dx = grid->dx[0];
40 0 : const double dy = grid->dy[0];
41 0 : const double inv_dx = 1.0 / dx;
42 0 : const double inv_dy = 1.0 / dy;
43 0 : const double inv_2dx = 0.5 * inv_dx;
44 0 : const double inv_2dy = 0.5 * inv_dy;
45 0 : const double inv_dx2 = inv_dx * inv_dx;
46 0 : const double inv_dy2 = inv_dy * inv_dy;
47 :
48 0 : const double* u = field->u;
49 0 : const double* v = field->v;
50 0 : const double* k = field->turb_k;
51 0 : const double* eps = field->turb_eps;
52 0 : const double* nu_t = field->nu_t;
53 :
54 0 : int j;
55 0 : #pragma omp parallel for schedule(static)
56 : for (j = 1; j < (int)ny - 1; j++) {
57 : for (int i = 1; i < (int)nx - 1; i++) {
58 : size_t idx = IDX_2D((size_t)i, (size_t)j, nx);
59 :
60 : double nu = params->mu / fmax(field->rho[idx], 1e-10);
61 : double u_c = u[idx];
62 : double v_c = v[idx];
63 : double k_c = fmax(k[idx], TURB_K_MIN);
64 : double eps_c = fmax(eps[idx], TURB_EPS_MIN);
65 :
66 : /* First-order upwind advection */
67 : double adv_k = (u_c > 0.0 ? u_c * (k[idx] - k[idx - 1]) * inv_dx
68 : : u_c * (k[idx + 1] - k[idx]) * inv_dx) +
69 : (v_c > 0.0 ? v_c * (k[idx] - k[idx - nx]) * inv_dy
70 : : v_c * (k[idx + nx] - k[idx]) * inv_dy);
71 : double adv_e = (u_c > 0.0 ? u_c * (eps[idx] - eps[idx - 1]) * inv_dx
72 : : u_c * (eps[idx + 1] - eps[idx]) * inv_dx) +
73 : (v_c > 0.0 ? v_c * (eps[idx] - eps[idx - nx]) * inv_dy
74 : : v_c * (eps[idx + nx] - eps[idx]) * inv_dy);
75 :
76 : /* Conservative face-averaged diffusion */
77 : double gam_e_k = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]) / TURB_SIGMA_K;
78 : double gam_w_k = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]) / TURB_SIGMA_K;
79 : double gam_n_k = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]) / TURB_SIGMA_K;
80 : double gam_s_k = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]) / TURB_SIGMA_K;
81 : double diff_k = (gam_e_k * (k[idx + 1] - k[idx]) -
82 : gam_w_k * (k[idx] - k[idx - 1])) * inv_dx2 +
83 : (gam_n_k * (k[idx + nx] - k[idx]) -
84 : gam_s_k * (k[idx] - k[idx - nx])) * inv_dy2;
85 :
86 : double gam_e_e = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]) / TURB_SIGMA_EPS;
87 : double gam_w_e = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]) / TURB_SIGMA_EPS;
88 : double gam_n_e = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]) / TURB_SIGMA_EPS;
89 : double gam_s_e = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]) / TURB_SIGMA_EPS;
90 : double diff_e = (gam_e_e * (eps[idx + 1] - eps[idx]) -
91 : gam_w_e * (eps[idx] - eps[idx - 1])) * inv_dx2 +
92 : (gam_n_e * (eps[idx + nx] - eps[idx]) -
93 : gam_s_e * (eps[idx] - eps[idx - nx])) * inv_dy2;
94 :
95 : /* Production from central velocity gradients, limited */
96 : double du_dx = (u[idx + 1] - u[idx - 1]) * inv_2dx;
97 : double du_dy = (u[idx + nx] - u[idx - nx]) * inv_2dy;
98 : double dv_dx = (v[idx + 1] - v[idx - 1]) * inv_2dx;
99 : double dv_dy = (v[idx + nx] - v[idx - nx]) * inv_2dy;
100 : double S2 = 2.0 * du_dx * du_dx + 2.0 * dv_dy * dv_dy +
101 : (du_dy + dv_dx) * (du_dy + dv_dx);
102 : double P_k = fmin(nu_t[idx] * S2, TURB_PROD_LIMIT_FACTOR * eps_c);
103 :
104 : /* Patankar semi-implicit updates: sink terms cannot cross zero */
105 : double eps_over_k = eps_c / k_c;
106 : double k_upd = (k[idx] + dt * (-adv_k + diff_k + P_k)) /
107 : (1.0 + dt * eps_over_k);
108 : double e_upd = (eps[idx] + dt * (-adv_e + diff_e +
109 : TURB_C1_EPS * eps_over_k * P_k)) /
110 : (1.0 + dt * TURB_C2_EPS * eps_over_k);
111 :
112 : k_new[idx] = fmax(k_upd, TURB_K_MIN);
113 : eps_new[idx] = fmax(e_upd, TURB_EPS_MIN);
114 : }
115 : }
116 0 : }
117 :
118 : /* OMP Spalart-Allmaras transport kernel — numerics identical to
119 : * turb_sa_step_scalar, j-loop parallelized. */
120 0 : static void turb_sa_step_omp(const flow_field* field, const grid* grid,
121 : const ns_solver_params_t* params, double dt,
122 : double* nt_new) {
123 0 : size_t nx = field->nx;
124 0 : size_t ny = field->ny;
125 :
126 0 : const double dx = grid->dx[0];
127 0 : const double dy = grid->dy[0];
128 0 : const double inv_dx = 1.0 / dx;
129 0 : const double inv_dy = 1.0 / dy;
130 0 : const double inv_2dx = 0.5 * inv_dx;
131 0 : const double inv_2dy = 0.5 * inv_dy;
132 0 : const double inv_dx2 = inv_dx * inv_dx;
133 0 : const double inv_dy2 = inv_dy * inv_dy;
134 :
135 0 : const double* u = field->u;
136 0 : const double* v = field->v;
137 0 : const double* nt = field->turb_nu_tilde;
138 0 : const double cv1_3 = SA_CV1 * SA_CV1 * SA_CV1;
139 :
140 0 : int j;
141 0 : #pragma omp parallel for schedule(static)
142 : for (j = 1; j < (int)ny - 1; j++) {
143 : for (int i = 1; i < (int)nx - 1; i++) {
144 : size_t idx = IDX_2D((size_t)i, (size_t)j, nx);
145 :
146 : double nu = params->mu / fmax(field->rho[idx], 1e-10);
147 : double u_c = u[idx];
148 : double v_c = v[idx];
149 : double nt_c = fmax(nt[idx], 0.0);
150 :
151 : /* Closure functions */
152 : double chi = nt_c / nu;
153 : double chi3 = chi * chi * chi;
154 : double fv1 = chi3 / (chi3 + cv1_3);
155 : double fv2 = 1.0 - chi / (1.0 + chi * fv1);
156 :
157 : /* Vorticity magnitude (2D) */
158 : double du_dy = (u[idx + nx] - u[idx - nx]) * inv_2dy;
159 : double dv_dx = (v[idx + 1] - v[idx - 1]) * inv_2dx;
160 : double omega = fabs(dv_dx - du_dy);
161 :
162 : /* Wall distance and modified vorticity S_tilde */
163 : int has_wall = 0;
164 : double d = turb_wall_distance(grid, ¶ms->turb_bc, (size_t)i, (size_t)j,
165 : &has_wall);
166 : double s_tilde = omega;
167 : double destr_rate = 0.0; /* cw1*fw*nt/d^2, the Patankar sink rate */
168 : if (has_wall && d > 1e-12) {
169 : double inv_kd2 = 1.0 / (SA_KAPPA * SA_KAPPA * d * d);
170 : s_tilde = fmax(omega + nt_c * fv2 * inv_kd2, 0.3 * omega);
171 :
172 : double r = fmin(nt_c / (s_tilde * SA_KAPPA * SA_KAPPA * d * d + 1e-16),
173 : 10.0);
174 : double r6 = pow(r, 6.0);
175 : double g = r + SA_CW2 * (r6 - r);
176 : double g6 = pow(g, 6.0);
177 : double cw3_6 = pow(SA_CW3, 6.0);
178 : double fw = g * pow((1.0 + cw3_6) / (g6 + cw3_6), 1.0 / 6.0);
179 :
180 : destr_rate = SA_CW1 * fw * nt_c / (d * d);
181 : }
182 :
183 : /* First-order upwind advection */
184 : double adv = (u_c > 0.0 ? u_c * (nt[idx] - nt[idx - 1]) * inv_dx
185 : : u_c * (nt[idx + 1] - nt[idx]) * inv_dx) +
186 : (v_c > 0.0 ? v_c * (nt[idx] - nt[idx - nx]) * inv_dy
187 : : v_c * (nt[idx + nx] - nt[idx]) * inv_dy);
188 :
189 : /* Conservative face-averaged diffusion + cb2 gradient-squared term */
190 : double gam_e = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx + 1], 0.0))) / SA_SIGMA;
191 : double gam_w = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx - 1], 0.0))) / SA_SIGMA;
192 : double gam_n = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx + nx], 0.0))) / SA_SIGMA;
193 : double gam_s = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx - nx], 0.0))) / SA_SIGMA;
194 : double diff = (gam_e * (nt[idx + 1] - nt[idx]) -
195 : gam_w * (nt[idx] - nt[idx - 1])) * inv_dx2 +
196 : (gam_n * (nt[idx + nx] - nt[idx]) -
197 : gam_s * (nt[idx] - nt[idx - nx])) * inv_dy2;
198 :
199 : double dnt_dx = (nt[idx + 1] - nt[idx - 1]) * inv_2dx;
200 : double dnt_dy = (nt[idx + nx] - nt[idx - nx]) * inv_2dy;
201 : double grad2 = (SA_CB2 / SA_SIGMA) * (dnt_dx * dnt_dx + dnt_dy * dnt_dy);
202 :
203 : /* Production */
204 : double prod = SA_CB1 * s_tilde * nt_c;
205 :
206 : /* Patankar semi-implicit update: destruction cannot cross zero */
207 : double nt_upd = (nt[idx] + dt * (-adv + diff + grad2 + prod)) /
208 : (1.0 + dt * destr_rate);
209 :
210 : nt_new[idx] = fmax(nt_upd, 0.0);
211 : }
212 : }
213 0 : }
214 :
215 1186 : cfd_status_t turbulence_step_explicit_omp_with_workspace(
216 : flow_field* field, const grid* grid,
217 : const ns_solver_params_t* params,
218 : double dt, double time,
219 : double* workspace, size_t workspace_size) {
220 1186 : (void)time;
221 :
222 1186 : if (!params) {
223 0 : cfd_set_error(CFD_ERROR_INVALID,
224 : "turbulence_solver_omp: params must be non-NULL");
225 0 : return CFD_ERROR_INVALID;
226 : }
227 : /* Checked before the disabled-model exit below: a correction configured
228 : * against no turbulence model is refused here exactly as it is at solver
229 : * init, rather than silently skipped because the step has nothing to do. */
230 1186 : cfd_status_t status = turb_check_closure_config(params);
231 1186 : if (status != CFD_SUCCESS) {
232 : return status;
233 : }
234 1186 : if (params->turb_model == TURB_MODEL_NONE) {
235 : return CFD_SUCCESS;
236 : }
237 :
238 0 : status = turb_validate_step_args(field, grid, params);
239 0 : if (status != CFD_SUCCESS) {
240 : return status;
241 : }
242 :
243 0 : size_t total = field->nx * field->ny * field->nz;
244 :
245 0 : int owns_buffer = 0;
246 0 : double* buf;
247 0 : if (workspace && workspace_size >= TURB_WORKSPACE_SIZE(total)) {
248 : buf = workspace;
249 : } else {
250 0 : buf = (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double));
251 0 : if (!buf) {
252 : return CFD_ERROR_NOMEM;
253 : }
254 : owns_buffer = 1;
255 : }
256 :
257 0 : int has_nan = 0;
258 0 : ptrdiff_t total_int = (ptrdiff_t)total;
259 0 : ptrdiff_t n;
260 :
261 0 : if (params->turb_model == TURB_MODEL_K_EPSILON) {
262 0 : double* k_new = buf;
263 0 : double* eps_new = buf + total;
264 0 : memcpy(k_new, field->turb_k, total * sizeof(double));
265 0 : memcpy(eps_new, field->turb_eps, total * sizeof(double));
266 :
267 0 : turb_kepsilon_step_omp(field, grid, params, dt, k_new, eps_new);
268 :
269 0 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
270 : for (n = 0; n < total_int; n++) {
271 : if (!isfinite(k_new[n]) || !isfinite(eps_new[n])) {
272 : has_nan = 1;
273 : }
274 : }
275 0 : if (has_nan) {
276 0 : cfd_set_error(CFD_ERROR_DIVERGED,
277 : "NaN/Inf detected in turbulence_step_explicit_omp (k-epsilon)");
278 0 : if (owns_buffer) cfd_free(buf);
279 0 : return CFD_ERROR_DIVERGED;
280 : }
281 0 : memcpy(field->turb_k, k_new, total * sizeof(double));
282 0 : memcpy(field->turb_eps, eps_new, total * sizeof(double));
283 : } else {
284 0 : double* nt_new = buf;
285 0 : memcpy(nt_new, field->turb_nu_tilde, total * sizeof(double));
286 :
287 0 : turb_sa_step_omp(field, grid, params, dt, nt_new);
288 :
289 0 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
290 : for (n = 0; n < total_int; n++) {
291 : if (!isfinite(nt_new[n])) {
292 : has_nan = 1;
293 : }
294 : }
295 0 : if (has_nan) {
296 0 : cfd_set_error(CFD_ERROR_DIVERGED,
297 : "NaN/Inf detected in turbulence_step_explicit_omp (SA)");
298 0 : if (owns_buffer) cfd_free(buf);
299 0 : return CFD_ERROR_DIVERGED;
300 : }
301 0 : memcpy(field->turb_nu_tilde, nt_new, total * sizeof(double));
302 : }
303 :
304 0 : turb_update_nu_t(field, params);
305 0 : cfd_status_t closure_status = turb_apply_nu_t_correction(field, grid, params);
306 :
307 0 : if (owns_buffer) cfd_free(buf);
308 : return closure_status;
309 : }
|