LCOV - code coverage report
Current view: top level - solvers/turbulence/omp - turbulence_solver_omp.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 7.4 % 81 6
Test Date: 2026-10-05 04:47:18 Functions: 33.3 % 3 1

            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, &params->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              : }
        

Generated by: LCOV version 2.0-1