simple shaded output , note requires grid functionality! More...

Classes
struct	BasicParticleData
	Simplest data class for particle systems. More...

class	BasicParticleSystem

class	Box

class	ConnectedParticleSystem

struct	Corner
	For fast access to nodes and neighboring triangles. More...

class	CustomCheckbox

class	CustomControl

class	CustomSlider

struct	CVec3Array
	helper vec3 array, for CUDA compatibility, remove at some point More...

struct	CVec3Ptr
	helper vec3 array container More...

class	Cylinder

class	Error

class	FastMarch
	fast marching algorithm wrapper class More...

class	FlagGrid

class	FluidSolver

class	FmHeapEntryIn

class	FmHeapEntryOut

class	FmValueTransportScalar

class	FmValueTransportVec3

class	GLWidget

class	Grid

class	Grid4d

class	Grid4dBase

class	GridBase

class	GridCg
	Run single iteration of the cg solver. More...

class	GridCgInterface
	Basic CG interface. More...

class	GridMg
	Multigrid solver. More...

class	GridPainter
	Painter object for int,Real,Vec3 grids. More...

class	Gui

class	GuiThread
	encapsulates GUI thread More...

struct	KernelBase
	Basic data structure for kernel data, initialized based on kernel type (e.g. single, idx, etc). More...

class	LevelsetGrid

class	LockedObjPainter
	Base clas for all painters that require access to a locked PbClass. More...

class	MACGrid

class	MainThread
	encapsulates working/python thread More...

class	MainWnd

class	Mesh
	Triangle mesh class. More...

class	MeshPainter
	Painter object for Meshes. More...

class	MovingObstacle

class	MTRand

struct	MuTime
	Timing class for preformance measuring. More...

struct	Namify

class	NKMinHeap

struct	Node
	Node position and flags. More...

struct	NodeChannel
	Base class for mesh data channels (texture coords, vorticity, ...) More...

class	NullShape

struct	OneRing

class	Painter
	Base class for all painter. More...

class	ParticleBase

class	ParticleDataBase

class	ParticleDataImpl

struct	ParticleIndexData
	Index into other particle system. More...

class	ParticleIndexSystem

class	ParticlePainter
	Painter object for Particle Systems. More...

class	ParticleSystem
	Main class for particle systems. More...

struct	PbVec3

struct	PbVec4

class	Quaternion
	Very basic quaternion class. More...

class	RandomStream

struct	remove_pointers

struct	remove_pointers< T & >

struct	remove_pointers< T * >

class	Shape

struct	SimpleNodeChannel
	Node channel using only a vector. More...

struct	SimpleTriChannel
	Tri channel using only a vector. More...

class	Slope
	Slope shape. More...

class	Sphere

struct	TexCoord3Channel
	Manages 3D texture coordinates. More...

class	TextCheckbox
	Checkbox with attached text display. More...

class	TextSlider
	Slider with attached text display. More...

class	ThreadSize

class	TimingData

class	Timings

struct	Tri

struct	Triangle
	Carries indices of its nodes. More...

struct	TriChannel
	Base class for mesh data channels (texture coords, vorticity, ...) More...

struct	TurbulenceChannel
	Manages k-epsilon information. More...

struct	TurbulenceInfo

struct	TurbulenceParticleData

class	TurbulenceParticleSystem

struct	UniHeader
	uni file header, v4 More...

struct	UniLegacyHeader
	legacy headers for reading old files More...

struct	UniLegacyHeader2

struct	UniLegacyHeader3

struct	UniPartHeader
	pdata uni header, v3 (similar to grid header) More...

class	Vector3D
	Basic inlined vector class. More...

class	Vector4D
	Basic inlined vector class. More...

struct	volHeader

struct	VortexParticleData

class	VortexParticleSystem

struct	VortexSheetInfo
	Stores vortex sheet info. More...

class	VortexSheetMesh

struct	VorticityChannel
	Manages vortex sheet info. More...

class	WaveletNoiseField

Typedefs
typedef long long	IndexInt

typedef float	Real

typedef Vector4D< Real >	Vec4
	3D vector class of type Real (typically float)

typedef Vector4D< int >	Vec4i
	3D vector class of type int

typedef Vector3D< Real >	Vec3
	3D vector class of type Real (typically float)

typedef Vector3D< int >	Vec3i
	3D vector class of type int

Enumerations
enum	Preconditioner { PcNone = 0, PcMIC = 1, PcMGDynamic = 2, PcMGStatic = 3 }
	Preconditioner for CG solver.

enum	IntegrationMode { IntEuler =0, IntRK2, IntRK4 }

Functions
void	InvertCheckFluid (FlagGrid &flags, Grid< Real > &grid)

double	GridSumSqr (Grid< Real > &grid)

void	CurlOp (const Grid< Vec3 > &grid, Grid< Vec3 > &dst)

void	DivergenceOpMAC (Grid< Real > &div, const MACGrid &grid)

void	GradientOpMAC (MACGrid &gradient, const Grid< Real > &grid)

void	GradientOp (Grid< Vec3 > &gradient, const Grid< Real > &grid)

void	LaplaceOp (Grid< Real > &laplace, const Grid< Real > &grid)

void	GetShiftedComponent (const Grid< Vec3 > &grid, Grid< Real > &comp, int dim)

void	GetComponent (const Grid< Vec3 > &grid, Grid< Real > &comp, int dim)

void	GridNorm (Grid< Real > &n, const Grid< Vec3 > &grid)

void	SetComponent (Grid< Vec3 > &grid, const Grid< Real > &comp, int dim)

void	GetCentered (Grid< Vec3 > &center, const MACGrid &vel)

void	GetMAC (MACGrid &vel, const Grid< Vec3 > &center)

void	FillInBoundary (Grid< Vec3 > &grid, int g)

void	kn_conv_mex_in_to_MAC (const double p_lin_array, MACGrid p_result)

void	kn_conv_MAC_to_mex_out (const MACGrid p_mac, double p_result)

void	kn_conv_mex_in_to_Vec3 (const double p_lin_array, Grid< Vec3 > p_result)

void	kn_conv_Vec3_to_mex_out (const Grid< Vec3 > p_Vec3, double p_result)

void	kn_conv_mex_in_to_Real (const double p_lin_array, Grid< Real > p_result)

void	kn_conv_Real_to_mex_out (const Grid< Real > p_grid, double p_result)

void	InitPreconditionIncompCholesky (FlagGrid &flags, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak, Grid< Real > &orgA0, Grid< Real > &orgAi, Grid< Real > &orgAj, Grid< Real > &orgAk)
	Preconditioning a la Wavelet Turbulence (needs 4 add. grids)

void	InitPreconditionModifiedIncompCholesky2 (FlagGrid &flags, Grid< Real > &Aprecond, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak)
	Preconditioning using modified IC ala Bridson (needs 1 add. grid)

void	InitPreconditionMultigrid (GridMg *MG, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak, Real mAccuracy)
	Preconditioning using multigrid ala Dick et al.

void	ApplyPreconditionIncompCholesky (Grid< Real > &dst, Grid< Real > &Var1, FlagGrid &flags, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak, Grid< Real > &orgA0, Grid< Real > &orgAi, Grid< Real > &orgAj, Grid< Real > &orgAk)
	Apply WT-style ICP.

void	ApplyPreconditionModifiedIncompCholesky2 (Grid< Real > &dst, Grid< Real > &Var1, FlagGrid &flags, Grid< Real > &Aprecond, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak)
	Apply Bridson-style mICP.

void	ApplyPreconditionMultigrid (GridMg *pMG, Grid< Real > &dst, Grid< Real > &Var1)
	Perform one Multigrid VCycle.

double	GridDotProduct (const Grid< Real > &a, const Grid< Real > &b)
	Kernel: Compute the dot product between two Real grids. More...

double	InitSigma (FlagGrid &flags, Grid< Real > &dst, Grid< Real > &rhs, Grid< Real > &temp)

void	UpdateSearchVec (Grid< Real > &dst, Grid< Real > &src, Real factor)

void	ApplyMatrix (FlagGrid &flags, Grid< Real > &dst, Grid< Real > &src, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak)

void	ApplyMatrix2D (FlagGrid &flags, Grid< Real > &dst, Grid< Real > &src, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak)

void	MakeLaplaceMatrix (FlagGrid &flags, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak, MACGrid *fractions=0)

Vec3	ButterflySubdivision (Mesh &m, const Corner &ca, const Corner &cb)

Vec3	OneSidedButterflySubdivision (Mesh &m, const int valence, const Corner &c)

Vec3	ModifiedButterflySubdivision (Mesh &m, const Corner &ca, const Corner &cb, const Vec3 &fallback)

void	CollapseEdge (Mesh &m, const int trinum, const int which, const Vec3 &edgevect, const Vec3 &endpoint, vector< int > &deletedNodes, std::map< int, bool > &taintedTris, int &numCollapses, bool doTubeCutting)

void	SetLevelsetBoundaries (Grid< Real > &phi)

void	knExtrapolateMACSimple (MACGrid &vel, int distance, Grid< int > &tmp, const int d, const int c)

void	knExtrapolateIntoBnd (FlagGrid &flags, MACGrid &vel)

Vec3	getNormal (const Grid< Real > &data, int i, int j, int k)

void	knUnprojectNormalComp (FlagGrid &flags, MACGrid &vel, Grid< Real > &phi, Real maxDist)

PYTHON void	extrapolateMACSimple (FlagGrid &flags, MACGrid &vel, int distance=4, LevelsetGrid *phiObs=NULL, bool intoObs=false)

void	knExtrapolateMACFromWeight (MACGrid &vel, Grid< Vec3 > &weight, int distance, const int d, const int c)

PYTHON void	extrapolateMACFromWeight (MACGrid &vel, Grid< Vec3 > &weight, int distance=2)

void	knExtrapolateLsSimple (Grid< S > &val, int distance, Grid< int > &tmp, const int d, S direction)

void	knSetRemaining (Grid< S > &phi, Grid< int > &tmp, S distance)

PYTHON void	extrapolateLsSimple (Grid< Real > &phi, int distance=4, bool inside=false)

PYTHON void	extrapolateVec3Simple (Grid< Vec3 > &vel, Grid< Real > &phi, int distance=4)

template<class GRID , class T >
T	fmInterpolateNeighbors (GRID mpVal, int x, int y, int z, Real weights)
	Fast marching. Transport certain values.

void	readBobjFile (const string &name, Mesh *mesh, bool append)

void	writeBobjFile (const string &name, Mesh *mesh)

void	readObjFile (const std::string &name, Mesh *mesh, bool append)

void	writeObjFile (const string &name, Mesh *mesh)

template<class GRIDT >
void	gridConvertWrite (gzFile &gzf, GRIDT &grid, void *ptr, UniHeader &head)

