LCOV - code coverage report
Current view: top level - solvers/turbulence/cpu - turbulence_sa.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 100.0 % 63 63
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 1 1

            Line data    Source code
       1              : /**
       2              :  * @file turbulence_sa.c
       3              :  * @brief Scalar CPU kernel for the Spalart-Allmaras transport equation
       4              :  *
       5              :  * No-ft2 (fully turbulent) variant — the trip terms only matter for laminar-
       6              :  * turbulent transition prediction and are omitted by virtually all RANS
       7              :  * solvers by default:
       8              :  *
       9              :  * dnt/dt + u*grad(nt) = (1/sigma)[div((nu+nt) grad nt) + cb2*|grad nt|^2]
      10              :  *                       + cb1*S_tilde*nt - cw1*fw*(nt/d)^2
      11              :  *
      12              :  * First-order upwind advection, conservative face-averaged diffusion, and
      13              :  * semi-implicit (Patankar) destruction so nt can never cross zero. Cells with
      14              :  * no wall-function wall configured (has_wall == 0) drop the wall-destruction
      15              :  * and fv2 near-wall terms entirely (S_tilde = Omega).
      16              :  */
      17              : 
      18              : #include "../turbulence_solver_internal.h"
      19              : 
      20              : #include "cfd/core/indexing.h"
      21              : 
      22              : #include <math.h>
      23              : 
      24          622 : void turb_sa_step_scalar(const flow_field* field, const grid* grid,
      25              :                          const ns_solver_params_t* params, double dt,
      26              :                          double* nt_new) {
      27          622 :     size_t nx = field->nx;
      28          622 :     size_t ny = field->ny;
      29              : 
      30          622 :     const double dx = grid->dx[0];
      31          622 :     const double dy = grid->dy[0];
      32          622 :     const double inv_dx = 1.0 / dx;
      33          622 :     const double inv_dy = 1.0 / dy;
      34          622 :     const double inv_2dx = 0.5 * inv_dx;
      35          622 :     const double inv_2dy = 0.5 * inv_dy;
      36          622 :     const double inv_dx2 = inv_dx * inv_dx;
      37          622 :     const double inv_dy2 = inv_dy * inv_dy;
      38              : 
      39          622 :     const double* u = field->u;
      40          622 :     const double* v = field->v;
      41          622 :     const double* nt = field->turb_nu_tilde;
      42          622 :     const double cv1_3 = SA_CV1 * SA_CV1 * SA_CV1;
      43              : 
      44         5124 :     for (size_t j = 1; j < ny - 1; j++) {
      45        38096 :         for (size_t i = 1; i < nx - 1; i++) {
      46        33594 :             size_t idx = IDX_2D(i, j, nx);
      47              : 
      48        33594 :             double nu = params->mu / fmax(field->rho[idx], 1e-10);
      49        33594 :             double u_c = u[idx];
      50        33594 :             double v_c = v[idx];
      51        33594 :             double nt_c = fmax(nt[idx], 0.0);
      52              : 
      53              :             /* Closure functions */
      54        33594 :             double chi = nt_c / nu;
      55        33594 :             double chi3 = chi * chi * chi;
      56        33594 :             double fv1 = chi3 / (chi3 + cv1_3);
      57        33594 :             double fv2 = 1.0 - chi / (1.0 + chi * fv1);
      58              : 
      59              :             /* Vorticity magnitude (2D) */
      60        33594 :             double du_dy = (u[idx + nx] - u[idx - nx]) * inv_2dy;
      61        33594 :             double dv_dx = (v[idx + 1] - v[idx - 1]) * inv_2dx;
      62        33594 :             double omega = fabs(dv_dx - du_dy);
      63              : 
      64              :             /* Wall distance and modified vorticity S_tilde */
      65        33594 :             int has_wall = 0;
      66        33594 :             double d = turb_wall_distance(grid, &params->turb_bc, i, j, &has_wall);
      67        33594 :             double s_tilde = omega;
      68        33594 :             double destr_rate = 0.0; /* cw1*fw*nt/d^2, the Patankar sink rate */
      69        33594 :             if (has_wall && d > 1e-12) {
      70        28469 :                 double inv_kd2 = 1.0 / (SA_KAPPA * SA_KAPPA * d * d);
      71        28469 :                 s_tilde = fmax(omega + nt_c * fv2 * inv_kd2, 0.3 * omega);
      72              : 
      73        28469 :                 double r = fmin(nt_c / (s_tilde * SA_KAPPA * SA_KAPPA * d * d + 1e-16),
      74              :                                 10.0);
      75        28469 :                 double r6 = pow(r, 6.0);
      76        28469 :                 double g = r + SA_CW2 * (r6 - r);
      77        28469 :                 double g6 = pow(g, 6.0);
      78        28469 :                 double cw3_6 = pow(SA_CW3, 6.0);
      79        28469 :                 double fw = g * pow((1.0 + cw3_6) / (g6 + cw3_6), 1.0 / 6.0);
      80              : 
      81        28469 :                 destr_rate = SA_CW1 * fw * nt_c / (d * d);
      82              :             }
      83              : 
      84              :             /* First-order upwind advection */
      85        93981 :             double adv = (u_c > 0.0 ? u_c * (nt[idx] - nt[idx - 1]) * inv_dx
      86        33594 :                                     : u_c * (nt[idx + 1] - nt[idx]) * inv_dx) +
      87         1780 :                          (v_c > 0.0 ? v_c * (nt[idx] - nt[idx - nx]) * inv_dy
      88        33594 :                                     : v_c * (nt[idx + nx] - nt[idx]) * inv_dy);
      89              : 
      90              :             /* Conservative face-averaged diffusion + cb2 gradient-squared term */
      91        33594 :             double gam_e = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx + 1], 0.0))) / SA_SIGMA;
      92        33594 :             double gam_w = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx - 1], 0.0))) / SA_SIGMA;
      93        33594 :             double gam_n = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx + nx], 0.0))) / SA_SIGMA;
      94        33594 :             double gam_s = (nu + 0.5 * (fmax(nt[idx], 0.0) + fmax(nt[idx - nx], 0.0))) / SA_SIGMA;
      95        33594 :             double diff = (gam_e * (nt[idx + 1] - nt[idx]) -
      96        33594 :                            gam_w * (nt[idx] - nt[idx - 1])) * inv_dx2 +
      97        33594 :                           (gam_n * (nt[idx + nx] - nt[idx]) -
      98        33594 :                            gam_s * (nt[idx] - nt[idx - nx])) * inv_dy2;
      99              : 
     100        33594 :             double dnt_dx = (nt[idx + 1] - nt[idx - 1]) * inv_2dx;
     101        33594 :             double dnt_dy = (nt[idx + nx] - nt[idx - nx]) * inv_2dy;
     102        33594 :             double grad2 = (SA_CB2 / SA_SIGMA) * (dnt_dx * dnt_dx + dnt_dy * dnt_dy);
     103              : 
     104              :             /* Production */
     105        33594 :             double prod = SA_CB1 * s_tilde * nt_c;
     106              : 
     107              :             /* Patankar semi-implicit update: destruction cannot cross zero */
     108        33594 :             double nt_upd = (nt[idx] + dt * (-adv + diff + grad2 + prod)) /
     109        33594 :                             (1.0 + dt * destr_rate);
     110              : 
     111        33594 :             nt_new[idx] = fmax(nt_upd, 0.0);
     112              :         }
     113              :     }
     114          622 : }
        

Generated by: LCOV version 2.0-1