diff options
Diffstat (limited to 'extern/mantaflow/preprocessed/plugin/ptsplugins.cpp')
| -rw-r--r-- | extern/mantaflow/preprocessed/plugin/ptsplugins.cpp | 502 |
1 files changed, 502 insertions, 0 deletions
diff --git a/extern/mantaflow/preprocessed/plugin/ptsplugins.cpp b/extern/mantaflow/preprocessed/plugin/ptsplugins.cpp new file mode 100644 index 00000000000..a6bbccc5966 --- /dev/null +++ b/extern/mantaflow/preprocessed/plugin/ptsplugins.cpp @@ -0,0 +1,502 @@ + + +// DO NOT EDIT ! +// This file is generated using the MantaFlow preprocessor (prep generate). + +// ---------------------------------------------------------------------------- +// +// MantaFlow fluid solver framework +// Copyright 2018 Kiwon Um, Nils Thuerey +// +// This program is free software, distributed under the terms of the +// GNU General Public License (GPL) +// http://www.gnu.org/licenses +// +// Particle system helper +// +// ---------------------------------------------------------------------------- + +#include "particle.h" + +namespace Manta { + +struct KnAddForcePvel : public KernelBase { + KnAddForcePvel(ParticleDataImpl<Vec3> &v, + const Vec3 &da, + const ParticleDataImpl<int> *ptype, + const int exclude) + : KernelBase(v.size()), v(v), da(da), ptype(ptype), exclude(exclude) + { + runMessage(); + run(); + } + inline void op(IndexInt idx, + ParticleDataImpl<Vec3> &v, + const Vec3 &da, + const ParticleDataImpl<int> *ptype, + const int exclude) const + { + if (ptype && ((*ptype)[idx] & exclude)) + return; + v[idx] += da; + } + inline ParticleDataImpl<Vec3> &getArg0() + { + return v; + } + typedef ParticleDataImpl<Vec3> type0; + inline const Vec3 &getArg1() + { + return da; + } + typedef Vec3 type1; + inline const ParticleDataImpl<int> *getArg2() + { + return ptype; + } + typedef ParticleDataImpl<int> type2; + inline const int &getArg3() + { + return exclude; + } + typedef int type3; + void runMessage() + { + debMsg("Executing kernel KnAddForcePvel ", 3); + debMsg("Kernel range" + << " size " << size << " ", + 4); + }; + void operator()(const tbb::blocked_range<IndexInt> &__r) const + { + for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++) + op(idx, v, da, ptype, exclude); + } + void run() + { + tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this); + } + ParticleDataImpl<Vec3> &v; + const Vec3 &da; + const ParticleDataImpl<int> *ptype; + const int exclude; +}; +//! add force to vec3 particle data; a: acceleration + +void addForcePvel(ParticleDataImpl<Vec3> &vel, + const Vec3 &a, + const Real dt, + const ParticleDataImpl<int> *ptype, + const int exclude) +{ + KnAddForcePvel(vel, a * dt, ptype, exclude); +} +static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds) +{ + try { + PbArgs _args(_linargs, _kwds); + FluidSolver *parent = _args.obtainParent(); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(parent, "addForcePvel", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 0, &_lock); + const Vec3 &a = _args.get<Vec3>("a", 1, &_lock); + const Real dt = _args.get<Real>("dt", 2, &_lock); + const ParticleDataImpl<int> *ptype = _args.getPtr<ParticleDataImpl<int>>("ptype", 3, &_lock); + const int exclude = _args.get<int>("exclude", 4, &_lock); + _retval = getPyNone(); + addForcePvel(vel, a, dt, ptype, exclude); + _args.check(); + } + pbFinalizePlugin(parent, "addForcePvel", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("addForcePvel", e.what()); + return 0; + } +} +static const Pb::Register _RP_addForcePvel("", "addForcePvel", _W_0); +extern "C" { +void PbRegister_addForcePvel() +{ + KEEP_UNUSED(_RP_addForcePvel); +} +} + +struct KnUpdateVelocityFromDeltaPos : public KernelBase { + KnUpdateVelocityFromDeltaPos(const BasicParticleSystem &p, + ParticleDataImpl<Vec3> &v, + const ParticleDataImpl<Vec3> &x_prev, + const Real over_dt, + const ParticleDataImpl<int> *ptype, + const int exclude) + : KernelBase(p.size()), + p(p), + v(v), + x_prev(x_prev), + over_dt(over_dt), + ptype(ptype), + exclude(exclude) + { + runMessage(); + run(); + } + inline void op(IndexInt idx, + const BasicParticleSystem &p, + ParticleDataImpl<Vec3> &v, + const ParticleDataImpl<Vec3> &x_prev, + const Real over_dt, + const ParticleDataImpl<int> *ptype, + const int exclude) const + { + if (ptype && ((*ptype)[idx] & exclude)) + return; + v[idx] = (p[idx].pos - x_prev[idx]) * over_dt; + } + inline const BasicParticleSystem &getArg0() + { + return p; + } + typedef BasicParticleSystem type0; + inline ParticleDataImpl<Vec3> &getArg1() + { + return v; + } + typedef ParticleDataImpl<Vec3> type1; + inline const ParticleDataImpl<Vec3> &getArg2() + { + return x_prev; + } + typedef ParticleDataImpl<Vec3> type2; + inline const Real &getArg3() + { + return over_dt; + } + typedef Real type3; + inline const ParticleDataImpl<int> *getArg4() + { + return ptype; + } + typedef ParticleDataImpl<int> type4; + inline const int &getArg5() + { + return exclude; + } + typedef int type5; + void runMessage() + { + debMsg("Executing kernel KnUpdateVelocityFromDeltaPos ", 3); + debMsg("Kernel range" + << " size " << size << " ", + 4); + }; + void operator()(const tbb::blocked_range<IndexInt> &__r) const + { + for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++) + op(idx, p, v, x_prev, over_dt, ptype, exclude); + } + void run() + { + tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this); + } + const BasicParticleSystem &p; + ParticleDataImpl<Vec3> &v; + const ParticleDataImpl<Vec3> &x_prev; + const Real over_dt; + const ParticleDataImpl<int> *ptype; + const int exclude; +}; +//! retrieve velocity from position change + +void updateVelocityFromDeltaPos(const BasicParticleSystem &parts, + ParticleDataImpl<Vec3> &vel, + const ParticleDataImpl<Vec3> &x_prev, + const Real dt, + const ParticleDataImpl<int> *ptype, + const int exclude) +{ + KnUpdateVelocityFromDeltaPos(parts, vel, x_prev, 1.0 / dt, ptype, exclude); +} +static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds) +{ + try { + PbArgs _args(_linargs, _kwds); + FluidSolver *parent = _args.obtainParent(); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(parent, "updateVelocityFromDeltaPos", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock); + ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 1, &_lock); + const ParticleDataImpl<Vec3> &x_prev = *_args.getPtr<ParticleDataImpl<Vec3>>( + "x_prev", 2, &_lock); + const Real dt = _args.get<Real>("dt", 3, &_lock); + const ParticleDataImpl<int> *ptype = _args.getPtr<ParticleDataImpl<int>>("ptype", 4, &_lock); + const int exclude = _args.get<int>("exclude", 5, &_lock); + _retval = getPyNone(); + updateVelocityFromDeltaPos(parts, vel, x_prev, dt, ptype, exclude); + _args.check(); + } + pbFinalizePlugin(parent, "updateVelocityFromDeltaPos", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("updateVelocityFromDeltaPos", e.what()); + return 0; + } +} +static const Pb::Register _RP_updateVelocityFromDeltaPos("", "updateVelocityFromDeltaPos", _W_1); +extern "C" { +void PbRegister_updateVelocityFromDeltaPos() +{ + KEEP_UNUSED(_RP_updateVelocityFromDeltaPos); +} +} + +struct KnStepEuler : public KernelBase { + KnStepEuler(BasicParticleSystem &p, + const ParticleDataImpl<Vec3> &v, + const Real dt, + const ParticleDataImpl<int> *ptype, + const int exclude) + : KernelBase(p.size()), p(p), v(v), dt(dt), ptype(ptype), exclude(exclude) + { + runMessage(); + run(); + } + inline void op(IndexInt idx, + BasicParticleSystem &p, + const ParticleDataImpl<Vec3> &v, + const Real dt, + const ParticleDataImpl<int> *ptype, + const int exclude) const + { + if (ptype && ((*ptype)[idx] & exclude)) + return; + p[idx].pos += v[idx] * dt; + } + inline BasicParticleSystem &getArg0() + { + return p; + } + typedef BasicParticleSystem type0; + inline const ParticleDataImpl<Vec3> &getArg1() + { + return v; + } + typedef ParticleDataImpl<Vec3> type1; + inline const Real &getArg2() + { + return dt; + } + typedef Real type2; + inline const ParticleDataImpl<int> *getArg3() + { + return ptype; + } + typedef ParticleDataImpl<int> type3; + inline const int &getArg4() + { + return exclude; + } + typedef int type4; + void runMessage() + { + debMsg("Executing kernel KnStepEuler ", 3); + debMsg("Kernel range" + << " size " << size << " ", + 4); + }; + void operator()(const tbb::blocked_range<IndexInt> &__r) const + { + for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++) + op(idx, p, v, dt, ptype, exclude); + } + void run() + { + tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this); + } + BasicParticleSystem &p; + const ParticleDataImpl<Vec3> &v; + const Real dt; + const ParticleDataImpl<int> *ptype; + const int exclude; +}; +//! simple foward Euler integration for particle system + +void eulerStep(BasicParticleSystem &parts, + const ParticleDataImpl<Vec3> &vel, + const ParticleDataImpl<int> *ptype, + const int exclude) +{ + KnStepEuler(parts, vel, parts.getParent()->getDt(), ptype, exclude); +} +static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds) +{ + try { + PbArgs _args(_linargs, _kwds); + FluidSolver *parent = _args.obtainParent(); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(parent, "eulerStep", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock); + const ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 1, &_lock); + const ParticleDataImpl<int> *ptype = _args.getPtr<ParticleDataImpl<int>>("ptype", 2, &_lock); + const int exclude = _args.get<int>("exclude", 3, &_lock); + _retval = getPyNone(); + eulerStep(parts, vel, ptype, exclude); + _args.check(); + } + pbFinalizePlugin(parent, "eulerStep", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("eulerStep", e.what()); + return 0; + } +} +static const Pb::Register _RP_eulerStep("", "eulerStep", _W_2); +extern "C" { +void PbRegister_eulerStep() +{ + KEEP_UNUSED(_RP_eulerStep); +} +} + +struct KnSetPartType : public KernelBase { + KnSetPartType(ParticleDataImpl<int> &ptype, + const BasicParticleSystem &part, + const int mark, + const int stype, + const FlagGrid &flags, + const int cflag) + : KernelBase(ptype.size()), + ptype(ptype), + part(part), + mark(mark), + stype(stype), + flags(flags), + cflag(cflag) + { + runMessage(); + run(); + } + inline void op(IndexInt idx, + ParticleDataImpl<int> &ptype, + const BasicParticleSystem &part, + const int mark, + const int stype, + const FlagGrid &flags, + const int cflag) const + { + if (flags.isInBounds(part.getPos(idx), 0) && (flags.getAt(part.getPos(idx)) & cflag) && + (ptype[idx] & stype)) + ptype[idx] = mark; + } + inline ParticleDataImpl<int> &getArg0() + { + return ptype; + } + typedef ParticleDataImpl<int> type0; + inline const BasicParticleSystem &getArg1() + { + return part; + } + typedef BasicParticleSystem type1; + inline const int &getArg2() + { + return mark; + } + typedef int type2; + inline const int &getArg3() + { + return stype; + } + typedef int type3; + inline const FlagGrid &getArg4() + { + return flags; + } + typedef FlagGrid type4; + inline const int &getArg5() + { + return cflag; + } + typedef int type5; + void runMessage() + { + debMsg("Executing kernel KnSetPartType ", 3); + debMsg("Kernel range" + << " size " << size << " ", + 4); + }; + void operator()(const tbb::blocked_range<IndexInt> &__r) const + { + for (IndexInt idx = __r.begin(); idx != (IndexInt)__r.end(); idx++) + op(idx, ptype, part, mark, stype, flags, cflag); + } + void run() + { + tbb::parallel_for(tbb::blocked_range<IndexInt>(0, size), *this); + } + ParticleDataImpl<int> &ptype; + const BasicParticleSystem ∂ + const int mark; + const int stype; + const FlagGrid &flags; + const int cflag; +}; +//! if particle is stype and in cflag cell, set ptype as mark + +void setPartType(const BasicParticleSystem &parts, + ParticleDataImpl<int> &ptype, + const int mark, + const int stype, + const FlagGrid &flags, + const int cflag) +{ + KnSetPartType(ptype, parts, mark, stype, flags, cflag); +} +static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds) +{ + try { + PbArgs _args(_linargs, _kwds); + FluidSolver *parent = _args.obtainParent(); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(parent, "setPartType", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock); + ParticleDataImpl<int> &ptype = *_args.getPtr<ParticleDataImpl<int>>("ptype", 1, &_lock); + const int mark = _args.get<int>("mark", 2, &_lock); + const int stype = _args.get<int>("stype", 3, &_lock); + const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 4, &_lock); + const int cflag = _args.get<int>("cflag", 5, &_lock); + _retval = getPyNone(); + setPartType(parts, ptype, mark, stype, flags, cflag); + _args.check(); + } + pbFinalizePlugin(parent, "setPartType", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("setPartType", e.what()); + return 0; + } +} +static const Pb::Register _RP_setPartType("", "setPartType", _W_3); +extern "C" { +void PbRegister_setPartType() +{ + KEEP_UNUSED(_RP_setPartType); +} +} + +} // namespace Manta |