Loading [MathJax]/extensions/TeX/AMSmath.js
ESPResSo
Extensible Simulation Package for Research on Soft Matter Systems
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages Concepts
DynamicUBBDoublePrecision.h
Go to the documentation of this file.
1//======================================================================================================================
2//
3// This file is part of waLBerla. waLBerla is free software: you can
4// redistribute it and/or modify it under the terms of the GNU General Public
5// License as published by the Free Software Foundation, either version 3 of
6// the License, or (at your option) any later version.
7//
8// waLBerla is distributed in the hope that it will be useful, but WITHOUT
9// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11// for more details.
12//
13// You should have received a copy of the GNU General Public License along
14// with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
15//
16//! \\file DynamicUBBDoublePrecision.h
17//! \\author pystencils
18//======================================================================================================================
19
20// kernel generated with pystencils v1.3.7, lbmpy v1.3.7, sympy v1.12.1,
21// lbmpy_walberla/pystencils_walberla from waLBerla commit
22// f36fa0a68bae59f0b516f6587ea8fa7c24a41141
23
24#pragma once
25#include "core/DataTypes.h"
26#include "core/logging/Logging.h"
27
28#include "blockforest/StructuredBlockForest.h"
29#include "core/debug/Debug.h"
30#include "domain_decomposition/BlockDataID.h"
31#include "domain_decomposition/IBlock.h"
32#include "field/FlagField.h"
33#include "field/GhostLayerField.h"
34
35#include <set>
36#include <vector>
37
38#ifdef __GNUC__
39#define RESTRICT __restrict__
40#elif _MSC_VER
41#define RESTRICT __restrict
42#else
43#define RESTRICT
44#endif
45
46#ifdef WALBERLA_BUILD_WITH_HALF_PRECISION_SUPPORT
47using walberla::half;
48#endif
49
50namespace walberla {
51namespace lbm {
52
53class DynamicUBBDoublePrecision {
54public:
55 struct IndexInfo {
56 int32_t x;
57 int32_t y;
58 int32_t z;
59 int32_t dir;
60 double vel_0;
61 double vel_1;
62 double vel_2;
63 IndexInfo(int32_t x_, int32_t y_, int32_t z_, int32_t dir_)
64 : x(x_), y(y_), z(z_), dir(dir_), vel_0(), vel_1(), vel_2() {}
65 bool operator==(const IndexInfo &o) const {
66 return x == o.x && y == o.y && z == o.z && dir == o.dir &&
67 floatIsEqual(vel_0, o.vel_0) && floatIsEqual(vel_1, o.vel_1) &&
68 floatIsEqual(vel_2, o.vel_2);
69 }
70 };
71
72 class IndexVectors {
73 public:
74 using CpuIndexVector = std::vector<IndexInfo>;
75
76 enum Type { ALL = 0, INNER = 1, OUTER = 2, NUM_TYPES = 3 };
77
78 IndexVectors() = default;
79 bool operator==(IndexVectors const &other) const {
80 return other.cpuVectors_ == cpuVectors_;
81 }
82
83 CpuIndexVector &indexVector(Type t) { return cpuVectors_[t]; }
84 IndexInfo *pointerCpu(Type t) { return cpuVectors_[t].data(); }
85
86 void syncGPU() {}
87
88 private:
89 std::vector<CpuIndexVector> cpuVectors_{NUM_TYPES};
90 };
91
92 DynamicUBBDoublePrecision(
93 const shared_ptr<StructuredBlockForest> &blocks, BlockDataID pdfsID_,
94 std::function<Vector3<float64>(const Cell &,
95 const shared_ptr<StructuredBlockForest> &,
96 IBlock &)> &velocityCallback)
97 : elementInitialiser(velocityCallback), pdfsID(pdfsID_) {
98 auto createIdxVector = [](IBlock *const, StructuredBlockStorage *const) {
99 return new IndexVectors();
100 };
101 indexVectorID = blocks->addStructuredBlockData<IndexVectors>(
102 createIdxVector, "IndexField_DynamicUBBDoublePrecision");
103 }
104
105 void run(IBlock *block);
106
107 void operator()(IBlock *block) { run(block); }
108
109 void inner(IBlock *block);
110
111 void outer(IBlock *block);
112
113 Vector3<double> getForce(IBlock * /*block*/) {
114
115 WALBERLA_ABORT(
116 "Boundary condition was not generated including force calculation.")
117 return Vector3<double>(double_c(0.0));
118 }
119
120 std::function<void(IBlock *)> getSweep() {
121 return [this](IBlock *b) { this->run(b); };
122 }
123
124 std::function<void(IBlock *)> getInnerSweep() {
125 return [this](IBlock *b) { this->inner(b); };
126 }
127
128 std::function<void(IBlock *)> getOuterSweep() {
129 return [this](IBlock *b) { this->outer(b); };
130 }
131
132 template <typename FlagField_T>
133 void fillFromFlagField(const shared_ptr<StructuredBlockForest> &blocks,
134 ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID,
135 FlagUID domainFlagUID) {
136 for (auto blockIt = blocks->begin(); blockIt != blocks->end(); ++blockIt)
137 fillFromFlagField<FlagField_T>(blocks, &*blockIt, flagFieldID,
138 boundaryFlagUID, domainFlagUID);
139 }
140
141 template <typename FlagField_T>
142 void fillFromFlagField(const shared_ptr<StructuredBlockForest> &blocks,
143 IBlock *block, ConstBlockDataID flagFieldID,
144 FlagUID boundaryFlagUID, FlagUID domainFlagUID) {
145 auto *indexVectors = block->getData<IndexVectors>(indexVectorID);
146 auto &indexVectorAll = indexVectors->indexVector(IndexVectors::ALL);
147 auto &indexVectorInner = indexVectors->indexVector(IndexVectors::INNER);
148 auto &indexVectorOuter = indexVectors->indexVector(IndexVectors::OUTER);
149
150 auto *flagField = block->getData<FlagField_T>(flagFieldID);
151
152 if (!(flagField->flagExists(boundaryFlagUID) &&
153 flagField->flagExists(domainFlagUID)))
154 return;
155
156 auto boundaryFlag = flagField->getFlag(boundaryFlagUID);
157 auto domainFlag = flagField->getFlag(domainFlagUID);
158
159 auto inner = flagField->xyzSize();
160 inner.expand(cell_idx_t(-1));
161
162 indexVectorAll.clear();
163 indexVectorInner.clear();
164 indexVectorOuter.clear();
165
166 for (auto it = flagField->beginWithGhostLayerXYZ(
167 cell_idx_c(flagField->nrOfGhostLayers() - 1));
168 it != flagField->end(); ++it) {
169 if (!isFlagSet(it, domainFlag))
170 continue;
171
172 if (isFlagSet(it.neighbor(0, 0, 0, 0), boundaryFlag)) {
173 auto element = IndexInfo(it.x(), it.y(), it.z(), 0);
174 auto const InitialisationAdditionalData = elementInitialiser(
175 Cell(it.x() + 0, it.y() + 0, it.z() + 0), blocks, *block);
176 element.vel_0 = InitialisationAdditionalData[0];
177 element.vel_1 = InitialisationAdditionalData[1];
178 element.vel_2 = InitialisationAdditionalData[2];
179 indexVectorAll.push_back(element);
180 if (inner.contains(it.x(), it.y(), it.z()))
181 indexVectorInner.push_back(element);
182 else
183 indexVectorOuter.push_back(element);
184 }
185 }
186
187 for (auto it = flagField->beginWithGhostLayerXYZ(
188 cell_idx_c(flagField->nrOfGhostLayers() - 1));
189 it != flagField->end(); ++it) {
190 if (!isFlagSet(it, domainFlag))
191 continue;
192
193 if (isFlagSet(it.neighbor(0, 1, 0, 0), boundaryFlag)) {
194 auto element = IndexInfo(it.x(), it.y(), it.z(), 1);
195 auto const InitialisationAdditionalData = elementInitialiser(
196 Cell(it.x() + 0, it.y() + 1, it.z() + 0), blocks, *block);
197 element.vel_0 = InitialisationAdditionalData[0];
198 element.vel_1 = InitialisationAdditionalData[1];
199 element.vel_2 = InitialisationAdditionalData[2];
200 indexVectorAll.push_back(element);
201 if (inner.contains(it.x(), it.y(), it.z()))
202 indexVectorInner.push_back(element);
203 else
204 indexVectorOuter.push_back(element);
205 }
206 }
207
208 for (auto it = flagField->beginWithGhostLayerXYZ(
209 cell_idx_c(flagField->nrOfGhostLayers() - 1));
210 it != flagField->end(); ++it) {
211 if (!isFlagSet(it, domainFlag))
212 continue;
213
214 if (isFlagSet(it.neighbor(0, -1, 0, 0), boundaryFlag)) {
215 auto element = IndexInfo(it.x(), it.y(), it.z(), 2);
216 auto const InitialisationAdditionalData = elementInitialiser(
217 Cell(it.x() + 0, it.y() - 1, it.z() + 0), blocks, *block);
218 element.vel_0 = InitialisationAdditionalData[0];
219 element.vel_1 = InitialisationAdditionalData[1];
220 element.vel_2 = InitialisationAdditionalData[2];
221 indexVectorAll.push_back(element);
222 if (inner.contains(it.x(), it.y(), it.z()))
223 indexVectorInner.push_back(element);
224 else
225 indexVectorOuter.push_back(element);
226 }
227 }
228
229 for (auto it = flagField->beginWithGhostLayerXYZ(
230 cell_idx_c(flagField->nrOfGhostLayers() - 1));
231 it != flagField->end(); ++it) {
232 if (!isFlagSet(it, domainFlag))
233 continue;
234
235 if (isFlagSet(it.neighbor(-1, 0, 0, 0), boundaryFlag)) {
236 auto element = IndexInfo(it.x(), it.y(), it.z(), 3);
237 auto const InitialisationAdditionalData = elementInitialiser(
238 Cell(it.x() - 1, it.y() + 0, it.z() + 0), blocks, *block);
239 element.vel_0 = InitialisationAdditionalData[0];
240 element.vel_1 = InitialisationAdditionalData[1];
241 element.vel_2 = InitialisationAdditionalData[2];
242 indexVectorAll.push_back(element);
243 if (inner.contains(it.x(), it.y(), it.z()))
244 indexVectorInner.push_back(element);
245 else
246 indexVectorOuter.push_back(element);
247 }
248 }
249
250 for (auto it = flagField->beginWithGhostLayerXYZ(
251 cell_idx_c(flagField->nrOfGhostLayers() - 1));
252 it != flagField->end(); ++it) {
253 if (!isFlagSet(it, domainFlag))
254 continue;
255
256 if (isFlagSet(it.neighbor(1, 0, 0, 0), boundaryFlag)) {
257 auto element = IndexInfo(it.x(), it.y(), it.z(), 4);
258 auto const InitialisationAdditionalData = elementInitialiser(
259 Cell(it.x() + 1, it.y() + 0, it.z() + 0), blocks, *block);
260 element.vel_0 = InitialisationAdditionalData[0];
261 element.vel_1 = InitialisationAdditionalData[1];
262 element.vel_2 = InitialisationAdditionalData[2];
263 indexVectorAll.push_back(element);
264 if (inner.contains(it.x(), it.y(), it.z()))
265 indexVectorInner.push_back(element);
266 else
267 indexVectorOuter.push_back(element);
268 }
269 }
270
271 for (auto it = flagField->beginWithGhostLayerXYZ(
272 cell_idx_c(flagField->nrOfGhostLayers() - 1));
273 it != flagField->end(); ++it) {
274 if (!isFlagSet(it, domainFlag))
275 continue;
276
277 if (isFlagSet(it.neighbor(0, 0, 1, 0), boundaryFlag)) {
278 auto element = IndexInfo(it.x(), it.y(), it.z(), 5);
279 auto const InitialisationAdditionalData = elementInitialiser(
280 Cell(it.x() + 0, it.y() + 0, it.z() + 1), blocks, *block);
281 element.vel_0 = InitialisationAdditionalData[0];
282 element.vel_1 = InitialisationAdditionalData[1];
283 element.vel_2 = InitialisationAdditionalData[2];
284 indexVectorAll.push_back(element);
285 if (inner.contains(it.x(), it.y(), it.z()))
286 indexVectorInner.push_back(element);
287 else
288 indexVectorOuter.push_back(element);
289 }
290 }
291
292 for (auto it = flagField->beginWithGhostLayerXYZ(
293 cell_idx_c(flagField->nrOfGhostLayers() - 1));
294 it != flagField->end(); ++it) {
295 if (!isFlagSet(it, domainFlag))
296 continue;
297
298 if (isFlagSet(it.neighbor(0, 0, -1, 0), boundaryFlag)) {
299 auto element = IndexInfo(it.x(), it.y(), it.z(), 6);
300 auto const InitialisationAdditionalData = elementInitialiser(
301 Cell(it.x() + 0, it.y() + 0, it.z() - 1), blocks, *block);
302 element.vel_0 = InitialisationAdditionalData[0];
303 element.vel_1 = InitialisationAdditionalData[1];
304 element.vel_2 = InitialisationAdditionalData[2];
305 indexVectorAll.push_back(element);
306 if (inner.contains(it.x(), it.y(), it.z()))
307 indexVectorInner.push_back(element);
308 else
309 indexVectorOuter.push_back(element);
310 }
311 }
312
313 for (auto it = flagField->beginWithGhostLayerXYZ(
314 cell_idx_c(flagField->nrOfGhostLayers() - 1));
315 it != flagField->end(); ++it) {
316 if (!isFlagSet(it, domainFlag))
317 continue;
318
319 if (isFlagSet(it.neighbor(-1, 1, 0, 0), boundaryFlag)) {
320 auto element = IndexInfo(it.x(), it.y(), it.z(), 7);
321 auto const InitialisationAdditionalData = elementInitialiser(
322 Cell(it.x() - 1, it.y() + 1, it.z() + 0), blocks, *block);
323 element.vel_0 = InitialisationAdditionalData[0];
324 element.vel_1 = InitialisationAdditionalData[1];
325 element.vel_2 = InitialisationAdditionalData[2];
326 indexVectorAll.push_back(element);
327 if (inner.contains(it.x(), it.y(), it.z()))
328 indexVectorInner.push_back(element);
329 else
330 indexVectorOuter.push_back(element);
331 }
332 }
333
334 for (auto it = flagField->beginWithGhostLayerXYZ(
335 cell_idx_c(flagField->nrOfGhostLayers() - 1));
336 it != flagField->end(); ++it) {
337 if (!isFlagSet(it, domainFlag))
338 continue;
339
340 if (isFlagSet(it.neighbor(1, 1, 0, 0), boundaryFlag)) {
341 auto element = IndexInfo(it.x(), it.y(), it.z(), 8);
342 auto const InitialisationAdditionalData = elementInitialiser(
343 Cell(it.x() + 1, it.y() + 1, it.z() + 0), blocks, *block);
344 element.vel_0 = InitialisationAdditionalData[0];
345 element.vel_1 = InitialisationAdditionalData[1];
346 element.vel_2 = InitialisationAdditionalData[2];
347 indexVectorAll.push_back(element);
348 if (inner.contains(it.x(), it.y(), it.z()))
349 indexVectorInner.push_back(element);
350 else
351 indexVectorOuter.push_back(element);
352 }
353 }
354
355 for (auto it = flagField->beginWithGhostLayerXYZ(
356 cell_idx_c(flagField->nrOfGhostLayers() - 1));
357 it != flagField->end(); ++it) {
358 if (!isFlagSet(it, domainFlag))
359 continue;
360
361 if (isFlagSet(it.neighbor(-1, -1, 0, 0), boundaryFlag)) {
362 auto element = IndexInfo(it.x(), it.y(), it.z(), 9);
363 auto const InitialisationAdditionalData = elementInitialiser(
364 Cell(it.x() - 1, it.y() - 1, it.z() + 0), blocks, *block);
365 element.vel_0 = InitialisationAdditionalData[0];
366 element.vel_1 = InitialisationAdditionalData[1];
367 element.vel_2 = InitialisationAdditionalData[2];
368 indexVectorAll.push_back(element);
369 if (inner.contains(it.x(), it.y(), it.z()))
370 indexVectorInner.push_back(element);
371 else
372 indexVectorOuter.push_back(element);
373 }
374 }
375
376 for (auto it = flagField->beginWithGhostLayerXYZ(
377 cell_idx_c(flagField->nrOfGhostLayers() - 1));
378 it != flagField->end(); ++it) {
379 if (!isFlagSet(it, domainFlag))
380 continue;
381
382 if (isFlagSet(it.neighbor(1, -1, 0, 0), boundaryFlag)) {
383 auto element = IndexInfo(it.x(), it.y(), it.z(), 10);
384 auto const InitialisationAdditionalData = elementInitialiser(
385 Cell(it.x() + 1, it.y() - 1, it.z() + 0), blocks, *block);
386 element.vel_0 = InitialisationAdditionalData[0];
387 element.vel_1 = InitialisationAdditionalData[1];
388 element.vel_2 = InitialisationAdditionalData[2];
389 indexVectorAll.push_back(element);
390 if (inner.contains(it.x(), it.y(), it.z()))
391 indexVectorInner.push_back(element);
392 else
393 indexVectorOuter.push_back(element);
394 }
395 }
396
397 for (auto it = flagField->beginWithGhostLayerXYZ(
398 cell_idx_c(flagField->nrOfGhostLayers() - 1));
399 it != flagField->end(); ++it) {
400 if (!isFlagSet(it, domainFlag))
401 continue;
402
403 if (isFlagSet(it.neighbor(0, 1, 1, 0), boundaryFlag)) {
404 auto element = IndexInfo(it.x(), it.y(), it.z(), 11);
405 auto const InitialisationAdditionalData = elementInitialiser(
406 Cell(it.x() + 0, it.y() + 1, it.z() + 1), blocks, *block);
407 element.vel_0 = InitialisationAdditionalData[0];
408 element.vel_1 = InitialisationAdditionalData[1];
409 element.vel_2 = InitialisationAdditionalData[2];
410 indexVectorAll.push_back(element);
411 if (inner.contains(it.x(), it.y(), it.z()))
412 indexVectorInner.push_back(element);
413 else
414 indexVectorOuter.push_back(element);
415 }
416 }
417
418 for (auto it = flagField->beginWithGhostLayerXYZ(
419 cell_idx_c(flagField->nrOfGhostLayers() - 1));
420 it != flagField->end(); ++it) {
421 if (!isFlagSet(it, domainFlag))
422 continue;
423
424 if (isFlagSet(it.neighbor(0, -1, 1, 0), boundaryFlag)) {
425 auto element = IndexInfo(it.x(), it.y(), it.z(), 12);
426 auto const InitialisationAdditionalData = elementInitialiser(
427 Cell(it.x() + 0, it.y() - 1, it.z() + 1), blocks, *block);
428 element.vel_0 = InitialisationAdditionalData[0];
429 element.vel_1 = InitialisationAdditionalData[1];
430 element.vel_2 = InitialisationAdditionalData[2];
431 indexVectorAll.push_back(element);
432 if (inner.contains(it.x(), it.y(), it.z()))
433 indexVectorInner.push_back(element);
434 else
435 indexVectorOuter.push_back(element);
436 }
437 }
438
439 for (auto it = flagField->beginWithGhostLayerXYZ(
440 cell_idx_c(flagField->nrOfGhostLayers() - 1));
441 it != flagField->end(); ++it) {
442 if (!isFlagSet(it, domainFlag))
443 continue;
444
445 if (isFlagSet(it.neighbor(-1, 0, 1, 0), boundaryFlag)) {
446 auto element = IndexInfo(it.x(), it.y(), it.z(), 13);
447 auto const InitialisationAdditionalData = elementInitialiser(
448 Cell(it.x() - 1, it.y() + 0, it.z() + 1), blocks, *block);
449 element.vel_0 = InitialisationAdditionalData[0];
450 element.vel_1 = InitialisationAdditionalData[1];
451 element.vel_2 = InitialisationAdditionalData[2];
452 indexVectorAll.push_back(element);
453 if (inner.contains(it.x(), it.y(), it.z()))
454 indexVectorInner.push_back(element);
455 else
456 indexVectorOuter.push_back(element);
457 }
458 }
459
460 for (auto it = flagField->beginWithGhostLayerXYZ(
461 cell_idx_c(flagField->nrOfGhostLayers() - 1));
462 it != flagField->end(); ++it) {
463 if (!isFlagSet(it, domainFlag))
464 continue;
465
466 if (isFlagSet(it.neighbor(1, 0, 1, 0), boundaryFlag)) {
467 auto element = IndexInfo(it.x(), it.y(), it.z(), 14);
468 auto const InitialisationAdditionalData = elementInitialiser(
469 Cell(it.x() + 1, it.y() + 0, it.z() + 1), blocks, *block);
470 element.vel_0 = InitialisationAdditionalData[0];
471 element.vel_1 = InitialisationAdditionalData[1];
472 element.vel_2 = InitialisationAdditionalData[2];
473 indexVectorAll.push_back(element);
474 if (inner.contains(it.x(), it.y(), it.z()))
475 indexVectorInner.push_back(element);
476 else
477 indexVectorOuter.push_back(element);
478 }
479 }
480
481 for (auto it = flagField->beginWithGhostLayerXYZ(
482 cell_idx_c(flagField->nrOfGhostLayers() - 1));
483 it != flagField->end(); ++it) {
484 if (!isFlagSet(it, domainFlag))
485 continue;
486
487 if (isFlagSet(it.neighbor(0, 1, -1, 0), boundaryFlag)) {
488 auto element = IndexInfo(it.x(), it.y(), it.z(), 15);
489 auto const InitialisationAdditionalData = elementInitialiser(
490 Cell(it.x() + 0, it.y() + 1, it.z() - 1), blocks, *block);
491 element.vel_0 = InitialisationAdditionalData[0];
492 element.vel_1 = InitialisationAdditionalData[1];
493 element.vel_2 = InitialisationAdditionalData[2];
494 indexVectorAll.push_back(element);
495 if (inner.contains(it.x(), it.y(), it.z()))
496 indexVectorInner.push_back(element);
497 else
498 indexVectorOuter.push_back(element);
499 }
500 }
501
502 for (auto it = flagField->beginWithGhostLayerXYZ(
503 cell_idx_c(flagField->nrOfGhostLayers() - 1));
504 it != flagField->end(); ++it) {
505 if (!isFlagSet(it, domainFlag))
506 continue;
507
508 if (isFlagSet(it.neighbor(0, -1, -1, 0), boundaryFlag)) {
509 auto element = IndexInfo(it.x(), it.y(), it.z(), 16);
510 auto const InitialisationAdditionalData = elementInitialiser(
511 Cell(it.x() + 0, it.y() - 1, it.z() - 1), blocks, *block);
512 element.vel_0 = InitialisationAdditionalData[0];
513 element.vel_1 = InitialisationAdditionalData[1];
514 element.vel_2 = InitialisationAdditionalData[2];
515 indexVectorAll.push_back(element);
516 if (inner.contains(it.x(), it.y(), it.z()))
517 indexVectorInner.push_back(element);
518 else
519 indexVectorOuter.push_back(element);
520 }
521 }
522
523 for (auto it = flagField->beginWithGhostLayerXYZ(
524 cell_idx_c(flagField->nrOfGhostLayers() - 1));
525 it != flagField->end(); ++it) {
526 if (!isFlagSet(it, domainFlag))
527 continue;
528
529 if (isFlagSet(it.neighbor(-1, 0, -1, 0), boundaryFlag)) {
530 auto element = IndexInfo(it.x(), it.y(), it.z(), 17);
531 auto const InitialisationAdditionalData = elementInitialiser(
532 Cell(it.x() - 1, it.y() + 0, it.z() - 1), blocks, *block);
533 element.vel_0 = InitialisationAdditionalData[0];
534 element.vel_1 = InitialisationAdditionalData[1];
535 element.vel_2 = InitialisationAdditionalData[2];
536 indexVectorAll.push_back(element);
537 if (inner.contains(it.x(), it.y(), it.z()))
538 indexVectorInner.push_back(element);
539 else
540 indexVectorOuter.push_back(element);
541 }
542 }
543
544 for (auto it = flagField->beginWithGhostLayerXYZ(
545 cell_idx_c(flagField->nrOfGhostLayers() - 1));
546 it != flagField->end(); ++it) {
547 if (!isFlagSet(it, domainFlag))
548 continue;
549
550 if (isFlagSet(it.neighbor(1, 0, -1, 0), boundaryFlag)) {
551 auto element = IndexInfo(it.x(), it.y(), it.z(), 18);
552 auto const InitialisationAdditionalData = elementInitialiser(
553 Cell(it.x() + 1, it.y() + 0, it.z() - 1), blocks, *block);
554 element.vel_0 = InitialisationAdditionalData[0];
555 element.vel_1 = InitialisationAdditionalData[1];
556 element.vel_2 = InitialisationAdditionalData[2];
557 indexVectorAll.push_back(element);
558 if (inner.contains(it.x(), it.y(), it.z()))
559 indexVectorInner.push_back(element);
560 else
561 indexVectorOuter.push_back(element);
562 }
563 }
564
565 indexVectors->syncGPU();
566 }
567
568private:
569 void run_impl(IBlock *block, IndexVectors::Type type);
570
571 BlockDataID indexVectorID;
572
573 std::function<Vector3<float64>(
574 const Cell &, const shared_ptr<StructuredBlockForest> &, IBlock &)>
575 elementInitialiser;
576
577public:
578 BlockDataID pdfsID;
579};
580
581} // namespace lbm
582} // namespace walberla
Cell
Definition Cell.hpp:96
walberla::lbm::DynamicUBBDoublePrecision::fillFromFlagField
void fillFromFlagField(const shared_ptr< StructuredBlockForest > &blocks, IBlock *block, ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID, FlagUID domainFlagUID)
Definition DynamicUBBDoublePrecision.h:142
walberla::lbm::DynamicUBBDoublePrecision::fillFromFlagField
void fillFromFlagField(const shared_ptr< StructuredBlockForest > &blocks, ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID, FlagUID domainFlagUID)
Definition DynamicUBBDoublePrecision.h:133
walberla::lbm::DynamicUBBDoublePrecision::DynamicUBBDoublePrecision
DynamicUBBDoublePrecision(const shared_ptr< StructuredBlockForest > &blocks, BlockDataID pdfsID_, std::function< Vector3< float64 >(const Cell &, const shared_ptr< StructuredBlockForest > &, IBlock &)> &velocityCallback)
Definition DynamicUBBDoublePrecision.h:92
block
static double * block(double *p, std::size_t index, std::size_t size)
Definition elc.cpp:172
walberla
\file PackInfoPdfDoublePrecision.cpp \author pystencils
Definition EKWalberla.hpp:36
walberla::lbm::DynamicUBBDoublePrecision::IndexInfo::IndexInfo
IndexInfo(int32_t x_, int32_t y_, int32_t z_, int32_t dir_)
Definition DynamicUBBDoublePrecision.h:63