2019-12-16 14:40:15 +00:00
|
|
|
|
|
|
|
|
|
|
|
// 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
|
|
|
|
*
|
|
|
|
* Vortex sheets
|
|
|
|
* (warning, the vortex methods are currently experimental, and not fully supported!)
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
#ifndef _VORTEXSHEET_H
|
|
|
|
#define _VORTEXSHEET_H
|
|
|
|
|
|
|
|
#include "mesh.h"
|
|
|
|
|
|
|
|
namespace Manta {
|
|
|
|
|
|
|
|
//! Stores vortex sheet info
|
|
|
|
struct VortexSheetInfo {
|
|
|
|
VortexSheetInfo()
|
|
|
|
: vorticity(0.0),
|
|
|
|
vorticitySmoothed(0.0),
|
|
|
|
circulation(0.0),
|
|
|
|
smokeAmount(1.0),
|
|
|
|
smokeParticles(0.0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Vec3 vorticity;
|
|
|
|
Vec3 vorticitySmoothed;
|
|
|
|
Vec3 circulation;
|
|
|
|
Real smokeAmount, smokeParticles;
|
|
|
|
};
|
|
|
|
|
|
|
|
//! Manages vortex sheet info
|
|
|
|
struct VorticityChannel : public SimpleTriChannel<VortexSheetInfo> {
|
|
|
|
virtual TriChannel *clone()
|
|
|
|
{
|
|
|
|
VorticityChannel *vc = new VorticityChannel();
|
|
|
|
*vc = *this;
|
|
|
|
return vc;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//! Manages 3D texture coordinates
|
|
|
|
struct TexCoord3Channel : public SimpleNodeChannel<Vec3> {
|
|
|
|
virtual NodeChannel *clone()
|
|
|
|
{
|
|
|
|
TexCoord3Channel *tc = new TexCoord3Channel();
|
|
|
|
*tc = *this;
|
|
|
|
return tc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void addInterpol(int a, int b, Real alpha)
|
|
|
|
{
|
|
|
|
data.push_back((1.0 - alpha) * data[a] + alpha * data[b]);
|
|
|
|
}
|
|
|
|
void mergeWith(int node, int delnode, Real alpha)
|
|
|
|
{
|
|
|
|
data[node] = 0.5 * (data[node] + data[delnode]);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct TurbulenceInfo {
|
|
|
|
TurbulenceInfo() : k(0.0), epsilon(0.0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
TurbulenceInfo(const TurbulenceInfo &a, const TurbulenceInfo &b, Real alpha)
|
|
|
|
: k((1.0 - alpha) * a.k + alpha * b.k),
|
|
|
|
epsilon((1.0 - alpha) * a.epsilon + alpha * b.epsilon)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
Real k, epsilon;
|
|
|
|
};
|
|
|
|
|
|
|
|
//! Manages k-epsilon information
|
|
|
|
struct TurbulenceChannel : public SimpleNodeChannel<TurbulenceInfo> {
|
|
|
|
virtual NodeChannel *clone()
|
|
|
|
{
|
|
|
|
TurbulenceChannel *tc = new TurbulenceChannel();
|
|
|
|
*tc = *this;
|
|
|
|
return tc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void addInterpol(int a, int b, Real alpha)
|
|
|
|
{
|
|
|
|
data.push_back(TurbulenceInfo(data[a], data[b], alpha));
|
|
|
|
}
|
|
|
|
void mergeWith(int node, int delnode, Real alpha)
|
|
|
|
{
|
|
|
|
data[node] = TurbulenceInfo(data[node], data[delnode], 0.5);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//! Typed Mesh with a vorticity and 2 texcoord3 channels
|
|
|
|
class VortexSheetMesh : public Mesh {
|
|
|
|
public:
|
|
|
|
VortexSheetMesh(FluidSolver *parent);
|
|
|
|
static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
|
|
{
|
|
|
|
PbClass *obj = Pb::objFromPy(_self);
|
|
|
|
if (obj)
|
|
|
|
delete obj;
|
|
|
|
try {
|
|
|
|
PbArgs _args(_linargs, _kwds);
|
|
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
|
|
pbPreparePlugin(0, "VortexSheetMesh::VortexSheetMesh", !noTiming);
|
|
|
|
{
|
|
|
|
ArgLocker _lock;
|
|
|
|
FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
|
|
|
|
obj = new VortexSheetMesh(parent);
|
|
|
|
obj->registerObject(_self, &_args);
|
|
|
|
_args.check();
|
|
|
|
}
|
|
|
|
pbFinalizePlugin(obj->getParent(), "VortexSheetMesh::VortexSheetMesh", !noTiming);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
catch (std::exception &e) {
|
|
|
|
pbSetError("VortexSheetMesh::VortexSheetMesh", e.what());
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual Mesh *clone();
|
|
|
|
|
|
|
|
virtual MeshType getType()
|
|
|
|
{
|
|
|
|
return TypeVortexSheet;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline VortexSheetInfo &sheet(int i)
|
|
|
|
{
|
|
|
|
return mVorticity.data[i];
|
|
|
|
};
|
|
|
|
inline Vec3 &tex1(int i)
|
|
|
|
{
|
|
|
|
return mTex1.data[i];
|
|
|
|
}
|
|
|
|
inline Vec3 &tex2(int i)
|
|
|
|
{
|
|
|
|
return mTex2.data[i];
|
|
|
|
}
|
|
|
|
inline TurbulenceInfo &turb(int i)
|
|
|
|
{
|
|
|
|
return mTurb.data[i];
|
|
|
|
}
|
|
|
|
void setReferenceTexOffset(const Vec3 &ref)
|
|
|
|
{
|
|
|
|
mTexOffset = ref;
|
|
|
|
}
|
|
|
|
void resetTex1();
|
|
|
|
void resetTex2();
|
|
|
|
|
|
|
|
void calcCirculation();
|
|
|
|
static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
|
|
{
|
|
|
|
try {
|
|
|
|
PbArgs _args(_linargs, _kwds);
|
|
|
|
VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
|
|
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
|
|
pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcCirculation", !noTiming);
|
2020-11-06 10:44:05 +00:00
|
|
|
PyObject *_retval = nullptr;
|
2019-12-16 14:40:15 +00:00
|
|
|
{
|
|
|
|
ArgLocker _lock;
|
|
|
|
pbo->_args.copy(_args);
|
|
|
|
_retval = getPyNone();
|
|
|
|
pbo->calcCirculation();
|
|
|
|
pbo->_args.check();
|
|
|
|
}
|
|
|
|
pbFinalizePlugin(pbo->getParent(), "VortexSheetMesh::calcCirculation", !noTiming);
|
|
|
|
return _retval;
|
|
|
|
}
|
|
|
|
catch (std::exception &e) {
|
|
|
|
pbSetError("VortexSheetMesh::calcCirculation", e.what());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void calcVorticity();
|
|
|
|
static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
|
|
{
|
|
|
|
try {
|
|
|
|
PbArgs _args(_linargs, _kwds);
|
|
|
|
VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
|
|
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
|
|
pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcVorticity", !noTiming);
|
2020-11-06 10:44:05 +00:00
|
|
|
PyObject *_retval = nullptr;
|
2019-12-16 14:40:15 +00:00
|
|
|
{
|
|
|
|
ArgLocker _lock;
|
|
|
|
pbo->_args.copy(_args);
|
|
|
|
_retval = getPyNone();
|
|
|
|
pbo->calcVorticity();
|
|
|
|
pbo->_args.check();
|
|
|
|
}
|
|
|
|
pbFinalizePlugin(pbo->getParent(), "VortexSheetMesh::calcVorticity", !noTiming);
|
|
|
|
return _retval;
|
|
|
|
}
|
|
|
|
catch (std::exception &e) {
|
|
|
|
pbSetError("VortexSheetMesh::calcVorticity", e.what());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void reinitTexCoords();
|
|
|
|
static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
|
|
{
|
|
|
|
try {
|
|
|
|
PbArgs _args(_linargs, _kwds);
|
|
|
|
VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
|
|
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
|
|
pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::reinitTexCoords", !noTiming);
|
2020-11-06 10:44:05 +00:00
|
|
|
PyObject *_retval = nullptr;
|
2019-12-16 14:40:15 +00:00
|
|
|
{
|
|
|
|
ArgLocker _lock;
|
|
|
|
pbo->_args.copy(_args);
|
|
|
|
_retval = getPyNone();
|
|
|
|
pbo->reinitTexCoords();
|
|
|
|
pbo->_args.check();
|
|
|
|
}
|
|
|
|
pbFinalizePlugin(pbo->getParent(), "VortexSheetMesh::reinitTexCoords", !noTiming);
|
|
|
|
return _retval;
|
|
|
|
}
|
|
|
|
catch (std::exception &e) {
|
|
|
|
pbSetError("VortexSheetMesh::reinitTexCoords", e.what());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
Vec3 mTexOffset;
|
|
|
|
VorticityChannel mVorticity;
|
|
|
|
TexCoord3Channel mTex1, mTex2;
|
|
|
|
TurbulenceChannel mTurb;
|
2021-05-18 20:32:54 +00:00
|
|
|
|
2019-12-16 14:40:15 +00:00
|
|
|
public:
|
|
|
|
PbArgs _args;
|
|
|
|
}
|
|
|
|
#define _C_VortexSheetMesh
|
|
|
|
;
|
|
|
|
|
|
|
|
}; // namespace Manta
|
|
|
|
|
|
|
|
#endif
|