ESPResSo
Extensible Simulation Package for Research on Soft Matter Systems
Loading...
Searching...
No Matches
EK_FieldAccessors_double_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<double, 1u> const *scalar_field,
52 Cell const &cell) {
53 return scalar_field->get(cell);
54}
55
56inline void set(GhostLayerField<double, 1u> *scalar_field, double const &value,
57 Cell const &cell) {
58 scalar_field->get(cell) = value;
59}
60
61inline void add(GhostLayerField<double, 1u> *scalar_field, double const &value,
62 Cell const &cell) {
63 scalar_field->get(cell) += value;
64}
65
66inline void initialize(GhostLayerField<double, 1u> *scalar_field,
67 double 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<double, 1u> *scalar_field,
73 double 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<double, 1u> const *scalar_field,
79 CellInterval const &ci) {
80 std::vector<double> 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<double, 1u> *scalar_field,
93 std::vector<double> 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<double, uint_t{3u}> const *vec_field,
109 Cell const &cell) {
110 const double &xyz0 = vec_field->get(cell, uint_t{0u});
111 Vector3<double> 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<double, uint_t{3u}> *vec_field,
119 Vector3<double> const &vec, Cell const &cell) {
120 double &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<double, uint_t{3u}> *vec_field,
127 Vector3<double> const &vec, Cell const &cell) {
128 double &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<double, uint_t{3u}> *vec_field,
135 Vector3<double> const &vec) {
136 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(vec_field, {
137 double &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<double, uint_t{3u}> *vec_field,
145 Vector3<double> const &vec) {
146 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(vec_field, {
147 double &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<double, uint_t{3u}> const *vec_field,
155 CellInterval const &ci) {
156 std::vector<double> 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 double &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<double, uint_t{3u}> *vec_field,
172 std::vector<double> 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 double &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<double, uint_t{13u}> const *flux_field,
191 Cell const &cell) {
192 const double &xyz0 = flux_field->get(cell, uint_t{0u});
193 std::array<double, 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<double, uint_t{13u}> *flux_field,
211 std::array<double, 13> const &values) {
212 WALBERLA_FOR_ALL_CELLS_INCLUDING_GHOST_LAYER_XYZ(flux_field, {
213 double &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<double, uint_t{13u}> const *flux_field,
231 CellInterval const &ci) {
232 std::vector<double> 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 double &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<double, uint_t{13u}> const *flux_field,
248 Cell const &cell) {
249 Vector3<double> result = Vector3<double>(0, 0, 0);
250 const double &xyz0 = flux_field->get(cell, uint_t{0u});
251 std::array<double, 27u> local_value;
252 // get fluxes in all directions
253 local_value[0] = double(0.0);
254 local_value[1] = double(-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] = double(0.5) * flux_field->getF(&xyz0, uint_t{1u});
258 local_value[3] = double(0.5) * flux_field->getF(&xyz0, uint_t{0u});
259 local_value[4] = double(-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] = double(-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] = double(0.5) * flux_field->getF(&xyz0, uint_t{2u});
266 local_value[7] = double(0.5) * flux_field->getF(&xyz0, uint_t{4u});
267 local_value[8] = double(-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] = double(0.5) * flux_field->getF(&xyz0, uint_t{3u});
271 local_value[10] = double(-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] = double(-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] = double(0.5) * flux_field->getF(&xyz0, uint_t{8u});
278 local_value[13] = double(0.5) * flux_field->getF(&xyz0, uint_t{6u});
279 local_value[14] = double(-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] = double(-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] = double(0.5) * flux_field->getF(&xyz0, uint_t{7u});
286 local_value[17] = double(0.5) * flux_field->getF(&xyz0, uint_t{5u});
287 local_value[18] = double(-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] = double(-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] = double(0.5) * flux_field->getF(&xyz0, uint_t{12u});
294 local_value[21] =
295 double(-0.5) * flux_field->getNeighbor(cell.x(), cell.y(), cell.z(),
296 uint_t{11u},
297 stencil::Direction(uint_t{21u}));
298 local_value[22] = double(0.5) * flux_field->getF(&xyz0, uint_t{10u});
299 local_value[23] =
300 double(-0.5) * flux_field->getNeighbor(cell.x(), cell.y(), cell.z(),
301 uint_t{10u},
302 stencil::Direction(uint_t{23u}));
303 local_value[24] = double(0.5) * flux_field->getF(&xyz0, uint_t{11u});
304 local_value[25] =
305 double(-0.5) * flux_field->getNeighbor(cell.x(), cell.y(), cell.z(),
306 uint_t{12u},
307 stencil::Direction(uint_t{25u}));
308 local_value[26] = double(0.5) * flux_field->getF(&xyz0, uint_t{9u});
309
310 result[1] += local_value[1] * 1;
311
312 result[1] += local_value[2] * -1;
313
314 result[0] += local_value[3] * -1;
315
316 result[0] += local_value[4] * 1;
317
318 result[2] += local_value[5] * 1;
319
320 result[2] += local_value[6] * -1;
321
322 result[0] += local_value[7] * -1;
323 result[1] += local_value[7] * 1;
324
325 result[0] += local_value[8] * 1;
326 result[1] += local_value[8] * 1;
327
328 result[0] += local_value[9] * -1;
329 result[1] += local_value[9] * -1;
330
331 result[0] += local_value[10] * 1;
332 result[1] += local_value[10] * -1;
333
334 result[1] += local_value[11] * 1;
335 result[2] += local_value[11] * 1;
336
337 result[1] += local_value[12] * -1;
338 result[2] += local_value[12] * 1;
339
340 result[0] += local_value[13] * -1;
341 result[2] += local_value[13] * 1;
342
343 result[0] += local_value[14] * 1;
344 result[2] += local_value[14] * 1;
345
346 result[1] += local_value[15] * 1;
347 result[2] += local_value[15] * -1;
348
349 result[1] += local_value[16] * -1;
350 result[2] += local_value[16] * -1;
351
352 result[0] += local_value[17] * -1;
353 result[2] += local_value[17] * -1;
354
355 result[0] += local_value[18] * 1;
356 result[2] += local_value[18] * -1;
357
358 result[0] += local_value[19] * 1;
359 result[1] += local_value[19] * 1;
360 result[2] += local_value[19] * 1;
361
362 result[0] += local_value[20] * -1;
363 result[1] += local_value[20] * 1;
364 result[2] += local_value[20] * 1;
365
366 result[0] += local_value[21] * 1;
367 result[1] += local_value[21] * -1;
368 result[2] += local_value[21] * 1;
369
370 result[0] += local_value[22] * -1;
371 result[1] += local_value[22] * -1;
372 result[2] += local_value[22] * 1;
373
374 result[0] += local_value[23] * 1;
375 result[1] += local_value[23] * 1;
376 result[2] += local_value[23] * -1;
377
378 result[0] += local_value[24] * -1;
379 result[1] += local_value[24] * 1;
380 result[2] += local_value[24] * -1;
381
382 result[0] += local_value[25] * 1;
383 result[1] += local_value[25] * -1;
384 result[2] += local_value[25] * -1;
385
386 result[0] += local_value[26] * -1;
387 result[1] += local_value[26] * -1;
388 result[2] += local_value[26] * -1;
389
390 return result;
391}
392
393inline auto get_vector(GhostLayerField<double, uint_t{13u}> const *flux_field,
394 CellInterval const &ci) {
395 std::vector<double> out;
396 out.reserve(ci.numCells() * uint_t(3u));
397 for (auto x = ci.xMin(); x <= ci.xMax(); ++x) {
398 for (auto y = ci.yMin(); y <= ci.yMax(); ++y) {
399 for (auto z = ci.zMin(); z <= ci.zMax(); ++z) {
400 Vector3<double> result = Vector3<double>(0, 0, 0);
401 const double &xyz0 = flux_field->get(x, y, z, uint_t{0u});
402 std::array<double, 27u> local_value;
403 // get fluxes in all directions
404 local_value[0] = double(0.0);
405 local_value[1] = double(-0.5) * flux_field->getNeighbor(
406 x, y, z, uint_t{1u},
407 stencil::Direction(uint_t{1u}));
408 local_value[2] = double(0.5) * flux_field->getF(&xyz0, uint_t{1u});
409 local_value[3] = double(0.5) * flux_field->getF(&xyz0, uint_t{0u});
410 local_value[4] = double(-0.5) * flux_field->getNeighbor(
411 x, y, z, uint_t{0u},
412 stencil::Direction(uint_t{4u}));
413 local_value[5] = double(-0.5) * flux_field->getNeighbor(
414 x, y, z, uint_t{2u},
415 stencil::Direction(uint_t{5u}));
416 local_value[6] = double(0.5) * flux_field->getF(&xyz0, uint_t{2u});
417 local_value[7] = double(0.5) * flux_field->getF(&xyz0, uint_t{4u});
418 local_value[8] = double(-0.5) * flux_field->getNeighbor(
419 x, y, z, uint_t{3u},
420 stencil::Direction(uint_t{8u}));
421 local_value[9] = double(0.5) * flux_field->getF(&xyz0, uint_t{3u});
422 local_value[10] = double(-0.5) * flux_field->getNeighbor(
423 x, y, z, uint_t{4u},
424 stencil::Direction(uint_t{10u}));
425 local_value[11] = double(-0.5) * flux_field->getNeighbor(
426 x, y, z, uint_t{7u},
427 stencil::Direction(uint_t{11u}));
428 local_value[12] = double(0.5) * flux_field->getF(&xyz0, uint_t{8u});
429 local_value[13] = double(0.5) * flux_field->getF(&xyz0, uint_t{6u});
430 local_value[14] = double(-0.5) * flux_field->getNeighbor(
431 x, y, z, uint_t{5u},
432 stencil::Direction(uint_t{14u}));
433 local_value[15] = double(-0.5) * flux_field->getNeighbor(
434 x, y, z, uint_t{8u},
435 stencil::Direction(uint_t{15u}));
436 local_value[16] = double(0.5) * flux_field->getF(&xyz0, uint_t{7u});
437 local_value[17] = double(0.5) * flux_field->getF(&xyz0, uint_t{5u});
438 local_value[18] = double(-0.5) * flux_field->getNeighbor(
439 x, y, z, uint_t{6u},
440 stencil::Direction(uint_t{18u}));
441 local_value[19] = double(-0.5) * flux_field->getNeighbor(
442 x, y, z, uint_t{9u},
443 stencil::Direction(uint_t{19u}));
444 local_value[20] = double(0.5) * flux_field->getF(&xyz0, uint_t{12u});
445 local_value[21] = double(-0.5) * flux_field->getNeighbor(
446 x, y, z, uint_t{11u},
447 stencil::Direction(uint_t{21u}));
448 local_value[22] = double(0.5) * flux_field->getF(&xyz0, uint_t{10u});
449 local_value[23] = double(-0.5) * flux_field->getNeighbor(
450 x, y, z, uint_t{10u},
451 stencil::Direction(uint_t{23u}));
452 local_value[24] = double(0.5) * flux_field->getF(&xyz0, uint_t{11u});
453 local_value[25] = double(-0.5) * flux_field->getNeighbor(
454 x, y, z, uint_t{12u},
455 stencil::Direction(uint_t{25u}));
456 local_value[26] = double(0.5) * flux_field->getF(&xyz0, uint_t{9u});
457
458 result[1] += local_value[1] * 1;
459
460 result[1] += local_value[2] * -1;
461
462 result[0] += local_value[3] * -1;
463
464 result[0] += local_value[4] * 1;
465
466 result[2] += local_value[5] * 1;
467
468 result[2] += local_value[6] * -1;
469
470 result[0] += local_value[7] * -1;
471 result[1] += local_value[7] * 1;
472
473 result[0] += local_value[8] * 1;
474 result[1] += local_value[8] * 1;
475
476 result[0] += local_value[9] * -1;
477 result[1] += local_value[9] * -1;
478
479 result[0] += local_value[10] * 1;
480 result[1] += local_value[10] * -1;
481
482 result[1] += local_value[11] * 1;
483 result[2] += local_value[11] * 1;
484
485 result[1] += local_value[12] * -1;
486 result[2] += local_value[12] * 1;
487
488 result[0] += local_value[13] * -1;
489 result[2] += local_value[13] * 1;
490
491 result[0] += local_value[14] * 1;
492 result[2] += local_value[14] * 1;
493
494 result[1] += local_value[15] * 1;
495 result[2] += local_value[15] * -1;
496
497 result[1] += local_value[16] * -1;
498 result[2] += local_value[16] * -1;
499
500 result[0] += local_value[17] * -1;
501 result[2] += local_value[17] * -1;
502
503 result[0] += local_value[18] * 1;
504 result[2] += local_value[18] * -1;
505
506 result[0] += local_value[19] * 1;
507 result[1] += local_value[19] * 1;
508 result[2] += local_value[19] * 1;
509
510 result[0] += local_value[20] * -1;
511 result[1] += local_value[20] * 1;
512 result[2] += local_value[20] * 1;
513
514 result[0] += local_value[21] * 1;
515 result[1] += local_value[21] * -1;
516 result[2] += local_value[21] * 1;
517
518 result[0] += local_value[22] * -1;
519 result[1] += local_value[22] * -1;
520 result[2] += local_value[22] * 1;
521
522 result[0] += local_value[23] * 1;
523 result[1] += local_value[23] * 1;
524 result[2] += local_value[23] * -1;
525
526 result[0] += local_value[24] * -1;
527 result[1] += local_value[24] * 1;
528 result[2] += local_value[24] * -1;
529
530 result[0] += local_value[25] * 1;
531 result[1] += local_value[25] * -1;
532 result[2] += local_value[25] * -1;
533
534 result[0] += local_value[26] * -1;
535 result[1] += local_value[26] * -1;
536 result[2] += local_value[26] * -1;
537
538 out.emplace_back(result[0u]);
539 out.emplace_back(result[1u]);
540 out.emplace_back(result[2u]);
541 }
542 }
543 }
544 return out;
545}
546} // namespace Flux
547
548} // namespace accessor
549} // namespace ek
550} // namespace walberla
Cell
Definition Cell.hpp:96
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