forked from bartvdbraak/blender
4ff7c5eed6
Includes preprocessed Mantaflow source files for both OpenMP and TBB (if OpenMP is not present, TBB files will be used instead). These files come directly from the Mantaflow repository. Future updates to the core fluid solver will take place by updating the files. Reviewed By: sergey, mont29 Maniphest Tasks: T59995 Differential Revision: https://developer.blender.org/D3850
134 lines
2.9 KiB
C++
134 lines
2.9 KiB
C++
|
|
|
|
// DO NOT EDIT !
|
|
// This file is generated using the MantaFlow preprocessor (prep generate).
|
|
|
|
/******************************************************************************
|
|
*
|
|
* MantaFlow fluid solver framework
|
|
* Copyright 2011 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
|
|
*
|
|
* Use this file to test new functionality
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include "levelset.h"
|
|
#include "commonkernels.h"
|
|
#include "particle.h"
|
|
#include <cmath>
|
|
|
|
using namespace std;
|
|
|
|
namespace Manta {
|
|
|
|
// two simple example kernels
|
|
|
|
struct reductionTest : public KernelBase {
|
|
reductionTest(const Grid<Real> &v) : KernelBase(&v, 0), v(v), sum(0)
|
|
{
|
|
runMessage();
|
|
run();
|
|
}
|
|
inline void op(IndexInt idx, const Grid<Real> &v, double &sum)
|
|
{
|
|
sum += v[idx];
|
|
}
|
|
inline operator double()
|
|
{
|
|
return sum;
|
|
}
|
|
inline double &getRet()
|
|
{
|
|
return sum;
|
|
}
|
|
inline const Grid<Real> &getArg0()
|
|
{
|
|
return v;
|
|
}
|
|
typedef Grid<Real> type0;
|
|
void runMessage()
|
|
{
|
|
debMsg("Executing kernel reductionTest ", 3);
|
|
debMsg("Kernel range"
|
|
<< " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
|
|
4);
|
|
};
|
|
void operator()(const tbb::blocked_range<IndexInt> &__r)
|
|
{
|
|
for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
|
|
op(idx, v, sum);
|
|
}
|
|
void run()
|
|
{
|
|
tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
|
|
}
|
|
reductionTest(reductionTest &o, tbb::split) : KernelBase(o), v(o.v), sum(0)
|
|
{
|
|
}
|
|
void join(const reductionTest &o)
|
|
{
|
|
sum += o.sum;
|
|
}
|
|
const Grid<Real> &v;
|
|
double sum;
|
|
};
|
|
|
|
struct minReduction : public KernelBase {
|
|
minReduction(const Grid<Real> &v) : KernelBase(&v, 0), v(v), sum(0)
|
|
{
|
|
runMessage();
|
|
run();
|
|
}
|
|
inline void op(IndexInt idx, const Grid<Real> &v, double &sum)
|
|
{
|
|
if (sum < v[idx])
|
|
sum = v[idx];
|
|
}
|
|
inline operator double()
|
|
{
|
|
return sum;
|
|
}
|
|
inline double &getRet()
|
|
{
|
|
return sum;
|
|
}
|
|
inline const Grid<Real> &getArg0()
|
|
{
|
|
return v;
|
|
}
|
|
typedef Grid<Real> type0;
|
|
void runMessage()
|
|
{
|
|
debMsg("Executing kernel minReduction ", 3);
|
|
debMsg("Kernel range"
|
|
<< " x " << maxX << " y " << maxY << " z " << minZ << " - " << maxZ << " ",
|
|
4);
|
|
};
|
|
void operator()(const tbb::blocked_range<IndexInt> &__r)
|
|
{
|
|
for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++)
|
|
op(idx, v, sum);
|
|
}
|
|
void run()
|
|
{
|
|
tbb::parallel_reduce(tbb::blocked_range<IndexInt>(0, size), *this);
|
|
}
|
|
minReduction(minReduction &o, tbb::split) : KernelBase(o), v(o.v), sum(0)
|
|
{
|
|
}
|
|
void join(const minReduction &o)
|
|
{
|
|
sum = min(sum, o.sum);
|
|
}
|
|
const Grid<Real> &v;
|
|
double sum;
|
|
};
|
|
|
|
// ... add more test code here if necessary ...
|
|
|
|
} // namespace Manta
|