Line data Source code
1 : /**
2 : * @file energy_solver_omp.c
3 : * @brief OpenMP-parallelized energy equation solver (advection-diffusion step)
4 : *
5 : * Solves: dT/dt + u*nabla(T) = alpha * nabla^2(T) + Q
6 : * using explicit Euler time integration, central differences for diffusion, and
7 : * central or first-order upwind differences for advection
8 : * (params->convection_scheme).
9 : *
10 : * Same numerics as the scalar reference (energy/cpu/energy_solver.c); the
11 : * interior stencil loop is parallelized over j. Read/write separation
12 : * (reads field->T, writes T_new) makes the loop race-free. Buoyancy and
13 : * thermal BC application are shared with the scalar backend.
14 : *
15 : * Branch-free 3D: when nz==1, stride_z=0 and inv_2dz/inv_dz2=0.0 cause all
16 : * z-terms to vanish, producing identical results to a 2D code path.
17 : */
18 :
19 : #include "../energy_solver_internal.h"
20 :
21 : #include "cfd/core/indexing.h"
22 : #include "cfd/core/memory.h"
23 : #include "cfd/math/stencils.h"
24 :
25 : #include <math.h>
26 : #include <omp.h>
27 : #include <string.h>
28 :
29 1186 : cfd_status_t energy_step_explicit_omp_with_workspace(
30 : flow_field* field, const grid* grid,
31 : const ns_solver_params_t* params,
32 : double dt, double time,
33 : double* T_workspace, size_t workspace_size) {
34 1186 : if (!field || !grid || !params) {
35 0 : cfd_set_error(CFD_ERROR_INVALID,
36 : "energy_solver_omp: field, grid, and params must be non-NULL");
37 0 : return CFD_ERROR_INVALID;
38 : }
39 1186 : if (!field->T) {
40 0 : cfd_set_error(CFD_ERROR_INVALID,
41 : "energy_solver_omp: missing temperature field");
42 0 : return CFD_ERROR_INVALID;
43 : }
44 :
45 : /* Skip when energy equation is disabled */
46 1186 : if (params->alpha <= 0.0) {
47 : return CFD_SUCCESS;
48 : }
49 :
50 120 : size_t nx = field->nx;
51 120 : size_t ny = field->ny;
52 120 : size_t nz = field->nz;
53 :
54 120 : if (!grid->dx || !grid->dy || nx < 3 || ny < 3) {
55 0 : cfd_set_error(CFD_ERROR_INVALID,
56 : "energy_solver_omp: grid too small or missing dx/dy");
57 0 : return CFD_ERROR_INVALID;
58 : }
59 120 : size_t plane = nx * ny;
60 120 : size_t total = plane * nz;
61 120 : double alpha = params->alpha;
62 :
63 : /* Validate uniform spacing (central-difference stencil assumes it) */
64 120 : const double dx0 = grid->dx[0];
65 120 : const double dy0 = grid->dy[0];
66 : {
67 120 : const double tol_x = 1e-12 * fmax(1.0, fabs(dx0));
68 960 : for (size_t i = 1; i < nx - 1; i++) {
69 840 : if (fabs(grid->dx[i] - dx0) > tol_x) {
70 0 : cfd_set_error(CFD_ERROR_UNSUPPORTED,
71 : "energy_solver_omp: non-uniform dx not supported");
72 0 : return CFD_ERROR_UNSUPPORTED;
73 : }
74 : }
75 120 : const double tol_y = 1e-12 * fmax(1.0, fabs(dy0));
76 960 : for (size_t j = 1; j < ny - 1; j++) {
77 840 : if (fabs(grid->dy[j] - dy0) > tol_y) {
78 0 : cfd_set_error(CFD_ERROR_UNSUPPORTED,
79 : "energy_solver_omp: non-uniform dy not supported");
80 0 : return CFD_ERROR_UNSUPPORTED;
81 : }
82 : }
83 : }
84 120 : if (nz > 1) {
85 0 : if (!grid->dz) {
86 0 : cfd_set_error(CFD_ERROR_INVALID,
87 : "energy_solver_omp: missing dz for 3D energy solve");
88 0 : return CFD_ERROR_INVALID;
89 : }
90 0 : const double dz0 = grid->dz[0];
91 0 : const double tol_z = 1e-12 * fmax(1.0, fabs(dz0));
92 0 : for (size_t k = 1; k < nz - 1; k++) {
93 0 : if (fabs(grid->dz[k] - dz0) > tol_z) {
94 0 : cfd_set_error(CFD_ERROR_UNSUPPORTED,
95 : "energy_solver_omp: non-uniform dz not supported");
96 0 : return CFD_ERROR_UNSUPPORTED;
97 : }
98 : }
99 : }
100 :
101 : /* Precomputed constants for uniform-grid stencil */
102 120 : double inv_2dx = 1.0 / (2.0 * dx0);
103 120 : double inv_2dy = 1.0 / (2.0 * dy0);
104 120 : double inv_dx2 = 1.0 / (dx0 * dx0);
105 120 : double inv_dy2 = 1.0 / (dy0 * dy0);
106 :
107 : /* Branch-free 3D constants */
108 120 : size_t stride_z = (nz > 1) ? plane : 0;
109 120 : size_t k_start = (nz > 1) ? 1 : 0;
110 120 : size_t k_end = (nz > 1) ? (nz - 1) : 1;
111 120 : double inv_2dz = (nz > 1 && grid->dz) ? 1.0 / (2.0 * grid->dz[0]) : 0.0;
112 0 : double inv_dz2 = (nz > 1 && grid->dz) ? 1.0 / (grid->dz[0] * grid->dz[0]) : 0.0;
113 120 : double inv_dz = 2.0 * inv_2dz;
114 120 : const int upwind = (params->convection_scheme == NS_CONVECTION_SCHEME_UPWIND);
115 :
116 : /* Use caller's workspace or allocate internally */
117 120 : int owns_buffer = 0;
118 120 : double* T_new;
119 120 : if (T_workspace && workspace_size >= total) {
120 : T_new = T_workspace;
121 : } else {
122 0 : T_new = (double*)cfd_calloc(total, sizeof(double));
123 0 : if (!T_new) {
124 : return CFD_ERROR_NOMEM;
125 : }
126 : owns_buffer = 1;
127 : }
128 120 : memcpy(T_new, field->T, total * sizeof(double));
129 :
130 240 : for (size_t k = k_start; k < k_end; k++) {
131 120 : size_t k_offset = k * stride_z;
132 120 : int j;
133 120 : #pragma omp parallel for schedule(static)
134 : for (j = 1; j < (int)ny - 1; j++) {
135 : for (int i = 1; i < (int)nx - 1; i++) {
136 : size_t idx = k_offset + IDX_2D((size_t)i, (size_t)j, nx);
137 :
138 : double T_c = field->T[idx];
139 : double u_c = field->u[idx];
140 : double v_c = field->v[idx];
141 : double w_c = field->w[idx];
142 :
143 : /* Advection: u * dT/dx + v * dT/dy + w * dT/dz, with central or
144 : * first-order upwind derivatives */
145 : double dT_dx, dT_dy, dT_dz;
146 : if (upwind) {
147 : dT_dx = stencil_upwind_deriv_x(field->T[idx + 1], T_c, field->T[idx - 1],
148 : dx0, u_c);
149 : dT_dy = stencil_upwind_deriv_y(field->T[idx + nx], T_c, field->T[idx - nx],
150 : dy0, v_c);
151 : dT_dz = stencil_upwind_diff(field->T[idx + stride_z], T_c,
152 : field->T[idx - stride_z], w_c) * inv_dz;
153 : } else {
154 : dT_dx = (field->T[idx + 1] - field->T[idx - 1]) * inv_2dx;
155 : dT_dy = (field->T[idx + nx] - field->T[idx - nx]) * inv_2dy;
156 : dT_dz = (field->T[idx + stride_z] - field->T[idx - stride_z]) * inv_2dz;
157 : }
158 :
159 : double advection = u_c * dT_dx + v_c * dT_dy + w_c * dT_dz;
160 :
161 : /* Diffusion: alpha * (d2T/dx2 + d2T/dy2 + d2T/dz2) */
162 : double d2T_dx2 = (field->T[idx + 1] - 2.0 * T_c + field->T[idx - 1]) * inv_dx2;
163 : double d2T_dy2 = (field->T[idx + nx] - 2.0 * T_c + field->T[idx - nx]) * inv_dy2;
164 : double d2T_dz2 = (field->T[idx + stride_z] - 2.0 * T_c +
165 : field->T[idx - stride_z]) * inv_dz2;
166 :
167 : double diffusion = alpha * (d2T_dx2 + d2T_dy2 + d2T_dz2);
168 :
169 : /* Heat source term */
170 : double Q = 0.0;
171 : if (params->heat_source_func) {
172 : double x = grid->x[i];
173 : double y = grid->y[j];
174 : double z = (nz > 1 && grid->z) ? grid->z[k] : 0.0;
175 : Q = params->heat_source_func(x, y, z, time,
176 : params->heat_source_context);
177 : }
178 :
179 : /* Explicit Euler update */
180 : double dT = dt * (-advection + diffusion + Q);
181 : T_new[idx] = T_c + dT;
182 : }
183 : }
184 : }
185 :
186 : /* Check for NaN/Inf */
187 120 : int has_nan = 0;
188 120 : ptrdiff_t total_int = (ptrdiff_t)total;
189 120 : ptrdiff_t n;
190 120 : #pragma omp parallel for reduction(| : has_nan) schedule(static)
191 : for (n = 0; n < total_int; n++) {
192 : if (!isfinite(T_new[n])) {
193 : has_nan = 1;
194 : }
195 : }
196 120 : if (has_nan) {
197 0 : cfd_set_error(CFD_ERROR_DIVERGED,
198 : "NaN/Inf detected in energy_step_explicit_omp");
199 0 : if (owns_buffer) cfd_free(T_new);
200 0 : return CFD_ERROR_DIVERGED;
201 : }
202 :
203 120 : memcpy(field->T, T_new, total * sizeof(double));
204 120 : if (owns_buffer) cfd_free(T_new);
205 :
206 : return CFD_SUCCESS;
207 : }
|