LCOV - code coverage report
Current view: top level - solvers/energy/omp - energy_solver_omp.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 64.3 % 70 45
Test Date: 2026-10-05 04:47:18 Functions: 100.0 % 1 1

            Line data    Source code
       1              : /**
       2              :  * @file energy_solver_omp.c
       3              :  * @brief OpenMP-parallelized energy equation solver (advection-diffusion step)
       4              :  *
       5              :  * Solves: dT/dt + u*nabla(T) = alpha * nabla^2(T) + Q
       6              :  * using explicit Euler time integration, central differences for diffusion, and
       7              :  * central or first-order upwind differences for advection
       8              :  * (params->convection_scheme).
       9              :  *
      10              :  * Same numerics as the scalar reference (energy/cpu/energy_solver.c); the
      11              :  * interior stencil loop is parallelized over j. Read/write separation
      12              :  * (reads field->T, writes T_new) makes the loop race-free. Buoyancy and
      13              :  * thermal BC application are shared with the scalar backend.
      14              :  *
      15              :  * Branch-free 3D: when nz==1, stride_z=0 and inv_2dz/inv_dz2=0.0 cause all
      16              :  * z-terms to vanish, producing identical results to a 2D code path.
      17              :  */
      18              : 
      19              : #include "../energy_solver_internal.h"
      20              : 
      21              : #include "cfd/core/indexing.h"
      22              : #include "cfd/core/memory.h"
      23              : #include "cfd/math/stencils.h"
      24              : 
      25              : #include <math.h>
      26              : #include <omp.h>
      27              : #include <string.h>
      28              : 
      29         1186 : cfd_status_t energy_step_explicit_omp_with_workspace(
      30              :     flow_field* field, const grid* grid,
      31              :     const ns_solver_params_t* params,
      32              :     double dt, double time,
      33              :     double* T_workspace, size_t workspace_size) {
      34         1186 :     if (!field || !grid || !params) {
      35            0 :         cfd_set_error(CFD_ERROR_INVALID,
      36              :                       "energy_solver_omp: field, grid, and params must be non-NULL");
      37            0 :         return CFD_ERROR_INVALID;
      38              :     }
      39         1186 :     if (!field->T) {
      40            0 :         cfd_set_error(CFD_ERROR_INVALID,
      41              :                       "energy_solver_omp: missing temperature field");
      42            0 :         return CFD_ERROR_INVALID;
      43              :     }
      44              : 
      45              :     /* Skip when energy equation is disabled */
      46         1186 :     if (params->alpha <= 0.0) {
      47              :         return CFD_SUCCESS;
      48              :     }
      49              : 
      50          120 :     size_t nx = field->nx;
      51          120 :     size_t ny = field->ny;
      52          120 :     size_t nz = field->nz;
      53              : 
      54          120 :     if (!grid->dx || !grid->dy || nx < 3 || ny < 3) {
      55            0 :         cfd_set_error(CFD_ERROR_INVALID,
      56              :                       "energy_solver_omp: grid too small or missing dx/dy");
      57            0 :         return CFD_ERROR_INVALID;
      58              :     }
      59          120 :     size_t plane = nx * ny;
      60          120 :     size_t total = plane * nz;
      61          120 :     double alpha = params->alpha;
      62              : 
      63              :     /* Validate uniform spacing (central-difference stencil assumes it) */
      64          120 :     const double dx0 = grid->dx[0];
      65          120 :     const double dy0 = grid->dy[0];
      66              :     {
      67          120 :         const double tol_x = 1e-12 * fmax(1.0, fabs(dx0));
      68          960 :         for (size_t i = 1; i < nx - 1; i++) {
      69          840 :             if (fabs(grid->dx[i] - dx0) > tol_x) {
      70            0 :                 cfd_set_error(CFD_ERROR_UNSUPPORTED,
      71              :                               "energy_solver_omp: non-uniform dx not supported");
      72            0 :                 return CFD_ERROR_UNSUPPORTED;
      73              :             }
      74              :         }
      75          120 :         const double tol_y = 1e-12 * fmax(1.0, fabs(dy0));
      76          960 :         for (size_t j = 1; j < ny - 1; j++) {
      77          840 :             if (fabs(grid->dy[j] - dy0) > tol_y) {
      78            0 :                 cfd_set_error(CFD_ERROR_UNSUPPORTED,
      79              :                               "energy_solver_omp: non-uniform dy not supported");
      80            0 :                 return CFD_ERROR_UNSUPPORTED;
      81              :             }
      82              :         }
      83              :     }
      84          120 :     if (nz > 1) {
      85            0 :         if (!grid->dz) {
      86            0 :             cfd_set_error(CFD_ERROR_INVALID,
      87              :                           "energy_solver_omp: missing dz for 3D energy solve");
      88            0 :             return CFD_ERROR_INVALID;
      89              :         }
      90            0 :         const double dz0 = grid->dz[0];
      91            0 :         const double tol_z = 1e-12 * fmax(1.0, fabs(dz0));
      92            0 :         for (size_t k = 1; k < nz - 1; k++) {
      93            0 :             if (fabs(grid->dz[k] - dz0) > tol_z) {
      94            0 :                 cfd_set_error(CFD_ERROR_UNSUPPORTED,
      95              :                               "energy_solver_omp: non-uniform dz not supported");
      96            0 :                 return CFD_ERROR_UNSUPPORTED;
      97              :             }
      98              :         }
      99              :     }
     100              : 
     101              :     /* Precomputed constants for uniform-grid stencil */
     102          120 :     double inv_2dx = 1.0 / (2.0 * dx0);
     103          120 :     double inv_2dy = 1.0 / (2.0 * dy0);
     104          120 :     double inv_dx2 = 1.0 / (dx0 * dx0);
     105          120 :     double inv_dy2 = 1.0 / (dy0 * dy0);
     106              : 
     107              :     /* Branch-free 3D constants */
     108          120 :     size_t stride_z = (nz > 1) ? plane : 0;
     109          120 :     size_t k_start  = (nz > 1) ? 1 : 0;
     110          120 :     size_t k_end    = (nz > 1) ? (nz - 1) : 1;
     111          120 :     double inv_2dz  = (nz > 1 && grid->dz) ? 1.0 / (2.0 * grid->dz[0]) : 0.0;
     112            0 :     double inv_dz2  = (nz > 1 && grid->dz) ? 1.0 / (grid->dz[0] * grid->dz[0]) : 0.0;
     113          120 :     double inv_dz   = 2.0 * inv_2dz;
     114          120 :     const int upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
     115              : 
     116              :     /* Use caller's workspace or allocate internally */
     117          120 :     int owns_buffer = 0;
     118          120 :     double* T_new;
     119          120 :     if (T_workspace && workspace_size >= total) {
     120              :         T_new = T_workspace;
     121              :     } else {
     122            0 :         T_new = (double*)cfd_calloc(total, sizeof(double));
     123            0 :         if (!T_new) {
     124              :             return CFD_ERROR_NOMEM;
     125              :         }
     126              :         owns_buffer = 1;
     127              :     }
     128          120 :     memcpy(T_new, field->T, total * sizeof(double));
     129              : 
     130          240 :     for (size_t k = k_start; k < k_end; k++) {
     131          120 :         size_t k_offset = k * stride_z;
     132          120 :         int j;
     133          120 : #pragma omp parallel for schedule(static)
     134              :         for (j = 1; j < (int)ny - 1; j++) {
     135              :             for (int i = 1; i < (int)nx - 1; i++) {
     136              :                 size_t idx = k_offset + IDX_2D((size_t)i, (size_t)j, nx);
     137              : 
     138              :                 double T_c = field->T[idx];
     139              :                 double u_c = field->u[idx];
     140              :                 double v_c = field->v[idx];
     141              :                 double w_c = field->w[idx];
     142              : 
     143              :                 /* Advection: u * dT/dx + v * dT/dy + w * dT/dz, with central or
     144              :                  * first-order upwind derivatives */
     145              :                 double dT_dx, dT_dy, dT_dz;
     146              :                 if (upwind) {
     147              :                     dT_dx = stencil_upwind_deriv_x(field->T[idx + 1], T_c, field->T[idx - 1],
     148              :                                                    dx0, u_c);
     149              :                     dT_dy = stencil_upwind_deriv_y(field->T[idx + nx], T_c, field->T[idx - nx],
     150              :                                                    dy0, v_c);
     151              :                     dT_dz = stencil_upwind_diff(field->T[idx + stride_z], T_c,
     152              :                                                 field->T[idx - stride_z], w_c) * inv_dz;
     153              :                 } else {
     154              :                     dT_dx = (field->T[idx + 1] - field->T[idx - 1]) * inv_2dx;
     155              :                     dT_dy = (field->T[idx + nx] - field->T[idx - nx]) * inv_2dy;
     156              :                     dT_dz = (field->T[idx + stride_z] - field->T[idx - stride_z]) * inv_2dz;
     157              :                 }
     158              : 
     159              :                 double advection = u_c * dT_dx + v_c * dT_dy + w_c * dT_dz;
     160              : 
     161              :                 /* Diffusion: alpha * (d2T/dx2 + d2T/dy2 + d2T/dz2) */
     162              :                 double d2T_dx2 = (field->T[idx + 1] - 2.0 * T_c + field->T[idx - 1]) * inv_dx2;
     163              :                 double d2T_dy2 = (field->T[idx + nx] - 2.0 * T_c + field->T[idx - nx]) * inv_dy2;
     164              :                 double d2T_dz2 = (field->T[idx + stride_z] - 2.0 * T_c +
     165              :                                    field->T[idx - stride_z]) * inv_dz2;
     166              : 
     167              :                 double diffusion = alpha * (d2T_dx2 + d2T_dy2 + d2T_dz2);
     168              : 
     169              :                 /* Heat source term */
     170              :                 double Q = 0.0;
     171              :                 if (params->heat_source_func) {
     172              :                     double x = grid->x[i];
     173              :                     double y = grid->y[j];
     174              :                     double z = (nz > 1 && grid->z) ? grid->z[k] : 0.0;
     175              :                     Q = params->heat_source_func(x, y, z, time,
     176              :                                                   params->heat_source_context);
     177              :                 }
     178              : 
     179              :                 /* Explicit Euler update */
     180              :                 double dT = dt * (-advection + diffusion + Q);
     181              :                 T_new[idx] = T_c + dT;
     182              :             }
     183              :         }
     184              :     }
     185              : 
     186              :     /* Check for NaN/Inf */
     187          120 :     int has_nan = 0;
     188          120 :     ptrdiff_t total_int = (ptrdiff_t)total;
     189          120 :     ptrdiff_t n;
     190          120 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
     191              :     for (n = 0; n < total_int; n++) {
     192              :         if (!isfinite(T_new[n])) {
     193              :             has_nan = 1;
     194              :         }
     195              :     }
     196          120 :     if (has_nan) {
     197            0 :         cfd_set_error(CFD_ERROR_DIVERGED,
     198              :                       "NaN/Inf detected in energy_step_explicit_omp");
     199            0 :         if (owns_buffer) cfd_free(T_new);
     200            0 :         return CFD_ERROR_DIVERGED;
     201              :     }
     202              : 
     203          120 :     memcpy(field->T, T_new, total * sizeof(double));
     204          120 :     if (owns_buffer) cfd_free(T_new);
     205              : 
     206              :     return CFD_SUCCESS;
     207              : }
        

Generated by: LCOV version 2.0-1