Page MenuHome
Differential D3850 Diff 20300 extern/mantaflow/preprocessed/shapes.h

Changeset View

Standalone View

View Options

extern/mantaflow/preprocessed/shapes.h

  • This file was added.
// 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 &center)
{
}
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 &center = _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 &center)
{
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 &center)
{
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 &center)
{
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