Line data Source code
1 : #include "cfd/boundary/boundary_conditions.h"
2 : #include "cfd/core/cfd_status.h"
3 : #include "cfd/core/grid.h"
4 : #include "cfd/core/indexing.h"
5 : #include "cfd/core/memory.h"
6 : #include "cfd/solvers/energy_solver.h"
7 : #include "cfd/solvers/navier_stokes_solver.h"
8 : #include "cfd/solvers/poisson_solver.h"
9 : #include "cfd/solvers/turbulence_solver.h"
10 : #include "../../energy/energy_solver_internal.h"
11 : #include "../../linear/multigrid_internal.h"
12 : #include "../../turbulence/turbulence_solver_internal.h"
13 :
14 : #include "../boundary_copy_utils.h"
15 : #include "../ns_convection_internal.h"
16 : #include "../ns_pressure_internal.h"
17 :
18 : #include <math.h>
19 : #include <omp.h>
20 : #include <stdio.h>
21 : #include <string.h>
22 :
23 :
24 : #ifndef M_PI
25 : #define M_PI 3.14159265358979323846
26 : #endif
27 :
28 : // Physical limits
29 : #define MAX_VELOCITY 100.0
30 :
31 : /**
32 : * Turn the explicit increment in `star` into the implicit viscous one:
33 : *
34 : * (I - theta*nu*dt*lap) delta = star - cur, star = cur + delta
35 : *
36 : * on the OpenMP CG solver the projection owns. Same numerics as the scalar
37 : * implicit_viscous_component(); see ns_viscous_internal.h.
38 : */
39 258 : static cfd_status_t implicit_viscous_component_omp(poisson_solver_t* viscous,
40 : const double* cur, double* star,
41 : double* rhs, double* delta,
42 : size_t nx, size_t ny, size_t total,
43 : size_t k_start, size_t k_end,
44 : size_t stride_z) {
45 258 : double sigma = viscous->params.helmholtz_shift;
46 :
47 258 : memset(delta, 0, total * sizeof(double));
48 1236 : for (size_t kk = k_start; kk < k_end; kk++) {
49 978 : int j;
50 978 : #pragma omp parallel for schedule(static)
51 : for (j = 1; j < (int)ny - 1; j++) {
52 : for (int i = 1; i < (int)nx - 1; i++) {
53 : size_t idx = kk * stride_z + IDX_2D(i, j, nx);
54 : rhs[idx] = -sigma * (star[idx] - cur[idx]);
55 : }
56 : }
57 : }
58 :
59 258 : poisson_solver_stats_t vstats = poisson_solver_stats_default();
60 258 : cfd_status_t status = poisson_solver_solve(viscous, delta, NULL, rhs, &vstats);
61 258 : if (status != CFD_SUCCESS) {
62 : return status;
63 : }
64 :
65 1236 : for (size_t kk = k_start; kk < k_end; kk++) {
66 978 : int j;
67 978 : #pragma omp parallel for schedule(static)
68 : for (j = 1; j < (int)ny - 1; j++) {
69 : for (int i = 1; i < (int)nx - 1; i++) {
70 : size_t idx = kk * stride_z + IDX_2D(i, j, nx);
71 : star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, cur[idx] + delta[idx]));
72 : }
73 : }
74 : }
75 : return CFD_SUCCESS;
76 : }
77 :
78 295 : cfd_status_t solve_projection_method_omp(flow_field* field, const grid* grid,
79 : const ns_solver_params_t* params,
80 : poisson_solver_t* pressure,
81 : poisson_solver_t* viscous) {
82 295 : if (!field || !grid || !params || !pressure) {
83 : return CFD_ERROR_INVALID;
84 : }
85 295 : if (field->nx < 3 || field->ny < 3 || (field->nz > 1 && field->nz < 3)) {
86 : return CFD_ERROR_INVALID;
87 : }
88 : /* The buffers below are sized from the field; the solver from the grid. */
89 295 : cfd_status_t shape_status =
90 295 : ns_pressure_check_shape(pressure, field->nx, field->ny, field->nz);
91 295 : if (shape_status == CFD_SUCCESS && viscous) {
92 86 : shape_status = ns_pressure_check_shape(viscous, field->nx, field->ny, field->nz);
93 : }
94 295 : if (shape_status != CFD_SUCCESS) {
95 : return shape_status;
96 : }
97 : /* The implicit operator has one constant viscosity; nu + nu_t does not. */
98 295 : if (viscous && params->turb_model != TURB_MODEL_NONE) {
99 0 : cfd_set_error(CFD_ERROR_UNSUPPORTED,
100 : "The implicit viscous solve does not support turbulence models");
101 0 : return CFD_ERROR_UNSUPPORTED;
102 : }
103 :
104 295 : size_t nx = field->nx;
105 295 : size_t ny = field->ny;
106 295 : size_t nz = field->nz;
107 :
108 : /* Reject non-uniform z-spacing */
109 295 : if (nz > 1 && grid->dz) {
110 327 : for (size_t kk = 1; kk < nz - 1; kk++) {
111 286 : if (fabs(grid->dz[kk] - grid->dz[0]) > 1e-14) {
112 : return CFD_ERROR_INVALID;
113 : }
114 : }
115 : }
116 :
117 295 : size_t plane = nx * ny;
118 295 : size_t total = plane * nz;
119 :
120 : /* Branch-free 3D constants */
121 295 : size_t stride_z = (nz > 1) ? plane : 0;
122 295 : size_t k_start = (nz > 1) ? 1 : 0;
123 295 : size_t k_end = (nz > 1) ? (nz - 1) : 1;
124 :
125 295 : double dx = grid->dx[0];
126 295 : double dy = grid->dy[0];
127 295 : double dz = (nz > 1 && grid->dz) ? grid->dz[0] : 0.0;
128 295 : double dt = params->dt;
129 295 : double nu = params->mu;
130 295 : double inv_2dz = (nz > 1 && grid->dz) ? 1.0 / (2.0 * dz) : 0.0;
131 41 : double inv_dz2 = (nz > 1 && grid->dz) ? 1.0 / (dz * dz) : 0.0;
132 295 : double inv_dz = 2.0 * inv_2dz;
133 295 : const int upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
134 :
135 :
136 295 : double* u_star = (double*)cfd_calloc(total, sizeof(double));
137 295 : double* v_star = (double*)cfd_calloc(total, sizeof(double));
138 295 : double* w_star = (double*)cfd_calloc(total, sizeof(double));
139 295 : double* p_new = (double*)cfd_calloc(total, sizeof(double));
140 295 : double* p_temp = (double*)cfd_calloc(total, sizeof(double));
141 295 : double* rhs = (double*)cfd_calloc(total, sizeof(double));
142 295 : int needs_T_ws = (params->alpha > 0.0 || params->beta != 0.0);
143 295 : double* T_energy_ws = needs_T_ws
144 2 : ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
145 295 : const int turb_on = (params->turb_model != TURB_MODEL_NONE);
146 590 : double* turb_ws = turb_on
147 295 : ? (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double)) : NULL;
148 295 : const int implicit_visc = (viscous != NULL);
149 295 : double* delta = implicit_visc ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
150 :
151 295 : if (!u_star || !v_star || !w_star || !p_new || !p_temp || !rhs ||
152 295 : (needs_T_ws && !T_energy_ws) || (turb_on && !turb_ws) ||
153 295 : (implicit_visc && !delta)) {
154 0 : cfd_free(u_star);
155 0 : cfd_free(v_star);
156 0 : cfd_free(w_star);
157 0 : cfd_free(p_new);
158 0 : cfd_free(p_temp);
159 0 : cfd_free(rhs);
160 0 : cfd_free(T_energy_ws);
161 0 : cfd_free(turb_ws);
162 0 : cfd_free(delta);
163 0 : return CFD_ERROR_NOMEM;
164 : }
165 :
166 295 : memcpy(u_star, field->u, total * sizeof(double));
167 295 : memcpy(v_star, field->v, total * sizeof(double));
168 295 : memcpy(w_star, field->w, total * sizeof(double));
169 295 : memcpy(p_new, field->p, total * sizeof(double));
170 :
171 628 : for (int iter = 0; iter < params->max_iter; iter++) {
172 : /* STEP 1: Predictor — compute u_star, v_star, w_star without pressure */
173 911 : for (size_t kk = k_start; kk < k_end; kk++) {
174 578 : int j;
175 578 : #pragma omp parallel for schedule(static)
176 : for (j = 1; j < (int)ny - 1; j++) {
177 : for (int i = 1; i < (int)nx - 1; i++) {
178 : size_t idx = kk * stride_z + IDX_2D(i, j, nx);
179 :
180 : double u = field->u[idx];
181 : double v = field->v[idx];
182 : double w = field->w[idx];
183 :
184 : double du_dx = (field->u[idx + 1] - field->u[idx - 1]) / (2.0 * dx);
185 : double du_dy = (field->u[idx + nx] - field->u[idx - nx]) / (2.0 * dy);
186 : double du_dz = (field->u[idx + stride_z] - field->u[idx - stride_z]) * inv_2dz;
187 : double dv_dx = (field->v[idx + 1] - field->v[idx - 1]) / (2.0 * dx);
188 : double dv_dy = (field->v[idx + nx] - field->v[idx - nx]) / (2.0 * dy);
189 : double dv_dz = (field->v[idx + stride_z] - field->v[idx - stride_z]) * inv_2dz;
190 : double dw_dx = (field->w[idx + 1] - field->w[idx - 1]) / (2.0 * dx);
191 : double dw_dy = (field->w[idx + nx] - field->w[idx - nx]) / (2.0 * dy);
192 : double dw_dz = (field->w[idx + stride_z] - field->w[idx - stride_z]) * inv_2dz;
193 :
194 : /* Convective derivatives: central, or first-order upwind */
195 : ns_conv_derivs_t cd = {du_dx, du_dy, du_dz, dv_dx, dv_dy, dv_dz,
196 : dw_dx, dw_dy, dw_dz};
197 : if (upwind) {
198 : ns_upwind_conv_derivs(field->u, field->v, field->w, idx,
199 : idx - 1, idx + 1, idx - nx, idx + nx,
200 : idx - stride_z, idx + stride_z,
201 : dx, dy, inv_dz, &cd);
202 : }
203 :
204 : double conv_u = u * cd.du_dx + v * cd.du_dy + w * cd.du_dz;
205 : double conv_v = u * cd.dv_dx + v * cd.dv_dy + w * cd.dv_dz;
206 : double conv_w = u * cd.dw_dx + v * cd.dw_dy + w * cd.dw_dz;
207 :
208 : double d2u_dx2 = (field->u[idx + 1] - 2.0 * u + field->u[idx - 1]) / (dx * dx);
209 : double d2u_dy2 = (field->u[idx + nx] - 2.0 * u + field->u[idx - nx]) / (dy * dy);
210 : double d2u_dz2 = (field->u[idx + stride_z] - 2.0 * u + field->u[idx - stride_z]) * inv_dz2;
211 : double d2v_dx2 = (field->v[idx + 1] - 2.0 * v + field->v[idx - 1]) / (dx * dx);
212 : double d2v_dy2 = (field->v[idx + nx] - 2.0 * v + field->v[idx - nx]) / (dy * dy);
213 : double d2v_dz2 = (field->v[idx + stride_z] - 2.0 * v + field->v[idx - stride_z]) * inv_dz2;
214 : double d2w_dx2 = (field->w[idx + 1] - 2.0 * w + field->w[idx - 1]) / (dx * dx);
215 : double d2w_dy2 = (field->w[idx + nx] - 2.0 * w + field->w[idx - nx]) / (dy * dy);
216 : double d2w_dz2 = (field->w[idx + stride_z] - 2.0 * w + field->w[idx - stride_z]) * inv_dz2;
217 :
218 : double visc_u, visc_v, visc_w;
219 : if (!turb_on) {
220 : visc_u = nu * (d2u_dx2 + d2u_dy2 + d2u_dz2);
221 : visc_v = nu * (d2v_dx2 + d2v_dy2 + d2v_dz2);
222 : visc_w = nu * (d2w_dx2 + d2w_dy2 + d2w_dz2);
223 : } else {
224 : /* Turbulent: conservative face-averaged effective viscosity
225 : * div((nu + nu_t) grad u). The z-term keeps the laminar nu
226 : * (turbulence is 2D-only; it vanishes when nz == 1). */
227 : const double* nu_t = field->nu_t;
228 : double nu_xp = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]);
229 : double nu_xm = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]);
230 : double nu_yp = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]);
231 : double nu_ym = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]);
232 :
233 : visc_u = (nu_xp * (field->u[idx + 1] - u) -
234 : nu_xm * (u - field->u[idx - 1])) / (dx * dx) +
235 : (nu_yp * (field->u[idx + nx] - u) -
236 : nu_ym * (u - field->u[idx - nx])) / (dy * dy) +
237 : nu * d2u_dz2;
238 : visc_v = (nu_xp * (field->v[idx + 1] - v) -
239 : nu_xm * (v - field->v[idx - 1])) / (dx * dx) +
240 : (nu_yp * (field->v[idx + nx] - v) -
241 : nu_ym * (v - field->v[idx - nx])) / (dy * dy) +
242 : nu * d2v_dz2;
243 : visc_w = (nu_xp * (field->w[idx + 1] - w) -
244 : nu_xm * (w - field->w[idx - 1])) / (dx * dx) +
245 : (nu_yp * (field->w[idx + nx] - w) -
246 : nu_ym * (w - field->w[idx - nx])) / (dy * dy) +
247 : nu * d2w_dz2;
248 : }
249 :
250 : double source_u = 0.0;
251 : double source_v = 0.0;
252 : double source_w = 0.0;
253 : double z_coord = (nz > 1 && grid->z) ? grid->z[kk] : 0.0;
254 : if (params->source_func) {
255 : params->source_func(grid->x[i], grid->y[j], z_coord, iter * dt,
256 : params->source_context,
257 : &source_u, &source_v, &source_w);
258 : } else if (params->source_amplitude_u > 0) {
259 : source_u = params->source_amplitude_u * sin(M_PI * grid->y[j]) *
260 : exp(-params->source_decay_rate * iter * dt);
261 : source_v = params->source_amplitude_v * sin(2.0 * M_PI * grid->x[i]) *
262 : exp(-params->source_decay_rate * iter * dt);
263 : }
264 :
265 : // Boussinesq buoyancy source (no-op when beta == 0)
266 : energy_compute_buoyancy(field->T[idx], params,
267 : &source_u, &source_v, &source_w);
268 :
269 : u_star[idx] = u + dt * (-conv_u + visc_u + source_u);
270 : v_star[idx] = v + dt * (-conv_v + visc_v + source_v);
271 : w_star[idx] = w + dt * (-conv_w + visc_w + source_w);
272 :
273 : /* An implicit scheme clamps after its solve instead */
274 : if (!implicit_visc) {
275 : u_star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, u_star[idx]));
276 : v_star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, v_star[idx]));
277 : w_star[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, w_star[idx]));
278 : }
279 : }
280 : }
281 : }
282 :
283 : /* Copy boundary values from field to star arrays */
284 333 : copy_boundary_velocities_3d(u_star, v_star, w_star,
285 333 : field->u, field->v, field->w, nx, ny, nz);
286 :
287 : /* Implicit viscous term, on the OpenMP CG solver: replace each explicit
288 : * increment by the solution of (I - theta*nu*dt*lap) delta = increment.
289 : * rhs is free until the pressure solve below overwrites it. */
290 333 : if (implicit_visc) {
291 86 : const double* cur[3] = {field->u, field->v, field->w};
292 86 : double* star[3] = {u_star, v_star, w_star};
293 344 : for (int c = 0; c < 3; c++) {
294 258 : cfd_status_t visc_status = implicit_viscous_component_omp(
295 : viscous, cur[c], star[c], rhs, delta, nx, ny, total,
296 : k_start, k_end, stride_z);
297 258 : if (visc_status != CFD_SUCCESS) {
298 0 : cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
299 0 : cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
300 0 : cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
301 0 : return visc_status;
302 : }
303 : }
304 : }
305 :
306 : /* STEP 2: Pressure Poisson equation */
307 333 : double rho = field->rho[0] < 1e-10 ? 1.0 : field->rho[0];
308 :
309 911 : for (size_t kk = k_start; kk < k_end; kk++) {
310 578 : int j;
311 578 : #pragma omp parallel for schedule(static)
312 : for (j = 1; j < (int)ny - 1; j++) {
313 : for (int i = 1; i < (int)nx - 1; i++) {
314 : size_t idx = kk * stride_z + IDX_2D(i, j, nx);
315 : double du_star_dx = (u_star[idx + 1] - u_star[idx - 1]) / (2.0 * dx);
316 : double dv_star_dy = (v_star[idx + nx] - v_star[idx - nx]) / (2.0 * dy);
317 : double dw_star_dz = (w_star[idx + stride_z] - w_star[idx - stride_z]) * inv_2dz;
318 : rhs[idx] = (rho / dt) * (du_star_dx + dv_star_dy + dw_star_dz);
319 : }
320 : }
321 : }
322 :
323 : /* Neumann compatibility projection, but only when the operator is actually
324 : * singular. With every face zero-gradient the constants are its nullspace,
325 : * so the RHS must have zero interior mean -- div(u*) only nearly does, and
326 : * the remainder is removed here rather than assumed away. With a face
327 : * prescribed the operator is nonsingular and shifting the RHS would change
328 : * the answer instead of making it exist. */
329 333 : if (poisson_walls_are_singular(¶ms->pressure_bc, nz)) {
330 333 : mg_subtract_interior_mean_omp(rhs, nx, ny, nz);
331 : }
332 :
333 : /* Parallel Poisson solve on the solver this projection owns, which was
334 : * built on the OpenMP backend at init -- never a scalar one. */
335 333 : poisson_solver_stats_t pstats = poisson_solver_stats_default();
336 333 : cfd_status_t poisson_status =
337 333 : poisson_solver_solve(pressure, p_new, p_temp, rhs, &pstats);
338 :
339 333 : if (poisson_status != CFD_SUCCESS) {
340 0 : cfd_free(u_star);
341 0 : cfd_free(v_star);
342 0 : cfd_free(w_star);
343 0 : cfd_free(p_new);
344 0 : cfd_free(p_temp);
345 0 : cfd_free(rhs);
346 0 : cfd_free(T_energy_ws);
347 0 : cfd_free(turb_ws);
348 0 : cfd_free(delta);
349 0 : return poisson_status;
350 : }
351 :
352 : /* STEP 3: Corrector — project velocities with pressure gradient */
353 333 : double dt_over_rho = dt / rho;
354 911 : for (size_t kk = k_start; kk < k_end; kk++) {
355 578 : int j;
356 578 : #pragma omp parallel for schedule(static)
357 : for (j = 1; j < (int)ny - 1; j++) {
358 : for (int i = 1; i < (int)nx - 1; i++) {
359 : size_t idx = kk * stride_z + IDX_2D(i, j, nx);
360 : double dp_dx = (p_new[idx + 1] - p_new[idx - 1]) / (2.0 * dx);
361 : double dp_dy = (p_new[idx + nx] - p_new[idx - nx]) / (2.0 * dy);
362 : double dp_dz = (p_new[idx + stride_z] - p_new[idx - stride_z]) * inv_2dz;
363 :
364 : field->u[idx] = u_star[idx] - dt_over_rho * dp_dx;
365 : field->v[idx] = v_star[idx] - dt_over_rho * dp_dy;
366 : field->w[idx] = w_star[idx] - dt_over_rho * dp_dz;
367 :
368 : field->u[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, field->u[idx]));
369 : field->v[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, field->v[idx]));
370 : field->w[idx] = fmax(-MAX_VELOCITY, fmin(MAX_VELOCITY, field->w[idx]));
371 : }
372 : }
373 : }
374 :
375 333 : memcpy(field->p, p_new, total * sizeof(double));
376 :
377 : /* Energy equation: advance temperature after velocity correction */
378 : {
379 333 : cfd_status_t energy_status = energy_step_explicit_omp_with_workspace(
380 : field, grid, params, dt, iter * dt, T_energy_ws, total);
381 333 : if (energy_status != CFD_SUCCESS) {
382 0 : cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
383 0 : cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
384 0 : cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
385 0 : return energy_status;
386 : }
387 : }
388 :
389 : /* Apply configured thermal BCs to temperature field */
390 333 : cfd_status_t bc_status = energy_apply_thermal_bcs(field, params);
391 333 : if (bc_status != CFD_SUCCESS) {
392 0 : cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
393 0 : cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
394 0 : cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
395 0 : return bc_status;
396 : }
397 :
398 : /* Copy boundary velocity values from star arrays (which have caller's BCs) */
399 333 : copy_boundary_velocities_3d(field->u, field->v, field->w,
400 : u_star, v_star, w_star, nx, ny, nz);
401 :
402 : /* Turbulence transport: advance k-eps/SA with the corrected velocity,
403 : * then apply turbulence BCs (including wall functions) */
404 : {
405 333 : cfd_status_t turb_status = turbulence_step_explicit_omp_with_workspace(
406 : field, grid, params, dt, iter * dt, turb_ws,
407 : turb_on ? TURB_WORKSPACE_SIZE(total) : 0);
408 333 : if (turb_status == CFD_SUCCESS) {
409 333 : turb_status = turbulence_apply_bcs(field, grid, params);
410 : }
411 333 : if (turb_status != CFD_SUCCESS) {
412 0 : cfd_free(u_star); cfd_free(v_star); cfd_free(w_star);
413 0 : cfd_free(p_new); cfd_free(p_temp); cfd_free(rhs);
414 0 : cfd_free(T_energy_ws); cfd_free(turb_ws); cfd_free(delta);
415 0 : return turb_status;
416 : }
417 : }
418 :
419 : /* Check for NaN/Inf values (parallelized) */
420 333 : int has_nan = 0;
421 333 : ptrdiff_t total_int = (ptrdiff_t)total;
422 333 : ptrdiff_t ii;
423 333 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
424 : for (ii = 0; ii < total_int; ii++) {
425 : if (!isfinite(field->u[ii]) || !isfinite(field->v[ii]) ||
426 : !isfinite(field->w[ii]) || !isfinite(field->p[ii])) {
427 : has_nan = 1;
428 : }
429 : }
430 333 : if (has_nan) {
431 0 : cfd_free(u_star);
432 0 : cfd_free(v_star);
433 0 : cfd_free(w_star);
434 0 : cfd_free(p_new);
435 0 : cfd_free(p_temp);
436 0 : cfd_free(rhs);
437 0 : cfd_free(T_energy_ws);
438 0 : cfd_free(turb_ws);
439 0 : cfd_free(delta);
440 0 : return CFD_ERROR_DIVERGED;
441 : }
442 : }
443 :
444 295 : cfd_free(u_star);
445 295 : cfd_free(v_star);
446 295 : cfd_free(w_star);
447 295 : cfd_free(p_new);
448 295 : cfd_free(p_temp);
449 295 : cfd_free(rhs);
450 295 : cfd_free(T_energy_ws);
451 295 : cfd_free(turb_ws);
452 295 : cfd_free(delta);
453 295 : return CFD_SUCCESS;
454 : }
|