template<>
void	gridConvertWrite (gzFile &gzf, Grid< int > &grid, void *ptr, UniHeader &head)

template<>
void	gridConvertWrite (gzFile &gzf, Grid< double > &grid, void *ptr, UniHeader &head)

template<>
void	gridConvertWrite (gzFile &gzf, Grid< Vector3D< double > > &grid, void *ptr, UniHeader &head)

template<>
void	gridConvertWrite (gzFile &gzf, Grid4d< int > &grid, void *ptr, UniHeader &head)

template<>
void	gridConvertWrite (gzFile &gzf, Grid4d< double > &grid, void *ptr, UniHeader &head)

template<>
void	gridConvertWrite (gzFile &gzf, Grid4d< Vector3D< double > > &grid, void *ptr, UniHeader &head)

template<>
void	gridConvertWrite (gzFile &gzf, Grid4d< Vector4D< double > > &grid, void *ptr, UniHeader &head)

template<class T >
void	pdataConvertWrite (gzFile &gzf, ParticleDataImpl< T > &pdata, void *ptr, UniPartHeader &head)

template<>
void	pdataConvertWrite (gzFile &gzf, ParticleDataImpl< int > &pdata, void *ptr, UniPartHeader &head)

template<>
void	pdataConvertWrite (gzFile &gzf, ParticleDataImpl< double > &pdata, void *ptr, UniPartHeader &head)

template<>
void	pdataConvertWrite (gzFile &gzf, ParticleDataImpl< Vec3 > &pdata, void *ptr, UniPartHeader &head)

template<class T >
void	gridReadConvert (gzFile &gzf, Grid< T > &grid, void *ptr, int bytesPerElement)

template<>
void	gridReadConvert< int > (gzFile &gzf, Grid< int > &grid, void *ptr, int bytesPerElement)

template<>
void	gridReadConvert< double > (gzFile &gzf, Grid< double > &grid, void *ptr, int bytesPerElement)

template<>
void	gridReadConvert< Vec3 > (gzFile &gzf, Grid< Vec3 > &grid, void *ptr, int bytesPerElement)

template<class T >
void	pdataReadConvert (gzFile &gzf, ParticleDataImpl< T > &grid, void *ptr, int bytesPerElement)

template<>
void	pdataReadConvert< int > (gzFile &gzf, ParticleDataImpl< int > &pdata, void *ptr, int bytesPerElement)

template<>
void	pdataReadConvert< double > (gzFile &gzf, ParticleDataImpl< double > &pdata, void *ptr, int bytesPerElement)

template<>
void	pdataReadConvert< Vec3 > (gzFile &gzf, ParticleDataImpl< Vec3 > &pdata, void *ptr, int bytesPerElement)

template<class T >
void	gridReadConvert4d (gzFile &gzf, Grid4d< T > &grid, void *ptr, int bytesPerElement, int t)

template<>
void	gridReadConvert4d< int > (gzFile &gzf, Grid4d< int > &grid, void *ptr, int bytesPerElement, int t)

template<>
void	gridReadConvert4d< double > (gzFile &gzf, Grid4d< double > &grid, void *ptr, int bytesPerElement, int t)

template<>
void	gridReadConvert4d< Vec3 > (gzFile &gzf, Grid4d< Vec3 > &grid, void *ptr, int bytesPerElement, int t)

template<>
void	gridReadConvert4d< Vec4 > (gzFile &gzf, Grid4d< Vec4 > &grid, void *ptr, int bytesPerElement, int t)

template<class T >
void	writeGridTxt (const string &name, Grid< T > *grid)

template<class T >
void	writeGridRaw (const string &name, Grid< T > *grid)

template<class T >
void	readGridRaw (const string &name, Grid< T > *grid)

void	getUniFileSize (const string &name, int &x, int &y, int &z, int t, std::string info)
	for auto-init & check of results of test runs , optionally returns info string of header

PYTHON Vec3	getUniFileSize (const string &name)

PYTHON void	printUniFileInfoString (const string &name)

template<class T >
void	writeGridUni (const string &name, Grid< T > *grid)

template<class T >
void	readGridUni (const string &name, Grid< T > *grid)

template<class T >
void	writeGridVol (const string &name, Grid< T > *grid)

template<>
void	writeGridVol< Real > (const string &name, Grid< Real > *grid)

template<class T >
void	readGridVol (const string &name, Grid< T > *grid)

template<>
void	readGridVol< Real > (const string &name, Grid< Real > *grid)

template<class T >
void	writeGrid4dUni (const string &name, Grid4d< T > *grid)

template<class T >
void	readGrid4dUni (const string &name, Grid4d< T > grid, int readTslice, Grid4d< T > slice, void **fileHandle)

void	readGrid4dUniCleanup (void **fileHandle)

template<class T >
void	writeGrid4dRaw (const string &name, Grid4d< T > *grid)

template<class T >
void	readGrid4dRaw (const string &name, Grid4d< T > *grid)

void	writeParticlesUni (const std::string &name, BasicParticleSystem *parts)

void	readParticlesUni (const std::string &name, BasicParticleSystem *parts)

template<class T >
void	writePdataUni (const std::string &name, ParticleDataImpl< T > *pdata)

template<class T >
void	readPdataUni (const std::string &name, ParticleDataImpl< T > *pdata)

void	knQuantize (Grid< Real > &grid, Real step)

PYTHON void	quantizeGrid (Grid< Real > &grid, Real step)

template void	writeGridRaw< int > (const string &name, Grid< int > *grid)

template void	writeGridRaw< Real > (const string &name, Grid< Real > *grid)

template void	writeGridRaw< Vec3 > (const string &name, Grid< Vec3 > *grid)

template void	writeGridUni< int > (const string &name, Grid< int > *grid)

template void	writeGridUni< Real > (const string &name, Grid< Real > *grid)

template void	writeGridUni< Vec3 > (const string &name, Grid< Vec3 > *grid)

template void	writeGridVol< int > (const string &name, Grid< int > *grid)

template void	writeGridVol< Vec3 > (const string &name, Grid< Vec3 > *grid)

template void	readGridVol< int > (const string &name, Grid< int > *grid)

template void	readGridVol< Vec3 > (const string &name, Grid< Vec3 > *grid)

template void	writeGridTxt< int > (const string &name, Grid< int > *grid)

template void	writeGridTxt< Real > (const string &name, Grid< Real > *grid)

template void	writeGridTxt< Vec3 > (const string &name, Grid< Vec3 > *grid)

template void	readGridRaw< int > (const string &name, Grid< int > *grid)

template void	readGridRaw< Real > (const string &name, Grid< Real > *grid)

template void	readGridRaw< Vec3 > (const string &name, Grid< Vec3 > *grid)

template void	readGridUni< int > (const string &name, Grid< int > *grid)

template void	readGridUni< Real > (const string &name, Grid< Real > *grid)

template void	readGridUni< Vec3 > (const string &name, Grid< Vec3 > *grid)

template void	writePdataUni< int > (const std::string &name, ParticleDataImpl< int > *pdata)

template void	writePdataUni< Real > (const std::string &name, ParticleDataImpl< Real > *pdata)

template void	writePdataUni< Vec3 > (const std::string &name, ParticleDataImpl< Vec3 > *pdata)

template void	readPdataUni< int > (const std::string &name, ParticleDataImpl< int > *pdata)

template void	readPdataUni< Real > (const std::string &name, ParticleDataImpl< Real > *pdata)

template void	readPdataUni< Vec3 > (const std::string &name, ParticleDataImpl< Vec3 > *pdata)

template void	readGrid4dUni< int > (const string &name, Grid4d< int > grid, int readTslice, Grid4d< int > slice, void **fileHandle)

template void	readGrid4dUni< Real > (const string &name, Grid4d< Real > grid, int readTslice, Grid4d< Real > slice, void **fileHandle)

template void	readGrid4dUni< Vec3 > (const string &name, Grid4d< Vec3 > grid, int readTslice, Grid4d< Vec3 > slice, void **fileHandle)

template void	readGrid4dUni< Vec4 > (const string &name, Grid4d< Vec4 > grid, int readTslice, Grid4d< Vec4 > slice, void **fileHandle)

template void	writeGrid4dUni< int > (const string &name, Grid4d< int > *grid)

template void	writeGrid4dUni< Real > (const string &name, Grid4d< Real > *grid)

template void	writeGrid4dUni< Vec3 > (const string &name, Grid4d< Vec3 > *grid)

template void	writeGrid4dUni< Vec4 > (const string &name, Grid4d< Vec4 > *grid)

template void	readGrid4dRaw< int > (const string &name, Grid4d< int > *grid)

template void	readGrid4dRaw< Real > (const string &name, Grid4d< Real > *grid)

template void	readGrid4dRaw< Vec3 > (const string &name, Grid4d< Vec3 > *grid)

template void	readGrid4dRaw< Vec4 > (const string &name, Grid4d< Vec4 > *grid)

template void	writeGrid4dRaw< int > (const string &name, Grid4d< int > *grid)

template void	writeGrid4dRaw< Real > (const string &name, Grid4d< Real > *grid)

template void	writeGrid4dRaw< Vec3 > (const string &name, Grid4d< Vec3 > *grid)

template void	writeGrid4dRaw< Vec4 > (const string &name, Grid4d< Vec4 > *grid)

PYTHON void	mantaMsg (const std::string &out, int level=1)

PYTHON std::string	printBuildInfo ()

PYTHON void	setDebugLevel (int level=1)

ostream &	operator<< (ostream &os, const MuTime &t)

std::string	buildInfoString ()
	generate a string with infos about the current mantaflow build

void	updateQtGui (bool full, int frame, float time, const std::string &curPlugin)

bool	_chklevel (int level=0)

template<class T >
T	square (T a)

template<class T >
T	cubed (T a)

template<class T >
T	clamp (const T &val, const T &vmin, const T &vmax)

template<class T >
T	nmod (const T &a, const T &b)

template<>
int	nmod (const int &a, const int &b)

template<>
float	nmod (const float &a, const float &b)

template<>
double	nmod (const double &a, const double &b)

template<class T >
T	safeDivide (const T &a, const T &b)

template<>
int	safeDivide< int > (const int &a, const int &b)

template<>
float	safeDivide< float > (const float &a, const float &b)

template<>
double	safeDivide< double > (const double &a, const double &b)

bool	c_isnan (float c)

template<class T >
GridBase::GridType	typeList ()

template<>
GridBase::GridType	typeList< Real > ()

template<>
GridBase::GridType	typeList< int > ()

template<>
GridBase::GridType	typeList< Vec3 > ()

Real	CompMinReal (Grid< Real > &val)

Real	CompMaxReal (Grid< Real > &val)

int	CompMinInt (Grid< int > &val)

