ESPResSo
Extensible Simulation Package for Research on Soft Matter Systems
Loading...
Searching...
No Matches
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:97
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