LCOV - code coverage report
Current view: top level - solvers/navier_stokes/omp - solver_explicit_euler_omp.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 82.2 % 90 74
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 1 1

            Line data    Source code
       1              : #include "cfd/core/cfd_status.h"
       2              : #include "cfd/core/grid.h"
       3              : #include "cfd/core/indexing.h"
       4              : #include "cfd/core/memory.h"
       5              : 
       6              : #include "cfd/solvers/energy_solver.h"
       7              : #include "cfd/solvers/navier_stokes_solver.h"
       8              : #include "cfd/solvers/turbulence_solver.h"
       9              : #include "../../energy/energy_solver_internal.h"
      10              : #include "../../turbulence/turbulence_solver_internal.h"
      11              : #include "../boundary_copy_utils.h"
      12              : #include "../ns_convection_internal.h"
      13              : #include <math.h>
      14              : #include <omp.h>
      15              : #include <stdio.h>
      16              : #include <string.h>
      17              : 
      18              : 
      19              : 
      20              : #ifndef M_PI
      21              : #define M_PI 3.14159265358979323846
      22              : #endif
      23              : 
      24              : // Physical stability limits (same as cpu solver)
      25              : #define MAX_DERIVATIVE_LIMIT        100.0
      26              : #define MAX_SECOND_DERIVATIVE_LIMIT 1000.0
      27              : #define MAX_VELOCITY_LIMIT          100.0
      28              : #define MAX_DIVERGENCE_LIMIT        10.0
      29              : /* One definition lives in navier_stokes_solver.h (NS_EULER_DT_LIMIT). */
      30              : #define DT_CONSERVATIVE_LIMIT NS_EULER_DT_LIMIT
      31              : #define UPDATE_LIMIT                1.0
      32              : #define PRESSURE_UPDATE_FACTOR      0.1
      33              : 
      34              : // Internal OpenMP explicit Euler implementation
      35          261 : cfd_status_t explicit_euler_omp_impl(flow_field* field, const grid* grid,
      36              :                                      const ns_solver_params_t* params) {
      37          261 :     if (field->nx < 3 || field->ny < 3 || (field->nz > 1 && field->nz < 3)) {
      38              :         return CFD_ERROR_INVALID;
      39              :     }
      40              : 
      41          261 :     size_t nz = field->nz;
      42          261 :     if (nz > 1 && grid->dz) {
      43           44 :         for (size_t kk = 1; kk < nz - 1; kk++) {
      44           37 :             if (fabs(grid->dz[kk] - grid->dz[0]) > 1e-14) {
      45              :                 return CFD_ERROR_INVALID;
      46              :             }
      47              :         }
      48              :     }
      49              : 
      50          261 :     size_t nx = field->nx;
      51          261 :     size_t ny = field->ny;
      52          261 :     size_t plane = nx * ny;
      53          261 :     size_t total = plane * nz;
      54              : 
      55          261 :     size_t stride_z = (nz > 1) ? plane : 0;
      56          261 :     size_t k_start  = (nz > 1) ? 1 : 0;
      57          261 :     size_t k_end    = (nz > 1) ? (nz - 1) : 1;
      58          261 :     double inv_2dz  = (nz > 1 && grid->dz) ? 1.0 / (2.0 * grid->dz[0]) : 0.0;
      59            7 :     double inv_dz2  = (nz > 1 && grid->dz) ? 1.0 / (grid->dz[0] * grid->dz[0]) : 0.0;
      60          261 :     double inv_dz   = 2.0 * inv_2dz;
      61          261 :     const int upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
      62              : 
      63              :     // Allocate temporary arrays
      64          261 :     double* u_new = (double*)cfd_calloc(total, sizeof(double));
      65          261 :     double* v_new = (double*)cfd_calloc(total, sizeof(double));
      66          261 :     double* w_new = (double*)cfd_calloc(total, sizeof(double));
      67          261 :     double* p_new = (double*)cfd_calloc(total, sizeof(double));
      68          261 :     int needs_T_ws = (params->alpha > 0.0 || params->beta != 0.0);
      69          261 :     double* T_energy_ws = needs_T_ws
      70            2 :         ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
      71          261 :     const int turb_on = (params->turb_model != TURB_MODEL_NONE);
      72          522 :     double* turb_ws = turb_on
      73          261 :         ? (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double)) : NULL;
      74              : 
      75          261 :     if (!u_new || !v_new || !w_new || !p_new ||
      76          261 :         (needs_T_ws && !T_energy_ws) || (turb_on && !turb_ws)) {
      77            0 :         cfd_free(u_new);
      78            0 :         cfd_free(v_new);
      79            0 :         cfd_free(w_new);
      80            0 :         cfd_free(p_new);
      81            0 :         cfd_free(T_energy_ws);
      82            0 :         cfd_free(turb_ws);
      83            0 :         return CFD_ERROR_NOMEM;
      84              :     }
      85              : 
      86              :     // Initialize with current values
      87          261 :     memcpy(u_new, field->u, total * sizeof(double));
      88          261 :     memcpy(v_new, field->v, total * sizeof(double));
      89          261 :     memcpy(w_new, field->w, total * sizeof(double));
      90          261 :     memcpy(p_new, field->p, total * sizeof(double));
      91              : 
      92          261 :     double conservative_dt = fmin(params->dt, DT_CONSERVATIVE_LIMIT);
      93              : 
      94          558 :     for (int iter = 0; iter < params->max_iter; iter++) {
      95          628 :         for (size_t kk = k_start; kk < k_end; kk++) {
      96          329 :             int j;
      97          329 : #pragma omp parallel for schedule(static)
      98              :             for (j = 1; j < (int)ny - 1; j++) {
      99              :                 for (int i = 1; i < (int)nx - 1; i++) {
     100              :                     size_t idx = (kk * stride_z) + IDX_2D(i, j, nx);
     101              : 
     102              :                     // Derivatives
     103              :                     double du_dx = (field->u[idx + 1] - field->u[idx - 1]) / (2.0 * grid->dx[i]);
     104              :                     double du_dy =
     105              :                         (field->u[idx + nx] - field->u[idx - nx]) / (2.0 * grid->dy[j]);
     106              :                     double dv_dx = (field->v[idx + 1] - field->v[idx - 1]) / (2.0 * grid->dx[i]);
     107              :                     double dv_dy =
     108              :                         (field->v[idx + nx] - field->v[idx - nx]) / (2.0 * grid->dy[j]);
     109              : 
     110              :                     double dp_dx = (field->p[idx + 1] - field->p[idx - 1]) / (2.0 * grid->dx[i]);
     111              :                     double dp_dy =
     112              :                         (field->p[idx + nx] - field->p[idx - nx]) / (2.0 * grid->dy[j]);
     113              : 
     114              :                     double d2u_dx2 = (field->u[idx + 1] - 2.0 * field->u[idx] + field->u[idx - 1]) /
     115              :                                      (grid->dx[i] * grid->dx[i]);
     116              :                     double d2u_dy2 =
     117              :                         (field->u[idx + nx] - 2.0 * field->u[idx] + field->u[idx - nx]) /
     118              :                         (grid->dy[j] * grid->dy[j]);
     119              :                     double d2v_dx2 = (field->v[idx + 1] - 2.0 * field->v[idx] + field->v[idx - 1]) /
     120              :                                      (grid->dx[i] * grid->dx[i]);
     121              :                     double d2v_dy2 =
     122              :                         (field->v[idx + nx] - 2.0 * field->v[idx] + field->v[idx - nx]) /
     123              :                         (grid->dy[j] * grid->dy[j]);
     124              : 
     125              :                     double du_dz = (field->u[idx + stride_z] - field->u[idx - stride_z]) * inv_2dz;
     126              :                     double dv_dz = (field->v[idx + stride_z] - field->v[idx - stride_z]) * inv_2dz;
     127              :                     double dw_dx = (field->w[idx + 1] - field->w[idx - 1]) / (2.0 * grid->dx[i]);
     128              :                     double dw_dy = (field->w[idx + nx] - field->w[idx - nx]) / (2.0 * grid->dy[j]);
     129              :                     double dw_dz = (field->w[idx + stride_z] - field->w[idx - stride_z]) * inv_2dz;
     130              :                     double dp_dz = (field->p[idx + stride_z] - field->p[idx - stride_z]) * inv_2dz;
     131              : 
     132              :                     double d2u_dz2 = (field->u[idx + stride_z] - 2.0 * field->u[idx] + field->u[idx - stride_z]) * inv_dz2;
     133              :                     double d2v_dz2 = (field->v[idx + stride_z] - 2.0 * field->v[idx] + field->v[idx - stride_z]) * inv_dz2;
     134              :                     double d2w_dx2 = (field->w[idx + 1] - 2.0 * field->w[idx] + field->w[idx - 1]) / (grid->dx[i] * grid->dx[i]);
     135              :                     double d2w_dy2 = (field->w[idx + nx] - 2.0 * field->w[idx] + field->w[idx - nx]) / (grid->dy[j] * grid->dy[j]);
     136              :                     double d2w_dz2 = (field->w[idx + stride_z] - 2.0 * field->w[idx] + field->w[idx - stride_z]) * inv_dz2;
     137              : 
     138              :                     if (field->rho[idx] <= 1e-10) {
     139              :                         continue;
     140              :                     }
     141              : 
     142              :                     double nu = params->mu / fmax(field->rho[idx], 1e-10);
     143              :                     nu = fmin(nu, 1.0);
     144              : 
     145              :                     // Convective derivatives: central, or first-order upwind.
     146              :                     // The divergence below stays central.
     147              :                     ns_conv_derivs_t cd = {du_dx, du_dy, du_dz, dv_dx, dv_dy, dv_dz,
     148              :                                            dw_dx, dw_dy, dw_dz};
     149              :                     if (upwind) {
     150              :                         ns_upwind_conv_derivs(field->u, field->v, field->w, idx,
     151              :                                               idx - 1, idx + 1, idx - nx, idx + nx,
     152              :                                               idx - stride_z, idx + stride_z,
     153              :                                               grid->dx[i], grid->dy[j], inv_dz, &cd);
     154              :                     }
     155              : 
     156              :                     // Source terms
     157              :                     double source_u = 0.0;
     158              :                     double source_v = 0.0;
     159              :                     double source_w = 0.0;
     160              :                     double z_coord = (nz > 1 && grid->z) ? grid->z[kk] : 0.0;
     161              :                     if (params->source_func) {
     162              :                         params->source_func(grid->x[i], grid->y[j], z_coord,
     163              :                                             iter * conservative_dt,
     164              :                                             params->source_context,
     165              :                                             &source_u, &source_v, &source_w);
     166              :                     } else {
     167              :                         source_u = params->source_amplitude_u * sin(M_PI * grid->y[j]) *
     168              :                                    exp(-params->source_decay_rate * iter * conservative_dt);
     169              :                         source_v = params->source_amplitude_v * sin(2.0 * M_PI * grid->x[i]) *
     170              :                                    exp(-params->source_decay_rate * iter * conservative_dt);
     171              :                     }
     172              : 
     173              :                     // Boussinesq buoyancy source (no-op when beta == 0)
     174              :                     energy_compute_buoyancy(field->T[idx], params,
     175              :                                             &source_u, &source_v, &source_w);
     176              : 
     177              :                     // Viscous terms: laminar or turbulent (face-averaged nu_eff)
     178              :                     double visc_u, visc_v, visc_w;
     179              :                     if (!turb_on) {
     180              :                         visc_u = nu * (d2u_dx2 + d2u_dy2 + d2u_dz2);
     181              :                         visc_v = nu * (d2v_dx2 + d2v_dy2 + d2v_dz2);
     182              :                         visc_w = nu * (d2w_dx2 + d2w_dy2 + d2w_dz2);
     183              :                     } else {
     184              :                         const double* nu_t = field->nu_t;
     185              :                         double dx2 = grid->dx[i] * grid->dx[i];
     186              :                         double dy2 = grid->dy[j] * grid->dy[j];
     187              :                         /* Face-averaged nu_eff = nu + nu_t (nu_t is bounded by the
     188              :                          * realizability clamp) */
     189              :                         double nu_xp = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]);
     190              :                         double nu_xm = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]);
     191              :                         double nu_yp = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]);
     192              :                         double nu_ym = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]);
     193              :                         visc_u = (nu_xp * (field->u[idx + 1]  - field->u[idx]) -
     194              :                                   nu_xm * (field->u[idx]      - field->u[idx - 1])) / dx2 +
     195              :                                  (nu_yp * (field->u[idx + nx] - field->u[idx]) -
     196              :                                   nu_ym * (field->u[idx]      - field->u[idx - nx])) / dy2 +
     197              :                                  nu * d2u_dz2;
     198              :                         visc_v = (nu_xp * (field->v[idx + 1]  - field->v[idx]) -
     199              :                                   nu_xm * (field->v[idx]      - field->v[idx - 1])) / dx2 +
     200              :                                  (nu_yp * (field->v[idx + nx] - field->v[idx]) -
     201              :                                   nu_ym * (field->v[idx]      - field->v[idx - nx])) / dy2 +
     202              :                                  nu * d2v_dz2;
     203              :                         visc_w = (nu_xp * (field->w[idx + 1]  - field->w[idx]) -
     204              :                                   nu_xm * (field->w[idx]      - field->w[idx - 1])) / dx2 +
     205              :                                  (nu_yp * (field->w[idx + nx] - field->w[idx]) -
     206              :                                   nu_ym * (field->w[idx]      - field->w[idx - nx])) / dy2 +
     207              :                                  nu * d2w_dz2;
     208              :                         visc_u = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_u));
     209              :                         visc_v = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_v));
     210              :                         visc_w = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_w));
     211              :                     }
     212              : 
     213              :                     // Update u
     214              :                     double du = conservative_dt * (-field->u[idx] * cd.du_dx - field->v[idx] * cd.du_dy
     215              :                                                    - field->w[idx] * cd.du_dz
     216              :                                                    - dp_dx / fmax(field->rho[idx], 1e-10)
     217              :                                                    + visc_u + source_u);
     218              : 
     219              :                     // Update v
     220              :                     double dv = conservative_dt * (-field->u[idx] * cd.dv_dx - field->v[idx] * cd.dv_dy
     221              :                                                    - field->w[idx] * cd.dv_dz
     222              :                                                    - dp_dy / fmax(field->rho[idx], 1e-10)
     223              :                                                    + visc_v + source_v);
     224              : 
     225              :                     // Update w
     226              :                     double dw = conservative_dt * (-field->u[idx] * cd.dw_dx - field->v[idx] * cd.dw_dy
     227              :                                                    - field->w[idx] * cd.dw_dz
     228              :                                                    - dp_dz / fmax(field->rho[idx], 1e-10)
     229              :                                                    + visc_w + source_w);
     230              : 
     231              :                     du = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, du));
     232              :                     dv = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dv));
     233              :                     dw = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dw));
     234              : 
     235              :                     u_new[idx] = field->u[idx] + du;
     236              :                     v_new[idx] = field->v[idx] + dv;
     237              : 
     238              :                     // Limit velocity
     239              :                     u_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, u_new[idx]));
     240              :                     v_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, v_new[idx]));
     241              :                     w_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->w[idx] + dw));
     242              : 
     243              :                     // Pressure update
     244              :                     double divergence = du_dx + dv_dy + dw_dz;
     245              :                     divergence = fmax(-MAX_DIVERGENCE_LIMIT, fmin(MAX_DIVERGENCE_LIMIT, divergence));
     246              : 
     247              :                     double dp =
     248              :                         -PRESSURE_UPDATE_FACTOR * conservative_dt * field->rho[idx] * divergence;
     249              :                     dp = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dp));
     250              :                     p_new[idx] = field->p[idx] + dp;
     251              :                 }
     252              :             }
     253              :         }
     254              : 
     255              :         // Copy back (implicit barrier at end of parallel for)
     256          299 :         memcpy(field->u, u_new, total * sizeof(double));
     257          299 :         memcpy(field->v, v_new, total * sizeof(double));
     258          299 :         memcpy(field->w, w_new, total * sizeof(double));
     259          299 :         memcpy(field->p, p_new, total * sizeof(double));
     260              : 
     261              :         // Energy equation: advance temperature using updated velocity
     262              :         {
     263          299 :             cfd_status_t energy_status = energy_step_explicit_omp_with_workspace(
     264              :                 field, grid, params, conservative_dt,
     265              :                 iter * conservative_dt, T_energy_ws, total);
     266          299 :             if (energy_status != CFD_SUCCESS) {
     267            0 :                 cfd_free(u_new); cfd_free(v_new); cfd_free(w_new);
     268            0 :                 cfd_free(p_new); cfd_free(T_energy_ws); cfd_free(turb_ws);
     269            0 :                 return energy_status;
     270              :             }
     271              :         }
     272              : 
     273              :         // Store caller-set boundary values before apply_boundary_conditions overwrites them,
     274              :         // then restore them afterward. Then apply configured thermal BCs.
     275          299 :         copy_boundary_velocities_3d(u_new, v_new, w_new,
     276          299 :                                     field->u, field->v, field->w, nx, ny, nz);
     277          299 :         apply_boundary_conditions(field, grid);
     278          299 :         copy_boundary_velocities_3d(field->u, field->v, field->w,
     279              :                                     u_new, v_new, w_new, nx, ny, nz);
     280          299 :         cfd_status_t bc_status = energy_apply_thermal_bcs(field, params);
     281          299 :         if (bc_status != CFD_SUCCESS) {
     282            0 :             cfd_free(u_new); cfd_free(v_new); cfd_free(w_new);
     283            0 :             cfd_free(p_new); cfd_free(T_energy_ws); cfd_free(turb_ws);
     284            0 :             return bc_status;
     285              :         }
     286              : 
     287              :         /* Turbulence transport: advance k-eps/SA with the updated velocity,
     288              :          * then apply turbulence BCs (including wall functions). nu_t is
     289              :          * frozen across the explicit Euler step and updated once per step. */
     290              :         {
     291          299 :             cfd_status_t turb_status = turbulence_step_explicit_omp_with_workspace(
     292              :                 field, grid, params, conservative_dt, iter * conservative_dt,
     293              :                 turb_ws, turb_on ? TURB_WORKSPACE_SIZE(total) : 0);
     294          299 :             if (turb_status == CFD_SUCCESS) {
     295          299 :                 turb_status = turbulence_apply_bcs(field, grid, params);
     296              :             }
     297          299 :             if (turb_status != CFD_SUCCESS) {
     298            0 :                 cfd_free(u_new); cfd_free(v_new); cfd_free(w_new);
     299            0 :                 cfd_free(p_new); cfd_free(T_energy_ws); cfd_free(turb_ws);
     300            0 :                 return turb_status;
     301              :             }
     302              :         }
     303              : 
     304              :         // Check for NaN/Inf values
     305          299 :         int has_nan = 0;
     306          299 :         ptrdiff_t total_int = (ptrdiff_t)total;
     307          299 :         ptrdiff_t ii;
     308          299 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
     309              :         for (ii = 0; ii < total_int; ii++) {
     310              :             if (!isfinite(field->u[ii]) || !isfinite(field->v[ii]) ||
     311              :                 !isfinite(field->w[ii]) || !isfinite(field->p[ii])) {
     312              :                 has_nan = 1;
     313              :             }
     314              :         }
     315              : 
     316          299 :         if (has_nan) {
     317            2 :             cfd_free(u_new);
     318            2 :             cfd_free(v_new);
     319            2 :             cfd_free(w_new);
     320            2 :             cfd_free(p_new);
     321            2 :             cfd_free(T_energy_ws);
     322            2 :             cfd_free(turb_ws);
     323            2 :             cfd_set_error(CFD_ERROR_DIVERGED,
     324              :                           "NaN/Inf detected in explicit_euler_omp step");
     325            2 :             return CFD_ERROR_DIVERGED;
     326              :         }
     327              :     }
     328              : 
     329          259 :     cfd_free(u_new);
     330          259 :     cfd_free(v_new);
     331          259 :     cfd_free(w_new);
     332          259 :     cfd_free(p_new);
     333          259 :     cfd_free(T_energy_ws);
     334          259 :     cfd_free(turb_ws);
     335              : 
     336          259 :     return CFD_SUCCESS;
     337              : }
        

Generated by: LCOV version 2.0-1