int	CompMaxInt (Grid< int > &val)

Real	CompMinVec (Grid< Vec3 > &val)

Real	CompMaxVec (Grid< Vec3 > &val)

void	knGridSetConstReal (Grid< T > &me, T val)

void	knGridAddConstReal (Grid< T > &me, T val)

void	knGridMultConst (Grid< T > &me, T val)

void	knGridClamp (Grid< T > &me, T min, T max)

PYTHON Real	gridMaxDiff (Grid< Real > &g1, Grid< Real > &g2)

PYTHON Real	gridMaxDiffInt (Grid< int > &g1, Grid< int > &g2)

PYTHON Real	gridMaxDiffVec3 (Grid< Vec3 > &g1, Grid< Vec3 > &g2)

PYTHON void	copyMacToVec3 (MACGrid &source, Grid< Vec3 > &target)

PYTHON void	convertMacToVec3 (MACGrid &source, Grid< Vec3 > &target)

PYTHON void	resampleVec3ToMac (Grid< Vec3 > &source, MACGrid &target)

PYTHON void	resampleMacToVec3 (MACGrid &source, Grid< Vec3 > &target)

PYTHON void	copyLevelsetToReal (LevelsetGrid &source, Grid< Real > &target)

PYTHON void	copyVec3ToReal (Grid< Vec3 > &source, Grid< Real > &targetX, Grid< Real > &targetY, Grid< Real > &targetZ)

PYTHON void	copyRealToVec3 (Grid< Real > &sourceX, Grid< Real > &sourceY, Grid< Real > &sourceZ, Grid< Vec3 > &target)

PYTHON void	convertLevelsetToReal (LevelsetGrid &source, Grid< Real > &target)

PYTHON void	swapComponents (Grid< Vec3 > &vel, int c1=0, int c2=1, int c3=2)

PYTHON Real	getUvWeight (Grid< Vec3 > &uv)

void	knResetUvGrid (Grid< Vec3 > &target)

PYTHON void	resetUvGrid (Grid< Vec3 > &target)

PYTHON void	updateUvWeight (Real resetTime, int index, int numUvs, Grid< Vec3 > &uv)

void	knSetBoundary (Grid< T > &grid, T value, int w)

void	knSetBoundaryNeumann (Grid< T > &grid, int w)

void	knSetBoundaryMAC (Grid< Vec3 > &grid, Vec3 value, int w)

void	knSetBoundaryMACNorm (Grid< Vec3 > &grid, Vec3 value, int w)

double	knGridTotalSum (const Grid< Real > &a, FlagGrid *flags)

int	knCountFluidCells (FlagGrid &flags)

PYTHON Real	getGridAvg (Grid< Real > &source, FlagGrid *flags=NULL)

void	knGetComponent (Grid< Vec3 > &source, Grid< Real > &target, int component)
	transfer data between real and vec3 grids More...

PYTHON void	getComponent (Grid< Vec3 > &source, Grid< Real > &target, int component)

void	knSetComponent (Grid< Real > &source, Grid< Vec3 > &target, int component)

PYTHON void	setComponent (Grid< Real > &source, Grid< Vec3 > &target, int component)

Vec3	calcGridSizeFactor (Vec3i s1, Vec3i s2)
	helper to compute grid conversion factor between local coordinates of two grids

void	getComponent (const Grid< Vec3 > &src, Grid< Real > &dst, int c)

void	setComponent (const Grid< Real > &src, Grid< Vec3 > &dst, int c)

void	gridAdd (Grid< T > &me, const Grid< S > &other)

void	gridSub (Grid< T > &me, const Grid< S > &other)

void	gridMult (Grid< T > &me, const Grid< S > &other)

void	gridDiv (Grid< T > &me, const Grid< S > &other)

void	gridAddScalar (Grid< T > &me, const S &other)

void	gridMultScalar (Grid< T > &me, const S &other)

void	gridScaledAdd (Grid< T > &me, const Grid< T > &other, const S &factor)

void	gridSafeDiv (Grid< T > &me, const Grid< T > &other)

void	gridSetConst (Grid< T > &grid, T value)

Vec3	getGradient (const Grid< Real > &data, int i, int j, int k)

void	knInterpolateGridTempl (Grid< S > &target, Grid< S > &source, const Vec3 &sourceFactor, Vec3 offset, int orderSpace=1)

template<class GRID >
void	interpolGridTempl (GRID &target, GRID &source)

template<class T >
Grid4dBase::Grid4dType	typeList ()

template<>
Grid4dBase::Grid4dType	typeList< Real > ()

template<>
Grid4dBase::Grid4dType	typeList< int > ()

template<>
Grid4dBase::Grid4dType	typeList< Vec3 > ()

template<>
Grid4dBase::Grid4dType	typeList< Vec4 > ()

Real	kn4dMinReal (Grid4d< Real > &val)

Real	kn4dMaxReal (Grid4d< Real > &val)

int	kn4dMinInt (Grid4d< int > &val)

int	kn4dMaxInt (Grid4d< int > &val)

template<class VEC >
Real	kn4dMinVec (Grid4d< VEC > &val)

template<class VEC >
Real	kn4dMaxVec (Grid4d< VEC > &val)

void	kn4dSetConstReal (Grid4d< T > &me, T val)

void	kn4dAddConstReal (Grid4d< T > &me, T val)

void	kn4dMultConst (Grid4d< T > &me, T val)

void	kn4dClamp (Grid4d< T > &me, T min, T max)

void	knGetComp4d (const Grid4d< Vec4 > &src, Grid4d< Real > &dst, int c)

void	knSetComp4d (const Grid4d< Real > &src, Grid4d< Vec4 > &dst, int c)

PYTHON void	getComp4d (const Grid4d< Vec4 > &src, Grid4d< Real > &dst, int c)

PYTHON void	setComp4d (const Grid4d< Real > &src, Grid4d< Vec4 > &dst, int c)

void	knSetBnd4d (Grid4d< T > &grid, T value, int w)

void	knSetBnd4dNeumann (Grid4d< T > &grid, int w)

PYTHON Real	grid4dMaxDiff (Grid4d< Real > &g1, Grid4d< Real > &g2)

PYTHON Real	grid4dMaxDiffInt (Grid4d< int > &g1, Grid4d< int > &g2)

PYTHON Real	grid4dMaxDiffVec3 (Grid4d< Vec3 > &g1, Grid4d< Vec3 > &g2)

PYTHON Real	grid4dMaxDiffVec4 (Grid4d< Vec4 > &g1, Grid4d< Vec4 > &g2)

void	knSetRegion4d (Grid4d< S > &dst, Vec4 start, Vec4 end, S value)

PYTHON void	setRegion4d (Grid4d< Real > &dst, Vec4 start, Vec4 end, Real value)

PYTHON void	setRegion4dVec4 (Grid4d< Vec4 > &dst, Vec4 start, Vec4 end, Vec4 value)

PYTHON void	getSliceFrom4d (Grid4d< Real > &src, int srct, Grid< Real > &dst)

PYTHON void	getSliceFrom4dVec (Grid4d< Vec4 > &src, int srct, Grid< Vec3 > &dst, Grid< Real > *dstt=NULL)

void	knInterpol4d (Grid4d< S > &target, Grid4d< S > &source, const Vec4 &srcFac, const Vec4 &offset)
	interpolate 4d grid from one size to another size More...

PYTHON void	interpolateGrid4d (Grid4d< Real > &target, Grid4d< Real > &source, Vec4 offset=Vec4(0.), Vec4 scale=Vec4(1.), Vec4 size=Vec4(-1.))

PYTHON void	interpolateGrid4dVec (Grid4d< Vec4 > &target, Grid4d< Vec4 > &source, Vec4 offset=Vec4(0.), Vec4 scale=Vec4(1.), Vec4 size=Vec4(-1.))

Vec4	calcGridSizeFactor4d (Vec4i s1, Vec4i s2)
	helper to compute grid conversion factor between local coordinates of two grids

Vec4	calcGridSizeFactor4d (Vec4 s1, Vec4 s2)

void	getComponent4d (const Grid4d< Vec4 > &src, Grid4d< Real > &dst, int c)

void	setComponent4d (const Grid4d< Real > &src, Grid4d< Vec4 > &dst, int c)

void	Grid4dAdd (Grid4d< T > &me, const Grid4d< S > &other)

void	Grid4dSub (Grid4d< T > &me, const Grid4d< S > &other)

void	Grid4dMult (Grid4d< T > &me, const Grid4d< S > &other)

void	Grid4dDiv (Grid4d< T > &me, const Grid4d< S > &other)

void	Grid4dAddScalar (Grid4d< T > &me, const S &other)

void	Grid4dMultScalar (Grid4d< T > &me, const S &other)

void	Grid4dScaledAdd (Grid4d< T > &me, const Grid4d< T > &other, const S &factor)

void	Grid4dSafeDiv (Grid4d< T > &me, const Grid4d< T > &other)

void	Grid4dSetConst (Grid4d< T > &me, T value)

Vec4	getGradient4d (const Grid4d< Real > &data, int i, int j, int k, int t)

void	KnInterpolateGrid4dTempl (Grid4d< S > &target, Grid4d< S > &source, const Vec4 &sourceFactor, Vec4 offset)

Vec3i	getQuad (const Vec3 &l0, const Vec3 &l1, int dim, int plane, Real dx)

Vec3i	__fRange (Vec3i size, int dim, int plane)

void	getCellCoordinates (const Vec3i &pos, Vec3 box[4], int dim, bool offset=false)

void	glBox (const Vec3 &p0, const Vec3 &p1, const float dx)

void	projectImg (SimpleImage &img, Grid< Real > &val, int shadeMode=0, Real scale=1.)

void	guiMain (int argc, char *argv[])

void	guiWaitFinish ()

void	InitFmIn (FlagGrid &flags, Grid< int > &fmFlags, Grid< Real > &phi, bool ignoreWalls, int obstacleType)

void	InitFmOut (FlagGrid &flags, Grid< int > &fmFlags, Grid< Real > &phi, bool ignoreWalls, int obstacleType)

void	SetUninitialized (Grid< int > &flags, Grid< int > &fmFlags, Grid< Real > &phi, const Real val, int ignoreWalls, int obstacleType)

template<bool inward>
bool	isAtInterface (Grid< int > &fmFlags, Grid< Real > &phi, const Vec3i &p)

void	KnJoin (Grid< Real > &a, const Grid< Real > &b)

void	KnSubtract (Grid< Real > &a, const Grid< Real > &b)

vector< Vec3 >	KnAdvectMeshInGrid (vector< Node > &nodes, const FlagGrid &flags, const MACGrid &vel, const Real dt)

void	meshSDF (Mesh &mesh, LevelsetGrid &levelset, Real sigma, Real cutoff=0.)

