vortexsheet.h

Go to the documentation of this file.

/******************************************************************************
 *
 * MantaFlow fluid solver framework
 * Copyright 2011 Tobias Pfaff, Nils Thuerey 
 *
 * This program is free software, distributed under the terms of the
 * GNU General Public License (GPL) 
 * http://www.gnu.org/licenses
 *
 * Vortex sheets
 * (warning, the vortex methods are currently experimental, and not fully supported!)
 *
 ******************************************************************************/

#ifndef _VORTEXSHEET_H
#define _VORTEXSHEET_H

#include "mesh.h"

namespace Manta {

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;
};

struct VorticityChannel : public SimpleTriChannel<VortexSheetInfo> {
    virtual TriChannel* clone() { VorticityChannel* vc = new VorticityChannel(); *vc = *this; return vc;}    
};

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;    
};

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); }
};

PYTHON class VortexSheetMesh : public Mesh {
public:
    PYTHON() VortexSheetMesh(FluidSolver* parent);
    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();
    
    PYTHON() void calcCirculation();
    PYTHON() void calcVorticity();
    PYTHON() void reinitTexCoords();
    
protected:
    Vec3 mTexOffset;
    VorticityChannel mVorticity;
    TexCoord3Channel mTex1, mTex2;
    TurbulenceChannel mTurb;
};

}; // namespace

#endif