Sebastián Barschkis
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
666 lines
18 KiB
C++
666 lines
18 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
|
|
*
|
|
* shapes classes
|
|
*
|
|
******************************************************************************/
|
|
|
|
#ifndef _SHAPES_H
|
|
#define _SHAPES_H
|
|
|
|
#include "manta.h"
|
|
#include "vectorbase.h"
|
|
#include "levelset.h"
|
|
|
|
namespace Manta {
|
|
|
|
// forward declaration
|
|
class Mesh;
|
|
|
|
//! Base class for all shapes
|
|
class Shape : public PbClass {
|
|
public:
|
|
enum GridType { TypeNone = 0, TypeBox = 1, TypeSphere = 2, TypeCylinder = 3, TypeSlope = 4 };
|
|
|
|
Shape(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, "Shape::Shape", !noTiming);
|
|
{
|
|
ArgLocker _lock;
|
|
FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
|
|
obj = new Shape(parent);
|
|
obj->registerObject(_self, &_args);
|
|
_args.check();
|
|
}
|
|
pbFinalizePlugin(obj->getParent(), "Shape::Shape", !noTiming);
|
|
return 0;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::Shape", e.what());
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
//! Get the type of grid
|
|
inline GridType getType() const
|
|
{
|
|
return mType;
|
|
}
|
|
|
|
//! Apply shape to flag grid, set inside cells to <value>
|
|
void applyToGrid(GridBase *grid, FlagGrid *respectFlags = 0);
|
|
static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
|
|
FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 1, 0, &_lock);
|
|
pbo->_args.copy(_args);
|
|
_retval = getPyNone();
|
|
pbo->applyToGrid(grid, respectFlags);
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::applyToGrid", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void applyToGridSmooth(GridBase *grid,
|
|
Real sigma = 1.0,
|
|
Real shift = 0,
|
|
FlagGrid *respectFlags = 0);
|
|
static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
|
|
Real sigma = _args.getOpt<Real>("sigma", 1, 1.0, &_lock);
|
|
Real shift = _args.getOpt<Real>("shift", 2, 0, &_lock);
|
|
FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 3, 0, &_lock);
|
|
pbo->_args.copy(_args);
|
|
_retval = getPyNone();
|
|
pbo->applyToGridSmooth(grid, sigma, shift, respectFlags);
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::applyToGridSmooth", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
LevelsetGrid computeLevelset();
|
|
static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
pbo->_args.copy(_args);
|
|
_retval = toPy(pbo->computeLevelset());
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::computeLevelset", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void collideMesh(Mesh &mesh);
|
|
static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
|
pbo->_args.copy(_args);
|
|
_retval = getPyNone();
|
|
pbo->collideMesh(mesh);
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::collideMesh", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual Vec3 getCenter() const
|
|
{
|
|
return Vec3::Zero;
|
|
}
|
|
static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Shape::getCenter", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
pbo->_args.copy(_args);
|
|
_retval = toPy(pbo->getCenter());
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Shape::getCenter", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::getCenter", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual void setCenter(const Vec3 ¢er)
|
|
{
|
|
}
|
|
static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Shape::setCenter", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
const Vec3 ¢er = _args.get<Vec3>("center", 0, &_lock);
|
|
pbo->_args.copy(_args);
|
|
_retval = getPyNone();
|
|
pbo->setCenter(center);
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Shape::setCenter", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::setCenter", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual Vec3 getExtent() const
|
|
{
|
|
return Vec3::Zero;
|
|
}
|
|
static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Shape::getExtent", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
pbo->_args.copy(_args);
|
|
_retval = toPy(pbo->getExtent());
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Shape::getExtent", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Shape::getExtent", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//! Inside test of the shape
|
|
virtual bool isInside(const Vec3 &pos) const;
|
|
inline bool isInsideGrid(int i, int j, int k) const
|
|
{
|
|
return isInside(Vec3(i + 0.5, j + 0.5, k + 0.5));
|
|
};
|
|
|
|
virtual void generateMesh(Mesh *mesh){};
|
|
virtual void generateLevelset(Grid<Real> &phi){};
|
|
|
|
protected:
|
|
GridType mType;
|
|
public:
|
|
PbArgs _args;
|
|
}
|
|
#define _C_Shape
|
|
;
|
|
|
|
//! Dummy shape
|
|
class NullShape : public Shape {
|
|
public:
|
|
NullShape(FluidSolver *parent) : Shape(parent)
|
|
{
|
|
}
|
|
static int _W_8(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, "NullShape::NullShape", !noTiming);
|
|
{
|
|
ArgLocker _lock;
|
|
FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
|
|
obj = new NullShape(parent);
|
|
obj->registerObject(_self, &_args);
|
|
_args.check();
|
|
}
|
|
pbFinalizePlugin(obj->getParent(), "NullShape::NullShape", !noTiming);
|
|
return 0;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("NullShape::NullShape", e.what());
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
virtual bool isInside(const Vec3 &pos) const
|
|
{
|
|
return false;
|
|
}
|
|
virtual void generateMesh(Mesh *mesh)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
virtual void generateLevelset(Grid<Real> &phi)
|
|
{
|
|
gridSetConst<Real>(phi, 1000.0f);
|
|
}
|
|
public:
|
|
PbArgs _args;
|
|
}
|
|
#define _C_NullShape
|
|
;
|
|
|
|
//! Box shape
|
|
class Box : public Shape {
|
|
public:
|
|
Box(FluidSolver *parent,
|
|
Vec3 center = Vec3::Invalid,
|
|
Vec3 p0 = Vec3::Invalid,
|
|
Vec3 p1 = Vec3::Invalid,
|
|
Vec3 size = Vec3::Invalid);
|
|
static int _W_9(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, "Box::Box", !noTiming);
|
|
{
|
|
ArgLocker _lock;
|
|
FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
|
|
Vec3 center = _args.getOpt<Vec3>("center", 1, Vec3::Invalid, &_lock);
|
|
Vec3 p0 = _args.getOpt<Vec3>("p0", 2, Vec3::Invalid, &_lock);
|
|
Vec3 p1 = _args.getOpt<Vec3>("p1", 3, Vec3::Invalid, &_lock);
|
|
Vec3 size = _args.getOpt<Vec3>("size", 4, Vec3::Invalid, &_lock);
|
|
obj = new Box(parent, center, p0, p1, size);
|
|
obj->registerObject(_self, &_args);
|
|
_args.check();
|
|
}
|
|
pbFinalizePlugin(obj->getParent(), "Box::Box", !noTiming);
|
|
return 0;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Box::Box", e.what());
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
inline Vec3 getSize() const
|
|
{
|
|
return mP1 - mP0;
|
|
}
|
|
inline Vec3 getP0() const
|
|
{
|
|
return mP0;
|
|
}
|
|
inline Vec3 getP1() const
|
|
{
|
|
return mP1;
|
|
}
|
|
virtual void setCenter(const Vec3 ¢er)
|
|
{
|
|
Vec3 dh = 0.5 * (mP1 - mP0);
|
|
mP0 = center - dh;
|
|
mP1 = center + dh;
|
|
}
|
|
virtual Vec3 getCenter() const
|
|
{
|
|
return 0.5 * (mP1 + mP0);
|
|
}
|
|
virtual Vec3 getExtent() const
|
|
{
|
|
return getSize();
|
|
}
|
|
virtual bool isInside(const Vec3 &pos) const;
|
|
virtual void generateMesh(Mesh *mesh);
|
|
virtual void generateLevelset(Grid<Real> &phi);
|
|
|
|
protected:
|
|
Vec3 mP0, mP1;
|
|
public:
|
|
PbArgs _args;
|
|
}
|
|
#define _C_Box
|
|
;
|
|
|
|
//! Spherical shape
|
|
class Sphere : public Shape {
|
|
public:
|
|
Sphere(FluidSolver *parent, Vec3 center, Real radius, Vec3 scale = Vec3(1, 1, 1));
|
|
static int _W_10(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, "Sphere::Sphere", !noTiming);
|
|
{
|
|
ArgLocker _lock;
|
|
FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
|
|
Vec3 center = _args.get<Vec3>("center", 1, &_lock);
|
|
Real radius = _args.get<Real>("radius", 2, &_lock);
|
|
Vec3 scale = _args.getOpt<Vec3>("scale", 3, Vec3(1, 1, 1), &_lock);
|
|
obj = new Sphere(parent, center, radius, scale);
|
|
obj->registerObject(_self, &_args);
|
|
_args.check();
|
|
}
|
|
pbFinalizePlugin(obj->getParent(), "Sphere::Sphere", !noTiming);
|
|
return 0;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Sphere::Sphere", e.what());
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
virtual void setCenter(const Vec3 ¢er)
|
|
{
|
|
mCenter = center;
|
|
}
|
|
virtual Vec3 getCenter() const
|
|
{
|
|
return mCenter;
|
|
}
|
|
inline Real getRadius() const
|
|
{
|
|
return mRadius;
|
|
}
|
|
virtual Vec3 getExtent() const
|
|
{
|
|
return Vec3(2.0 * mRadius);
|
|
}
|
|
virtual bool isInside(const Vec3 &pos) const;
|
|
virtual void generateMesh(Mesh *mesh);
|
|
virtual void generateLevelset(Grid<Real> &phi);
|
|
|
|
protected:
|
|
Vec3 mCenter, mScale;
|
|
Real mRadius;
|
|
public:
|
|
PbArgs _args;
|
|
}
|
|
#define _C_Sphere
|
|
;
|
|
|
|
//! Cylindrical shape
|
|
class Cylinder : public Shape {
|
|
public:
|
|
Cylinder(FluidSolver *parent, Vec3 center, Real radius, Vec3 z);
|
|
static int _W_11(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, "Cylinder::Cylinder", !noTiming);
|
|
{
|
|
ArgLocker _lock;
|
|
FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
|
|
Vec3 center = _args.get<Vec3>("center", 1, &_lock);
|
|
Real radius = _args.get<Real>("radius", 2, &_lock);
|
|
Vec3 z = _args.get<Vec3>("z", 3, &_lock);
|
|
obj = new Cylinder(parent, center, radius, z);
|
|
obj->registerObject(_self, &_args);
|
|
_args.check();
|
|
}
|
|
pbFinalizePlugin(obj->getParent(), "Cylinder::Cylinder", !noTiming);
|
|
return 0;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Cylinder::Cylinder", e.what());
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void setRadius(Real r)
|
|
{
|
|
mRadius = r;
|
|
}
|
|
static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
Real r = _args.get<Real>("r", 0, &_lock);
|
|
pbo->_args.copy(_args);
|
|
_retval = getPyNone();
|
|
pbo->setRadius(r);
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Cylinder::setRadius", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void setZ(Vec3 z)
|
|
{
|
|
mZDir = z;
|
|
mZ = normalize(mZDir);
|
|
}
|
|
static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|
{
|
|
try {
|
|
PbArgs _args(_linargs, _kwds);
|
|
Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
|
|
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
|
pbPreparePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming);
|
|
PyObject *_retval = 0;
|
|
{
|
|
ArgLocker _lock;
|
|
Vec3 z = _args.get<Vec3>("z", 0, &_lock);
|
|
pbo->_args.copy(_args);
|
|
_retval = getPyNone();
|
|
pbo->setZ(z);
|
|
pbo->_args.check();
|
|
}
|
|
pbFinalizePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming);
|
|
return _retval;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Cylinder::setZ", e.what());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual void setCenter(const Vec3 ¢er)
|
|
{
|
|
mCenter = center;
|
|
}
|
|
virtual Vec3 getCenter() const
|
|
{
|
|
return mCenter;
|
|
}
|
|
inline Real getRadius() const
|
|
{
|
|
return mRadius;
|
|
}
|
|
inline Vec3 getZ() const
|
|
{
|
|
return mZ * mZDir;
|
|
}
|
|
virtual Vec3 getExtent() const
|
|
{
|
|
return Vec3(2.0 * sqrt(square(mZ) + square(mRadius)));
|
|
}
|
|
virtual bool isInside(const Vec3 &pos) const;
|
|
virtual void generateMesh(Mesh *mesh);
|
|
virtual void generateLevelset(Grid<Real> &phi);
|
|
|
|
protected:
|
|
Vec3 mCenter, mZDir;
|
|
Real mRadius, mZ;
|
|
public:
|
|
PbArgs _args;
|
|
}
|
|
#define _C_Cylinder
|
|
;
|
|
|
|
//! Slope shape
|
|
// generates a levelset based on a plane
|
|
// plane is specified by two angles and an offset on the y axis in (offset vector would be ( 0,
|
|
// offset, 0) ) the two angles are specified in degrees, between: y-axis and x-axis
|
|
// y-axis and z-axis
|
|
class Slope : public Shape {
|
|
public:
|
|
Slope(FluidSolver *parent, Real anglexy, Real angleyz, Real origin, Vec3 gs);
|
|
static int _W_14(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, "Slope::Slope", !noTiming);
|
|
{
|
|
ArgLocker _lock;
|
|
FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
|
|
Real anglexy = _args.get<Real>("anglexy", 1, &_lock);
|
|
Real angleyz = _args.get<Real>("angleyz", 2, &_lock);
|
|
Real origin = _args.get<Real>("origin", 3, &_lock);
|
|
Vec3 gs = _args.get<Vec3>("gs", 4, &_lock);
|
|
obj = new Slope(parent, anglexy, angleyz, origin, gs);
|
|
obj->registerObject(_self, &_args);
|
|
_args.check();
|
|
}
|
|
pbFinalizePlugin(obj->getParent(), "Slope::Slope", !noTiming);
|
|
return 0;
|
|
}
|
|
catch (std::exception &e) {
|
|
pbSetError("Slope::Slope", e.what());
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
virtual void setOrigin(const Real &origin)
|
|
{
|
|
mOrigin = origin;
|
|
}
|
|
virtual void setAnglexy(const Real &anglexy)
|
|
{
|
|
mAnglexy = anglexy;
|
|
}
|
|
virtual void setAngleyz(const Real &angleyz)
|
|
{
|
|
mAnglexy = angleyz;
|
|
}
|
|
|
|
inline Real getOrigin() const
|
|
{
|
|
return mOrigin;
|
|
}
|
|
inline Real getmAnglexy() const
|
|
{
|
|
return mAnglexy;
|
|
}
|
|
inline Real getmAngleyz() const
|
|
{
|
|
return mAngleyz;
|
|
}
|
|
virtual bool isInside(const Vec3 &pos) const;
|
|
virtual void generateMesh(Mesh *mesh);
|
|
virtual void generateLevelset(Grid<Real> &phi);
|
|
|
|
protected:
|
|
Real mAnglexy, mAngleyz;
|
|
Real mOrigin;
|
|
Vec3 mGs;
|
|
public:
|
|
PbArgs _args;
|
|
}
|
|
#define _C_Slope
|
|
;
|
|
|
|
} // namespace Manta
|
|
#endif
|