void	ApplyMeshToGrid (Grid< T > grid, Grid< Real > &sdf, T value, FlagGrid respectFlags)

void	knCopyA (std::vector< Real > &sizeRef, std::vector< Real > &A0, int stencilSize0, bool is3D, const Grid< Real > pA0, const Grid< Real > pAi, const Grid< Real > pAj, const Grid< Real > pAk)

void	knActivateVertices (std::vector< GridMg::VertexType > &type_0, std::vector< Real > &A0, bool &nonZeroStencilSumFound, bool &trivialEquationsFound, const GridMg &mg)

void	knSetRhs (std::vector< Real > &b, const Grid< Real > &rhs, const GridMg &mg)

void	knSet (std::vector< T > &data, T value)

void	knCopyToVector (std::vector< T > &dst, const Grid< T > &src)

void	knCopyToGrid (const std::vector< T > &src, Grid< T > &dst)

void	knAddAssign (std::vector< T > &dst, const std::vector< T > &src)

void	knActivateCoarseVertices (std::vector< GridMg::VertexType > &type, int unused)

void	knGenCoarseGridOperator (std::vector< Real > &sizeRef, std::vector< Real > &A, int l, const GridMg &mg)

void	knSmoothColor (ThreadSize &numBlocks, std::vector< Real > &x, const Vec3i &blockSize, const std::vector< Vec3i > &colorOffs, int l, const GridMg &mg)

void	knCalcResidual (std::vector< Real > &r, int l, const GridMg &mg)

Real	knResidualNormSumSqr (const vector< Real > &r, int l, const GridMg &mg)

void	knRestrict (std::vector< Real > &dst, const std::vector< Real > &src, int l_dst, const GridMg &mg)

void	knInterpolate (std::vector< Real > &dst, const std::vector< Real > &src, int l_dst, const GridMg &mg)

void	knSetPdataConst (ParticleDataImpl< T > &pdata, T value)

void	knPdataSet (ParticleDataImpl< T > &me, const ParticleDataImpl< S > &other)

void	knPdataAdd (ParticleDataImpl< T > &me, const ParticleDataImpl< S > &other)

void	knPdataSub (ParticleDataImpl< T > &me, const ParticleDataImpl< S > &other)

void	knPdataMult (ParticleDataImpl< T > &me, const ParticleDataImpl< S > &other)

void	knPdataDiv (ParticleDataImpl< T > &me, const ParticleDataImpl< S > &other)

void	knPdataSetScalar (ParticleDataImpl< T > &me, const S &other)

void	knPdataAddScalar (ParticleDataImpl< T > &me, const S &other)

void	knPdataMultScalar (ParticleDataImpl< T > &me, const S &other)

void	knPdataScaledAdd (ParticleDataImpl< T > &me, const ParticleDataImpl< T > &other, const S &factor)

void	knPdataSafeDiv (ParticleDataImpl< T > &me, const ParticleDataImpl< T > &other)

void	knPdataSetConst (ParticleDataImpl< T > &pdata, T value)

void	knPdataClamp (ParticleDataImpl< T > &me, T min, T max)

template<typename T >
Real	CompPdata_Min (const ParticleDataImpl< T > &val)

template<typename T >
Real	CompPdata_Max (const ParticleDataImpl< T > &val)

Real	CompPdata_MinVec3 (const ParticleDataImpl< Vec3 > &val)

Real	CompPdata_MaxVec3 (const ParticleDataImpl< Vec3 > &val)

template<class S >
std::vector< Vec3 >	GridAdvectKernel (std::vector< S > &p, const MACGrid &vel, const FlagGrid &flags, Real dt, bool deleteInObstacle, bool stopInObstacle)

void	KnDeleteInObstacle (std::vector< S > &p, const FlagGrid &flags)

void	KnClampPositions (std::vector< S > &p, const FlagGrid &flags, ParticleDataImpl< Vec3 > *posOld=NULL, bool stopInObstacle=true)

void	KnProjectParticles (ParticleSystem< S > &part, Grid< Vec3 > &gradient)

void	SemiLagrange (FlagGrid &flags, MACGrid &vel, Grid< T > &dst, Grid< T > &src, Real dt, bool isLevelset, int orderSpace)

void	SemiLagrangeMAC (FlagGrid &flags, MACGrid &vel, MACGrid &dst, MACGrid &src, Real dt, int orderSpace)

void	MacCormackCorrect (FlagGrid &flags, Grid< T > &dst, Grid< T > &old, Grid< T > &fwd, Grid< T > &bwd, Real strength, bool isLevelSet, bool isMAC=false)

void	MacCormackCorrectMAC (FlagGrid &flags, Grid< T > &dst, Grid< T > &old, Grid< T > &fwd, Grid< T > &bwd, Real strength, bool isLevelSet, bool isMAC=false)

template<class T >
void	getMinMax (T &minv, T &maxv, const T &val)

template<>
void	getMinMax< Vec3 > (Vec3 &minv, Vec3 &maxv, const Vec3 &val)

template<class T >
T	doClampComponent (const Vec3i &gridSize, T dst, Grid< T > &orig, T fwd, const Vec3 &pos, const Vec3 &vel)
	Helper function for clamping non-mac grids.

template<int c>
Real	doClampComponentMAC (const Vec3i &gridSize, Real dst, MACGrid &orig, Real fwd, const Vec3 &pos, const Vec3 &vel)
	Helper function for clamping MAC grids.

void	MacCormackClamp (FlagGrid &flags, MACGrid &vel, Grid< T > &dst, Grid< T > &orig, Grid< T > &fwd, Real dt)
	Kernel: Clamp obtained value to min/max in source area, and reset values that point out of grid or into boundaries. More...

void	MacCormackClampMAC (FlagGrid &flags, MACGrid &vel, MACGrid &dst, MACGrid &orig, MACGrid &fwd, Real dt)

template<class GridType >
void	fnAdvectSemiLagrange (FluidSolver *parent, FlagGrid &flags, MACGrid &vel, GridType &orig, int order, Real strength, int orderSpace, bool openBounds, int bWidth)

Vec3	getBulkVel (FlagGrid &flags, MACGrid &vel, int i, int j, int k)
	calculate local propagation velocity for cell (i,j,k)

void	extrapolateVelConvectiveBC (FlagGrid &flags, MACGrid &vel, MACGrid &velDst, MACGrid &velPrev, Real timeStep, int bWidth)

void	copyChangedVels (FlagGrid &flags, MACGrid &velDst, MACGrid &vel)

void	applyOutflowBC (FlagGrid &flags, MACGrid &vel, MACGrid &velPrev, double timeStep, int bWidth=1)
	extrapolate normal velocity components into open boundary cells (marked as outflow cells)

void	knResetPhiInObs (FlagGrid &flags, Grid< Real > &sdf)

PYTHON void	resetPhiInObs (FlagGrid &flags, Grid< Real > &sdf)

template<>
void	fnAdvectSemiLagrange< MACGrid > (FluidSolver *parent, FlagGrid &flags, MACGrid &vel, MACGrid &orig, int order, Real strength, int orderSpace, bool openBounds, int bWidth)
	template function for performing SL advection: specialized version for MAC grids

PYTHON void	advectSemiLagrange (FlagGrid flags, MACGrid vel, GridBase *grid, int order=1, Real strength=1.0, int orderSpace=1, bool openBounds=false, int boundaryWidth=1)

void	KnAddForceField (FlagGrid &flags, MACGrid &vel, Grid< Vec3 > &force)

void	KnAddForce (FlagGrid &flags, MACGrid &vel, Vec3 force)

PYTHON void	addGravity (FlagGrid &flags, MACGrid &vel, Vec3 gravity)

void	KnAddBuoyancy (FlagGrid &flags, Grid< Real > &factor, MACGrid &vel, Vec3 strength)

PYTHON void	addBuoyancy (FlagGrid &flags, Grid< Real > &density, MACGrid &vel, Vec3 gravity, Real coefficient=1.)

void	convertDescToVec (const string &desc, Vector3D< bool > &lo, Vector3D< bool > &up)
	helper to parse openbounds string [xXyYzZ] , convert to vec3

PYTHON void	setOpenBound (FlagGrid &flags, int bWidth, string openBound="", int type=FlagGrid::TypeOutflow\|FlagGrid::TypeEmpty)

PYTHON void	resetOutflow (FlagGrid &flags, Grid< Real > phi=0, BasicParticleSystem parts=0, Grid< Real > real=0, Grid< int > index=0, ParticleIndexSystem *indexSys=0)

void	KnSetInflow (MACGrid &vel, int dim, int p0, const Vec3 &val)

PYTHON void	setInflowBcs (MACGrid &vel, string dir, Vec3 value)

void	KnSetWallBcs (FlagGrid &flags, MACGrid &vel)

void	KnSetWallBcsFrac (FlagGrid &flags, MACGrid &vel, MACGrid &velTarget, Grid< Real > *phiObs, const int &boundaryWidth=0)

PYTHON void	setWallBcs (FlagGrid &flags, MACGrid &vel, MACGrid fractions=0, Grid< Real > phiObs=0, int boundaryWidth=0)
	set zero normal velocity boundary condition on walls More...

void	KnConfForce (Grid< Vec3 > &force, const Grid< Real > &grid, const Grid< Vec3 > &curl, Real str)

PYTHON void	vorticityConfinement (MACGrid &vel, FlagGrid &flags, Real strength)

PYTHON void	addForceField (FlagGrid &flags, MACGrid &vel, Grid< Vec3 > &force)

void	KnProcessBurn (Grid< Real > &fuel, Grid< Real > &density, Grid< Real > &react, Grid< Real > red, Grid< Real > green, Grid< Real > blue, Grid< Real > heat, Real burningRate, Real flameSmoke, Real ignitionTemp, Real maxTemp, Real dt, Vec3 flameSmokeColor)

PYTHON void	processBurn (Grid< Real > &fuel, Grid< Real > &density, Grid< Real > &react, Grid< Real > red=NULL, Grid< Real > green=NULL, Grid< Real > blue=NULL, Grid< Real > heat=NULL, Real burningRate=0.75f, Real flameSmoke=1.0f, Real ignitionTemp=1.25f, Real maxTemp=1.75f, Real dt=0.1f, Vec3 flameSmokeColor=Vec3(0.7f, 0.7f, 0.7f))

void	KnUpdateFlame (Grid< Real > &react, Grid< Real > &flame)

PYTHON void	updateFlame (Grid< Real > &react, Grid< Real > &flame)

PYTHON void	sampleFlagsWithParticles (FlagGrid &flags, BasicParticleSystem &parts, int discretization, Real randomness)

PYTHON void	sampleLevelsetWithParticles (LevelsetGrid &phi, FlagGrid &flags, BasicParticleSystem &parts, int discretization, Real randomness, bool reset=false, bool refillEmpty=false)

