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

            Line data    Source code
       1              : /**
       2              :  * @file turbulence_kepsilon.c
       3              :  * @brief Scalar CPU kernel for the standard k-epsilon transport equations
       4              :  *
       5              :  * dk/dt   + u*grad(k)   = div((nu + nu_t/sigma_k) grad k)   + P_k - eps
       6              :  * deps/dt + u*grad(eps) = div((nu + nu_t/sigma_e) grad eps) + (eps/k)(C1*P_k - C2*eps)
       7              :  *
       8              :  * First-order upwind advection (positivity), conservative face-averaged
       9              :  * diffusion, production from central velocity gradients with the limiter
      10              :  * P_k <= 10*eps, and semi-implicit (Patankar) sink treatment: destruction is
      11              :  * written as (eps/k)*k_new resp. C2*(eps/k)*eps_new so the update divides by
      12              :  * (1 + dt*sink_rate) and can never cross zero. Floors keep k and eps positive.
      13              :  */
      14              : 
      15              : #include "../turbulence_solver_internal.h"
      16              : 
      17              : #include "cfd/core/indexing.h"
      18              : 
      19              : #include <math.h>
      20              : 
      21         1248 : void turb_kepsilon_step_scalar(const flow_field* field, const grid* grid,
      22              :                                const ns_solver_params_t* params, double dt,
      23              :                                double* k_new, double* eps_new) {
      24         1248 :     size_t nx = field->nx;
      25         1248 :     size_t ny = field->ny;
      26              : 
      27         1248 :     const double dx = grid->dx[0];
      28         1248 :     const double dy = grid->dy[0];
      29         1248 :     const double inv_dx = 1.0 / dx;
      30         1248 :     const double inv_dy = 1.0 / dy;
      31         1248 :     const double inv_2dx = 0.5 * inv_dx;
      32         1248 :     const double inv_2dy = 0.5 * inv_dy;
      33         1248 :     const double inv_dx2 = inv_dx * inv_dx;
      34         1248 :     const double inv_dy2 = inv_dy * inv_dy;
      35              : 
      36         1248 :     const double* u = field->u;
      37         1248 :     const double* v = field->v;
      38         1248 :     const double* k = field->turb_k;
      39         1248 :     const double* eps = field->turb_eps;
      40         1248 :     const double* nu_t = field->nu_t;
      41              : 
      42        10132 :     for (size_t j = 1; j < ny - 1; j++) {
      43        73152 :         for (size_t i = 1; i < nx - 1; i++) {
      44        64268 :             size_t idx = IDX_2D(i, j, nx);
      45              : 
      46        64268 :             double nu = params->mu / fmax(field->rho[idx], 1e-10);
      47        64268 :             double u_c = u[idx];
      48        64268 :             double v_c = v[idx];
      49        64268 :             double k_c = fmax(k[idx], TURB_K_MIN);
      50        64268 :             double eps_c = fmax(eps[idx], TURB_EPS_MIN);
      51              : 
      52              :             /* First-order upwind advection */
      53       132124 :             double adv_k = (u_c > 0.0 ? u_c * (k[idx] - k[idx - 1]) * inv_dx
      54        64268 :                                       : u_c * (k[idx + 1] - k[idx]) * inv_dx) +
      55         1803 :                            (v_c > 0.0 ? v_c * (k[idx] - k[idx - nx]) * inv_dy
      56        64268 :                                       : v_c * (k[idx + nx] - k[idx]) * inv_dy);
      57       132124 :             double adv_e = (u_c > 0.0 ? u_c * (eps[idx] - eps[idx - 1]) * inv_dx
      58        64268 :                                       : u_c * (eps[idx + 1] - eps[idx]) * inv_dx) +
      59         1803 :                            (v_c > 0.0 ? v_c * (eps[idx] - eps[idx - nx]) * inv_dy
      60        64268 :                                       : v_c * (eps[idx + nx] - eps[idx]) * inv_dy);
      61              : 
      62              :             /* Conservative face-averaged diffusion */
      63        64268 :             double gam_e_k = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]) / TURB_SIGMA_K;
      64        64268 :             double gam_w_k = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]) / TURB_SIGMA_K;
      65        64268 :             double gam_n_k = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]) / TURB_SIGMA_K;
      66        64268 :             double gam_s_k = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]) / TURB_SIGMA_K;
      67        64268 :             double diff_k = (gam_e_k * (k[idx + 1] - k[idx]) -
      68        64268 :                              gam_w_k * (k[idx] - k[idx - 1])) * inv_dx2 +
      69        64268 :                             (gam_n_k * (k[idx + nx] - k[idx]) -
      70        64268 :                              gam_s_k * (k[idx] - k[idx - nx])) * inv_dy2;
      71              : 
      72        64268 :             double gam_e_e = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]) / TURB_SIGMA_EPS;
      73        64268 :             double gam_w_e = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]) / TURB_SIGMA_EPS;
      74        64268 :             double gam_n_e = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]) / TURB_SIGMA_EPS;
      75        64268 :             double gam_s_e = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]) / TURB_SIGMA_EPS;
      76        64268 :             double diff_e = (gam_e_e * (eps[idx + 1] - eps[idx]) -
      77        64268 :                              gam_w_e * (eps[idx] - eps[idx - 1])) * inv_dx2 +
      78        64268 :                             (gam_n_e * (eps[idx + nx] - eps[idx]) -
      79        64268 :                              gam_s_e * (eps[idx] - eps[idx - nx])) * inv_dy2;
      80              : 
      81              :             /* Production from central velocity gradients, limited */
      82        64268 :             double du_dx = (u[idx + 1] - u[idx - 1]) * inv_2dx;
      83        64268 :             double du_dy = (u[idx + nx] - u[idx - nx]) * inv_2dy;
      84        64268 :             double dv_dx = (v[idx + 1] - v[idx - 1]) * inv_2dx;
      85        64268 :             double dv_dy = (v[idx + nx] - v[idx - nx]) * inv_2dy;
      86        64268 :             double S2 = 2.0 * du_dx * du_dx + 2.0 * dv_dy * dv_dy +
      87        64268 :                         (du_dy + dv_dx) * (du_dy + dv_dx);
      88        64268 :             double P_k = fmin(nu_t[idx] * S2, TURB_PROD_LIMIT_FACTOR * eps_c);
      89              : 
      90              :             /* Patankar semi-implicit updates: sink terms cannot cross zero */
      91        64268 :             double eps_over_k = eps_c / k_c;
      92        64268 :             double k_upd = (k[idx] + dt * (-adv_k + diff_k + P_k)) /
      93        64268 :                            (1.0 + dt * eps_over_k);
      94        64268 :             double e_upd = (eps[idx] + dt * (-adv_e + diff_e +
      95        64268 :                                              TURB_C1_EPS * eps_over_k * P_k)) /
      96        64268 :                            (1.0 + dt * TURB_C2_EPS * eps_over_k);
      97              : 
      98        64268 :             k_new[idx] = fmax(k_upd, TURB_K_MIN);
      99        64268 :             eps_new[idx] = fmax(e_upd, TURB_EPS_MIN);
     100              :         }
     101              :     }
     102         1248 : }
        

Generated by: LCOV version 2.0-1