blender/extern/mantaflow/preprocessed/vortexsheet.h

// 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);
      PyObject *_retval = nullptr;
      {
        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);
      PyObject *_retval = nullptr;
      {
        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);
      PyObject *_retval = nullptr;
      {
        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;

 public:
  PbArgs _args;
}
#define _C_VortexSheetMesh
;

};  // namespace Manta

#endif