void	knClearFluidFLags (FlagGrid &flags, int dummy=0)

void	knSetNbObstacle (FlagGrid &nflags, const FlagGrid &flags, const Grid< Real > &phiObs)

PYTHON void	markFluidCells (BasicParticleSystem &parts, FlagGrid &flags, Grid< Real > *phiObs=NULL)

PYTHON void	testInitGridWithPos (Grid< Real > &grid)

Real	calculateRadiusFactor (Grid< Real > &grid, Real factor)
	helper to calculate particle radius factor to cover the diagonal of a cell in 2d/3d

PYTHON void	adjustNumber (BasicParticleSystem &parts, MACGrid &vel, FlagGrid &flags, int minParticles, int maxParticles, LevelsetGrid &phi, Real radiusFactor=1., Real narrowBand=-1., Grid< Real > *exclude=NULL)
	re-sample particles based on an input levelset More...

PYTHON void	debugIntToReal (Grid< int > &source, Grid< Real > &dest, Real factor=1.)

PYTHON void	gridParticleIndex (BasicParticleSystem &parts, ParticleIndexSystem &indexSys, FlagGrid &flags, Grid< int > &index, Grid< int > *counter=NULL)

void	ComputeUnionLevelsetPindex (Grid< int > &index, BasicParticleSystem &parts, ParticleIndexSystem &indexSys, LevelsetGrid &phi, Real radius=1.)

PYTHON void	unionParticleLevelset (BasicParticleSystem &parts, ParticleIndexSystem &indexSys, FlagGrid &flags, Grid< int > &index, LevelsetGrid &phi, Real radiusFactor=1.)

void	ComputeAveragedLevelsetWeight (BasicParticleSystem &parts, Grid< int > &index, ParticleIndexSystem &indexSys, LevelsetGrid &phi, Real radius=1.)

template<class T >
T	smoothingValue (Grid< T > val, int i, int j, int k, T center)

void	knSmoothGrid (Grid< T > &me, Grid< T > &tmp, Real factor)

void	knSmoothGridNeg (Grid< T > &me, Grid< T > &tmp, Real factor)

PYTHON void	averagedParticleLevelset (BasicParticleSystem &parts, ParticleIndexSystem &indexSys, FlagGrid &flags, Grid< int > &index, LevelsetGrid &phi, Real radiusFactor=1., int smoothen=1, int smoothenNeg=1)

void	knPushOutofObs (BasicParticleSystem &parts, FlagGrid &flags, Grid< Real > &phiObs, Real shift=0.05, Real thresh=0.)

PYTHON void	pushOutofObs (BasicParticleSystem &parts, FlagGrid &flags, Grid< Real > &phiObs, Real shift=0.05, Real thresh=0.)

void	knSafeDivReal (Grid< T > &me, const Grid< Real > &other, Real cutoff=VECTOR_EPSILON)

void	knStompVec3PerComponent (Grid< Vec3 > &grid, Real threshold)

void	knMapLinearVec3ToMACGrid (BasicParticleSystem &p, FlagGrid &flags, MACGrid &vel, Grid< Vec3 > &tmp, ParticleDataImpl< Vec3 > &pvel)

PYTHON void	mapPartsToMAC (FlagGrid &flags, MACGrid &vel, MACGrid &velOld, BasicParticleSystem &parts, ParticleDataImpl< Vec3 > &partVel, Grid< Vec3 > *weight=NULL)

void	knMapLinear (BasicParticleSystem &p, FlagGrid &flags, Grid< T > &target, Grid< Real > &gtmp, ParticleDataImpl< T > &psource)

template<class T >
void	mapLinearRealHelper (FlagGrid &flags, Grid< T > &target, BasicParticleSystem &parts, ParticleDataImpl< T > &source)

PYTHON void	mapPartsToGrid (FlagGrid &flags, Grid< Real > &target, BasicParticleSystem &parts, ParticleDataImpl< Real > &source)

PYTHON void	mapPartsToGridVec3 (FlagGrid &flags, Grid< Vec3 > &target, BasicParticleSystem &parts, ParticleDataImpl< Vec3 > &source)

void	knMapFromGrid (BasicParticleSystem &p, Grid< T > &gsrc, ParticleDataImpl< T > &target)

PYTHON void	mapGridToParts (Grid< Real > &source, BasicParticleSystem &parts, ParticleDataImpl< Real > &target)

PYTHON void	mapGridToPartsVec3 (Grid< Vec3 > &source, BasicParticleSystem &parts, ParticleDataImpl< Vec3 > &target)

void	knMapLinearMACGridToVec3_PIC (BasicParticleSystem &p, FlagGrid &flags, MACGrid &vel, ParticleDataImpl< Vec3 > &pvel)

PYTHON void	mapMACToParts (FlagGrid &flags, MACGrid &vel, BasicParticleSystem &parts, ParticleDataImpl< Vec3 > &partVel)

void	knMapLinearMACGridToVec3_FLIP (BasicParticleSystem &p, FlagGrid &flags, MACGrid &vel, MACGrid &oldVel, ParticleDataImpl< Vec3 > &pvel, Real flipRatio)

PYTHON void	flipVelocityUpdate (FlagGrid &flags, MACGrid &vel, MACGrid &velOld, BasicParticleSystem &parts, ParticleDataImpl< Vec3 > &partVel, Real flipRatio)

void	knCombineVels (MACGrid &vel, Grid< Vec3 > &w, MACGrid &combineVel, LevelsetGrid *phi, Real narrowBand, Real thresh)

PYTHON void	combineGridVel (MACGrid &vel, Grid< Vec3 > &weight, MACGrid &combineVel, LevelsetGrid *phi=NULL, Real narrowBand=0.0, Real thresh=0.0)

Matrix	get1DGaussianBlurKernel (const int n, const int sigma)
	creates a 1D (horizontal) Gaussian blur kernel of size n and standard deviation sigma

void	apply1DKernelDirX (MACGrid &in, MACGrid &out, const Matrix &kernel)

void	apply1DKernelDirY (MACGrid &in, MACGrid &out, const Matrix &kernel)

void	apply1DKernelDirZ (MACGrid &in, MACGrid &out, const Matrix &kernel)

void	applySeparableKernel2D (MACGrid &grid, FlagGrid &flags, const Matrix &kernel)
	Apply separable Gaussian blur in 2D.

void	applySeparableKernel3D (MACGrid &grid, FlagGrid &flags, const Matrix &kernel)
	Apply separable Gaussian blur in 3D.

void	applySeparableKernel (MACGrid &grid, FlagGrid &flags, const Matrix &kernel)
	Apply separable Gaussian blur in 2D or 3D depending on input dimensions.

Real	getRNorm (const MACGrid &x, const MACGrid &z)
	Compute r-norm for the stopping criterion.

Real	getSNorm (const Real rho, const MACGrid &z, const MACGrid &z_prev)
	Compute s-norm for the stopping criterion.

Real	getEpsPri (const Real eps_abs, const Real eps_rel, MACGrid &x, MACGrid &z)
	Compute primal eps for the stopping criterion.

Real	getEpsDual (const Real eps_abs, const Real eps_rel, MACGrid &y)
	Compute dual eps for the stopping criterion.

PYTHON void	getSpiralVelocity2D (const FlagGrid &flags, MACGrid &vel, Real strength=1.0)

PYTHON void	setGradientYWeight (Grid< Real > &W, const int minY, const int maxY, const Real valAtMin, const Real valAtMax)

void	applySeparableGaussianBlur (MACGrid &grid, FlagGrid &flags, const Matrix &kernel1D)
	Apply Gaussian blur (either 2D or 3D) in a separable way.

void	ADMM_precompute_Separable (int blurRadius)
	Precomputation performed before the first PD iteration.

void	applyApproxInvM (MACGrid &v, FlagGrid &flags, MACGrid &invA)
	Apply approximate multiplication of inverse(M)

void	precomputeQ (MACGrid &Q, FlagGrid &flags, const MACGrid &velT_region, const MACGrid &velC, const Matrix &gBlurKernel, const Real sigma)

void	precomputeInvA (MACGrid &invA, Grid< Real > &weight, const Real sigma)

void	prox_f (MACGrid &v, FlagGrid &flags, MACGrid &Q, const MACGrid &velC, const Real sigma, MACGrid &invA)
	proximal operator of f , guiding

void	solvePressure (MACGrid &vel, Grid< Real > &pressure, FlagGrid &flags, Real cgAccuracy=1e-3, Grid< Real > phi=0, Grid< Real > perCellCorr=0, MACGrid fractions=0, Real gfClamp=1e-04, Real cgMaxIterFac=1.5, bool precondition=true, int preconditioner=1, bool enforceCompatibility=false, bool useL2Norm=false, bool zeroPressureFixing=false, Grid< Real > retRhs=NULL)

PYTHON void	PD_fluid_guiding (MACGrid &vel, MACGrid &velT, Grid< Real > &pressure, FlagGrid &flags, Grid< Real > &weight, int blurRadius=5, Real theta=1.0, Real tau=1.0, Real sigma=1.0, Real epsRel=1e-3, Real epsAbs=1e-3, int maxIters=200, Grid< Real > phi=0, Grid< Real > perCellCorr=0, MACGrid *fractions=0, Real gfClamp=1e-04, Real cgMaxIterFac=1.5, Real cgAccuracy=1e-3, int preconditioner=1, bool zeroPressureFixing=false)

void	KnApplyNoiseInfl (FlagGrid &flags, Grid< Real > &density, WaveletNoiseField &noise, Grid< Real > &sdf, Real scale, Real sigma)

PYTHON void	densityInflow (FlagGrid &flags, Grid< Real > &density, WaveletNoiseField &noise, Shape *shape, Real scale=1.0, Real sigma=0)

void	KnAddNoise (FlagGrid &flags, Grid< Real > &density, WaveletNoiseField &noise, Grid< Real > *sdf, Real scale)

PYTHON void	addNoise (FlagGrid &flags, Grid< Real > &density, WaveletNoiseField &noise, Grid< Real > *sdf=NULL, Real scale=1.0)

void	knSetPdataNoise (BasicParticleSystem &parts, ParticleDataImpl< T > &pdata, WaveletNoiseField &noise, Real scale)

void	knSetPdataNoiseVec (BasicParticleSystem &parts, ParticleDataImpl< T > &pdata, WaveletNoiseField &noise, Real scale)

PYTHON void	setNoisePdata (BasicParticleSystem &parts, ParticleDataImpl< Real > &pd, WaveletNoiseField &noise, Real scale=1.)

PYTHON void	setNoisePdataVec3 (BasicParticleSystem &parts, ParticleDataImpl< Vec3 > &pd, WaveletNoiseField &noise, Real scale=1.)

