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

            Line data    Source code
       1              : /**
       2              :  * @file multigrid_transfer.c
       3              :  * @brief Grid-transfer operators for geometric multigrid (restriction/prolongation)
       4              :  *
       5              :  * Pure array math with no library runtime dependencies, so the operator unit
       6              :  * test can compile this translation unit directly (see multigrid_internal.h).
       7              :  * The OpenMP multigrid backend has row-parallel counterparts with the same
       8              :  * arithmetic in omp/linear_solver_multigrid_omp.c.
       9              :  *
      10              :  * Grid relationship: nxf = 2*nxc - 1 (fine dims are 2^k+1, coarse (2^(k-1))+1).
      11              :  * Coarse interior point (I,J,K) sits at fine point (2I,2J,2K); its
      12              :  * full-weighting stencil spans fine indices 2I-1..2I+1, which always lie in
      13              :  * the fine interior for coarse-interior I. Restriction therefore never reads
      14              :  * fine boundary values, and both operators write interior points only.
      15              :  */
      16              : 
      17              : #include "../multigrid_internal.h"
      18              : 
      19              : #include "cfd/core/indexing.h"
      20              : 
      21              : /* ============================================================================
      22              :  * RESTRICTION (fine -> coarse, full weighting)
      23              :  * ============================================================================ */
      24              : 
      25        11876 : void mg_restrict_2d(const double* fine, double* coarse,
      26              :                     size_t nxf, size_t nyf, size_t nxc, size_t nyc,
      27              :                     int fold_neumann) {
      28        11876 :     (void)nyf;
      29              :     /* Separable full weighting: interior stencil (1/16)*(4 center, 2 edge,
      30              :      * 1 corner) */
      31       217942 :     for (size_t J = 1; J < nyc - 1; J++) {
      32       206066 :         double wy[3];
      33       206066 :         mg_weights_1d(J, nyc, fold_neumann, wy);
      34     13778354 :         for (size_t I = 1; I < nxc - 1; I++) {
      35     13572288 :             double wx[3];
      36     13572288 :             mg_weights_1d(I, nxc, fold_neumann, wx);
      37              : 
      38     13572288 :             size_t i = 2 * I;
      39     13572288 :             size_t j = 2 * J;
      40     13572288 :             double sum = 0.0;
      41     54289152 :             for (int oj = -1; oj <= 1; oj++) {
      42    162867456 :                 for (int oi = -1; oi <= 1; oi++) {
      43    122150592 :                     double w = wx[oi + 1] * wy[oj + 1];
      44    122150592 :                     sum += w * fine[IDX_2D(i + oi, j + oj, nxf)];
      45              :                 }
      46              :             }
      47     13572288 :             coarse[IDX_2D(I, J, nxc)] = sum / 16.0;
      48              :         }
      49              :     }
      50        11876 : }
      51              : 
      52         1025 : void mg_restrict_3d(const double* fine, double* coarse,
      53              :                     size_t nxf, size_t nyf, size_t nzf,
      54              :                     size_t nxc, size_t nyc, size_t nzc,
      55              :                     int fold_neumann) {
      56         1025 :     (void)nzf;
      57              :     /* Separable 27-point full weighting: interior stencil (1/64)*(8 center,
      58              :      * 4 face, 2 edge, 1 corner) */
      59         3968 :     for (size_t K = 1; K < nzc - 1; K++) {
      60         2943 :         double wz[3];
      61         2943 :         mg_weights_1d(K, nzc, fold_neumann, wz);
      62        16128 :         for (size_t J = 1; J < nyc - 1; J++) {
      63        13185 :             double wy[3];
      64        13185 :             mg_weights_1d(J, nyc, fold_neumann, wy);
      65       275124 :             for (size_t I = 1; I < nxc - 1; I++) {
      66       261939 :                 double wx[3];
      67       261939 :                 mg_weights_1d(I, nxc, fold_neumann, wx);
      68              : 
      69       261939 :                 size_t i = 2 * I;
      70       261939 :                 size_t j = 2 * J;
      71       261939 :                 size_t k = 2 * K;
      72       261939 :                 double sum = 0.0;
      73      1047756 :                 for (int ok = -1; ok <= 1; ok++) {
      74      3143268 :                     for (int oj = -1; oj <= 1; oj++) {
      75      9429804 :                         for (int oi = -1; oi <= 1; oi++) {
      76      7072353 :                             double w = wx[oi + 1] * wy[oj + 1] * wz[ok + 1];
      77      7072353 :                             sum += w * fine[IDX_3D(i + oi, j + oj, k + ok,
      78              :                                                    nxf, nyf)];
      79              :                         }
      80              :                     }
      81              :                 }
      82       261939 :                 coarse[IDX_3D(I, J, K, nxc, nyc)] = sum / 64.0;
      83              :             }
      84              :         }
      85              :     }
      86         1025 : }
      87              : 
      88              : /* ============================================================================
      89              :  * PROLONGATION (coarse -> fine, bilinear/trilinear, additive)
      90              :  * ============================================================================ */
      91              : 
      92        11873 : void mg_prolongate_add_2d(const double* coarse, double* fine,
      93              :                           size_t nxc, size_t nyc, size_t nxf, size_t nyf) {
      94        11873 :     (void)nyc;
      95       435836 :     for (size_t j = 1; j < nyf - 1; j++) {
      96       423963 :         size_t J = j >> 1;
      97       423963 :         int jodd = (int)(j & 1);
      98     55554196 :         for (size_t i = 1; i < nxf - 1; i++) {
      99     55130233 :             size_t I = i >> 1;
     100     55130233 :             int iodd = (int)(i & 1);
     101     55130233 :             double e;
     102     55130233 :             if (!iodd && !jodd) {
     103     13572141 :                 e = coarse[IDX_2D(I, J, nxc)];
     104     41558092 :             } else if (iodd && !jodd) {
     105     13778186 :                 e = 0.5 * (coarse[IDX_2D(I, J, nxc)]
     106     13778186 :                          + coarse[IDX_2D(I + 1, J, nxc)]);
     107     27779906 :             } else if (!iodd && jodd) {
     108     13780994 :                 e = 0.5 * (coarse[IDX_2D(I, J, nxc)]
     109     13780994 :                          + coarse[IDX_2D(I, J + 1, nxc)]);
     110              :             } else {
     111     13998912 :                 e = 0.25 * (coarse[IDX_2D(I, J, nxc)]
     112     13998912 :                           + coarse[IDX_2D(I + 1, J, nxc)]
     113     13998912 :                           + coarse[IDX_2D(I, J + 1, nxc)]
     114     13998912 :                           + coarse[IDX_2D(I + 1, J + 1, nxc)]);
     115              :             }
     116     55130233 :             fine[IDX_2D(i, j, nxf)] += e;
     117              :         }
     118              :     }
     119        11873 : }
     120              : 
     121         1023 : void mg_prolongate_add_3d(const double* coarse, double* fine,
     122              :                           size_t nxc, size_t nyc, size_t nzc,
     123              :                           size_t nxf, size_t nyf, size_t nzf) {
     124         1023 :     (void)nzc;
     125         7920 :     for (size_t k = 1; k < nzf - 1; k++) {
     126         6897 :         size_t K = k >> 1;
     127         6897 :         size_t nk = (k & 1) ? 2 : 1;
     128         6897 :         double wk = (k & 1) ? 0.5 : 1.0;
     129        74016 :         for (size_t j = 1; j < nyf - 1; j++) {
     130        67119 :             size_t J = j >> 1;
     131        67119 :             size_t nj = (j & 1) ? 2 : 1;
     132        67119 :             double wj = (j & 1) ? 0.5 : 1.0;
     133      3123192 :             for (size_t i = 1; i < nxf - 1; i++) {
     134      3056073 :                 size_t I = i >> 1;
     135      3056073 :                 size_t ni = (i & 1) ? 2 : 1;
     136      3056073 :                 double wi = (i & 1) ? 0.5 : 1.0;
     137      3056073 :                 double e = 0.0;
     138      8064762 :                 for (size_t ck = 0; ck < nk; ck++) {
     139     12574986 :                     for (size_t cj = 0; cj < nj; cj++) {
     140     18997182 :                         for (size_t ci = 0; ci < ni; ci++) {
     141     11430885 :                             e += wi * wj * wk
     142     11430885 :                                * coarse[IDX_3D(I + ci, J + cj, K + ck,
     143              :                                                nxc, nyc)];
     144              :                         }
     145              :                     }
     146              :                 }
     147      3056073 :                 fine[IDX_3D(i, j, k, nxf, nyf)] += e;
     148              :             }
     149              :         }
     150              :     }
     151         1023 : }
     152              : 
     153              : /* ============================================================================
     154              :  * INTERIOR MEAN (Neumann nullspace handling)
     155              :  * ============================================================================ */
     156              : 
     157        20527 : void mg_subtract_interior_mean(double* f, size_t nx, size_t ny, size_t nz) {
     158        20527 :     double mean = mg_interior_mean(f, nx, ny, nz);
     159              : 
     160        20527 :     size_t stride_z = (nz > 1) ? nx * ny : 0;
     161        20527 :     size_t k_start = (nz > 1) ? 1 : 0;
     162        20527 :     size_t k_end = (nz > 1) ? nz - 1 : 1;
     163              : 
     164        42567 :     for (size_t k = k_start; k < k_end; k++) {
     165       551044 :         for (size_t j = 1; j < ny - 1; j++) {
     166     21512644 :             for (size_t i = 1; i < nx - 1; i++) {
     167     20983640 :                 f[k * stride_z + IDX_2D(i, j, nx)] -= mean;
     168              :             }
     169              :         }
     170              :     }
     171        20527 : }
        

Generated by: LCOV version 2.0-1