LCOV - code coverage report
Current view: top level - boundary - boundary_conditions_core_impl.h (source / functions) Coverage Total Hit
Test: coverage.info Lines: 83.7 % 92 77
Test Date: 2026-10-05 04:47:18 Functions: 83.3 % 6 5

            Line data    Source code
       1              : /**
       2              :  * Boundary Conditions - Parameterized Core Implementation
       3              :  *
       4              :  * Shared implementation for Neumann, Periodic, and Dirichlet BCs.
       5              :  * Before including, define:
       6              :  *   BC_CORE_FUNC_PREFIX  - function name prefix (scalar or omp)
       7              :  *   BC_CORE_USE_OMP      - 1 for OpenMP pragmas, 0 for plain loops
       8              :  *
       9              :  * Generates:
      10              :  *   bc_apply_neumann_<prefix>_impl()
      11              :  *   bc_apply_periodic_<prefix>_impl()
      12              :  *   bc_apply_dirichlet_<prefix>_impl()
      13              :  *
      14              :  * 3D support: all functions accept (nz, stride_z). When nz <= 1,
      15              :  * z-face loops are skipped and x/y-face loops run for a single plane.
      16              :  */
      17              : 
      18              : #include "boundary_conditions_internal.h"
      19              : #include "cfd/core/indexing.h"
      20              : #include <limits.h>
      21              : 
      22              : /* Token pasting helpers */
      23              : #define BC_CORE_PASTE2(a, b) a##b
      24              : #define BC_CORE_PASTE(a, b) BC_CORE_PASTE2(a, b)
      25              : #define BC_CORE_FN(name) BC_CORE_PASTE(BC_CORE_PASTE(bc_apply_, name), BC_CORE_PASTE(_, BC_CORE_PASTE(BC_CORE_FUNC_PREFIX, _impl)))
      26              : 
      27              : /* Loop variable type and cast for OMP compatibility */
      28              : #if BC_CORE_USE_OMP
      29              : #define BC_LOOP_VAR int
      30              : #define BC_LOOP_LIMIT(n) ((n) > (size_t)INT_MAX ? INT_MAX : (int)(n))
      31              : /* points: boundary values the loop writes, gated by BC_OMP_MIN_POINTS. The if()
      32              :  * clause calls a function, so the stringized pragma relies on no macro expansion. */
      33              : #define BC_OMP_PRAGMA(x) _Pragma(#x)
      34              : #define BC_OMP_FOR(points) \
      35              :     BC_OMP_PRAGMA(omp parallel for schedule(static) if(bc_omp_worth_threading(points)))
      36              : #else
      37              : #define BC_LOOP_VAR size_t
      38              : #define BC_LOOP_LIMIT(n) (n)
      39              : #define BC_OMP_FOR(points)
      40              : #endif
      41              : 
      42              : /* --------------------------------------------------------------------
      43              :  * Neumann (zero-gradient)
      44              :  * -------------------------------------------------------------------- */
      45      1853211 : void BC_CORE_FN(neumann)(double* field, size_t nx, size_t ny,
      46              :                           size_t nz, size_t stride_z) {
      47      1853211 :     BC_LOOP_VAR j, i;
      48      1853211 :     size_t k;
      49              : 
      50              :     /* x-faces (left/right) for each z-plane */
      51      3706426 :     for (k = 0; k < nz; k++) {
      52      1853215 :         size_t base = k * stride_z;
      53         4017 :         BC_OMP_FOR(2 * ny)
      54     59265052 :         for (j = 0; j < BC_LOOP_LIMIT(ny); j++) {
      55     57415854 :             field[base + IDX_2D(0, j, nx)] = field[base + IDX_2D(1, j, nx)];
      56     57415854 :             field[base + IDX_2D(nx - 1, j, nx)] = field[base + IDX_2D(nx - 2, j, nx)];
      57              :         }
      58              :     }
      59              : 
      60              :     /* y-faces (bottom/top) for each z-plane */
      61      3706426 :     for (k = 0; k < nz; k++) {
      62      1853215 :         size_t base = k * stride_z;
      63      1853215 :         double* bottom_dst = field + base;
      64      1853215 :         double* bottom_src = field + base + nx;
      65      1853215 :         double* top_dst = field + base + ((ny - 1) * nx);
      66      1853215 :         double* top_src = field + base + ((ny - 2) * nx);
      67              : 
      68         4017 :         BC_OMP_FOR(2 * nx)
      69     58970458 :         for (i = 0; i < BC_LOOP_LIMIT(nx); i++) {
      70     57121260 :             bottom_dst[i] = bottom_src[i];
      71     57121260 :             top_dst[i] = top_src[i];
      72              :         }
      73              :     }
      74              : 
      75              :     /* z-faces (back/front) - only when nz > 1 */
      76      1853211 :     if (nz > 1) {
      77            1 :         double* back_dst = field;                            /* k=0 plane */
      78            1 :         double* back_src = field + stride_z;                 /* k=1 plane */
      79            1 :         double* front_dst = field + ((nz - 1) * stride_z);  /* k=nz-1 plane */
      80            1 :         double* front_src = field + ((nz - 2) * stride_z);  /* k=nz-2 plane */
      81            1 :         size_t plane_size = nx * ny;
      82              : 
      83            1 :         BC_OMP_FOR(2 * plane_size)
      84            0 :         for (i = 0; i < BC_LOOP_LIMIT(plane_size); i++) {
      85            0 :             back_dst[i] = back_src[i];
      86            0 :             front_dst[i] = front_src[i];
      87              :         }
      88              :     }
      89      1853211 : }
      90              : 
      91              : /* --------------------------------------------------------------------
      92              :  * Periodic
      93              :  * -------------------------------------------------------------------- */
      94        26149 : void BC_CORE_FN(periodic)(double* field, size_t nx, size_t ny,
      95              :                            size_t nz, size_t stride_z) {
      96        26149 :     BC_LOOP_VAR j, i;
      97        26149 :     size_t k;
      98              : 
      99              :     /* x-faces (left/right) for each z-plane */
     100        52302 :     for (k = 0; k < nz; k++) {
     101        26153 :         size_t base = k * stride_z;
     102        26153 :         BC_OMP_FOR(2 * ny)
     103            0 :         for (j = 0; j < BC_LOOP_LIMIT(ny); j++) {
     104            0 :             field[base + IDX_2D(0, j, nx)] = field[base + IDX_2D(nx - 2, j, nx)];
     105            0 :             field[base + IDX_2D(nx - 1, j, nx)] = field[base + IDX_2D(1, j, nx)];
     106              :         }
     107              :     }
     108              : 
     109              :     /* y-faces (bottom/top) for each z-plane */
     110        52302 :     for (k = 0; k < nz; k++) {
     111        26153 :         size_t base = k * stride_z;
     112        26153 :         double* bottom_dst = field + base;
     113        26153 :         double* bottom_src = field + base + ((ny - 2) * nx);
     114        26153 :         double* top_dst = field + base + ((ny - 1) * nx);
     115        26153 :         double* top_src = field + base + nx;
     116              : 
     117        26153 :         BC_OMP_FOR(2 * nx)
     118            0 :         for (i = 0; i < BC_LOOP_LIMIT(nx); i++) {
     119            0 :             bottom_dst[i] = bottom_src[i];
     120            0 :             top_dst[i] = top_src[i];
     121              :         }
     122              :     }
     123              : 
     124              :     /* z-faces (back/front) - only when nz > 1 */
     125        26149 :     if (nz > 1) {
     126            1 :         double* back_dst = field;                            /* k=0 plane */
     127            1 :         double* back_src = field + ((nz - 2) * stride_z);   /* k=nz-2 plane */
     128            1 :         double* front_dst = field + ((nz - 1) * stride_z);  /* k=nz-1 plane */
     129            1 :         double* front_src = field + stride_z;                /* k=1 plane */
     130            1 :         size_t plane_size = nx * ny;
     131              : 
     132            1 :         BC_OMP_FOR(2 * plane_size)
     133            0 :         for (i = 0; i < BC_LOOP_LIMIT(plane_size); i++) {
     134            0 :             back_dst[i] = back_src[i];
     135            0 :             front_dst[i] = front_src[i];
     136              :         }
     137              :     }
     138        26149 : }
     139              : 
     140              : /* --------------------------------------------------------------------
     141              :  * Dirichlet (fixed value)
     142              :  * -------------------------------------------------------------------- */
     143         8052 : void BC_CORE_FN(dirichlet)(double* field, size_t nx, size_t ny,
     144              :                             size_t nz, size_t stride_z,
     145              :                             const bc_dirichlet_values_t* values) {
     146         8052 :     BC_LOOP_VAR j, i;
     147         8052 :     size_t k;
     148         8052 :     double val_left = values->left;
     149         8052 :     double val_right = values->right;
     150         8052 :     double val_bottom = values->bottom;
     151         8052 :     double val_top = values->top;
     152              : 
     153              :     /* x-faces (left/right) for each z-plane */
     154        16120 :     for (k = 0; k < nz; k++) {
     155         8068 :         size_t base = k * stride_z;
     156         8055 :         BC_OMP_FOR(2 * ny)
     157          425 :         for (j = 0; j < BC_LOOP_LIMIT(ny); j++) {
     158          412 :             field[base + IDX_2D(0, j, nx)] = val_left;
     159          412 :             field[base + IDX_2D(nx - 1, j, nx)] = val_right;
     160              :         }
     161              :     }
     162              : 
     163              :     /* y-faces (bottom/top) for each z-plane */
     164        16120 :     for (k = 0; k < nz; k++) {
     165         8068 :         size_t base = k * stride_z;
     166         8068 :         double* bottom_row = field + base;
     167         8068 :         double* top_row = field + base + ((ny - 1) * nx);
     168              : 
     169         8055 :         BC_OMP_FOR(2 * nx)
     170          425 :         for (i = 0; i < BC_LOOP_LIMIT(nx); i++) {
     171          412 :             bottom_row[i] = val_bottom;
     172          412 :             top_row[i] = val_top;
     173              :         }
     174              :     }
     175              : 
     176              :     /* z-faces (back/front) - only when nz > 1 */
     177         8052 :     if (nz > 1) {
     178            4 :         double val_back = values->back;
     179            4 :         double val_front = values->front;
     180            4 :         double* back_plane = field;                         /* k=0 plane */
     181            4 :         double* front_plane = field + ((nz - 1) * stride_z); /* k=nz-1 plane */
     182            4 :         size_t plane_size = nx * ny;
     183              : 
     184            4 :         BC_OMP_FOR(2 * plane_size)
     185            0 :         for (i = 0; i < BC_LOOP_LIMIT(plane_size); i++) {
     186            0 :             back_plane[i] = val_back;
     187            0 :             front_plane[i] = val_front;
     188              :         }
     189              :     }
     190         8052 : }
     191              : 
     192              : /* Clean up macros to allow re-inclusion with different parameters */
     193              : #undef BC_LOOP_VAR
     194              : #undef BC_LOOP_LIMIT
     195              : #undef BC_OMP_FOR
     196              : #undef BC_OMP_PRAGMA
     197              : #undef BC_CORE_FN
     198              : #undef BC_CORE_PASTE
     199              : #undef BC_CORE_PASTE2
     200              : #undef BC_CORE_FUNC_PREFIX
     201              : #undef BC_CORE_USE_OMP
        

Generated by: LCOV version 2.0-1