PYTHON void	setNoisePdataInt (BasicParticleSystem &parts, ParticleDataImpl< int > &pd, WaveletNoiseField &noise, Real scale=1.)

PYTHON Grid< Vec3 >	obstacleGradient (FlagGrid &flags)

PYTHON LevelsetGrid	obstacleLevelset (FlagGrid &flags)

void	KnApplyEmission (FlagGrid &flags, Grid< Real > &density, Grid< Real > &emission, bool isAbsolute)

PYTHON void	applyEmission (FlagGrid &flags, Grid< Real > &density, Grid< Real > &emission, bool isAbsolute)
	Add emission values. More...

void	KnApplyDensity (FlagGrid &flags, Grid< Real > &density, Grid< Real > &sdf, Real value, Real sigma)

PYTHON void	densityInflowMeshNoise (FlagGrid &flags, Grid< Real > &density, WaveletNoiseField &noise, Mesh *mesh, Real scale=1.0, Real sigma=0)

PYTHON void	densityInflowMesh (FlagGrid &flags, Grid< Real > &density, Mesh *mesh, Real value=1., Real cutoff=7, Real sigma=0)

PYTHON void	checkSymmetry (Grid< Real > &a, Grid< Real > *err=NULL, bool symmetrize=false, int axis=0, int bound=0)

PYTHON void	checkSymmetryVec3 (Grid< Vec3 > &a, Grid< Real > *err=NULL, bool symmetrize=false, int axis=0, int bound=0, int disable=0)

PYTHON void	projectPpmFull (Grid< Real > &val, string name, int shadeMode=0, Real scale=1.)

PYTHON void	addTestParts (BasicParticleSystem &parts, int num)

PYTHON Real	pdataMaxDiff (ParticleDataBase a, ParticleDataBase b)

void	kninitVortexVelocity (Grid< Real > &phiObs, MACGrid &vel, const Vec3 &center, const Real &radius)

PYTHON void	initVortexVelocity (Grid< Real > &phiObs, MACGrid &vel, const Vec3 &center, const Real &radius)

void	KnUpdateFractions (FlagGrid &flags, Grid< Real > &phiObs, MACGrid &fractions, const int &boundaryWidth)

PYTHON void	updateFractions (FlagGrid &flags, Grid< Real > &phiObs, MACGrid &fractions, const int &boundaryWidth=0)

void	KnUpdateFlags (FlagGrid &flags, MACGrid &fractions, Grid< Real > &phiObs)

PYTHON void	setObstacleFlags (FlagGrid &flags, MACGrid &fractions, Grid< Real > &phiObs)

void	KnTurbulenceClamp (Grid< Real > &kgrid, Grid< Real > &egrid, Real minK, Real maxK, Real minNu, Real maxNu)

void	KnComputeProduction (const MACGrid &vel, const Grid< Vec3 > &velCenter, const Grid< Real > &ke, const Grid< Real > &eps, Grid< Real > &prod, Grid< Real > &nuT, Grid< Real > *strain, Real pscale=1.0f)

PYTHON void	KEpsilonComputeProduction (MACGrid &vel, Grid< Real > &k, Grid< Real > &eps, Grid< Real > &prod, Grid< Real > &nuT, Grid< Real > *strain=0, Real pscale=1.0f)

void	KnAddTurbulenceSource (Grid< Real > &kgrid, Grid< Real > &egrid, const Grid< Real > &pgrid, Real dt)

PYTHON void	KEpsilonSources (Grid< Real > &k, Grid< Real > &eps, Grid< Real > &prod)

PYTHON void	KEpsilonBcs (FlagGrid &flags, Grid< Real > &k, Grid< Real > &eps, Real intensity, Real nu, bool fillArea)

void	ApplyGradDiff (const Grid< Real > &grid, Grid< Real > &res, const Grid< Real > &nu, Real dt, Real sigma)
	Gradient diffusion smoothing. Not unconditionally stable – should probably do substepping etc.

PYTHON void	KEpsilonGradientDiffusion (Grid< Real > &k, Grid< Real > &eps, Grid< Real > &nuT, Real sigmaU=4.0, MACGrid *vel=0)

PYTHON void	smoothMesh (Mesh &mesh, Real strength, int steps=1, Real minLength=1e-5)
	Mesh smoothing. More...

PYTHON void	subdivideMesh (Mesh &mesh, Real minAngle, Real minLength, Real maxLength, bool cutTubes=false)

PYTHON void	killSmallComponents (Mesh &mesh, int elements=10)

void	MakeRhs (FlagGrid &flags, Grid< Real > &rhs, MACGrid &vel, Grid< Real > perCellCorr, MACGrid fractions)

void	CorrectVelocity (FlagGrid &flags, MACGrid &vel, Grid< Real > &pressure)

void	ApplyGhostFluidDiagonal (Grid< Real > &A0, const FlagGrid &flags, const Grid< Real > &phi, Real gfClamp)

void	CorrectVelocityGhostFluid (MACGrid &vel, const FlagGrid &flags, const Grid< Real > &pressure, const Grid< Real > &phi, Real gfClamp)

void	ReplaceClampedGhostFluidVels (MACGrid &vel, FlagGrid &flags, const Grid< Real > &pressure, const Grid< Real > &phi, Real gfClamp)

int	CountEmptyCells (FlagGrid &flags)

void	fixPressure (int fixPidx, Real value, Grid< Real > &rhs, Grid< Real > &A0, Grid< Real > &Ai, Grid< Real > &Aj, Grid< Real > &Ak)
	Change 'A' and 'rhs' such that pressure at 'fixPidx' is fixed to 'value'.

PYTHON void	releaseMG ()

PYTHON void	markAsFixed (Mesh &mesh, Shape *shape, bool exclusive=true)

PYTHON void	texcoordInflow (VortexSheetMesh &mesh, Shape *shape, MACGrid &vel)

PYTHON void	meshSmokeInflow (VortexSheetMesh &mesh, Shape *shape, Real amount)

void	KnAcceleration (MACGrid &a, const MACGrid &v1, const MACGrid &v0, const Real idt)

PYTHON void	vorticitySource (VortexSheetMesh &mesh, Vec3 gravity, MACGrid vel=NULL, MACGrid velOld=NULL, Real scale=0.1, Real maxAmount=0, Real mult=1.0)

PYTHON void	smoothVorticity (VortexSheetMesh &mesh, int iter=1, Real sigma=0.2, Real alpha=0.8)

PYTHON void	VPseedK41 (VortexParticleSystem &system, Shape *shape, Real strength=0, Real sigma0=0.2, Real sigma1=1.0, Real probability=1.0, Real N=3.0)

PYTHON void	VICintegration (VortexSheetMesh &mesh, Real sigma, Grid< Vec3 > &vel, FlagGrid &flags, Grid< Vec3 > *vorticity=NULL, Real cgMaxIterFac=1.5, Real cgAccuracy=1e-3, Real scale=0.01, int precondition=0)

PYTHON void	densityFromLevelset (LevelsetGrid &phi, Grid< Real > &density, Real value=1.0, Real sigma=1.0)

void	calcGridSizeFactorMod (Vec3i s1, Vec3i s2, Vec3i optSize, Vec3 scale, Vec3 &sourceFactor, Vec3 &retOff)
	same as in grid.h , but takes an additional optional "desired" size

PYTHON void	interpolateGrid (Grid< Real > &target, Grid< Real > &source, Vec3 scale=Vec3(1.), Vec3 offset=Vec3(0.), Vec3i size=Vec3i(-1,-1,-1), int orderSpace=1)

PYTHON void	interpolateGridVec3 (Grid< Vec3 > &target, Grid< Vec3 > &source, Vec3 scale=Vec3(1.), Vec3 offset=Vec3(0.), Vec3i size=Vec3i(-1,-1,-1), int orderSpace=1)

void	KnInterpolateMACGrid (MACGrid &target, MACGrid &source, const Vec3 &sourceFactor, const Vec3 &off, int orderSpace)

PYTHON void	interpolateMACGrid (MACGrid &target, MACGrid &source, Vec3 scale=Vec3(1.), Vec3 offset=Vec3(0.), Vec3i size=Vec3i(-1,-1,-1), int orderSpace=1)

void	knApplySimpleNoiseVec3 (FlagGrid &flags, Grid< Vec3 > &target, WaveletNoiseField &noise, Real scale, Grid< Real > *weight)

PYTHON void	applySimpleNoiseVec3 (FlagGrid &flags, Grid< Vec3 > &target, WaveletNoiseField &noise, Real scale=1.0, Grid< Real > *weight=NULL)

void	knApplySimpleNoiseReal (FlagGrid &flags, Grid< Real > &target, WaveletNoiseField &noise, Real scale, Grid< Real > *weight)

PYTHON void	applySimpleNoiseReal (FlagGrid &flags, Grid< Real > &target, WaveletNoiseField &noise, Real scale=1.0, Grid< Real > *weight=NULL)

void	knApplyNoiseVec3 (FlagGrid &flags, Grid< Vec3 > &target, WaveletNoiseField &noise, Real scale, Real scaleSpatial, Grid< Real > weight, Grid< Vec3 > uv, bool uvInterpol, const Vec3 &sourceFactor)

PYTHON void	applyNoiseVec3 (FlagGrid &flags, Grid< Vec3 > &target, WaveletNoiseField &noise, Real scale=1.0, Real scaleSpatial=1.0, Grid< Real > weight=NULL, Grid< Vec3 > uv=NULL)

void	KnApplyComputeEnergy (FlagGrid &flags, MACGrid &vel, Grid< Real > &energy)

PYTHON void	computeEnergy (FlagGrid &flags, MACGrid &vel, Grid< Real > &energy)

PYTHON void	computeWaveletCoeffs (Grid< Real > &input)

PYTHON void	computeVorticity (MACGrid &vel, Grid< Vec3 > &vorticity, Grid< Real > *norm)

void	KnComputeStrainRateMag (const MACGrid &vel, const Grid< Vec3 > &velCenter, Grid< Real > &prod)

PYTHON void	computeStrainRateMag (MACGrid &vel, Grid< Real > &mag)

template<class T >
void	extrapolSimpleFlagsHelper (FlagGrid &flags, Grid< T > &val, int distance=4, int flagFrom=FlagGrid::TypeFluid, int flagTo=FlagGrid::TypeObstacle)

PYTHON void	extrapolateSimpleFlags (FlagGrid &flags, GridBase *val, int distance=4, int flagFrom=FlagGrid::TypeFluid, int flagTo=FlagGrid::TypeObstacle)

PYTHON void	getCurl (MACGrid &vel, Grid< Real > &vort, int comp)

void	knCalcSecDeriv2d (const Grid< Real > &v, Grid< Real > &ret)

PYTHON void	calcSecDeriv2d (const Grid< Real > &v, Grid< Real > &curv)

