Line data Source code
1 : #include "cfd/core/cfd_status.h"
2 : #include "cfd/core/grid.h"
3 : #include "cfd/core/indexing.h"
4 : #include "cfd/core/memory.h"
5 :
6 : #include "cfd/solvers/energy_solver.h"
7 : #include "cfd/solvers/navier_stokes_solver.h"
8 : #include "cfd/solvers/turbulence_solver.h"
9 : #include "../../energy/energy_solver_internal.h"
10 : #include "../../turbulence/turbulence_solver_internal.h"
11 : #include "../boundary_copy_utils.h"
12 : #include "../ns_convection_internal.h"
13 : #include <math.h>
14 : #include <omp.h>
15 : #include <stdio.h>
16 : #include <string.h>
17 :
18 :
19 :
20 : #ifndef M_PI
21 : #define M_PI 3.14159265358979323846
22 : #endif
23 :
24 : // Physical stability limits (same as cpu solver)
25 : #define MAX_DERIVATIVE_LIMIT 100.0
26 : #define MAX_SECOND_DERIVATIVE_LIMIT 1000.0
27 : #define MAX_VELOCITY_LIMIT 100.0
28 : #define MAX_DIVERGENCE_LIMIT 10.0
29 : /* One definition lives in navier_stokes_solver.h (NS_EULER_DT_LIMIT). */
30 : #define DT_CONSERVATIVE_LIMIT NS_EULER_DT_LIMIT
31 : #define UPDATE_LIMIT 1.0
32 : #define PRESSURE_UPDATE_FACTOR 0.1
33 :
34 : // Internal OpenMP explicit Euler implementation
35 261 : cfd_status_t explicit_euler_omp_impl(flow_field* field, const grid* grid,
36 : const ns_solver_params_t* params) {
37 261 : if (field->nx < 3 || field->ny < 3 || (field->nz > 1 && field->nz < 3)) {
38 : return CFD_ERROR_INVALID;
39 : }
40 :
41 261 : size_t nz = field->nz;
42 261 : if (nz > 1 && grid->dz) {
43 44 : for (size_t kk = 1; kk < nz - 1; kk++) {
44 37 : if (fabs(grid->dz[kk] - grid->dz[0]) > 1e-14) {
45 : return CFD_ERROR_INVALID;
46 : }
47 : }
48 : }
49 :
50 261 : size_t nx = field->nx;
51 261 : size_t ny = field->ny;
52 261 : size_t plane = nx * ny;
53 261 : size_t total = plane * nz;
54 :
55 261 : size_t stride_z = (nz > 1) ? plane : 0;
56 261 : size_t k_start = (nz > 1) ? 1 : 0;
57 261 : size_t k_end = (nz > 1) ? (nz - 1) : 1;
58 261 : double inv_2dz = (nz > 1 && grid->dz) ? 1.0 / (2.0 * grid->dz[0]) : 0.0;
59 7 : double inv_dz2 = (nz > 1 && grid->dz) ? 1.0 / (grid->dz[0] * grid->dz[0]) : 0.0;
60 261 : double inv_dz = 2.0 * inv_2dz;
61 261 : const int upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
62 :
63 : // Allocate temporary arrays
64 261 : double* u_new = (double*)cfd_calloc(total, sizeof(double));
65 261 : double* v_new = (double*)cfd_calloc(total, sizeof(double));
66 261 : double* w_new = (double*)cfd_calloc(total, sizeof(double));
67 261 : double* p_new = (double*)cfd_calloc(total, sizeof(double));
68 261 : int needs_T_ws = (params->alpha > 0.0 || params->beta != 0.0);
69 261 : double* T_energy_ws = needs_T_ws
70 2 : ? (double*)cfd_calloc(total, sizeof(double)) : NULL;
71 261 : const int turb_on = (params->turb_model != TURB_MODEL_NONE);
72 522 : double* turb_ws = turb_on
73 261 : ? (double*)cfd_calloc(TURB_WORKSPACE_SIZE(total), sizeof(double)) : NULL;
74 :
75 261 : if (!u_new || !v_new || !w_new || !p_new ||
76 261 : (needs_T_ws && !T_energy_ws) || (turb_on && !turb_ws)) {
77 0 : cfd_free(u_new);
78 0 : cfd_free(v_new);
79 0 : cfd_free(w_new);
80 0 : cfd_free(p_new);
81 0 : cfd_free(T_energy_ws);
82 0 : cfd_free(turb_ws);
83 0 : return CFD_ERROR_NOMEM;
84 : }
85 :
86 : // Initialize with current values
87 261 : memcpy(u_new, field->u, total * sizeof(double));
88 261 : memcpy(v_new, field->v, total * sizeof(double));
89 261 : memcpy(w_new, field->w, total * sizeof(double));
90 261 : memcpy(p_new, field->p, total * sizeof(double));
91 :
92 261 : double conservative_dt = fmin(params->dt, DT_CONSERVATIVE_LIMIT);
93 :
94 558 : for (int iter = 0; iter < params->max_iter; iter++) {
95 628 : for (size_t kk = k_start; kk < k_end; kk++) {
96 329 : int j;
97 329 : #pragma omp parallel for schedule(static)
98 : for (j = 1; j < (int)ny - 1; j++) {
99 : for (int i = 1; i < (int)nx - 1; i++) {
100 : size_t idx = (kk * stride_z) + IDX_2D(i, j, nx);
101 :
102 : // Derivatives
103 : double du_dx = (field->u[idx + 1] - field->u[idx - 1]) / (2.0 * grid->dx[i]);
104 : double du_dy =
105 : (field->u[idx + nx] - field->u[idx - nx]) / (2.0 * grid->dy[j]);
106 : double dv_dx = (field->v[idx + 1] - field->v[idx - 1]) / (2.0 * grid->dx[i]);
107 : double dv_dy =
108 : (field->v[idx + nx] - field->v[idx - nx]) / (2.0 * grid->dy[j]);
109 :
110 : double dp_dx = (field->p[idx + 1] - field->p[idx - 1]) / (2.0 * grid->dx[i]);
111 : double dp_dy =
112 : (field->p[idx + nx] - field->p[idx - nx]) / (2.0 * grid->dy[j]);
113 :
114 : double d2u_dx2 = (field->u[idx + 1] - 2.0 * field->u[idx] + field->u[idx - 1]) /
115 : (grid->dx[i] * grid->dx[i]);
116 : double d2u_dy2 =
117 : (field->u[idx + nx] - 2.0 * field->u[idx] + field->u[idx - nx]) /
118 : (grid->dy[j] * grid->dy[j]);
119 : double d2v_dx2 = (field->v[idx + 1] - 2.0 * field->v[idx] + field->v[idx - 1]) /
120 : (grid->dx[i] * grid->dx[i]);
121 : double d2v_dy2 =
122 : (field->v[idx + nx] - 2.0 * field->v[idx] + field->v[idx - nx]) /
123 : (grid->dy[j] * grid->dy[j]);
124 :
125 : double du_dz = (field->u[idx + stride_z] - field->u[idx - stride_z]) * inv_2dz;
126 : double dv_dz = (field->v[idx + stride_z] - field->v[idx - stride_z]) * inv_2dz;
127 : double dw_dx = (field->w[idx + 1] - field->w[idx - 1]) / (2.0 * grid->dx[i]);
128 : double dw_dy = (field->w[idx + nx] - field->w[idx - nx]) / (2.0 * grid->dy[j]);
129 : double dw_dz = (field->w[idx + stride_z] - field->w[idx - stride_z]) * inv_2dz;
130 : double dp_dz = (field->p[idx + stride_z] - field->p[idx - stride_z]) * inv_2dz;
131 :
132 : double d2u_dz2 = (field->u[idx + stride_z] - 2.0 * field->u[idx] + field->u[idx - stride_z]) * inv_dz2;
133 : double d2v_dz2 = (field->v[idx + stride_z] - 2.0 * field->v[idx] + field->v[idx - stride_z]) * inv_dz2;
134 : double d2w_dx2 = (field->w[idx + 1] - 2.0 * field->w[idx] + field->w[idx - 1]) / (grid->dx[i] * grid->dx[i]);
135 : double d2w_dy2 = (field->w[idx + nx] - 2.0 * field->w[idx] + field->w[idx - nx]) / (grid->dy[j] * grid->dy[j]);
136 : double d2w_dz2 = (field->w[idx + stride_z] - 2.0 * field->w[idx] + field->w[idx - stride_z]) * inv_dz2;
137 :
138 : if (field->rho[idx] <= 1e-10) {
139 : continue;
140 : }
141 :
142 : double nu = params->mu / fmax(field->rho[idx], 1e-10);
143 : nu = fmin(nu, 1.0);
144 :
145 : // Convective derivatives: central, or first-order upwind.
146 : // The divergence below stays central.
147 : ns_conv_derivs_t cd = {du_dx, du_dy, du_dz, dv_dx, dv_dy, dv_dz,
148 : dw_dx, dw_dy, dw_dz};
149 : if (upwind) {
150 : ns_upwind_conv_derivs(field->u, field->v, field->w, idx,
151 : idx - 1, idx + 1, idx - nx, idx + nx,
152 : idx - stride_z, idx + stride_z,
153 : grid->dx[i], grid->dy[j], inv_dz, &cd);
154 : }
155 :
156 : // Source terms
157 : double source_u = 0.0;
158 : double source_v = 0.0;
159 : double source_w = 0.0;
160 : double z_coord = (nz > 1 && grid->z) ? grid->z[kk] : 0.0;
161 : if (params->source_func) {
162 : params->source_func(grid->x[i], grid->y[j], z_coord,
163 : iter * conservative_dt,
164 : params->source_context,
165 : &source_u, &source_v, &source_w);
166 : } else {
167 : source_u = params->source_amplitude_u * sin(M_PI * grid->y[j]) *
168 : exp(-params->source_decay_rate * iter * conservative_dt);
169 : source_v = params->source_amplitude_v * sin(2.0 * M_PI * grid->x[i]) *
170 : exp(-params->source_decay_rate * iter * conservative_dt);
171 : }
172 :
173 : // Boussinesq buoyancy source (no-op when beta == 0)
174 : energy_compute_buoyancy(field->T[idx], params,
175 : &source_u, &source_v, &source_w);
176 :
177 : // Viscous terms: laminar or turbulent (face-averaged nu_eff)
178 : double visc_u, visc_v, visc_w;
179 : if (!turb_on) {
180 : visc_u = nu * (d2u_dx2 + d2u_dy2 + d2u_dz2);
181 : visc_v = nu * (d2v_dx2 + d2v_dy2 + d2v_dz2);
182 : visc_w = nu * (d2w_dx2 + d2w_dy2 + d2w_dz2);
183 : } else {
184 : const double* nu_t = field->nu_t;
185 : double dx2 = grid->dx[i] * grid->dx[i];
186 : double dy2 = grid->dy[j] * grid->dy[j];
187 : /* Face-averaged nu_eff = nu + nu_t (nu_t is bounded by the
188 : * realizability clamp) */
189 : double nu_xp = nu + 0.5 * (nu_t[idx] + nu_t[idx + 1]);
190 : double nu_xm = nu + 0.5 * (nu_t[idx] + nu_t[idx - 1]);
191 : double nu_yp = nu + 0.5 * (nu_t[idx] + nu_t[idx + nx]);
192 : double nu_ym = nu + 0.5 * (nu_t[idx] + nu_t[idx - nx]);
193 : visc_u = (nu_xp * (field->u[idx + 1] - field->u[idx]) -
194 : nu_xm * (field->u[idx] - field->u[idx - 1])) / dx2 +
195 : (nu_yp * (field->u[idx + nx] - field->u[idx]) -
196 : nu_ym * (field->u[idx] - field->u[idx - nx])) / dy2 +
197 : nu * d2u_dz2;
198 : visc_v = (nu_xp * (field->v[idx + 1] - field->v[idx]) -
199 : nu_xm * (field->v[idx] - field->v[idx - 1])) / dx2 +
200 : (nu_yp * (field->v[idx + nx] - field->v[idx]) -
201 : nu_ym * (field->v[idx] - field->v[idx - nx])) / dy2 +
202 : nu * d2v_dz2;
203 : visc_w = (nu_xp * (field->w[idx + 1] - field->w[idx]) -
204 : nu_xm * (field->w[idx] - field->w[idx - 1])) / dx2 +
205 : (nu_yp * (field->w[idx + nx] - field->w[idx]) -
206 : nu_ym * (field->w[idx] - field->w[idx - nx])) / dy2 +
207 : nu * d2w_dz2;
208 : visc_u = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_u));
209 : visc_v = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_v));
210 : visc_w = fmax(-MAX_SECOND_DERIVATIVE_LIMIT, fmin(MAX_SECOND_DERIVATIVE_LIMIT, visc_w));
211 : }
212 :
213 : // Update u
214 : double du = conservative_dt * (-field->u[idx] * cd.du_dx - field->v[idx] * cd.du_dy
215 : - field->w[idx] * cd.du_dz
216 : - dp_dx / fmax(field->rho[idx], 1e-10)
217 : + visc_u + source_u);
218 :
219 : // Update v
220 : double dv = conservative_dt * (-field->u[idx] * cd.dv_dx - field->v[idx] * cd.dv_dy
221 : - field->w[idx] * cd.dv_dz
222 : - dp_dy / fmax(field->rho[idx], 1e-10)
223 : + visc_v + source_v);
224 :
225 : // Update w
226 : double dw = conservative_dt * (-field->u[idx] * cd.dw_dx - field->v[idx] * cd.dw_dy
227 : - field->w[idx] * cd.dw_dz
228 : - dp_dz / fmax(field->rho[idx], 1e-10)
229 : + visc_w + source_w);
230 :
231 : du = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, du));
232 : dv = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dv));
233 : dw = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dw));
234 :
235 : u_new[idx] = field->u[idx] + du;
236 : v_new[idx] = field->v[idx] + dv;
237 :
238 : // Limit velocity
239 : u_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, u_new[idx]));
240 : v_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, v_new[idx]));
241 : w_new[idx] = fmax(-MAX_VELOCITY_LIMIT, fmin(MAX_VELOCITY_LIMIT, field->w[idx] + dw));
242 :
243 : // Pressure update
244 : double divergence = du_dx + dv_dy + dw_dz;
245 : divergence = fmax(-MAX_DIVERGENCE_LIMIT, fmin(MAX_DIVERGENCE_LIMIT, divergence));
246 :
247 : double dp =
248 : -PRESSURE_UPDATE_FACTOR * conservative_dt * field->rho[idx] * divergence;
249 : dp = fmax(-UPDATE_LIMIT, fmin(UPDATE_LIMIT, dp));
250 : p_new[idx] = field->p[idx] + dp;
251 : }
252 : }
253 : }
254 :
255 : // Copy back (implicit barrier at end of parallel for)
256 299 : memcpy(field->u, u_new, total * sizeof(double));
257 299 : memcpy(field->v, v_new, total * sizeof(double));
258 299 : memcpy(field->w, w_new, total * sizeof(double));
259 299 : memcpy(field->p, p_new, total * sizeof(double));
260 :
261 : // Energy equation: advance temperature using updated velocity
262 : {
263 299 : cfd_status_t energy_status = energy_step_explicit_omp_with_workspace(
264 : field, grid, params, conservative_dt,
265 : iter * conservative_dt, T_energy_ws, total);
266 299 : if (energy_status != CFD_SUCCESS) {
267 0 : cfd_free(u_new); cfd_free(v_new); cfd_free(w_new);
268 0 : cfd_free(p_new); cfd_free(T_energy_ws); cfd_free(turb_ws);
269 0 : return energy_status;
270 : }
271 : }
272 :
273 : // Store caller-set boundary values before apply_boundary_conditions overwrites them,
274 : // then restore them afterward. Then apply configured thermal BCs.
275 299 : copy_boundary_velocities_3d(u_new, v_new, w_new,
276 299 : field->u, field->v, field->w, nx, ny, nz);
277 299 : apply_boundary_conditions(field, grid);
278 299 : copy_boundary_velocities_3d(field->u, field->v, field->w,
279 : u_new, v_new, w_new, nx, ny, nz);
280 299 : cfd_status_t bc_status = energy_apply_thermal_bcs(field, params);
281 299 : if (bc_status != CFD_SUCCESS) {
282 0 : cfd_free(u_new); cfd_free(v_new); cfd_free(w_new);
283 0 : cfd_free(p_new); cfd_free(T_energy_ws); cfd_free(turb_ws);
284 0 : return bc_status;
285 : }
286 :
287 : /* Turbulence transport: advance k-eps/SA with the updated velocity,
288 : * then apply turbulence BCs (including wall functions). nu_t is
289 : * frozen across the explicit Euler step and updated once per step. */
290 : {
291 299 : cfd_status_t turb_status = turbulence_step_explicit_omp_with_workspace(
292 : field, grid, params, conservative_dt, iter * conservative_dt,
293 : turb_ws, turb_on ? TURB_WORKSPACE_SIZE(total) : 0);
294 299 : if (turb_status == CFD_SUCCESS) {
295 299 : turb_status = turbulence_apply_bcs(field, grid, params);
296 : }
297 299 : if (turb_status != CFD_SUCCESS) {
298 0 : cfd_free(u_new); cfd_free(v_new); cfd_free(w_new);
299 0 : cfd_free(p_new); cfd_free(T_energy_ws); cfd_free(turb_ws);
300 0 : return turb_status;
301 : }
302 : }
303 :
304 : // Check for NaN/Inf values
305 299 : int has_nan = 0;
306 299 : ptrdiff_t total_int = (ptrdiff_t)total;
307 299 : ptrdiff_t ii;
308 299 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
309 : for (ii = 0; ii < total_int; ii++) {
310 : if (!isfinite(field->u[ii]) || !isfinite(field->v[ii]) ||
311 : !isfinite(field->w[ii]) || !isfinite(field->p[ii])) {
312 : has_nan = 1;
313 : }
314 : }
315 :
316 299 : if (has_nan) {
317 2 : cfd_free(u_new);
318 2 : cfd_free(v_new);
319 2 : cfd_free(w_new);
320 2 : cfd_free(p_new);
321 2 : cfd_free(T_energy_ws);
322 2 : cfd_free(turb_ws);
323 2 : cfd_set_error(CFD_ERROR_DIVERGED,
324 : "NaN/Inf detected in explicit_euler_omp step");
325 2 : return CFD_ERROR_DIVERGED;
326 : }
327 : }
328 :
329 259 : cfd_free(u_new);
330 259 : cfd_free(v_new);
331 259 : cfd_free(w_new);
332 259 : cfd_free(p_new);
333 259 : cfd_free(T_energy_ws);
334 259 : cfd_free(turb_ws);
335 :
336 259 : return CFD_SUCCESS;
337 : }
|