LCOV - code coverage report
Current view: top level - solvers/navier_stokes/omp - solver_projection_omp.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 70.2 % 161 113
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 2 2

            Line data    Source code
       1              : #include "cfd/boundary/boundary_conditions.h"
       2              : #include "cfd/core/cfd_status.h"
       3              : #include "cfd/core/grid.h"
       4              : #include "cfd/core/indexing.h"
       5              : #include "cfd/core/memory.h"
       6              : #include "cfd/solvers/energy_solver.h"
       7              : #include "cfd/solvers/navier_stokes_solver.h"
       8              : #include "cfd/solvers/poisson_solver.h"
       9              : #include "cfd/solvers/turbulence_solver.h"
      10              : #include "../../energy/energy_solver_internal.h"
      11              : #include "../../linear/multigrid_internal.h"
      12              : #include "../../turbulence/turbulence_solver_internal.h"
      13              : 
      14              : #include "../boundary_copy_utils.h"
      15              : #include "../ns_convection_internal.h"
      16              : #include "../ns_pressure_internal.h"
      17              : 
      18              : #include <math.h>
      19              : #include <omp.h>
      20              : #include <stdio.h>
      21              : #include <string.h>
      22              : 
      23              : 
      24              : #ifndef M_PI
      25              : #define M_PI 3.14159265358979323846
      26              : #endif
      27              : 
      28              : // Physical limits
      29              : #define MAX_VELOCITY 100.0
      30              : 
      31              : /**
      32              :  * Turn the explicit increment in `star` into the implicit viscous one:
      33              :  *
      34              :  *     (I - theta*nu*dt*lap) delta = star - cur,   star = cur + delta
      35              :  *
      36              :  * on the OpenMP CG solver the projection owns. Same numerics as the scalar
      37              :  * implicit_viscous_component(); see ns_viscous_internal.h.
      38              :  */
      39          258 : static cfd_status_t implicit_viscous_component_omp(poisson_solver_t* viscous,
      40              :                                                    const double* cur, double* star,
      41              :                                                    double* rhs, double* delta,
      42              :                                                    size_t nx, size_t ny, size_t total,
      43              :                                                    size_t k_start, size_t k_end,
      44              :                                                    size_t stride_z) {
      45          258 :     double sigma = viscous->params.helmholtz_shift;
      46              : 
      47          258 :     memset(delta, 0, total * sizeof(double));
      48         1236 :     for (size_t kk = k_start; kk < k_end; kk++) {
      49          978 :         int j;
      50          978 : #pragma omp parallel for schedule(static)
      51              :         for (j = 1; j < (int)ny - 1; j++) {
      52              :             for (int i = 1; i < (int)nx - 1; i++) {
      53              :                 size_t idx = kk * stride_z + IDX_2D(i, j, nx);
      54              :                 rhs[idx] = -sigma * (star[idx] - cur[idx]);
      55              :             }
      56              :         }
      57              :     }
      58              : 
      59          258 :     poisson_solver_stats_t vstats = poisson_solver_stats_default();
      60          258 :     cfd_status_t status = poisson_solver_solve(viscous, delta, NULL, rhs, &vstats);
      61          258 :     if (status != CFD_SUCCESS) {
      62              :         return status;
      63              :     }
      64              : 
      65         1236 :     for (size_t kk = k_start; kk < k_end; kk++) {
      66          978 :         int j;
      67          978 : #pragma omp parallel for schedule(static)
      68              :         for (j = 1; j < (int)ny - 1; j++) {
      69              :             for (int i = 1; i < (int)nx - 1; i++) {
      70              :                 size_t idx = kk * stride_z + IDX_2D(i, j, nx);
      71              :                 star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, cur[idx] + delta[idx]));
      72              :             }
      73              :         }
      74              :     }
      75              :     return CFD_SUCCESS;
      76              : }
      77              : 
      78          295 : cfd_status_t solve_projection_method_omp(flow_field* field, const grid* grid,
      79              :                                          const ns_solver_params_t* params,
      80              :                                          poisson_solver_t* pressure,
      81              :                                          poisson_solver_t* viscous) {
      82          295 :     if (!field || !grid || !params || !pressure) {
      83              :         return CFD_ERROR_INVALID;
      84              :     }
      85          295 :     if (field->nx < 3 || field->ny < 3 || (field->nz > 1 && field->nz < 3)) {
      86              :         return CFD_ERROR_INVALID;
      87              :     }
      88              :     /* The buffers below are sized from the field; the solver from the grid. */
      89          295 :     cfd_status_t shape_status =
      90          295 :         ns_pressure_check_shape(pressure, field->nx, field->ny, field->nz);
      91          295 :     if (shape_status == CFD_SUCCESS && viscous) {
      92           86 :         shape_status = ns_pressure_check_shape(viscous, field->nx, field->ny, field->nz);
      93              :     }
      94          295 :     if (shape_status != CFD_SUCCESS) {
      95              :         return shape_status;
      96              :     }
      97              :     /* The implicit operator has one constant viscosity; nu + nu_t does not. */
      98          295 :     if (viscous && params->turb_model != TURB_MODEL_NONE) {
      99            0 :         cfd_set_error(CFD_ERROR_UNSUPPORTED,
     100              :                       "The implicit viscous solve does not support turbulence models");
     101            0 :         return CFD_ERROR_UNSUPPORTED;
     102              :     }
     103              : 
     104          295 :     size_t nx = field->nx;
     105          295 :     size_t ny = field->ny;
     106          295 :     size_t nz = field->nz;
     107              : 
     108              :     /* Reject non-uniform z-spacing */
     109          295 :     if (nz > 1 && grid->dz) {
     110          327 :         for (size_t kk = 1; kk < nz - 1; kk++) {
     111          286 :             if (fabs(grid->dz[kk] - grid->dz[0]) > 1e-14) {
     112              :                 return CFD_ERROR_INVALID;
     113              :             }
     114              :         }
     115              :     }
     116              : 
     117          295 :     size_t plane = nx * ny;
     118          295 :     size_t total = plane * nz;
     119              : 
     120              :     /* Branch-free 3D constants */
     121          295 :     size_t stride_z = (nz > 1) ? plane : 0;
     122          295 :     size_t k_start  = (nz > 1) ? 1 : 0;
     123          295 :     size_t k_end    = (nz > 1) ? (nz - 1) : 1;
     124              : 
     125          295 :     double dx = grid->dx[0];
     126          295 :     double dy = grid->dy[0];
     127          295 :     double dz = (nz > 1 && grid->dz) ? grid->dz[0] : 0.0;
     128          295 :     double dt = params->dt;
     129          295 :     double nu = params->mu;
     130          295 :     double inv_2dz = (nz > 1 && grid->dz) ? 1.0 / (2.0 * dz) : 0.0;
     131           41 :     double inv_dz2 = (nz > 1 && grid->dz) ? 1.0 / (dz * dz) : 0.0;
     132          295 :     double inv_dz  = 2.0 * inv_2dz;
     133          295 :     const int upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
     134              : 
     135              : 
     136          295 :     double* u_star = (double*)cfd_calloc(total, sizeof(double));
     137          295 :     double* v_star = (double*)cfd_calloc(total, sizeof(double));
     138          295 :     double* w_star = (double*)cfd_calloc(total, sizeof(double));
     139          295 :     double* p_new = (double*)cfd_calloc(total, sizeof(double));
     140          295 :     double* p_temp = (double*)cfd_calloc(total, sizeof(double));
     141          295 :     double* rhs = (double*)cfd_calloc(total, sizeof(double));
     142          295 :     int needs_T_ws = (params->alpha > 0.0 || params->beta != 0.0);
     143          295 :     double* T_energy_ws = needs_T_ws
     144            2 :         ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
     145          295 :     const int turb_on = (params->turb_model != TURB_MODEL_NONE);
     146          590 :     double* turb_ws = turb_on
     147          295 :         ? (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double)) : NULL;
     148          295 :     const int implicit_visc = (viscous != NULL);
     149          295 :     double* delta = implicit_visc ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
     150              : 
     151          295 :     if (!u_star || !v_star || !w_star || !p_new || !p_temp || !rhs ||
     152          295 :         (needs_T_ws && !T_energy_ws) || (turb_on && !turb_ws) ||
     153          295 :         (implicit_visc && !delta)) {
     154            0 :         cfd_free(u_star);
     155            0 :         cfd_free(v_star);
     156            0 :         cfd_free(w_star);
     157            0 :         cfd_free(p_new);
     158            0 :         cfd_free(p_temp);
     159            0 :         cfd_free(rhs);
     160            0 :         cfd_free(T_energy_ws);
     161            0 :         cfd_free(turb_ws);
     162            0 :         cfd_free(delta);
     163            0 :         return CFD_ERROR_NOMEM;
     164              :     }
     165              : 
     166          295 :     memcpy(u_star, field->u, total * sizeof(double));
     167          295 :     memcpy(v_star, field->v, total * sizeof(double));
     168          295 :     memcpy(w_star, field->w, total * sizeof(double));
     169          295 :     memcpy(p_new, field->p, total * sizeof(double));
     170              : 
     171          628 :     for (int iter = 0; iter < params->max_iter; iter++) {
     172              :         /* STEP 1: Predictor — compute u_star, v_star, w_star without pressure */
     173          911 :         for (size_t kk = k_start; kk < k_end; kk++) {
     174          578 :             int j;
     175          578 : #pragma omp parallel for schedule(static)
     176              :             for (j = 1; j < (int)ny - 1; j++) {
     177              :                 for (int i = 1; i < (int)nx - 1; i++) {
     178              :                     size_t idx = kk * stride_z + IDX_2D(i, j, nx);
     179              : 
     180              :                     double u = field->u[idx];
     181              :                     double v = field->v[idx];
     182              :                     double w = field->w[idx];
     183              : 
     184              :                     double du_dx = (field->u[idx + 1] - field->u[idx - 1]) / (2.0 * dx);
     185              :                     double du_dy = (field->u[idx + nx] - field->u[idx - nx]) / (2.0 * dy);
     186              :                     double du_dz = (field->u[idx + stride_z] - field->u[idx - stride_z]) * inv_2dz;
     187              :                     double dv_dx = (field->v[idx + 1] - field->v[idx - 1]) / (2.0 * dx);
     188              :                     double dv_dy = (field->v[idx + nx] - field->v[idx - nx]) / (2.0 * dy);
     189              :                     double dv_dz = (field->v[idx + stride_z] - field->v[idx - stride_z]) * inv_2dz;
     190              :                     double dw_dx = (field->w[idx + 1] - field->w[idx - 1]) / (2.0 * dx);
     191              :                     double dw_dy = (field->w[idx + nx] - field->w[idx - nx]) / (2.0 * dy);
     192              :                     double dw_dz = (field->w[idx + stride_z] - field->w[idx - stride_z]) * inv_2dz;
     193              : 
     194              :                     /* Convective derivatives: central, or first-order upwind */
     195              :                     ns_conv_derivs_t cd = {du_dx, du_dy, du_dz, dv_dx, dv_dy, dv_dz,
     196              :                                            dw_dx, dw_dy, dw_dz};
     197              :                     if (upwind) {
     198              :                         ns_upwind_conv_derivs(field->u, field->v, field->w, idx,
     199              :                                               idx - 1, idx + 1, idx - nx, idx + nx,
     200              :                                               idx - stride_z, idx + stride_z,
     201              :                                               dx, dy, inv_dz, &cd);
     202              :                     }
     203              : 
     204              :                     double conv_u = u * cd.du_dx + v * cd.du_dy + w * cd.du_dz;
     205              :                     double conv_v = u * cd.dv_dx + v * cd.dv_dy + w * cd.dv_dz;
     206              :                     double conv_w = u * cd.dw_dx + v * cd.dw_dy + w * cd.dw_dz;
     207              : 
     208              :                     double d2u_dx2 = (field->u[idx + 1] - 2.0 * u + field->u[idx - 1]) / (dx * dx);
     209              :                     double d2u_dy2 = (field->u[idx + nx] - 2.0 * u + field->u[idx - nx]) / (dy * dy);
     210              :                     double d2u_dz2 = (field->u[idx + stride_z] - 2.0 * u + field->u[idx - stride_z]) * inv_dz2;
     211              :                     double d2v_dx2 = (field->v[idx + 1] - 2.0 * v + field->v[idx - 1]) / (dx * dx);
     212              :                     double d2v_dy2 = (field->v[idx + nx] - 2.0 * v + field->v[idx - nx]) / (dy * dy);
     213              :                     double d2v_dz2 = (field->v[idx + stride_z] - 2.0 * v + field->v[idx - stride_z]) * inv_dz2;
     214              :                     double d2w_dx2 = (field->w[idx + 1] - 2.0 * w + field->w[idx - 1]) / (dx * dx);
     215              :                     double d2w_dy2 = (field->w[idx + nx] - 2.0 * w + field->w[idx - nx]) / (dy * dy);
     216              :                     double d2w_dz2 = (field->w[idx + stride_z] - 2.0 * w + field->w[idx - stride_z]) * inv_dz2;
     217              : 
     218              :                     double visc_u, visc_v, visc_w;
     219              :                     if (!turb_on) {
     220              :                         visc_u = nu * (d2u_dx2 + d2u_dy2 + d2u_dz2);
     221              :                         visc_v = nu * (d2v_dx2 + d2v_dy2 + d2v_dz2);
     222              :                         visc_w = nu * (d2w_dx2 + d2w_dy2 + d2w_dz2);
     223              :                     } else {
     224              :                         /* Turbulent: conservative face-averaged effective viscosity
     225              :                          * div((nu + nu_t) grad u). The z-term keeps the laminar nu
     226              :                          * (turbulence is 2D-only; it vanishes when nz == 1). */
     227              :                         const double* nu_t = field->nu_t;
     228              :                         double nu_xp = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]);
     229              :                         double nu_xm = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]);
     230              :                         double nu_yp = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]);
     231              :                         double nu_ym = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]);
     232              : 
     233              :                         visc_u = (nu_xp * (field->u[idx + 1] - u) -
     234              :                                   nu_xm * (u - field->u[idx - 1])) / (dx * dx) +
     235              :                                  (nu_yp * (field->u[idx + nx] - u) -
     236              :                                   nu_ym * (u - field->u[idx - nx])) / (dy * dy) +
     237              :                                  nu * d2u_dz2;
     238              :                         visc_v = (nu_xp * (field->v[idx + 1] - v) -
     239              :                                   nu_xm * (v - field->v[idx - 1])) / (dx * dx) +
     240              :                                  (nu_yp * (field->v[idx + nx] - v) -
     241              :                                   nu_ym * (v - field->v[idx - nx])) / (dy * dy) +
     242              :                                  nu * d2v_dz2;
     243              :                         visc_w = (nu_xp * (field->w[idx + 1] - w) -
     244              :                                   nu_xm * (w - field->w[idx - 1])) / (dx * dx) +
     245              :                                  (nu_yp * (field->w[idx + nx] - w) -
     246              :                                   nu_ym * (w - field->w[idx - nx])) / (dy * dy) +
     247              :                                  nu * d2w_dz2;
     248              :                     }
     249              : 
     250              :                     double source_u = 0.0;
     251              :                     double source_v = 0.0;
     252              :                     double source_w = 0.0;
     253              :                     double z_coord = (nz > 1 && grid->z) ? grid->z[kk] : 0.0;
     254              :                     if (params->source_func) {
     255              :                         params->source_func(grid->x[i], grid->y[j], z_coord, iter * dt,
     256              :                                             params->source_context,
     257              :                                             &source_u, &source_v, &source_w);
     258              :                     } else if (params->source_amplitude_u > 0) {
     259              :                         source_u = params->source_amplitude_u * sin(M_PI * grid->y[j]) *
     260              :                                    exp(-params->source_decay_rate * iter * dt);
     261              :                         source_v = params->source_amplitude_v * sin(2.0 * M_PI * grid->x[i]) *
     262              :                                    exp(-params->source_decay_rate * iter * dt);
     263              :                     }
     264              : 
     265              :                     // Boussinesq buoyancy source (no-op when beta == 0)
     266              :                     energy_compute_buoyancy(field->T[idx], params,
     267              :                                             &source_u, &source_v, &source_w);
     268              : 
     269              :                     u_star[idx] = u + dt * (-conv_u + visc_u + source_u);
     270              :                     v_star[idx] = v + dt * (-conv_v + visc_v + source_v);
     271              :                     w_star[idx] = w + dt * (-conv_w + visc_w + source_w);
     272              : 
     273              :                     /* An implicit scheme clamps after its solve instead */
     274              :                     if (!implicit_visc) {
     275              :                         u_star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, u_star[idx]));
     276              :                         v_star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, v_star[idx]));
     277              :                         w_star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, w_star[idx]));
     278              :                     }
     279              :                 }
     280              :             }
     281              :         }
     282              : 
     283              :         /* Copy boundary values from field to star arrays */
     284          333 :         copy_boundary_velocities_3d(u_star, v_star, w_star,
     285          333 :                                     field->u, field->v, field->w, nx, ny, nz);
     286              : 
     287              :         /* Implicit viscous term, on the OpenMP CG solver: replace each explicit
     288              :          * increment by the solution of (I - theta*nu*dt*lap) delta = increment.
     289              :          * rhs is free until the pressure solve below overwrites it. */
     290          333 :         if (implicit_visc) {
     291           86 :             const double* cur[3] = {field->u, field->v, field->w};
     292           86 :             double* star[3] = {u_star, v_star, w_star};
     293          344 :             for (int c = 0; c < 3; c++) {
     294          258 :                 cfd_status_t visc_status = implicit_viscous_component_omp(
     295              :                     viscous, cur[c], star[c], rhs, delta, nx, ny, total,
     296              :                     k_start, k_end, stride_z);
     297          258 :                 if (visc_status != CFD_SUCCESS) {
     298            0 :                     cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
     299            0 :                     cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
     300            0 :                     cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
     301            0 :                     return visc_status;
     302              :                 }
     303              :             }
     304              :         }
     305              : 
     306              :         /* STEP 2: Pressure Poisson equation */
     307          333 :         double rho = field->rho[0] < 1e-10 ? 1.0 : field->rho[0];
     308              : 
     309          911 :         for (size_t kk = k_start; kk < k_end; kk++) {
     310          578 :             int j;
     311          578 : #pragma omp parallel for schedule(static)
     312              :             for (j = 1; j < (int)ny - 1; j++) {
     313              :                 for (int i = 1; i < (int)nx - 1; i++) {
     314              :                     size_t idx = kk * stride_z + IDX_2D(i, j, nx);
     315              :                     double du_star_dx = (u_star[idx + 1] - u_star[idx - 1]) / (2.0 * dx);
     316              :                     double dv_star_dy = (v_star[idx + nx] - v_star[idx - nx]) / (2.0 * dy);
     317              :                     double dw_star_dz = (w_star[idx + stride_z] - w_star[idx - stride_z]) * inv_2dz;
     318              :                     rhs[idx] = (rho / dt) * (du_star_dx + dv_star_dy + dw_star_dz);
     319              :                 }
     320              :             }
     321              :         }
     322              : 
     323              :         /* Neumann compatibility projection, but only when the operator is actually
     324              :          * singular. With every face zero-gradient the constants are its nullspace,
     325              :          * so the RHS must have zero interior mean -- div(u*) only nearly does, and
     326              :          * the remainder is removed here rather than assumed away. With a face
     327              :          * prescribed the operator is nonsingular and shifting the RHS would change
     328              :          * the answer instead of making it exist. */
     329          333 :         if (poisson_walls_are_singular(&params->pressure_bc, nz)) {
     330          333 :             mg_subtract_interior_mean_omp(rhs, nx, ny, nz);
     331              :         }
     332              : 
     333              :         /* Parallel Poisson solve on the solver this projection owns, which was
     334              :          * built on the OpenMP backend at init -- never a scalar one. */
     335          333 :         poisson_solver_stats_t pstats = poisson_solver_stats_default();
     336          333 :         cfd_status_t poisson_status =
     337          333 :             poisson_solver_solve(pressure, p_new, p_temp, rhs, &pstats);
     338              : 
     339          333 :         if (poisson_status != CFD_SUCCESS) {
     340            0 :             cfd_free(u_star);
     341            0 :             cfd_free(v_star);
     342            0 :             cfd_free(w_star);
     343            0 :             cfd_free(p_new);
     344            0 :             cfd_free(p_temp);
     345            0 :             cfd_free(rhs);
     346            0 :             cfd_free(T_energy_ws);
     347            0 :             cfd_free(turb_ws);
     348            0 :             cfd_free(delta);
     349            0 :             return poisson_status;
     350              :         }
     351              : 
     352              :         /* STEP 3: Corrector — project velocities with pressure gradient */
     353          333 :         double dt_over_rho = dt / rho;
     354          911 :         for (size_t kk = k_start; kk < k_end; kk++) {
     355          578 :             int j;
     356          578 : #pragma omp parallel for schedule(static)
     357              :             for (j = 1; j < (int)ny - 1; j++) {
     358              :                 for (int i = 1; i < (int)nx - 1; i++) {
     359              :                     size_t idx = kk * stride_z + IDX_2D(i, j, nx);
     360              :                     double dp_dx = (p_new[idx + 1] - p_new[idx - 1]) / (2.0 * dx);
     361              :                     double dp_dy = (p_new[idx + nx] - p_new[idx - nx]) / (2.0 * dy);
     362              :                     double dp_dz = (p_new[idx + stride_z] - p_new[idx - stride_z]) * inv_2dz;
     363              : 
     364              :                     field->u[idx] = u_star[idx] - dt_over_rho * dp_dx;
     365              :                     field->v[idx] = v_star[idx] - dt_over_rho * dp_dy;
     366              :                     field->w[idx] = w_star[idx] - dt_over_rho * dp_dz;
     367              : 
     368              :                     field->u[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, field->u[idx]));
     369              :                     field->v[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, field->v[idx]));
     370              :                     field->w[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, field->w[idx]));
     371              :                 }
     372              :             }
     373              :         }
     374              : 
     375          333 :         memcpy(field->p, p_new, total * sizeof(double));
     376              : 
     377              :         /* Energy equation: advance temperature after velocity correction */
     378              :         {
     379          333 :             cfd_status_t energy_status = energy_step_explicit_omp_with_workspace(
     380              :                 field, grid, params, dt, iter * dt, T_energy_ws, total);
     381          333 :             if (energy_status != CFD_SUCCESS) {
     382            0 :                 cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
     383            0 :                 cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
     384            0 :                 cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
     385            0 :                 return energy_status;
     386              :             }
     387              :         }
     388              : 
     389              :         /* Apply configured thermal BCs to temperature field */
     390          333 :         cfd_status_t bc_status = energy_apply_thermal_bcs(field, params);
     391          333 :         if (bc_status != CFD_SUCCESS) {
     392            0 :             cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
     393            0 :             cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
     394            0 :             cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
     395            0 :             return bc_status;
     396              :         }
     397              : 
     398              :         /* Copy boundary velocity values from star arrays (which have caller's BCs) */
     399          333 :         copy_boundary_velocities_3d(field->u, field->v, field->w,
     400              :                                     u_star, v_star, w_star, nx, ny, nz);
     401              : 
     402              :         /* Turbulence transport: advance k-eps/SA with the corrected velocity,
     403              :          * then apply turbulence BCs (including wall functions) */
     404              :         {
     405          333 :             cfd_status_t turb_status = turbulence_step_explicit_omp_with_workspace(
     406              :                 field, grid, params, dt, iter * dt, turb_ws,
     407              :                 turb_on ? TURB_WORKSPACE_SIZE(total) : 0);
     408          333 :             if (turb_status == CFD_SUCCESS) {
     409          333 :                 turb_status = turbulence_apply_bcs(field, grid, params);
     410              :             }
     411          333 :             if (turb_status != CFD_SUCCESS) {
     412            0 :                 cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
     413            0 :                 cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
     414            0 :                 cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
     415            0 :                 return turb_status;
     416              :             }
     417              :         }
     418              : 
     419              :         /* Check for NaN/Inf values (parallelized) */
     420          333 :         int has_nan = 0;
     421          333 :         ptrdiff_t total_int = (ptrdiff_t)total;
     422          333 :         ptrdiff_t ii;
     423          333 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
     424              :         for (ii = 0; ii < total_int; ii++) {
     425              :             if (!isfinite(field->u[ii]) || !isfinite(field->v[ii]) ||
     426              :                 !isfinite(field->w[ii]) || !isfinite(field->p[ii])) {
     427              :                 has_nan = 1;
     428              :             }
     429              :         }
     430          333 :         if (has_nan) {
     431            0 :             cfd_free(u_star);
     432            0 :             cfd_free(v_star);
     433            0 :             cfd_free(w_star);
     434            0 :             cfd_free(p_new);
     435            0 :             cfd_free(p_temp);
     436            0 :             cfd_free(rhs);
     437            0 :             cfd_free(T_energy_ws);
     438            0 :             cfd_free(turb_ws);
     439            0 :             cfd_free(delta);
     440            0 :             return CFD_ERROR_DIVERGED;
     441              :         }
     442              :     }
     443              : 
     444          295 :     cfd_free(u_star);
     445          295 :     cfd_free(v_star);
     446          295 :     cfd_free(w_star);
     447          295 :     cfd_free(p_new);
     448          295 :     cfd_free(p_temp);
     449          295 :     cfd_free(rhs);
     450          295 :     cfd_free(T_energy_ws);
     451          295 :     cfd_free(turb_ws);
     452          295 :     cfd_free(delta);
     453          295 :     return CFD_SUCCESS;
     454              : }
        

Generated by: LCOV version 2.0-1