double	knTotalSum (Grid< Real > &h)

PYTHON Real	totalSum (Grid< Real > &height)

PYTHON void	normalizeSumTo (Grid< Real > &height, Real target)

void	MakeRhsWE (FlagGrid &flags, Grid< Real > &rhs, Grid< Real > &ut, Grid< Real > &utm1, Real s, bool crankNic=false)

PYTHON void	cgSolveWE (FlagGrid &flags, Grid< Real > &ut, Grid< Real > &utm1, Grid< Real > &out, bool crankNic=false, Real cSqr=0.25, Real cgMaxIterFac=1.5, Real cgAccuracy=1e-5)

void	pbPreparePlugin (FluidSolver *parent, const string &name, bool doTime)

void	pbFinalizePlugin (FluidSolver *parent, const string &name, bool doTime)

void	pbSetError (const string &fn, const string &ex)

PyObject *	getPyNone ()

PyObject *	incref (PyObject *obj)

template<>
PyObject *	toPy< int > (const int &v)

template<>
PyObject *	toPy< string > (const string &val)

template<>
PyObject *	toPy< float > (const float &v)

template<>
PyObject *	toPy< double > (const double &v)

template<>
PyObject *	toPy< bool > (const bool &v)

template<>
PyObject *	toPy< Vec3i > (const Vec3i &v)

template<>
PyObject *	toPy< Vec3 > (const Vec3 &v)

template<>
PyObject *	toPy< Vec4i > (const Vec4i &v)

template<>
PyObject *	toPy< Vec4 > (const Vec4 &v)

template<>
PyObject *	*toPy< PbClass >** (const PbClass_Ptr &obj)

template<>
float	fromPy< float > (PyObject *obj)

template<>
double	fromPy< double > (PyObject *obj)

template<>
PyObject *	*fromPy< PyObject >** (PyObject *obj)

template<>
int	fromPy< int > (PyObject *obj)

template<>
string	fromPy< string > (PyObject *obj)

template<>
const char *	*fromPy< const char >** (PyObject *obj)

template<>
bool	fromPy< bool > (PyObject *obj)

template<>
Vec3	fromPy< Vec3 > (PyObject *obj)

template<>
Vec3i	fromPy< Vec3i > (PyObject *obj)

template<>
Vec4	fromPy< Vec4 > (PyObject *obj)

template<>
Vec4i	fromPy< Vec4i > (PyObject *obj)

template<>
PbType	fromPy< PbType > (PyObject *obj)

template<>
PbTypeVec	fromPy< PbTypeVec > (PyObject *obj)

template<class T >
T *	tmpAlloc (PyObject obj, std::vector< void > *tmp)

template<>
float *	fromPyPtr< float > (PyObject obj, std::vector< void > *tmp)

template<>
double *	fromPyPtr< double > (PyObject obj, std::vector< void > *tmp)

template<>
int *	fromPyPtr< int > (PyObject obj, std::vector< void > *tmp)

template<>
std::string *	fromPyPtr< std::string > (PyObject obj, std::vector< void > *tmp)

template<>
bool *	fromPyPtr< bool > (PyObject obj, std::vector< void > *tmp)

template<>
Vec3 *	fromPyPtr< Vec3 > (PyObject obj, std::vector< void > *tmp)

template<>
Vec3i *	fromPyPtr< Vec3i > (PyObject obj, std::vector< void > *tmp)

template<>
Vec4 *	fromPyPtr< Vec4 > (PyObject obj, std::vector< void > *tmp)

template<>
Vec4i *	fromPyPtr< Vec4i > (PyObject obj, std::vector< void > *tmp)

template<>
bool	isPy< float > (PyObject *obj)

template<>
bool	isPy< double > (PyObject *obj)

template<>
bool	*isPy< PyObject >** (PyObject *obj)

template<>
bool	isPy< int > (PyObject *obj)

template<>
bool	isPy< string > (PyObject *obj)

template<>
bool	*isPy< const char >** (PyObject *obj)

template<>
bool	isPy< bool > (PyObject *obj)

template<>
bool	isPy< Vec3 > (PyObject *obj)

template<>
bool	isPy< Vec3i > (PyObject *obj)

template<>
bool	isPy< Vec4 > (PyObject *obj)

template<>
bool	isPy< Vec4i > (PyObject *obj)

template<>
bool	isPy< PbType > (PyObject *obj)

PyObject *	PbNew (const Vec3 &a)

PyObject *	PbVec3Add (PyObject a, PyObject b)

PyObject *	PbVec3Sub (PyObject a, PyObject b)

PyObject *	PbVec3Mult (PyObject a, PyObject b)

PyObject *	PbVec3Div (PyObject a, PyObject b)

PyObject *	PbVec3Negative (PyObject *a)

PyObject *	castPy (PyTypeObject *p)

void	PbVecInitialize (PyObject *module)

void	ApplyShapeToGrid (Grid< T > grid, Shape shape, T value, FlagGrid *respectFlags)

void	ApplyShapeToGridSmooth (Grid< T > grid, Grid< Real > &phi, Real sigma, Real shift, T value, FlagGrid respectFlags)

void	ApplyShapeToMACGrid (MACGrid grid, Shape shape, Vec3 value, FlagGrid *respectFlags)

void	BoxSDF (Grid< Real > &phi, const Vec3 &p1, const Vec3 &p2)

void	SphereSDF (Grid< Real > &phi, Vec3 center, Real radius, Vec3 scale)

void	CylinderSDF (Grid< Real > &phi, Vec3 center, Real radius, Vec3 zaxis, Real maxz)

void	SlopeSDF (const Vec3 &n, Grid< Real > &phiObs, const Real &fac, const Real &origin)

double	reductionTest (const Grid< Real > &v)

double	minReduction (const Grid< Real > &v)

Vec3	hsv2rgb (Real h, Real s, Real v)

void	KnSynthesizeTurbulence (TurbulenceParticleSystem &p, FlagGrid &flags, WaveletNoiseField &noise, Grid< Real > &kGrid, Real alpha, Real dt, int octaves, Real scale, Real invL0, Real kmin)

template<class VelKernel >
void	integratePointSet (VelKernel &k, int mode)
	Integrate a particle set with a given velocity kernel.

Vec3	fdTangent (const Vec3 &p0, const Vec3 &p1, const Vec3 &p2)

Vec3	crTangent (const Vec3 &p0, const Vec3 &p1, const Vec3 &p2)

Vec3	hermiteSpline (const Vec3 &p0, const Vec3 &p1, const Vec3 &m0, const Vec3 &m1, Real t)

template<class T >
T	interpol (const T *data, const Vec3i &size, const int Z, const Vec3 &pos)

template<int c>
Real	interpolComponent (const Vec3 *data, const Vec3i &size, const int Z, const Vec3 &pos)

template<class T >
void	setInterpol (T data, const Vec3i &size, const int Z, const Vec3 &pos, const T &v, Real sumBuffer)

Vec3	interpolMAC (const Vec3 *data, const Vec3i &size, const int Z, const Vec3 &pos)

void	setInterpolMAC (Vec3 data, const Vec3i &size, const int Z, const Vec3 &pos, const Vec3 &val, Vec3 sumBuffer)

Quaternion	operator* (const Quaternion &q1, const Quaternion &q2)
	Multiplication operator.

Quaternion	operator* (const Quaternion &q, const Real a)
	Multiplication operator.

std::ostream &	operator<< (std::ostream &os, const MTRand &mtrand)

std::istream &	operator>> (std::istream &is, MTRand &mtrand)

template<class S >
Vector4D< S >	operator+ (const Vector4D< S > &v1, const Vector4D< S > &v2)
	Addition operator.

template<class S , class S2 >
Vector4D< S >	operator+ (const Vector4D< S > &v, S2 s)
	Addition operator.

template<class S , class S2 >
Vector4D< S >	operator+ (S2 s, const Vector4D< S > &v)
	Addition operator.

template<class S >
Vector4D< S >	operator- (const Vector4D< S > &v1, const Vector4D< S > &v2)
	Subtraction operator.

template<class S , class S2 >
Vector4D< S >	operator- (const Vector4D< S > &v, S2 s)
	Subtraction operator.

template<class S , class S2 >
Vector4D< S >	operator- (S2 s, const Vector4D< S > &v)
	Subtraction operator.

template<class S >
Vector4D< S >	operator* (const Vector4D< S > &v1, const Vector4D< S > &v2)
	Multiplication operator.

template<class S , class S2 >
Vector4D< S >	operator* (const Vector4D< S > &v, S2 s)
	Multiplication operator.

template<class S , class S2 >
Vector4D< S >	operator* (S2 s, const Vector4D< S > &v)
	Multiplication operator.

template<class S >
Vector4D< S >	operator/ (const Vector4D< S > &v1, const Vector4D< S > &v2)
	Division operator.

template<class S , class S2 >
Vector4D< S >	operator/ (const Vector4D< S > &v, S2 s)
	Division operator.

template<class S , class S2 >
Vector4D< S >	operator/ (S2 s, const Vector4D< S > &v)
	Division operator.

template<class S >
bool	operator== (const Vector4D< S > &s1, const Vector4D< S > &s2)
	Comparison operator.

template<class S >
bool	operator!= (const Vector4D< S > &s1, const Vector4D< S > &s2)
	Comparison operator.

template<class S >
S	dot (const Vector4D< S > &t, const Vector4D< S > &v)
	Dot product.

template<class S >
S	norm (const Vector4D< S > &v)
	Cross product. More...

template<class S >
S	normSquare (const Vector4D< S > &v)
	Compute squared magnitude.

template<class S >
Vector4D< S >	getNormalized (const Vector4D< S > &v)
	Returns a normalized vector.

template<class S >
S	normalize (Vector4D< S > &v)
	Compute the norm of the vector and normalize it. More...

template<class S >
std::ostream &	operator<< (std::ostream &os, const Vector4D< S > &i)
	Outputs the object in human readable form to stream.

template<class S >
std::istream &	operator>> (std::istream &is, Vector4D< S > &i)
	Reads the contents of the object from a stream.

template<class T >
Vec4	toVec4 (T v)
	convert to Real Vector

template<class T >
Vec4i	toVec4i (T v)

template<>
Vec4	clamp< Vec4 > (const Vec4 &a, const Vec4 &b, const Vec4 &c)

template<>
Vec4	safeDivide< Vec4 > (const Vec4 &a, const Vec4 &b)

template<>
Vec4	nmod< Vec4 > (const Vec4 &a, const Vec4 &b)

template<class T >
T	interpol4d (const T *data, const Vec4i &size, const IndexInt sZ, const IndexInt sT, const Vec4 &pos)

template<class S >
Vector3D< S >	operator+ (const Vector3D< S > &v1, const Vector3D< S > &v2)
	Addition operator.

