ESPResSo
Extensible Simulation Package for Research on Soft Matter Systems
Loading...
Searching...
No Matches
ReactionKernelIndexed_1_double_precision.h
Go to the documentation of this file.
1/*
2 * Copyright (C) 2022-2023 The ESPResSo project
3 * Copyright (C) 2020-2023 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.3, lbmpy v1.3.3,
22// lbmpy_walberla/pystencils_walberla from waLBerla commit
23// b0842e1a493ce19ef1bbb8d2cf382fc343970a7f
24
25/*
26 * Boundary class.
27 * Adapted from the waLBerla source file
28 * https://i10git.cs.fau.de/walberla/walberla/-/blob/fb076cd18daa6e2f24448349d1fffb974c845269/python/pystencils_walberla/templates/Boundary.tmpl.h
29 */
30
31#pragma once
32
33#include <core/DataTypes.h>
34
35#include <blockforest/StructuredBlockForest.h>
36#include <core/debug/Debug.h>
37#include <domain_decomposition/BlockDataID.h>
38#include <domain_decomposition/IBlock.h>
39#include <field/FlagField.h>
40#include <field/GhostLayerField.h>
41
42#include <cassert>
43#include <functional>
44#include <memory>
45#include <vector>
46
47#if defined(__clang__)
48#pragma clang diagnostic push
49#pragma clang diagnostic ignored "-Wunused-variable"
50#pragma clang diagnostic ignored "-Wunused-parameter"
51#elif defined(__GNUC__) or defined(__GNUG__)
52#pragma GCC diagnostic push
53#pragma GCC diagnostic ignored "-Wunused-variable"
54#pragma GCC diagnostic ignored "-Wunused-parameter"
55#endif
56
57#ifdef __GNUC__
58#define RESTRICT __restrict__
59#elif _MSC_VER
60#define RESTRICT __restrict
61#else
62#define RESTRICT
63
64#endif
65
66namespace walberla {
67namespace pystencils {
68
70public:
71 struct IndexInfo {
72 int32_t x;
73 int32_t y;
74 int32_t z;
75 IndexInfo(int32_t x_, int32_t y_, int32_t z_) : x(x_), y(y_), z(z_) {}
76 bool operator==(const IndexInfo &o) const {
77 return x == o.x && y == o.y && z == o.z;
78 }
79 };
80
82 public:
83 using CpuIndexVector = std::vector<IndexInfo>;
84
85 enum Type { ALL = 0, INNER = 1, OUTER = 2, NUM_TYPES = 3 };
86
87 IndexVectors() = default;
88 bool operator==(IndexVectors const &other) const {
89 return other.cpuVectors_ == cpuVectors_;
90 }
91
92 CpuIndexVector &indexVector(Type t) { return cpuVectors_[t]; }
93 IndexInfo *pointerCpu(Type t) { return cpuVectors_[t].data(); }
94
95 void syncGPU() {}
96
97 private:
98 std::vector<CpuIndexVector> cpuVectors_{NUM_TYPES};
99 };
100
102 const std::shared_ptr<StructuredBlockForest> &blocks,
103 BlockDataID rho_0ID_, double order_0, double rate_coefficient,
104 double stoech_0)
105 : rho_0ID(rho_0ID_), order_0_(order_0),
106 rate_coefficient_(rate_coefficient), stoech_0_(stoech_0) {
107 auto createIdxVector = [](IBlock *const, StructuredBlockStorage *const) {
108 return new IndexVectors();
109 };
110 indexVectorID = blocks->addStructuredBlockData<IndexVectors>(
111 createIdxVector, "IndexField_ReactionKernelIndexed_1_double_precision");
112 };
113
115 BlockDataID rho_0ID_, double order_0,
116 double rate_coefficient,
117 double stoech_0)
118 : indexVectorID(indexVectorID_), rho_0ID(rho_0ID_), order_0_(order_0),
119 rate_coefficient_(rate_coefficient), stoech_0_(stoech_0){};
120
121 void run(IBlock *block);
122
123 void operator()(IBlock *block) { run(block); }
124
125 void inner(IBlock *block);
126
127 void outer(IBlock *block);
128
129 std::function<void(IBlock *)> getSweep() {
130 return [this](IBlock *b) { this->run(b); };
131 }
132
133 std::function<void(IBlock *)> getInnerSweep() {
134 return [this](IBlock *b) { this->inner(b); };
135 }
136
137 std::function<void(IBlock *)> getOuterSweep() {
138 return [this](IBlock *b) { this->outer(b); };
139 }
140
141 template <typename FlagField_T>
142 void fillFromFlagField(const std::shared_ptr<StructuredBlockForest> &blocks,
143 ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID,
144 FlagUID domainFlagUID) {
145 for (auto blockIt = blocks->begin(); blockIt != blocks->end(); ++blockIt)
146 fillFromFlagField<FlagField_T>(&*blockIt, flagFieldID, boundaryFlagUID,
147 domainFlagUID);
148 }
149
150 template <typename FlagField_T>
151 void fillFromFlagField(IBlock *block, ConstBlockDataID flagFieldID,
152 FlagUID boundaryFlagUID, FlagUID domainFlagUID) {
153 auto *indexVectors = block->getData<IndexVectors>(indexVectorID);
154 auto &indexVectorAll = indexVectors->indexVector(IndexVectors::ALL);
155 auto &indexVectorInner = indexVectors->indexVector(IndexVectors::INNER);
156 auto &indexVectorOuter = indexVectors->indexVector(IndexVectors::OUTER);
157
158 auto *flagField = block->getData<FlagField_T>(flagFieldID);
159
160 assert(flagField->flagExists(boundaryFlagUID) and
161 flagField->flagExists(domainFlagUID));
162
163 auto boundaryFlag = flagField->getFlag(boundaryFlagUID);
164 auto domainFlag = flagField->getFlag(domainFlagUID);
165
166 auto inner = flagField->xyzSize();
167 inner.expand(cell_idx_t(-1));
168
169 indexVectorAll.clear();
170 indexVectorInner.clear();
171 indexVectorOuter.clear();
172
173 auto flagWithGLayers = flagField->xyzSizeWithGhostLayer();
174 for (auto it = flagField->beginWithGhostLayerXYZ(); it != flagField->end();
175 ++it) {
176
177 if (!isFlagSet(it, boundaryFlag))
178 continue;
179 if (flagWithGLayers.contains(it.x() + cell_idx_c(0),
180 it.y() + cell_idx_c(0),
181 it.z() + cell_idx_c(0)) &&
182 isFlagSet(it.neighbor(0, 0, 0, 0), domainFlag)) {
183
184 auto element = IndexInfo(it.x(), it.y(), it.z(), 0);
185
186 indexVectorAll.push_back(element);
187 if (inner.contains(it.x(), it.y(), it.z()))
188 indexVectorInner.push_back(element);
189 else
190 indexVectorOuter.push_back(element);
191 }
192 }
193
194 indexVectors->syncGPU();
195 }
196
197private:
198 void run_impl(IBlock *block, IndexVectors::Type type);
199
200 BlockDataID indexVectorID;
201
202public:
203 BlockDataID rho_0ID;
204 double order_0_;
206 double stoech_0_;
207};
208
209} // namespace pystencils
210} // namespace walberla
ReactionKernelIndexed_1_double_precision(BlockDataID indexVectorID_, BlockDataID rho_0ID_, double order_0, double rate_coefficient, double stoech_0)
void fillFromFlagField(const std::shared_ptr< StructuredBlockForest > &blocks, ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID, FlagUID domainFlagUID)
void fillFromFlagField(IBlock *block, ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID, FlagUID domainFlagUID)
ReactionKernelIndexed_1_double_precision(const std::shared_ptr< StructuredBlockForest > &blocks, BlockDataID rho_0ID_, double order_0, double rate_coefficient, double stoech_0)
static double * block(double *p, std::size_t index, std::size_t size)
Definition elc.cpp:172
\file PackInfoPdfDoublePrecision.cpp \author pystencils