Line data Source code
1 : /**
2 : * @file linear_solver_redblack_omp.c
3 : * @brief Red-Black SOR solver - OpenMP parallel implementation
4 : *
5 : * Red-Black SOR characteristics:
6 : * - Two-color sweep (red then black) allows parallelization
7 : * - In-place updates (no temporary buffer needed)
8 : * - SOR acceleration (omega > 1) for faster convergence
9 : * - Best balance of convergence speed and parallelism
10 : */
11 :
12 : #include "../linear_solver_internal.h"
13 :
14 : #include "cfd/core/indexing.h"
15 : #include "cfd/core/memory.h"
16 :
17 : #include <math.h>
18 :
19 : #ifdef CFD_ENABLE_OPENMP
20 : #include <omp.h>
21 : #endif
22 :
23 : /* ============================================================================
24 : * RED-BLACK CONTEXT
25 : * ============================================================================ */
26 :
27 : typedef struct {
28 : double dx2; /* dx^2 */
29 : double dy2; /* dy^2 */
30 : double inv_dx2; /* 1/dx^2 */
31 : double inv_dy2; /* 1/dy^2 */
32 : double inv_dz2; /* 1/dz^2 (0 for 2D) */
33 : double factor; /* 2 * (1/dx^2 + 1/dy^2 + inv_dz2) */
34 : double inv_factor; /* 1 / factor */
35 : double omega; /* SOR relaxation parameter */
36 : size_t stride_z; /* nx*ny for 3D, 0 for 2D */
37 : size_t k_start; /* first interior k index */
38 : size_t k_end; /* one-past-last interior k index */
39 : int initialized;
40 : } redblack_omp_context_t;
41 :
42 : /* ============================================================================
43 : * RED-BLACK OPENMP IMPLEMENTATION
44 : * ============================================================================ */
45 :
46 : #ifdef CFD_ENABLE_OPENMP
47 :
48 7 : static cfd_status_t redblack_omp_init(
49 : poisson_solver_t* solver,
50 : size_t nx, size_t ny, size_t nz,
51 : double dx, double dy, double dz,
52 : const poisson_solver_params_t* params)
53 : {
54 7 : redblack_omp_context_t* ctx = (redblack_omp_context_t*)cfd_calloc(1, sizeof(redblack_omp_context_t));
55 7 : if (!ctx) {
56 : return CFD_ERROR_NOMEM;
57 : }
58 :
59 7 : ctx->dx2 = dx * dx;
60 7 : ctx->dy2 = dy * dy;
61 7 : ctx->inv_dx2 = 1.0 / ctx->dx2;
62 7 : ctx->inv_dy2 = 1.0 / ctx->dy2;
63 7 : ctx->inv_dz2 = poisson_solver_compute_inv_dz2(dz);
64 7 : poisson_solver_compute_3d_bounds(nz, nx, ny, &ctx->stride_z, &ctx->k_start, &ctx->k_end);
65 7 : ctx->factor = 2.0 * (1.0 / ctx->dx2 + 1.0 / ctx->dy2 + ctx->inv_dz2);
66 7 : ctx->inv_factor = 1.0 / ctx->factor;
67 7 : ctx->omega = poisson_solver_resolve_omega(solver, params ? params->sor.omega : 0.0);
68 7 : ctx->initialized = 1;
69 :
70 7 : solver->context = ctx;
71 7 : return CFD_SUCCESS;
72 : }
73 :
74 10 : static void redblack_omp_destroy(poisson_solver_t* solver) {
75 10 : if (solver && solver->context) {
76 7 : cfd_free(solver->context);
77 7 : solver->context = NULL;
78 : }
79 10 : }
80 :
81 573 : static cfd_status_t redblack_omp_iterate(
82 : poisson_solver_t* solver,
83 : double* x,
84 : double* x_temp,
85 : const double* rhs,
86 : double* residual)
87 : {
88 573 : (void)x_temp;
89 :
90 573 : redblack_omp_context_t* ctx = (redblack_omp_context_t*)solver->context;
91 573 : size_t nx = solver->nx;
92 573 : size_t ny = solver->ny;
93 573 : size_t nz = solver->nz;
94 573 : double dx2 = ctx->dx2;
95 573 : double dy2 = ctx->dy2;
96 573 : double inv_dz2 = ctx->inv_dz2;
97 573 : double inv_factor = ctx->inv_factor;
98 573 : double omega = ctx->omega;
99 573 : size_t stride_z = ctx->stride_z;
100 573 : size_t k_start = ctx->k_start;
101 573 : size_t k_end = ctx->k_end;
102 573 : int walls = poisson_solver_uses_default_walls(solver);
103 :
104 : /* Red sweep (parallel) */
105 3344 : for (size_t k = k_start; k < k_end; k++) {
106 2771 : int j;
107 2771 : #pragma omp parallel for schedule(static)
108 : for (j = 1; j < (int)ny - 1; j++) {
109 : double w_row, w_edge;
110 : poisson_solver_row_omegas(walls, omega, ctx->factor, nx, ny, nz, (size_t)j, k,
111 : ctx->inv_dx2, ctx->inv_dy2, inv_dz2, &w_row, &w_edge);
112 : size_t i_start = ((j + k) % 2 == 0) ? 1 : 2;
113 : size_t i;
114 : for (i = i_start; i < nx - 1; i += 2) {
115 : size_t idx = k * stride_z + IDX_2D(i, (size_t)j, nx);
116 :
117 : double p_new = -(rhs[idx]
118 : - (x[idx + 1] + x[idx - 1]) / dx2
119 : - (x[idx + nx] + x[idx - nx]) / dy2
120 : - (x[idx + stride_z] + x[idx - stride_z]) * inv_dz2
121 : ) * inv_factor;
122 :
123 : double w = (i == 1 || i == nx - 2) ? w_edge : w_row;
124 : x[idx] = x[idx] + w * (p_new - x[idx]);
125 : }
126 : }
127 : }
128 :
129 : /* Black sweep (parallel) */
130 3344 : for (size_t k = k_start; k < k_end; k++) {
131 2771 : int j;
132 2771 : #pragma omp parallel for schedule(static)
133 : for (j = 1; j < (int)ny - 1; j++) {
134 : double w_row, w_edge;
135 : poisson_solver_row_omegas(walls, omega, ctx->factor, nx, ny, nz, (size_t)j, k,
136 : ctx->inv_dx2, ctx->inv_dy2, inv_dz2, &w_row, &w_edge);
137 : size_t i_start = ((j + k) % 2 == 0) ? 2 : 1;
138 : size_t i;
139 : for (i = i_start; i < nx - 1; i += 2) {
140 : size_t idx = k * stride_z + IDX_2D(i, (size_t)j, nx);
141 :
142 : double p_new = -(rhs[idx]
143 : - (x[idx + 1] + x[idx - 1]) / dx2
144 : - (x[idx + nx] + x[idx - nx]) / dy2
145 : - (x[idx + stride_z] + x[idx - stride_z]) * inv_dz2
146 : ) * inv_factor;
147 :
148 : double w = (i == 1 || i == nx - 2) ? w_edge : w_row;
149 : x[idx] = x[idx] + w * (p_new - x[idx]);
150 : }
151 : }
152 : }
153 :
154 : /* Apply boundary conditions */
155 573 : poisson_solver_apply_bc(solver, x);
156 :
157 : /* Compute residual if requested */
158 573 : if (residual) {
159 573 : *residual = poisson_solver_compute_residual(solver, x, rhs);
160 : }
161 :
162 573 : return CFD_SUCCESS;
163 : }
164 :
165 : #endif /* CFD_ENABLE_OPENMP */
166 :
167 : /* ============================================================================
168 : * FACTORY FUNCTION
169 : * ============================================================================ */
170 :
171 : #ifdef CFD_ENABLE_OPENMP
172 10 : poisson_solver_t* create_redblack_omp_solver(void) {
173 10 : poisson_solver_t* solver = (poisson_solver_t*)cfd_calloc(1, sizeof(poisson_solver_t));
174 10 : if (!solver) {
175 : return NULL;
176 : }
177 :
178 10 : solver->name = POISSON_SOLVER_TYPE_REDBLACK_OMP;
179 10 : solver->description = "Red-Black SOR iteration (OpenMP parallel)";
180 10 : solver->method = POISSON_METHOD_REDBLACK_SOR;
181 10 : solver->backend = POISSON_BACKEND_OMP;
182 10 : solver->params = poisson_solver_params_default();
183 :
184 10 : solver->init = redblack_omp_init;
185 10 : solver->destroy = redblack_omp_destroy;
186 10 : solver->solve = NULL;
187 10 : solver->iterate = redblack_omp_iterate;
188 10 : solver->apply_bc = NULL;
189 :
190 10 : return solver;
191 : }
192 : #endif
|