template<class S , class S2 >
Vector3D< S >	operator+ (const Vector3D< S > &v, S2 s)
	Addition operator.

template<class S , class S2 >
Vector3D< S >	operator+ (S2 s, const Vector3D< S > &v)
	Addition operator.

template<class S >
Vector3D< S >	operator- (const Vector3D< S > &v1, const Vector3D< S > &v2)
	Subtraction operator.

template<class S , class S2 >
Vector3D< S >	operator- (const Vector3D< S > &v, S2 s)
	Subtraction operator.

template<class S , class S2 >
Vector3D< S >	operator- (S2 s, const Vector3D< S > &v)
	Subtraction operator.

template<class S >
Vector3D< S >	operator* (const Vector3D< S > &v1, const Vector3D< S > &v2)
	Multiplication operator.

template<class S , class S2 >
Vector3D< S >	operator* (const Vector3D< S > &v, S2 s)
	Multiplication operator.

template<class S , class S2 >
Vector3D< S >	operator* (S2 s, const Vector3D< S > &v)
	Multiplication operator.

template<class S >
Vector3D< S >	operator/ (const Vector3D< S > &v1, const Vector3D< S > &v2)
	Division operator.

template<class S , class S2 >
Vector3D< S >	operator/ (const Vector3D< S > &v, S2 s)
	Division operator.

template<class S , class S2 >
Vector3D< S >	operator/ (S2 s, const Vector3D< S > &v)
	Division operator.

template<class S >
bool	operator== (const Vector3D< S > &s1, const Vector3D< S > &s2)
	Comparison operator.

template<class S >
bool	operator!= (const Vector3D< S > &s1, const Vector3D< S > &s2)
	Comparison operator.

template<class S >
Vector3D< S >	vmin (const Vector3D< S > &s1, const Vector3D< S > &s2)
	Min operator.

template<class S , class S2 >
Vector3D< S >	vmin (const Vector3D< S > &s1, S2 s2)
	Min operator.

template<class S1 , class S >
Vector3D< S >	vmin (S1 s1, const Vector3D< S > &s2)
	Min operator.

template<class S >
Vector3D< S >	vmax (const Vector3D< S > &s1, const Vector3D< S > &s2)
	Max operator.

template<class S , class S2 >
Vector3D< S >	vmax (const Vector3D< S > &s1, S2 s2)
	Max operator.

template<class S1 , class S >
Vector3D< S >	vmax (S1 s1, const Vector3D< S > &s2)
	Max operator.

template<class S >
S	dot (const Vector3D< S > &t, const Vector3D< S > &v)
	Dot product.

template<class S >
Vector3D< S >	cross (const Vector3D< S > &t, const Vector3D< S > &v)
	Cross product.

template<class S >
const Vector3D< S > &	projectNormalTo (const Vector3D< S > &v, const Vector3D< S > &n)
	Project a vector into a plane, defined by its normal. More...

template<class S >
S	norm (const Vector3D< S > &v)

template<class S >
S	normSquare (const Vector3D< S > &v)
	Compute squared magnitude.

template<class S >
Vector3D< S >	getNormalized (const Vector3D< S > &v)
	Returns a normalized vector.

template<class S >
S	normalize (Vector3D< S > &v)
	Compute the norm of the vector and normalize it. More...

template<class S >
Vector3D< S >	getOrthogonalVector (const Vector3D< S > &v)
	Obtain an orthogonal vector. More...

template<class S >
void	vecToAngle (const Vector3D< S > &v, S &phi, S &theta)
	Convert vector to polar coordinates. More...

template<class S >
Vector3D< S >	reflectVector (const Vector3D< S > &t, const Vector3D< S > &n)
	Compute vector reflected at a surface. More...

template<class S >
Vector3D< S >	refractVector (const Vector3D< S > &t, const Vector3D< S > &normal, S nt, S nair, int &refRefl)
	Compute vector refracted at a surface. More...

template<class S >
std::ostream &	operator<< (std::ostream &os, const Vector3D< S > &i)
	Outputs the object in human readable form to stream. More...

template<class S >
std::istream &	operator>> (std::istream &is, Vector3D< S > &i)
	Reads the contents of the object from a stream. More...

template<class T >
Vec3	toVec3 (T v)
	convert to Real Vector

template<class T >
Vec3i	toVec3i (T v)
	convert to int Vector

template<class T >
Vec3i	toVec3i (T v0, T v1, T v2)
	convert to int Vector

template<class T >
Vec3i	toVec3iRound (T v)
	round, and convert to int Vector

template<class T >
Vec3i	toVec3iChecked (T v)
	convert to int Vector if values are close enough to an int

template<class T >
Vector3D< double >	toVec3d (T v)
	convert to double Vector

template<class T >
Vector3D< float >	toVec3f (T v)
	convert to float Vector

template<>
Vec3	clamp< Vec3 > (const Vec3 &a, const Vec3 &b, const Vec3 &c)

template<>
Vec3	safeDivide< Vec3 > (const Vec3 &a, const Vec3 &b)

template<>
Vec3	nmod< Vec3 > (const Vec3 &a, const Vec3 &b)

Vec3	VortexKernel (const Vec3 &p, const vector< VortexParticleData > &vp, Real scale)

vector< Vec3 >	KnVpAdvectMesh (vector< Node > &nodes, const vector< VortexParticleData > &vp, Real scale)

vector< Vec3 >	KnVpAdvectSelf (vector< VortexParticleData > &vp, Real scale)

Variables
const int	CG_DEBUGLEVEL = 5

bool	gAbort = false

int	gDebugLevel = 1

MainThread *	gMainThread = NULL

GuiThread *	gGuiThread = NULL

const int	DELETE_PART = 20

bool	gBlurPrecomputed = false

int	gBlurKernelRadius = -1

Matrix	gBlurKernel

const Real	keCmu = 0.09

const Real	keC1 = 1.44

const Real	keC2 = 1.92

const Real	keS1 = 1.0

const Real	keS2 = 1.3

const Real	keU0 = 1.0

const Real	keImin = 2e-3

const Real	keImax = 1.0

const Real	keNuMin = 1e-3

const Real	keNuMax = 5.0

PyTypeObject	PbVec3Type

PyTypeObject	PbVec4Type

Detailed Description

simple shaded output , note requires grid functionality!

Function Documentation

◆ fnAdvectSemiLagrange()

template<class GridType >

void Manta::fnAdvectSemiLagrange	(	FluidSolver *	parent,
		FlagGrid &	flags,
		MACGrid &	vel,
		GridType &	orig,
		int	order,
		Real	strength,
		int	orderSpace,
		bool	openBounds,
		int	bWidth
	)

template function for performing SL advection (Note boundary width only needed for specialization for MAC grids below)

◆ getOrthogonalVector()

template<class S >

Vector3D<S> Manta::getOrthogonalVector ( const Vector3D< S > & v )

Obtain an orthogonal vector.

Compute a vector that is orthonormal to the given vector. Nothing else can be assumed for the direction of the new vector.

Returns: The orthonormal vector

◆ norm() [1/2]

template<class S >

S Manta::norm ( const Vector4D< S > & v )

inline

Cross product.

Compute the magnitude (length) of the vector

◆ norm() [2/2]

template<class S >

S Manta::norm ( const Vector3D< S > & v )

inline

Compute the magnitude (length) of the vector (clamps to 0 and 1 with VECTOR_EPSILON)

◆ normalize() [1/2]

template<class S >

S Manta::normalize ( Vector4D< S > & v )

inline

Compute the norm of the vector and normalize it.

Returns: The value of the norm

◆ normalize() [2/2]

template<class S >

S Manta::normalize ( Vector3D< S > & v )

inline

Compute the norm of the vector and normalize it.

Returns: The value of the norm

◆ operator<<()

template<class S >

std::ostream& Manta::operator<<	(	std::ostream &	os,
		const Vector3D< S > &	i
	)

Outputs the object in human readable form to stream.

Output format [x,y,z]

◆ operator>>()

template<class S >

std::istream& Manta::operator>>	(	std::istream &	is,
		Vector3D< S > &	i
	)

Reads the contents of the object from a stream.

Input format [x,y,z]

◆ precomputeInvA()

void Manta::precomputeInvA	(	MACGrid &	invA,
		Grid< Real > &	weight,
		const Real	sigma
	)

Precompute inverse(A), a reused quantity in the PD iterations A = 2*S^2 + p*I, invA = elementwise 1/A

◆ precomputeQ()

void Manta::precomputeQ	(	MACGrid &	Q,
		FlagGrid &	flags,
		const MACGrid &	velT_region,
		const MACGrid &	velC,
		const Matrix &	gBlurKernel,
		const Real	sigma
	)

Precompute Q, a reused quantity in the PD iterations Q = 2*G*G*(velT-velC)-sigma*velC

◆ projectNormalTo()

template<class S >

const Vector3D<S>& Manta::projectNormalTo	(	const Vector3D< S > &	v,
		const Vector3D< S > &	n
	)

inline

Project a vector into a plane, defined by its normal.

Projects a vector into a plane normal to the given vector, which must have unit length. Self is modified.

Parameters

v	The vector to project
n	The plane normal

Returns: The projected vector

◆ reflectVector()

template<class S >

Vector3D<S> Manta::reflectVector	(	const Vector3D< S > &	t,
		const Vector3D< S > &	n
	)

inline

Compute vector reflected at a surface.

Compute a vector, that is self (as an incoming vector) reflected at a surface with a distinct normal vector. Note that the normal is reversed, if the scalar product with it is positive.

Parameters

t	The incoming vector
n	The surface normal

Returns: The new reflected vector

◆ refractVector()

template<class S >

Vector3D<S> Manta::refractVector	(	const Vector3D< S > &	t,
		const Vector3D< S > &	normal,
		S	nt,
		S	nair,
		int &	refRefl
	)

inline

Compute vector refracted at a surface.

Parameters

t	The incoming vector
n	The surface normal
nt	The "inside" refraction index
nair	The "outside" refraction index
refRefl	Set to 1 on total reflection

Returns: The refracted vector

◆ vecToAngle()

template<class S >

void Manta::vecToAngle	(	const Vector3D< S > &	v,
		S &	phi,
		S &	theta
	)

inline

Convert vector to polar coordinates.

Stable vector to angle conversion

Parameters

v	vector to convert
phi	unique angle [0,2PI]
theta	unique angle [0,PI]

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Function Documentation

◆ fnAdvectSemiLagrange()

◆ getOrthogonalVector()

◆ norm() [1/2]

◆ norm() [2/2]

◆ normalize() [1/2]

◆ normalize() [2/2]

◆ operator<<()

◆ operator>>()

◆ precomputeInvA()

◆ precomputeQ()

◆ projectNormalTo()

◆ reflectVector()

◆ refractVector()

◆ vecToAngle()