113 lines
3.3 KiB
C++
113 lines
3.3 KiB
C++
|
|
|
|
// DO NOT EDIT !
|
|
// This file is generated using the MantaFlow preprocessor (prep generate).
|
|
|
|
/******************************************************************************
|
|
*
|
|
* MantaFlow fluid solver framework
|
|
* Copyright 2011-2014 Tobias Pfaff, Nils Thuerey
|
|
*
|
|
* This program is free software, distributed under the terms of the
|
|
* Apache License, Version 2.0
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Function and macros for defining compution kernels over grids
|
|
*
|
|
******************************************************************************/
|
|
|
|
#ifndef _KERNEL_H
|
|
#define _KERNEL_H
|
|
|
|
#if TBB == 1
|
|
# include <tbb/blocked_range3d.h>
|
|
# include <tbb/blocked_range.h>
|
|
# include <tbb/parallel_for.h>
|
|
# include <tbb/parallel_reduce.h>
|
|
#endif
|
|
|
|
#if OPENMP == 1
|
|
# include <omp.h>
|
|
#endif
|
|
|
|
#include "general.h"
|
|
|
|
namespace Manta {
|
|
|
|
// fwd decl
|
|
class GridBase;
|
|
class Grid4dBase;
|
|
class ParticleBase;
|
|
|
|
// simple iteration
|
|
#define FOR_IJK_BND(grid, bnd) \
|
|
for (int k = ((grid).is3D() ? bnd : 0), \
|
|
__kmax = ((grid).is3D() ? ((grid).getSizeZ() - bnd) : 1); \
|
|
k < __kmax; \
|
|
k++) \
|
|
for (int j = bnd; j < (grid).getSizeY() - bnd; j++) \
|
|
for (int i = bnd; i < (grid).getSizeX() - bnd; i++)
|
|
|
|
#define FOR_IJK_REVERSE(grid) \
|
|
for (int k = (grid).getSizeZ() - 1; k >= 0; k--) \
|
|
for (int j = (grid).getSizeY() - 1; j >= 0; j--) \
|
|
for (int i = (grid).getSizeX() - 1; i >= 0; i--)
|
|
|
|
#define FOR_IDX(grid) \
|
|
for (IndexInt idx = 0, total = (grid).getSizeX() * (grid).getSizeY() * (grid).getSizeZ(); \
|
|
idx < total; \
|
|
idx++)
|
|
|
|
#define FOR_IJK(grid) FOR_IJK_BND(grid, 0)
|
|
|
|
#define FOR_PARTS(parts) for (IndexInt idx = 0, total = (parts).size(); idx < total; idx++)
|
|
|
|
// simple loop over 4d grids
|
|
#define FOR_IJKT_BND(grid, bnd) \
|
|
for (int t = ((grid).is4D() ? bnd : 0); t < ((grid).is4D() ? ((grid).getSizeT() - bnd) : 1); \
|
|
++t) \
|
|
for (int k = ((grid).is3D() ? bnd : 0); k < ((grid).is3D() ? ((grid).getSizeZ() - bnd) : 1); \
|
|
++k) \
|
|
for (int j = bnd; j < (grid).getSizeY() - bnd; ++j) \
|
|
for (int i = bnd; i < (grid).getSizeX() - bnd; ++i)
|
|
|
|
#define FOR_NEIGHBORS_BND(grid, radius, bnd) \
|
|
for (int zj = ((grid).is3D() ? std::max(bnd, k - radius) : 0); \
|
|
zj <= ((grid).is3D() ? std::min(k + radius, (grid).getSizeZ() - 1 - bnd) : 0); \
|
|
zj++) \
|
|
for (int yj = std::max(bnd, j - radius); \
|
|
yj <= std::min(j + radius, (grid).getSizeY() - 1 - bnd); \
|
|
yj++) \
|
|
for (int xj = std::max(bnd, i - radius); \
|
|
xj <= std::min(i + radius, (grid).getSizeX() - 1 - bnd); \
|
|
xj++)
|
|
|
|
#define FOR_NEIGHBORS(grid, radius) FOR_NEIGHBORS_BND(grid, radius, 0)
|
|
|
|
//! Basic data structure for kernel data, initialized based on kernel type (e.g. single, idx, etc).
|
|
struct KernelBase {
|
|
int maxX, maxY, maxZ, minZ, maxT, minT;
|
|
int X, Y, Z, dimT;
|
|
IndexInt size;
|
|
|
|
KernelBase(IndexInt num);
|
|
KernelBase(const GridBase *base, int bnd);
|
|
KernelBase(const Grid4dBase *base, int bnd);
|
|
|
|
// specify in your derived classes:
|
|
|
|
// kernel operators
|
|
// ijk mode: void operator() (int i, int j, int k)
|
|
// idx mode: void operator() (IndexInt idx)
|
|
|
|
// reduce mode:
|
|
// void join(classname& other)
|
|
// void setup()
|
|
};
|
|
|
|
} // namespace Manta
|
|
|
|
// all kernels will automatically be added to the "Kernels" group in doxygen
|
|
|
|
#endif
|