Line data Source code
1 : /**
2 : * @file solver_rk2_omp.c
3 : * @brief RK2 (Heun's method) time integration - OpenMP parallelized
4 : *
5 : * Same algorithm as scalar RK2 but with OpenMP-parallelized loops.
6 : * Achieves O(dt^2) temporal accuracy with multi-threaded execution.
7 : *
8 : * Branch-free 3D: when nz==1, stride_z=0 and inv_2dz/inv_dz2=0.0 cause all
9 : * z-terms to vanish, producing bit-identical results to the 2D code path.
10 : */
11 :
12 : #include "cfd/core/cfd_status.h"
13 : #include "cfd/core/grid.h"
14 : #include "cfd/core/indexing.h"
15 : #include "cfd/core/memory.h"
16 : #include "cfd/solvers/energy_solver.h"
17 : #include "cfd/solvers/navier_stokes_solver.h"
18 : #include "cfd/solvers/turbulence_solver.h"
19 : #include "../../energy/energy_solver_internal.h"
20 : #include "../../turbulence/turbulence_solver_internal.h"
21 :
22 : #include <math.h>
23 : #include <stddef.h>
24 : #include <string.h>
25 :
26 : #ifdef CFD_ENABLE_OPENMP
27 :
28 : #include <omp.h>
29 :
30 : /* OpenMP version-gated pragmas */
31 : #if _OPENMP >= 201307 /* OMP 4.0 */
32 : # define OMP_FOR_SIMD _Pragma("omp parallel for simd schedule(static)")
33 : #else
34 : # define OMP_FOR_SIMD _Pragma("omp parallel for schedule(static)")
35 : #endif
36 :
37 : #ifndef M_PI
38 : #define M_PI 3.14159265358979323846
39 : #endif
40 :
41 : /* Velocity clamp used by the time-step update (not the RHS kernel) */
42 : #define MAX_VELOCITY_LIMIT 100.0
43 :
44 : /* Shared OpenMP momentum RHS kernel (also #include-d by solver_rk4_omp.c).
45 : * Included inside the CFD_ENABLE_OPENMP block, after <omp.h>/<math.h>/grid/
46 : * energy. Defines the shared clamp constants MAX_DERIVATIVE_LIMIT /
47 : * MAX_SECOND_DERIVATIVE_LIMIT / MAX_DIVERGENCE_LIMIT / PRESSURE_UPDATE_FACTOR. */
48 : #include "../momentum_rhs/ns_momentum_rhs_omp.h"
49 :
50 :
51 : /* ============================================================================
52 : * RK2 OMP SOLVER
53 : * ============================================================================ */
54 :
55 259 : cfd_status_t rk2_omp_impl(flow_field* field, const grid* grid,
56 : const ns_solver_params_t* params) {
57 259 : if (field->nx < 3 || field->ny < 3 || (field->nz > 1 && field->nz < 3)) {
58 : return CFD_ERROR_INVALID;
59 : }
60 :
61 259 : size_t nx = field->nx;
62 259 : size_t ny = field->ny;
63 259 : size_t nz = field->nz;
64 :
65 : /* Reject non-uniform z-spacing (solver uses constant inv_2dz/inv_dz2) */
66 259 : if (nz > 1 && grid->dz) {
67 44 : for (size_t k = 1; k < nz - 1; k++) {
68 37 : if (fabs(grid->dz[k] - grid->dz[0]) > 1e-14) {
69 : return CFD_ERROR_INVALID;
70 : }
71 : }
72 : }
73 :
74 259 : size_t plane = nx * ny;
75 259 : size_t total = plane * nz;
76 259 : size_t bytes = total * sizeof(double);
77 :
78 : /* Branch-free 3D constants */
79 259 : size_t stride_z = (nz > 1) ? plane : 0;
80 259 : size_t k_start = (nz > 1) ? 1 : 0;
81 259 : size_t k_end = (nz > 1) ? (nz - 1) : 1;
82 259 : double inv_2dz = (nz > 1 && grid->dz) ? 1.0 / (2.0 * grid->dz[0]) : 0.0;
83 7 : double inv_dz2 = (nz > 1 && grid->dz) ? 1.0 / (grid->dz[0] * grid->dz[0]) : 0.0;
84 :
85 : /* Allocate working arrays:
86 : * k1_u/v/w/p : Stage 1 derivatives
87 : * k2_u/v/w/p : Stage 2 derivatives
88 : * u0/v0/w0/p0 : Saved state Q^n
89 : */
90 259 : double* k1_u = (double*)cfd_calloc(total, sizeof(double));
91 259 : double* k1_v = (double*)cfd_calloc(total, sizeof(double));
92 259 : double* k1_w = (double*)cfd_calloc(total, sizeof(double));
93 259 : double* k1_p = (double*)cfd_calloc(total, sizeof(double));
94 259 : double* k2_u = (double*)cfd_calloc(total, sizeof(double));
95 259 : double* k2_v = (double*)cfd_calloc(total, sizeof(double));
96 259 : double* k2_w = (double*)cfd_calloc(total, sizeof(double));
97 259 : double* k2_p = (double*)cfd_calloc(total, sizeof(double));
98 259 : double* u0 = (double*)cfd_calloc(total, sizeof(double));
99 259 : double* v0 = (double*)cfd_calloc(total, sizeof(double));
100 259 : double* w0 = (double*)cfd_calloc(total, sizeof(double));
101 259 : double* p0 = (double*)cfd_calloc(total, sizeof(double));
102 259 : int needs_T_ws = (params->alpha > 0.0 || params->beta != 0.0);
103 259 : double* T_energy_ws = needs_T_ws
104 2 : ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
105 259 : const int turb_on = (params->turb_model != TURB_MODEL_NONE);
106 518 : double* turb_ws = turb_on
107 259 : ? (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double)) : NULL;
108 :
109 259 : if (!k1_u || !k1_v || !k1_w || !k1_p ||
110 259 : !k2_u || !k2_v || !k2_w || !k2_p ||
111 259 : !u0 || !v0 || !w0 || !p0 ||
112 259 : (needs_T_ws && !T_energy_ws) || (turb_on && !turb_ws)) {
113 0 : cfd_free(k1_u); cfd_free(k1_v); cfd_free(k1_w); cfd_free(k1_p);
114 0 : cfd_free(k2_u); cfd_free(k2_v); cfd_free(k2_w); cfd_free(k2_p);
115 0 : cfd_free(u0); cfd_free(v0); cfd_free(w0); cfd_free(p0);
116 0 : cfd_free(T_energy_ws); cfd_free(turb_ws);
117 0 : return CFD_ERROR_NOMEM;
118 : }
119 :
120 259 : double dt = params->dt;
121 259 : ptrdiff_t total_int = (ptrdiff_t)total;
122 259 : cfd_status_t status = CFD_SUCCESS;
123 :
124 556 : for (int iter = 0; iter < params->max_iter; iter++) {
125 : /* Save Q^n */
126 297 : memcpy(u0, field->u, bytes);
127 297 : memcpy(v0, field->v, bytes);
128 297 : memcpy(w0, field->w, bytes);
129 297 : memcpy(p0, field->p, bytes);
130 :
131 : /* ---- Stage 1: k1 = RHS(Q^n) ---- */
132 297 : memset(k1_u, 0, bytes);
133 297 : memset(k1_v, 0, bytes);
134 297 : memset(k1_w, 0, bytes);
135 297 : memset(k1_p, 0, bytes);
136 :
137 297 : compute_rhs_omp(field->u, field->v, field->w, field->p, field->rho, field->T,
138 297 : field->nu_t,
139 : k1_u, k1_v, k1_w, k1_p,
140 : grid, params, nx, ny, nz,
141 : stride_z, k_start, k_end, inv_2dz, inv_dz2,
142 : iter, dt);
143 :
144 : /* ---- Intermediate: field = Q^n + dt * k1 ---- */
145 : {
146 297 : ptrdiff_t kk;
147 297 : OMP_FOR_SIMD
148 : for (kk = 0; kk < total_int; kk++) {
149 : field->u[kk] = u0[kk] + dt * k1_u[kk];
150 : field->v[kk] = v0[kk] + dt * k1_v[kk];
151 : field->w[kk] = w0[kk] + dt * k1_w[kk];
152 : field->p[kk] = p0[kk] + dt * k1_p[kk];
153 :
154 : field->u[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->u[kk]));
155 : field->v[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->v[kk]));
156 : field->w[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->w[kk]));
157 : }
158 : }
159 :
160 : /* NOTE: Do NOT apply BCs between RK stages. The ghost cells carry
161 : * zero-derivative evolution (k1[ghost]=0), which is consistent with
162 : * the semi-discrete ODE system. Applying BCs here would reduce RK2
163 : * to first-order temporal accuracy. */
164 :
165 : /* ---- Stage 2: k2 = RHS(Q_pred) ---- */
166 297 : memset(k2_u, 0, bytes);
167 297 : memset(k2_v, 0, bytes);
168 297 : memset(k2_w, 0, bytes);
169 297 : memset(k2_p, 0, bytes);
170 :
171 297 : compute_rhs_omp(field->u, field->v, field->w, field->p, field->rho, field->T,
172 297 : field->nu_t,
173 : k2_u, k2_v, k2_w, k2_p,
174 : grid, params, nx, ny, nz,
175 : stride_z, k_start, k_end, inv_2dz, inv_dz2,
176 : iter, dt);
177 :
178 : /* ---- Final update: Q^{n+1} = Q^n + (dt/2)*(k1 + k2) ---- */
179 : {
180 297 : double half_dt = 0.5 * dt;
181 297 : ptrdiff_t kk;
182 297 : OMP_FOR_SIMD
183 : for (kk = 0; kk < total_int; kk++) {
184 : field->u[kk] = u0[kk] + half_dt * (k1_u[kk] + k2_u[kk]);
185 : field->v[kk] = v0[kk] + half_dt * (k1_v[kk] + k2_v[kk]);
186 : field->w[kk] = w0[kk] + half_dt * (k1_w[kk] + k2_w[kk]);
187 : field->p[kk] = p0[kk] + half_dt * (k1_p[kk] + k2_p[kk]);
188 :
189 : field->u[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->u[kk]));
190 : field->v[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->v[kk]));
191 : field->w[kk] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->w[kk]));
192 : }
193 : }
194 :
195 : /* Energy equation: advance temperature after RK2 velocity update */
196 : {
197 297 : cfd_status_t energy_status = energy_step_explicit_omp_with_workspace(
198 : field, grid, params, dt, iter * dt, T_energy_ws, total);
199 297 : if (energy_status != CFD_SUCCESS) {
200 0 : status = energy_status;
201 0 : goto cleanup;
202 : }
203 : }
204 :
205 : /* Apply BCs to final state only (after the full RK2 step).
206 : * Then apply configured thermal BCs (overwrites periodic T values). */
207 297 : apply_boundary_conditions(field, grid);
208 297 : status = energy_apply_thermal_bcs(field, params);
209 297 : if (status != CFD_SUCCESS) {
210 0 : goto cleanup;
211 : }
212 :
213 : /* Turbulence transport: advance k-eps/SA with the updated velocity,
214 : * then apply turbulence BCs (including wall functions). nu_t is
215 : * frozen across RK stages and updated once per full step. */
216 297 : status = turbulence_step_explicit_omp_with_workspace(
217 : field, grid, params, dt, iter * dt, turb_ws,
218 : turb_on ? TURB_WORKSPACE_SIZE(total) : 0);
219 297 : if (status == CFD_SUCCESS) {
220 297 : status = turbulence_apply_bcs(field, grid, params);
221 : }
222 297 : if (status != CFD_SUCCESS) {
223 0 : goto cleanup;
224 : }
225 :
226 : /* NaN / Inf check (parallelized) */
227 : {
228 297 : int has_nan = 0;
229 297 : ptrdiff_t kk;
230 297 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
231 : for (kk = 0; kk < total_int; kk++) {
232 : if (!isfinite(field->u[kk]) || !isfinite(field->v[kk]) ||
233 : !isfinite(field->w[kk]) || !isfinite(field->p[kk])) {
234 : has_nan = 1;
235 : }
236 : }
237 297 : if (has_nan) {
238 0 : status = CFD_ERROR_DIVERGED;
239 0 : goto cleanup;
240 : }
241 : }
242 : }
243 :
244 259 : cleanup:
245 259 : cfd_free(k1_u); cfd_free(k1_v); cfd_free(k1_w); cfd_free(k1_p);
246 259 : cfd_free(k2_u); cfd_free(k2_v); cfd_free(k2_w); cfd_free(k2_p);
247 259 : cfd_free(u0); cfd_free(v0); cfd_free(w0); cfd_free(p0);
248 259 : cfd_free(T_energy_ws); cfd_free(turb_ws);
249 :
250 259 : return status;
251 : }
252 :
253 : #endif /* CFD_ENABLE_OPENMP */
|