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
|