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 : }
|