diff options
Diffstat (limited to 'extern/mantaflow/preprocessed/mesh.h')
| -rw-r--r-- | extern/mantaflow/preprocessed/mesh.h | 1690 |
1 files changed, 1690 insertions, 0 deletions
diff --git a/extern/mantaflow/preprocessed/mesh.h b/extern/mantaflow/preprocessed/mesh.h new file mode 100644 index 00000000000..f49619515ce --- /dev/null +++ b/extern/mantaflow/preprocessed/mesh.h @@ -0,0 +1,1690 @@ + + +// 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 + * + * Meshes + * + * note: this is only a temporary solution, details are bound to change + * long term goal is integration with Split&Merge code by Wojtan et al. + * + ******************************************************************************/ + +#ifndef _MESH_H +#define _MESH_H + +#include <vector> +#include "manta.h" +#include "vectorbase.h" +#include <set> +#include "levelset.h" + +namespace Manta { + +// fwd decl +class GridBase; +// class LevelsetGrid; +class FlagGrid; +class MACGrid; +class Shape; +class MeshDataBase; +template<class T> class MeshDataImpl; + +//! Node position and flags +struct Node { + Node() : flags(0), pos(Vec3::Zero), normal(Vec3::Zero) + { + } + Node(const Vec3 &p) : flags(0), pos(p) + { + } + int flags; + Vec3 pos, normal; +}; + +//! Carries indices of its nodes +struct Triangle { + Triangle() : flags(0) + { + c[0] = c[1] = c[2] = 0; + } + Triangle(int n0, int n1, int n2) : flags(0) + { + c[0] = n0; + c[1] = n1; + c[2] = n2; + } + + int c[3]; + int flags; +}; + +//! For fast access to nodes and neighboring triangles +struct Corner { + Corner() : tri(-1), node(-1), opposite(-1), next(-1), prev(-1){}; + Corner(int t, int n) : tri(t), node(n), opposite(-1), next(-1), prev(-1) + { + } + + int tri; + int node; + int opposite; + int next; + int prev; +}; + +//! Base class for mesh data channels (texture coords, vorticity, ...) +struct NodeChannel { + virtual ~NodeChannel(){}; + virtual void resize(int num) = 0; + virtual int size() = 0; + virtual NodeChannel *clone() = 0; + + virtual void addInterpol(int a, int b, Real alpha) = 0; + virtual void mergeWith(int node, int delnode, Real alpha) = 0; + virtual void renumber(const std::vector<int> &newIndex, int newsize) = 0; +}; + +//! Node channel using only a vector +template<class T> struct SimpleNodeChannel : public NodeChannel { + SimpleNodeChannel(){}; + SimpleNodeChannel(const SimpleNodeChannel<T> &a) : data(a.data) + { + } + void resize(int num) + { + data.resize(num); + } + virtual int size() + { + return data.size(); + } + virtual void renumber(const std::vector<int> &newIndex, int newsize); + + // virtual void addSplit(int from, Real alpha) { data.push_back(data[from]); } + + std::vector<T> data; +}; + +//! Base class for mesh data channels (texture coords, vorticity, ...) +struct TriChannel { + virtual ~TriChannel(){}; + virtual void resize(int num) = 0; + virtual TriChannel *clone() = 0; + virtual int size() = 0; + + virtual void addNew() = 0; + virtual void addSplit(int from, Real alpha) = 0; + virtual void remove(int tri) = 0; +}; + +//! Tri channel using only a vector +template<class T> struct SimpleTriChannel : public TriChannel { + SimpleTriChannel(){}; + SimpleTriChannel(const SimpleTriChannel<T> &a) : data(a.data) + { + } + void resize(int num) + { + data.resize(num); + } + void remove(int tri) + { + if (tri != (int)data.size() - 1) + data[tri] = *data.rbegin(); + data.pop_back(); + } + virtual int size() + { + return data.size(); + } + + virtual void addSplit(int from, Real alpha) + { + data.push_back(data[from]); + } + virtual void addNew() + { + data.push_back(T()); + } + + std::vector<T> data; +}; + +struct OneRing { + OneRing() + { + } + std::set<int> nodes; + std::set<int> tris; +}; + +//! Triangle mesh class +/*! note: this is only a temporary solution, details are bound to change + long term goal is integration with Split&Merge code by Wojtan et al.*/ +class Mesh : public PbClass { + public: + Mesh(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, "Mesh::Mesh", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + obj = new Mesh(parent); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "Mesh::Mesh", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("Mesh::Mesh", e.what()); + return -1; + } + } + + virtual ~Mesh(); + virtual Mesh *clone(); + + enum NodeFlags { NfNone = 0, NfFixed = 1, NfMarked = 2, NfKillme = 4, NfCollide = 8 }; + enum FaceFlags { FfNone = 0, FfDoubled = 1, FfMarked = 2 }; + enum MeshType { TypeNormal = 0, TypeVortexSheet }; + + virtual MeshType getType() + { + return TypeNormal; + } + + Real computeCenterOfMass(Vec3 &cm) const; + void computeVertexNormals(); + + // plugins + void clear(); + static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::clear", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->clear(); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::clear", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::clear", e.what()); + return 0; + } + } + + void load(std::string name, bool append = false); + static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::load", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + std::string name = _args.get<std::string>("name", 0, &_lock); + bool append = _args.getOpt<bool>("append", 1, false, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->load(name, append); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::load", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::load", e.what()); + return 0; + } + } + + void fromShape(Shape &shape, bool append = false); + static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::fromShape", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Shape &shape = *_args.getPtr<Shape>("shape", 0, &_lock); + bool append = _args.getOpt<bool>("append", 1, false, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->fromShape(shape, append); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::fromShape", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::fromShape", e.what()); + return 0; + } + } + + void save(std::string name); + static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::save", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + std::string name = _args.get<std::string>("name", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->save(name); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::save", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::save", e.what()); + return 0; + } + } + + void advectInGrid(FlagGrid &flags, MACGrid &vel, int integrationMode); + static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::advectInGrid", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock); + MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock); + int integrationMode = _args.get<int>("integrationMode", 2, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->advectInGrid(flags, vel, integrationMode); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::advectInGrid", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::advectInGrid", e.what()); + return 0; + } + } + + void scale(Vec3 s); + static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::scale", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Vec3 s = _args.get<Vec3>("s", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->scale(s); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::scale", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::scale", e.what()); + return 0; + } + } + + void offset(Vec3 o); + static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::offset", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Vec3 o = _args.get<Vec3>("o", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->offset(o); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::offset", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::offset", e.what()); + return 0; + } + } + + void rotate(Vec3 thetas); + static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::rotate", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Vec3 thetas = _args.get<Vec3>("thetas", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->rotate(thetas); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::rotate", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::rotate", e.what()); + return 0; + } + } + + void computeVelocity(Mesh &oldMesh, MACGrid &vel); + static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::computeVelocity", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Mesh &oldMesh = *_args.getPtr<Mesh>("oldMesh", 0, &_lock); + MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->computeVelocity(oldMesh, vel); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::computeVelocity", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::computeVelocity", e.what()); + return 0; + } + } + + void computeLevelset(LevelsetGrid &levelset, Real sigma, Real cutoff = -1.); + static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::computeLevelset", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + LevelsetGrid &levelset = *_args.getPtr<LevelsetGrid>("levelset", 0, &_lock); + Real sigma = _args.get<Real>("sigma", 1, &_lock); + Real cutoff = _args.getOpt<Real>("cutoff", 2, -1., &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->computeLevelset(levelset, sigma, cutoff); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::computeLevelset", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::computeLevelset", e.what()); + return 0; + } + } + + LevelsetGrid getLevelset(Real sigma, Real cutoff = -1.); + static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::getLevelset", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Real sigma = _args.get<Real>("sigma", 0, &_lock); + Real cutoff = _args.getOpt<Real>("cutoff", 1, -1., &_lock); + pbo->_args.copy(_args); + _retval = toPy(pbo->getLevelset(sigma, cutoff)); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::getLevelset", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::getLevelset", e.what()); + return 0; + } + } + + //! map mesh to grid with sdf + void applyMeshToGrid(GridBase *grid, + FlagGrid *respectFlags = 0, + Real cutoff = -1., + Real meshSigma = 2.); + static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::applyMeshToGrid", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock); + FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 1, 0, &_lock); + Real cutoff = _args.getOpt<Real>("cutoff", 2, -1., &_lock); + Real meshSigma = _args.getOpt<Real>("meshSigma", 3, 2., &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->applyMeshToGrid(grid, respectFlags, cutoff, meshSigma); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::applyMeshToGrid", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::applyMeshToGrid", e.what()); + return 0; + } + } + + //! get data pointer of nodes + std::string getNodesDataPointer(); + static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::getNodesDataPointer", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getNodesDataPointer()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::getNodesDataPointer", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::getNodesDataPointer", e.what()); + return 0; + } + } + + //! get data pointer of tris + std::string getTrisDataPointer(); + static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::getTrisDataPointer", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getTrisDataPointer()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::getTrisDataPointer", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::getTrisDataPointer", e.what()); + return 0; + } + } + + // ops + Mesh &operator=(const Mesh &o); + + // accessors + inline int numTris() const + { + return mTris.size(); + } + inline int numNodes() const + { + return mNodes.size(); + } + inline int numTriChannels() const + { + return mTriChannels.size(); + } + inline int numNodeChannels() const + { + return mNodeChannels.size(); + } + + //! return size of container + //! note , python binding disabled for now! cannot yet deal with long-long types + inline IndexInt size() const + { + return mNodes.size(); + } + //! slow virtual function of base class, also returns size + virtual IndexInt getSizeSlow() const + { + return size(); + } + + inline Triangle &tris(int i) + { + return mTris[i]; + } + inline Node &nodes(int i) + { + return mNodes[i]; + } + inline Corner &corners(int tri, int c) + { + return mCorners[tri * 3 + c]; + } + inline Corner &corners(int c) + { + return mCorners[c]; + } + inline NodeChannel *nodeChannel(int i) + { + return mNodeChannels[i]; + } + inline TriChannel *triChannel(int i) + { + return mTriChannels[i]; + } + + // allocate memory (eg upon load) + void resizeTris(int numTris); + void resizeNodes(int numNodes); + + inline bool isNodeFixed(int n) + { + return mNodes[n].flags & NfFixed; + } + inline bool isTriangleFixed(int t) + { + return (mNodes[mTris[t].c[0]].flags & NfFixed) || (mNodes[mTris[t].c[1]].flags & NfFixed) || + (mNodes[mTris[t].c[2]].flags & NfFixed); + } + + inline const Vec3 getNode(int tri, int c) const + { + return mNodes[mTris[tri].c[c]].pos; + } + inline Vec3 &getNode(int tri, int c) + { + return mNodes[mTris[tri].c[c]].pos; + } + inline const Vec3 getEdge(int tri, int e) const + { + return getNode(tri, (e + 1) % 3) - getNode(tri, e); + } + inline OneRing &get1Ring(int node) + { + return m1RingLookup[node]; + } + inline Real getFaceArea(int t) const + { + Vec3 c0 = mNodes[mTris[t].c[0]].pos; + return 0.5 * norm(cross(mNodes[mTris[t].c[1]].pos - c0, mNodes[mTris[t].c[2]].pos - c0)); + } + inline Vec3 getFaceNormal(int t) + { + Vec3 c0 = mNodes[mTris[t].c[0]].pos; + return getNormalized(cross(mNodes[mTris[t].c[1]].pos - c0, mNodes[mTris[t].c[2]].pos - c0)); + } + inline Vec3 getFaceCenter(int t) const + { + return (mNodes[mTris[t].c[0]].pos + mNodes[mTris[t].c[1]].pos + mNodes[mTris[t].c[2]].pos) / + 3.0; + } + inline std::vector<Node> &getNodeData() + { + return mNodes; + } + + void mergeNode(int node, int delnode); + int addNode(Node a); + int addTri(Triangle a); + void addCorner(Corner a); + void removeTri(int tri); + void removeTriFromLookup(int tri); + void removeNodes(const std::vector<int> &deletedNodes); + void rebuildCorners(int from = 0, int to = -1); + void rebuildLookup(int from = 0, int to = -1); + void rebuildQuickCheck(); + void fastNodeLookupRebuild(int corner); + void sanityCheck(bool strict = true, + std::vector<int> *deletedNodes = 0, + std::map<int, bool> *taintedTris = 0); + + void addTriChannel(TriChannel *c) + { + mTriChannels.push_back(c); + rebuildChannels(); + } + void addNodeChannel(NodeChannel *c) + { + mNodeChannels.push_back(c); + rebuildChannels(); + } + + //! mesh data functions + + //! create a mesh data object + PbClass *create(PbType type, PbTypeVec T = PbTypeVec(), const std::string &name = ""); + static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "Mesh::create", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + PbType type = _args.get<PbType>("type", 0, &_lock); + PbTypeVec T = _args.getOpt<PbTypeVec>("T", 1, PbTypeVec(), &_lock); + const std::string &name = _args.getOpt<std::string>("name", 2, "", &_lock); + pbo->_args.copy(_args); + _retval = toPy(pbo->create(type, T, name)); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "Mesh::create", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("Mesh::create", e.what()); + return 0; + } + } + + //! add a mesh data field, set its parent mesh pointer + void registerMdata(MeshDataBase *mdata); + void registerMdataReal(MeshDataImpl<Real> *mdata); + void registerMdataVec3(MeshDataImpl<Vec3> *mdata); + void registerMdataInt(MeshDataImpl<int> *mdata); + //! remove a mesh data entry + void deregister(MeshDataBase *mdata); + //! add one zero entry to all data fields + void addAllMdata(); + // note - deletion of mdata is handled in compress function + + //! how many are there? + IndexInt getNumMdata() const + { + return mMeshData.size(); + } + //! access one of the fields + MeshDataBase *getMdata(int i) + { + return mMeshData[i]; + } + + //! update data fields + void updateDataFields(); + + protected: + void rebuildChannels(); + + std::vector<Node> mNodes; + std::vector<Triangle> mTris; + std::vector<Corner> mCorners; + std::vector<NodeChannel *> mNodeChannels; + std::vector<TriChannel *> mTriChannels; + std::vector<OneRing> m1RingLookup; + + //! store mesh data , each pointer has its own storage vector of a certain type (int, real, vec3) + std::vector<MeshDataBase *> mMeshData; + //! lists of different types, for fast operations w/o virtual function calls + std::vector<MeshDataImpl<Real> *> mMdataReal; + std::vector<MeshDataImpl<Vec3> *> mMdataVec3; + std::vector<MeshDataImpl<int> *> + mMdataInt; //! indicate that mdata of this mesh is copied, and needs to be freed + bool mFreeMdata; + public: + PbArgs _args; +} +#define _C_Mesh +; + +//****************************************************************************** + +//! abstract interface for mesh data +class MeshDataBase : public PbClass { + public: + MeshDataBase(FluidSolver *parent); + static int _W_16(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, "MeshDataBase::MeshDataBase", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + obj = new MeshDataBase(parent); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "MeshDataBase::MeshDataBase", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("MeshDataBase::MeshDataBase", e.what()); + return -1; + } + } + + virtual ~MeshDataBase(); + + //! data type IDs, in line with those for grids + enum MdataType { TypeNone = 0, TypeReal = 1, TypeInt = 2, TypeVec3 = 4 }; + + //! interface functions, using assert instead of pure virtual for python compatibility + virtual IndexInt getSizeSlow() const + { + assertMsg(false, "Dont use, override..."); + return 0; + } + virtual void addEntry() + { + assertMsg(false, "Dont use, override..."); + return; + } + virtual MeshDataBase *clone() + { + assertMsg(false, "Dont use, override..."); + return NULL; + } + virtual MdataType getType() const + { + assertMsg(false, "Dont use, override..."); + return TypeNone; + } + virtual void resize(IndexInt size) + { + assertMsg(false, "Dont use, override..."); + return; + } + virtual void copyValueSlow(IndexInt from, IndexInt to) + { + assertMsg(false, "Dont use, override..."); + return; + } + + //! set base pointer + void setMesh(Mesh *set) + { + mMesh = set; + } + + //! debugging + inline void checkNodeIndex(IndexInt idx) const; + + protected: + Mesh *mMesh; + public: + PbArgs _args; +} +#define _C_MeshDataBase +; + +//! abstract interface for mesh data + +template<class T> class MeshDataImpl : public MeshDataBase { + public: + MeshDataImpl(FluidSolver *parent); + static int _W_17(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, "MeshDataImpl::MeshDataImpl", !noTiming); + { + ArgLocker _lock; + FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock); + obj = new MeshDataImpl(parent); + obj->registerObject(_self, &_args); + _args.check(); + } + pbFinalizePlugin(obj->getParent(), "MeshDataImpl::MeshDataImpl", !noTiming); + return 0; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::MeshDataImpl", e.what()); + return -1; + } + } + + MeshDataImpl(FluidSolver *parent, MeshDataImpl<T> *other); + virtual ~MeshDataImpl(); + + //! access data + inline T &get(IndexInt idx) + { + DEBUG_ONLY(checkNodeIndex(idx)); + return mData[idx]; + } + inline const T &get(IndexInt idx) const + { + DEBUG_ONLY(checkNodeIndex(idx)); + return mData[idx]; + } + inline T &operator[](IndexInt idx) + { + DEBUG_ONLY(checkNodeIndex(idx)); + return mData[idx]; + } + inline const T &operator[](IndexInt idx) const + { + DEBUG_ONLY(checkNodeIndex(idx)); + return mData[idx]; + } + + //! set all values to 0, note - different from meshSystem::clear! doesnt modify size of array + //! (has to stay in sync with parent system) + void clear(); + static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clear", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->clear(); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clear", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::clear", e.what()); + return 0; + } + } + + //! set grid from which to get data... + void setSource(Grid<T> *grid, bool isMAC = false); + static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setSource", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Grid<T> *grid = _args.getPtr<Grid<T>>("grid", 0, &_lock); + bool isMAC = _args.getOpt<bool>("isMAC", 1, false, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->setSource(grid, isMAC); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setSource", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::setSource", e.what()); + return 0; + } + } + + //! mesh data base interface + virtual IndexInt getSizeSlow() const; + virtual void addEntry(); + virtual MeshDataBase *clone(); + virtual MdataType getType() const; + virtual void resize(IndexInt s); + virtual void copyValueSlow(IndexInt from, IndexInt to); + + IndexInt size() const + { + return mData.size(); + } + + //! fast inlined functions for per mesh operations + inline void copyValue(IndexInt from, IndexInt to) + { + get(to) = get(from); + } + void initNewValue(IndexInt idx, Vec3 pos); + + //! python interface (similar to grid data) + void setConst(T s); + static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConst", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + T s = _args.get<T>("s", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->setConst(s); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setConst", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::setConst", e.what()); + return 0; + } + } + + void setConstRange(T s, const int begin, const int end); + static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstRange", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + T s = _args.get<T>("s", 0, &_lock); + const int begin = _args.get<int>("begin", 1, &_lock); + const int end = _args.get<int>("end", 2, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->setConstRange(s, begin, end); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setConstRange", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::setConstRange", e.what()); + return 0; + } + } + + MeshDataImpl<T> ©From(const MeshDataImpl<T> &a); + static PyObject *_W_22(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::copyFrom", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock); + pbo->_args.copy(_args); + _retval = toPy(pbo->copyFrom(a)); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::copyFrom", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::copyFrom", e.what()); + return 0; + } + } + + void add(const MeshDataImpl<T> &a); + static PyObject *_W_23(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::add", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->add(a); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::add", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::add", e.what()); + return 0; + } + } + + void sub(const MeshDataImpl<T> &a); + static PyObject *_W_24(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sub", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->sub(a); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sub", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::sub", e.what()); + return 0; + } + } + + void addConst(T s); + static PyObject *_W_25(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addConst", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + T s = _args.get<T>("s", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->addConst(s); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::addConst", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::addConst", e.what()); + return 0; + } + } + + void addScaled(const MeshDataImpl<T> &a, const T &factor); + static PyObject *_W_26(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addScaled", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock); + const T &factor = *_args.getPtr<T>("factor", 1, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->addScaled(a, factor); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::addScaled", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::addScaled", e.what()); + return 0; + } + } + + void mult(const MeshDataImpl<T> &a); + static PyObject *_W_27(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::mult", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->mult(a); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::mult", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::mult", e.what()); + return 0; + } + } + + void multConst(T s); + static PyObject *_W_28(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::multConst", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + T s = _args.get<T>("s", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->multConst(s); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::multConst", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::multConst", e.what()); + return 0; + } + } + + void safeDiv(const MeshDataImpl<T> &a); + static PyObject *_W_29(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::safeDiv", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->safeDiv(a); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::safeDiv", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::safeDiv", e.what()); + return 0; + } + } + + void clamp(Real min, Real max); + static PyObject *_W_30(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clamp", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Real min = _args.get<Real>("min", 0, &_lock); + Real max = _args.get<Real>("max", 1, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->clamp(min, max); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clamp", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::clamp", e.what()); + return 0; + } + } + + void clampMin(Real vmin); + static PyObject *_W_31(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMin", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Real vmin = _args.get<Real>("vmin", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->clampMin(vmin); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clampMin", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::clampMin", e.what()); + return 0; + } + } + + void clampMax(Real vmax); + static PyObject *_W_32(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMax", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + Real vmax = _args.get<Real>("vmax", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->clampMax(vmax); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::clampMax", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::clampMax", e.what()); + return 0; + } + } + + Real getMaxAbs(); + static PyObject *_W_33(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMaxAbs", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getMaxAbs()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getMaxAbs", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::getMaxAbs", e.what()); + return 0; + } + } + + Real getMax(); + static PyObject *_W_34(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMax", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getMax()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getMax", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::getMax", e.what()); + return 0; + } + } + + Real getMin(); + static PyObject *_W_35(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMin", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getMin()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getMin", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::getMin", e.what()); + return 0; + } + } + + T sum(const MeshDataImpl<int> *t = NULL, const int itype = 0) const; + static PyObject *_W_36(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sum", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const MeshDataImpl<int> *t = _args.getPtrOpt<MeshDataImpl<int>>("t", 0, NULL, &_lock); + const int itype = _args.getOpt<int>("itype", 1, 0, &_lock); + pbo->_args.copy(_args); + _retval = toPy(pbo->sum(t, itype)); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sum", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::sum", e.what()); + return 0; + } + } + + Real sumSquare() const; + static PyObject *_W_37(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumSquare", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->sumSquare()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sumSquare", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::sumSquare", e.what()); + return 0; + } + } + + Real sumMagnitude() const; + static PyObject *_W_38(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumMagnitude", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->sumMagnitude()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::sumMagnitude", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::sumMagnitude", e.what()); + return 0; + } + } + + //! special, set if int flag in t has "flag" + void setConstIntFlag(T s, const MeshDataImpl<int> &t, const int flag); + static PyObject *_W_39(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstIntFlag", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + T s = _args.get<T>("s", 0, &_lock); + const MeshDataImpl<int> &t = *_args.getPtr<MeshDataImpl<int>>("t", 1, &_lock); + const int flag = _args.get<int>("flag", 2, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->setConstIntFlag(s, t, flag); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::setConstIntFlag", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::setConstIntFlag", e.what()); + return 0; + } + } + + void printMdata(IndexInt start = -1, IndexInt stop = -1, bool printIndex = false); + static PyObject *_W_40(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::printMdata", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock); + IndexInt stop = _args.getOpt<IndexInt>("stop", 1, -1, &_lock); + bool printIndex = _args.getOpt<bool>("printIndex", 2, false, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->printMdata(start, stop, printIndex); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::printMdata", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::printMdata", e.what()); + return 0; + } + } + + //! file io + void save(const std::string name); + static PyObject *_W_41(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::save", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const std::string name = _args.get<std::string>("name", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->save(name); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::save", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::save", e.what()); + return 0; + } + } + + void load(const std::string name); + static PyObject *_W_42(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::load", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + const std::string name = _args.get<std::string>("name", 0, &_lock); + pbo->_args.copy(_args); + _retval = getPyNone(); + pbo->load(name); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::load", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::load", e.what()); + return 0; + } + } + + //! get data pointer of mesh data + std::string getDataPointer(); + static PyObject *_W_43(PyObject *_self, PyObject *_linargs, PyObject *_kwds) + { + try { + PbArgs _args(_linargs, _kwds); + MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self)); + bool noTiming = _args.getOpt<bool>("notiming", -1, 0); + pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getDataPointer", !noTiming); + PyObject *_retval = 0; + { + ArgLocker _lock; + pbo->_args.copy(_args); + _retval = toPy(pbo->getDataPointer()); + pbo->_args.check(); + } + pbFinalizePlugin(pbo->getParent(), "MeshDataImpl::getDataPointer", !noTiming); + return _retval; + } + catch (std::exception &e) { + pbSetError("MeshDataImpl::getDataPointer", e.what()); + return 0; + } + } + + protected: + //! data storage + std::vector<T> mData; + + //! optionally , we might have an associated grid from which to grab new data + Grid<T> *mpGridSource; //! unfortunately , we need to distinguish mac vs regular vec3 + bool mGridSourceMAC; + public: + PbArgs _args; +} +#define _C_MeshDataImpl +; + +// *************************************************************************************************************** +// Implementation + +template<class T> +void SimpleNodeChannel<T>::renumber(const std::vector<int> &newIndex, int newsize) +{ + for (size_t i = 0; i < newIndex.size(); i++) { + if (newIndex[i] != -1) + data[newIndex[i]] = data[newsize + i]; + } + data.resize(newsize); +} + +inline void MeshDataBase::checkNodeIndex(IndexInt idx) const +{ + IndexInt mySize = this->getSizeSlow(); + if (idx < 0 || idx > mySize) { + errMsg("MeshData " + << " size " << mySize << " : index " << idx << " out of bound "); + } + if (mMesh && mMesh->getSizeSlow() != mySize) { + errMsg("MeshData " + << " size " << mySize << " does not match parent! (" << mMesh->getSizeSlow() << ") "); + } +} + +template<class T> void MeshDataImpl<T>::clear() +{ + for (IndexInt i = 0; i < (IndexInt)mData.size(); ++i) + mData[i] = 0.; +} + +} // namespace Manta +#endif |