ESPResSo
Extensible Simulation Package for Research on Soft Matter Systems
Loading...
Searching...
No Matches
EK_FieldAccessors_single_precision.h
Go to the documentation of this file.
1/*
2 * Copyright (C) 2021-2025 The ESPResSo project
3 * Copyright (C) 2020 The waLBerla project
4 *
5 * This file is part of ESPResSo.
6 *
7 * ESPResSo is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * ESPResSo is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21// kernel generated with pystencils v1.3.7, lbmpy v1.3.7, sympy v1.12.1,
22// lbmpy_walberla/pystencils_walberla from waLBerla commit
23// c69cb11d6a95d32b2280544d3d9abde1fe5fdbb5
24
25/*
26 * Lattice field accessors.
27 * Adapted from the waLBerla source file
28 * https://i10git.cs.fau.de/walberla/walberla/-/blob/a16141524c58ab88386e2a0f8fdd7c63c5edd704/python/lbmpy_walberla/templates/LatticeModel.tmpl.h
29 */
30
31#pragma once
32
33#include <core/DataTypes.h>
34#include <core/cell/Cell.h>
35#include <core/cell/CellInterval.h>
36#include <core/math/Vector3.h>
37
38#include <field/GhostLayerField.h>
39
40#include <array>
41#include <cassert>
42#include <iterator>
43#include <tuple>
44#include <vector>
45
46namespace walberla {
47namespace ek {
48namespace accessor {
49
50namespace Scalar {
51inline auto get(GhostLayerField<float, 1u> const *scalar_field,
52 Cell const &cell) {
53 return scalar_field->get(cell);
54}
55
56inline void set(GhostLayerField<float, 1u> *scalar_field, float const &value,
57 Cell const &cell) {
58 scalar_field->get(cell) = value;
59}
60
61inline void add(GhostLayerField<float, 1u> *scalar_field, float const &value,
62 Cell const &cell) {
63 scalar_field->get(cell) += value;
64}
65
66inline void initialize(GhostLayerField<float, 1u> *scalar_field,
67 float const &value) {
68 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(
69 scalar_field, { scalar_field->get(x, y, z) = value; });
70}
71
72inline void add_to_all(GhostLayerField<float, 1u> *scalar_field,
73 float const &value) {
74 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(
75 scalar_field, { scalar_field->get(x, y, z) += value; });
76}
77
78inline auto get(GhostLayerField<float, 1u> const *scalar_field,
79 CellInterval const &ci) {
80 std::vector<float> out;
81 out.reserve(ci.numCells());
82 for (auto x = ci.xMin(); x <= ci.xMax(); ++x) {
83 for (auto y = ci.yMin(); y <= ci.yMax(); ++y) {
84 for (auto z = ci.zMin(); z <= ci.zMax(); ++z) {
85 out.emplace_back(scalar_field->get(x, y, z));
86 }
87 }
88 }
89 return out;
90}
91
92inline void set(GhostLayerField<float, 1u> *scalar_field,
93 std::vector<float> const &values, CellInterval const &ci) {
94 assert(uint_c(values.size()) == ci.numCells());
95 auto values_ptr = values.data();
96 for (auto x = ci.xMin(); x <= ci.xMax(); ++x) {
97 for (auto y = ci.yMin(); y <= ci.yMax(); ++y) {
98 for (auto z = ci.zMin(); z <= ci.zMax(); ++z) {
99 scalar_field->get(x, y, z) = values_ptr[0u];
100 std::advance(values_ptr, 1);
101 }
102 }
103 }
104}
105} // namespace Scalar
106
107namespace Vector {
108inline auto get(GhostLayerField<float, uint_t{3u}> const *vec_field,
109 Cell const &cell) {
110 const float &xyz0 = vec_field->get(cell, uint_t{0u});
111 Vector3<float> vec;
112 vec[0] = vec_field->getF(&xyz0, uint_t{0u});
113 vec[1] = vec_field->getF(&xyz0, uint_t{1u});
114 vec[2] = vec_field->getF(&xyz0, uint_t{2u});
115 return vec;
116}
117
118inline void set(GhostLayerField<float, uint_t{3u}> *vec_field,
119 Vector3<float> const &vec, Cell const &cell) {
120 float &xyz0 = vec_field->get(cell, uint_t{0u});
121 vec_field->getF(&xyz0, uint_t{0u}) = vec[0u];
122 vec_field->getF(&xyz0, uint_t{1u}) = vec[1u];
123 vec_field->getF(&xyz0, uint_t{2u}) = vec[2u];
124}
125
126inline void add(GhostLayerField<float, uint_t{3u}> *vec_field,
127 Vector3<float> const &vec, Cell const &cell) {
128 float &xyz0 = vec_field->get(cell, uint_t{0u});
129 vec_field->getF(&xyz0, uint_t{0u}) += vec[0u];
130 vec_field->getF(&xyz0, uint_t{1u}) += vec[1u];
131 vec_field->getF(&xyz0, uint_t{2u}) += vec[2u];
132}
133
134inline void initialize(GhostLayerField<float, uint_t{3u}> *vec_field,
135 Vector3<float> const &vec) {
136 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(vec_field, {
137 float &xyz0 = vec_field->get(x, y, z, uint_t{0u});
138 vec_field->getF(&xyz0, uint_t{0u}) = vec[0u];
139 vec_field->getF(&xyz0, uint_t{1u}) = vec[1u];
140 vec_field->getF(&xyz0, uint_t{2u}) = vec[2u];
141 });
142}
143
144inline void add_to_all(GhostLayerField<float, uint_t{3u}> *vec_field,
145 Vector3<float> const &vec) {
146 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(vec_field, {
147 float &xyz0 = vec_field->get(x, y, z, uint_t{0u});
148 vec_field->getF(&xyz0, uint_t{0u}) += vec[0u];
149 vec_field->getF(&xyz0, uint_t{1u}) += vec[1u];
150 vec_field->getF(&xyz0, uint_t{2u}) += vec[2u];
151 });
152}
153
154inline auto get(GhostLayerField<float, uint_t{3u}> const *vec_field,
155 CellInterval const &ci) {
156 std::vector<float> out;
157 out.reserve(ci.numCells() * uint_t(3u));
158 for (auto x = ci.xMin(); x <= ci.xMax(); ++x) {
159 for (auto y = ci.yMin(); y <= ci.yMax(); ++y) {
160 for (auto z = ci.zMin(); z <= ci.zMax(); ++z) {
161 const float &xyz0 = vec_field->get(x, y, z, uint_t{0u});
162 out.emplace_back(vec_field->getF(&xyz0, uint_t{0u}));
163 out.emplace_back(vec_field->getF(&xyz0, uint_t{1u}));
164 out.emplace_back(vec_field->getF(&xyz0, uint_t{2u}));
165 }
166 }
167 }
168 return out;
169}
170
171inline void set(GhostLayerField<float, uint_t{3u}> *vec_field,
172 std::vector<float> const &values, CellInterval const &ci) {
173 assert(uint_c(values.size()) == ci.numCells() * uint_t(3u));
174 auto values_ptr = values.data();
175 for (auto x = ci.xMin(); x <= ci.xMax(); ++x) {
176 for (auto y = ci.yMin(); y <= ci.yMax(); ++y) {
177 for (auto z = ci.zMin(); z <= ci.zMax(); ++z) {
178 float &xyz0 = vec_field->get(x, y, z, uint_t{0u});
179 vec_field->getF(&xyz0, uint_t{0u}) = values_ptr[0u];
180 vec_field->getF(&xyz0, uint_t{1u}) = values_ptr[1u];
181 vec_field->getF(&xyz0, uint_t{2u}) = values_ptr[2u];
182 std::advance(values_ptr, 3);
183 }
184 }
185 }
186}
187} // namespace Vector
188
189namespace Flux {
190inline auto get(GhostLayerField<float, uint_t{13u}> const *flux_field,
191 Cell const &cell) {
192 const float &xyz0 = flux_field->get(cell, uint_t{0u});
193 std::array<float, 13u> value;
194 value[0] = flux_field->getF(&xyz0, uint_t{0u});
195 value[1] = flux_field->getF(&xyz0, uint_t{1u});
196 value[2] = flux_field->getF(&xyz0, uint_t{2u});
197 value[3] = flux_field->getF(&xyz0, uint_t{3u});
198 value[4] = flux_field->getF(&xyz0, uint_t{4u});
199 value[5] = flux_field->getF(&xyz0, uint_t{5u});
200 value[6] = flux_field->getF(&xyz0, uint_t{6u});
201 value[7] = flux_field->getF(&xyz0, uint_t{7u});
202 value[8] = flux_field->getF(&xyz0, uint_t{8u});
203 value[9] = flux_field->getF(&xyz0, uint_t{9u});
204 value[10] = flux_field->getF(&xyz0, uint_t{10u});
205 value[11] = flux_field->getF(&xyz0, uint_t{11u});
206 value[12] = flux_field->getF(&xyz0, uint_t{12u});
207 return value;
208}
209
210inline void initialize(GhostLayerField<float, uint_t{13u}> *flux_field,
211 std::array<float, 13> const &values) {
212 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(flux_field, {
213 float &xyz0 = flux_field->get(x, y, z, uint_t{0u});
214 flux_field->getF(&xyz0, uint_t{0u}) = values[0u];
215 flux_field->getF(&xyz0, uint_t{1u}) = values[1u];
216 flux_field->getF(&xyz0, uint_t{2u}) = values[2u];
217 flux_field->getF(&xyz0, uint_t{3u}) = values[3u];
218 flux_field->getF(&xyz0, uint_t{4u}) = values[4u];
219 flux_field->getF(&xyz0, uint_t{5u}) = values[5u];
220 flux_field->getF(&xyz0, uint_t{6u}) = values[6u];
221 flux_field->getF(&xyz0, uint_t{7u}) = values[7u];
222 flux_field->getF(&xyz0, uint_t{8u}) = values[8u];
223 flux_field->getF(&xyz0, uint_t{9u}) = values[9u];
224 flux_field->getF(&xyz0, uint_t{10u}) = values[10u];
225 flux_field->getF(&xyz0, uint_t{11u}) = values[11u];
226 flux_field->getF(&xyz0, uint_t{12u}) = values[12u];
227 });
228}
229
230inline auto get(GhostLayerField<float, uint_t{13u}> const *flux_field,
231 CellInterval const &ci) {
232 std::vector<float> out;
233 out.reserve(ci.numCells() * uint_t(13u));
234 for (auto x = ci.xMin(); x <= ci.xMax(); ++x) {
235 for (auto y = ci.yMin(); y <= ci.yMax(); ++y) {
236 for (auto z = ci.zMin(); z <= ci.zMax(); ++z) {
237 const float &xyz0 = flux_field->get(x, y, z, uint_t{0u});
238 out.emplace_back(flux_field->getF(&xyz0, uint_t{0u}));
239 out.emplace_back(flux_field->getF(&xyz0, uint_t{1u}));
240 out.emplace_back(flux_field->getF(&xyz0, uint_t{2u}));
241 }
242 }
243 }
244 return out;
245}
246
247inline auto get_vector(GhostLayerField<float, uint_t{13u}> const *flux_field,
248 Cell const &cell) {
249 Vector3<float> result = Vector3<float>(0, 0, 0);
250 const float &xyz0 = flux_field->get(cell, uint_t{0u});
251 std::array<float, 27u> local_value;
252 // get fluxes in all directions
253 local_value[0] = float(0.0);
254 local_value[1] = float(-0.5) * flux_field->getNeighbor(
255 cell.x(), cell.y(), cell.z(), uint_t{1u},
256 stencil::Direction(uint_t{1u}));
257 local_value[2] = float(0.5) * flux_field->getF(&xyz0, uint_t{1u});
258 local_value[3] = float(0.5) * flux_field->getF(&xyz0, uint_t{0u});
259 local_value[4] = float(-0.5) * flux_field->getNeighbor(
260 cell.x(), cell.y(), cell.z(), uint_t{0u},
261 stencil::Direction(uint_t{4u}));
262 local_value[5] = float(-0.5) * flux_field->getNeighbor(
263 cell.x(), cell.y(), cell.z(), uint_t{2u},
264 stencil::Direction(uint_t{5u}));
265 local_value[6] = float(0.5) * flux_field->getF(&xyz0, uint_t{2u});
266 local_value[7] = float(0.5) * flux_field->getF(&xyz0, uint_t{4u});
267 local_value[8] = float(-0.5) * flux_field->getNeighbor(
268 cell.x(), cell.y(), cell.z(), uint_t{3u},
269 stencil::Direction(uint_t{8u}));
270 local_value[9] = float(0.5) * flux_field->getF(&xyz0, uint_t{3u});
271 local_value[10] = float(-0.5) * flux_field->getNeighbor(
272 cell.x(), cell.y(), cell.z(), uint_t{4u},
273 stencil::Direction(uint_t{10u}));
274 local_value[11] = float(-0.5) * flux_field->getNeighbor(
275 cell.x(), cell.y(), cell.z(), uint_t{7u},
276 stencil::Direction(uint_t{11u}));
277 local_value[12] = float(0.5) * flux_field->getF(&xyz0, uint_t{8u});
278 local_value[13] = float(0.5) * flux_field->getF(&xyz0, uint_t{6u});
279 local_value[14] = float(-0.5) * flux_field->getNeighbor(
280 cell.x(), cell.y(), cell.z(), uint_t{5u},
281 stencil::Direction(uint_t{14u}));
282 local_value[15] = float(-0.5) * flux_field->getNeighbor(
283 cell.x(), cell.y(), cell.z(), uint_t{8u},
284 stencil::Direction(uint_t{15u}));
285 local_value[16] = float(0.5) * flux_field->getF(&xyz0, uint_t{7u});
286 local_value[17] = float(0.5) * flux_field->getF(&xyz0, uint_t{5u});
287 local_value[18] = float(-0.5) * flux_field->getNeighbor(
288 cell.x(), cell.y(), cell.z(), uint_t{6u},
289 stencil::Direction(uint_t{18u}));
290 local_value[19] = float(-0.5) * flux_field->getNeighbor(
291 cell.x(), cell.y(), cell.z(), uint_t{9u},
292 stencil::Direction(uint_t{19u}));
293 local_value[20] = float(0.5) * flux_field->getF(&xyz0, uint_t{12u});
294 local_value[21] = float(-0.5) * flux_field->getNeighbor(
295 cell.x(), cell.y(), cell.z(), uint_t{11u},
296 stencil::Direction(uint_t{21u}));
297 local_value[22] = float(0.5) * flux_field->getF(&xyz0, uint_t{10u});
298 local_value[23] = float(-0.5) * flux_field->getNeighbor(
299 cell.x(), cell.y(), cell.z(), uint_t{10u},
300 stencil::Direction(uint_t{23u}));
301 local_value[24] = float(0.5) * flux_field->getF(&xyz0, uint_t{11u});
302 local_value[25] = float(-0.5) * flux_field->getNeighbor(
303 cell.x(), cell.y(), cell.z(), uint_t{12u},
304 stencil::Direction(uint_t{25u}));
305 local_value[26] = float(0.5) * flux_field->getF(&xyz0, uint_t{9u});
306
307 result[1] += local_value[1] * 1;
308
309 result[1] += local_value[2] * -1;
310
311 result[0] += local_value[3] * -1;
312
313 result[0] += local_value[4] * 1;
314
315 result[2] += local_value[5] * 1;
316
317 result[2] += local_value[6] * -1;
318
319 result[0] += local_value[7] * -1;
320 result[1] += local_value[7] * 1;
321
322 result[0] += local_value[8] * 1;
323 result[1] += local_value[8] * 1;
324
325 result[0] += local_value[9] * -1;
326 result[1] += local_value[9] * -1;
327
328 result[0] += local_value[10] * 1;
329 result[1] += local_value[10] * -1;
330
331 result[1] += local_value[11] * 1;
332 result[2] += local_value[11] * 1;
333
334 result[1] += local_value[12] * -1;
335 result[2] += local_value[12] * 1;
336
337 result[0] += local_value[13] * -1;
338 result[2] += local_value[13] * 1;
339
340 result[0] += local_value[14] * 1;
341 result[2] += local_value[14] * 1;
342
343 result[1] += local_value[15] * 1;
344 result[2] += local_value[15] * -1;
345
346 result[1] += local_value[16] * -1;
347 result[2] += local_value[16] * -1;
348
349 result[0] += local_value[17] * -1;
350 result[2] += local_value[17] * -1;
351
352 result[0] += local_value[18] * 1;
353 result[2] += local_value[18] * -1;
354
355 result[0] += local_value[19] * 1;
356 result[1] += local_value[19] * 1;
357 result[2] += local_value[19] * 1;
358
359 result[0] += local_value[20] * -1;
360 result[1] += local_value[20] * 1;
361 result[2] += local_value[20] * 1;
362
363 result[0] += local_value[21] * 1;
364 result[1] += local_value[21] * -1;
365 result[2] += local_value[21] * 1;
366
367 result[0] += local_value[22] * -1;
368 result[1] += local_value[22] * -1;
369 result[2] += local_value[22] * 1;
370
371 result[0] += local_value[23] * 1;
372 result[1] += local_value[23] * 1;
373 result[2] += local_value[23] * -1;
374
375 result[0] += local_value[24] * -1;
376 result[1] += local_value[24] * 1;
377 result[2] += local_value[24] * -1;
378
379 result[0] += local_value[25] * 1;
380 result[1] += local_value[25] * -1;
381 result[2] += local_value[25] * -1;
382
383 result[0] += local_value[26] * -1;
384 result[1] += local_value[26] * -1;
385 result[2] += local_value[26] * -1;
386
387 return result;
388}
389
390inline auto get_vector(GhostLayerField<float, uint_t{13u}> const *flux_field,
391 CellInterval const &ci) {
392 std::vector<float> out;
393 out.reserve(ci.numCells() * uint_t(3u));
394 for (auto x = ci.xMin(); x <= ci.xMax(); ++x) {
395 for (auto y = ci.yMin(); y <= ci.yMax(); ++y) {
396 for (auto z = ci.zMin(); z <= ci.zMax(); ++z) {
397 Vector3<float> result = Vector3<float>(0, 0, 0);
398 const float &xyz0 = flux_field->get(x, y, z, uint_t{0u});
399 std::array<float, 27u> local_value;
400 // get fluxes in all directions
401 local_value[0] = float(0.0);
402 local_value[1] = float(-0.5) * flux_field->getNeighbor(
403 x, y, z, uint_t{1u},
404 stencil::Direction(uint_t{1u}));
405 local_value[2] = float(0.5) * flux_field->getF(&xyz0, uint_t{1u});
406 local_value[3] = float(0.5) * flux_field->getF(&xyz0, uint_t{0u});
407 local_value[4] = float(-0.5) * flux_field->getNeighbor(
408 x, y, z, uint_t{0u},
409 stencil::Direction(uint_t{4u}));
410 local_value[5] = float(-0.5) * flux_field->getNeighbor(
411 x, y, z, uint_t{2u},
412 stencil::Direction(uint_t{5u}));
413 local_value[6] = float(0.5) * flux_field->getF(&xyz0, uint_t{2u});
414 local_value[7] = float(0.5) * flux_field->getF(&xyz0, uint_t{4u});
415 local_value[8] = float(-0.5) * flux_field->getNeighbor(
416 x, y, z, uint_t{3u},
417 stencil::Direction(uint_t{8u}));
418 local_value[9] = float(0.5) * flux_field->getF(&xyz0, uint_t{3u});
419 local_value[10] = float(-0.5) * flux_field->getNeighbor(
420 x, y, z, uint_t{4u},
421 stencil::Direction(uint_t{10u}));
422 local_value[11] = float(-0.5) * flux_field->getNeighbor(
423 x, y, z, uint_t{7u},
424 stencil::Direction(uint_t{11u}));
425 local_value[12] = float(0.5) * flux_field->getF(&xyz0, uint_t{8u});
426 local_value[13] = float(0.5) * flux_field->getF(&xyz0, uint_t{6u});
427 local_value[14] = float(-0.5) * flux_field->getNeighbor(
428 x, y, z, uint_t{5u},
429 stencil::Direction(uint_t{14u}));
430 local_value[15] = float(-0.5) * flux_field->getNeighbor(
431 x, y, z, uint_t{8u},
432 stencil::Direction(uint_t{15u}));
433 local_value[16] = float(0.5) * flux_field->getF(&xyz0, uint_t{7u});
434 local_value[17] = float(0.5) * flux_field->getF(&xyz0, uint_t{5u});
435 local_value[18] = float(-0.5) * flux_field->getNeighbor(
436 x, y, z, uint_t{6u},
437 stencil::Direction(uint_t{18u}));
438 local_value[19] = float(-0.5) * flux_field->getNeighbor(
439 x, y, z, uint_t{9u},
440 stencil::Direction(uint_t{19u}));
441 local_value[20] = float(0.5) * flux_field->getF(&xyz0, uint_t{12u});
442 local_value[21] = float(-0.5) * flux_field->getNeighbor(
443 x, y, z, uint_t{11u},
444 stencil::Direction(uint_t{21u}));
445 local_value[22] = float(0.5) * flux_field->getF(&xyz0, uint_t{10u});
446 local_value[23] = float(-0.5) * flux_field->getNeighbor(
447 x, y, z, uint_t{10u},
448 stencil::Direction(uint_t{23u}));
449 local_value[24] = float(0.5) * flux_field->getF(&xyz0, uint_t{11u});
450 local_value[25] = float(-0.5) * flux_field->getNeighbor(
451 x, y, z, uint_t{12u},
452 stencil::Direction(uint_t{25u}));
453 local_value[26] = float(0.5) * flux_field->getF(&xyz0, uint_t{9u});
454
455 result[1] += local_value[1] * 1;
456
457 result[1] += local_value[2] * -1;
458
459 result[0] += local_value[3] * -1;
460
461 result[0] += local_value[4] * 1;
462
463 result[2] += local_value[5] * 1;
464
465 result[2] += local_value[6] * -1;
466
467 result[0] += local_value[7] * -1;
468 result[1] += local_value[7] * 1;
469
470 result[0] += local_value[8] * 1;
471 result[1] += local_value[8] * 1;
472
473 result[0] += local_value[9] * -1;
474 result[1] += local_value[9] * -1;
475
476 result[0] += local_value[10] * 1;
477 result[1] += local_value[10] * -1;
478
479 result[1] += local_value[11] * 1;
480 result[2] += local_value[11] * 1;
481
482 result[1] += local_value[12] * -1;
483 result[2] += local_value[12] * 1;
484
485 result[0] += local_value[13] * -1;
486 result[2] += local_value[13] * 1;
487
488 result[0] += local_value[14] * 1;
489 result[2] += local_value[14] * 1;
490
491 result[1] += local_value[15] * 1;
492 result[2] += local_value[15] * -1;
493
494 result[1] += local_value[16] * -1;
495 result[2] += local_value[16] * -1;
496
497 result[0] += local_value[17] * -1;
498 result[2] += local_value[17] * -1;
499
500 result[0] += local_value[18] * 1;
501 result[2] += local_value[18] * -1;
502
503 result[0] += local_value[19] * 1;
504 result[1] += local_value[19] * 1;
505 result[2] += local_value[19] * 1;
506
507 result[0] += local_value[20] * -1;
508 result[1] += local_value[20] * 1;
509 result[2] += local_value[20] * 1;
510
511 result[0] += local_value[21] * 1;
512 result[1] += local_value[21] * -1;
513 result[2] += local_value[21] * 1;
514
515 result[0] += local_value[22] * -1;
516 result[1] += local_value[22] * -1;
517 result[2] += local_value[22] * 1;
518
519 result[0] += local_value[23] * 1;
520 result[1] += local_value[23] * 1;
521 result[2] += local_value[23] * -1;
522
523 result[0] += local_value[24] * -1;
524 result[1] += local_value[24] * 1;
525 result[2] += local_value[24] * -1;
526
527 result[0] += local_value[25] * 1;
528 result[1] += local_value[25] * -1;
529 result[2] += local_value[25] * -1;
530
531 result[0] += local_value[26] * -1;
532 result[1] += local_value[26] * -1;
533 result[2] += local_value[26] * -1;
534
535 out.emplace_back(result[0u]);
536 out.emplace_back(result[1u]);
537 out.emplace_back(result[2u]);
538 }
539 }
540 }
541 return out;
542}
543} // namespace Flux
544
545} // namespace accessor
546} // namespace ek
547} // namespace walberla
Cell
Definition Cell.hpp:96
stream
cudaStream_t stream[1]
CUDA streams for parallel computing on CPU and GPU.
Definition common_cuda.cu:34
walberla::ek::accessor::Flux::get_vector
auto get_vector(GhostLayerField< double, uint_t{13u}> const *flux_field, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:247
walberla::ek::accessor::Flux::initialize
void initialize(GhostLayerField< double, uint_t{13u}> *flux_field, std::array< double, 13 > const &values)
Definition EK_FieldAccessors_double_precision.h:210
walberla::ek::accessor::Flux::get
auto get(GhostLayerField< double, uint_t{13u}> const *flux_field, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:190
walberla::ek::accessor::Scalar::add_to_all
void add_to_all(GhostLayerField< double, 1u > *scalar_field, double const &value)
Definition EK_FieldAccessors_double_precision.h:72
walberla::ek::accessor::Scalar::initialize
void initialize(GhostLayerField< double, 1u > *scalar_field, double const &value)
Definition EK_FieldAccessors_double_precision.h:66
walberla::ek::accessor::Scalar::set
void set(GhostLayerField< double, 1u > *scalar_field, double const &value, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:56
walberla::ek::accessor::Scalar::get
auto get(GhostLayerField< double, 1u > const *scalar_field, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:51
walberla::ek::accessor::Scalar::add
void add(GhostLayerField< double, 1u > *scalar_field, double const &value, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:61
walberla::ek::accessor::Vector::set
void set(GhostLayerField< double, uint_t{3u}> *vec_field, Vector3< double > const &vec, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:118
walberla::ek::accessor::Vector::initialize
void initialize(GhostLayerField< double, uint_t{3u}> *vec_field, Vector3< double > const &vec)
Definition EK_FieldAccessors_double_precision.h:134
walberla::ek::accessor::Vector::add
void add(GhostLayerField< double, uint_t{3u}> *vec_field, Vector3< double > const &vec, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:126
walberla::ek::accessor::Vector::add_to_all
void add_to_all(GhostLayerField< double, uint_t{3u}> *vec_field, Vector3< double > const &vec)
Definition EK_FieldAccessors_double_precision.h:144
walberla::ek::accessor::Vector::get
auto get(GhostLayerField< double, uint_t{3u}> const *vec_field, Cell const &cell)
Definition EK_FieldAccessors_double_precision.h:108
walberla
\file PackInfoPdfDoublePrecision.cpp \author pystencils
Definition EKWalberla.hpp:36