//! add Buoyancy force based on smoke density
KERNEL(bnd=1) void KnAddBuoyancy(FlagGrid& flags, Grid<Real>& density, MACGrid& vel, Vec3 strength) {
if (!flags.isFluid(i,j,k)) return;
if (flags.isFluid(i-1,j,k))
vel(i,j,k).x += (0.5 * strength.x) * (density(i,j,k)+density(i-1,j,k));
if (flags.isFluid(i,j-1,k))
vel(i,j,k).y += (0.5 * strength.y) * (density(i,j,k)+density(i,j-1,k));
if (vel.is3D() && flags.isFluid(i,j,k-1))
vel(i,j,k).z += (0.5 * strength.z) * (density(i,j,k)+density(i,j,k-1));
}
//! add Forces between fl/fl and fl/em cells
KERNEL(bnd=1) void KnAddForce(FlagGrid& flags, MACGrid& vel, Vec3 force) {
bool curFluid = flags.isFluid(i,j,k);
bool curEmpty = flags.isEmpty(i,j,k);
if (!curFluid && !curEmpty) return;
if (flags.isFluid(i-1,j,k) || (curFluid && flags.isEmpty(i-1,j,k)))
vel(i,j,k).x += force.x;
if (flags.isFluid(i,j-1,k) || (curFluid && flags.isEmpty(i,j-1,k)))
vel(i,j,k).y += force.y;
if (vel.is3D() && (flags.isFluid(i,j,k-1) || (curFluid && flags.isEmpty(i,j,k-1))))
vel(i,j,k).z += force.z;
}
//! Kernel: Set matrix stencils and velocities to enable open boundaries
KERNEL void SetOpenBound(Grid<Real>& A0, Grid<Real>& Ai, Grid<Real>& Aj, Grid<Real>& Ak, MACGrid& vel,
Vector3D<bool> lowerBound, Vector3D<bool> upperBound)
{
// set velocity boundary conditions
if (lowerBound.x && i == 0) vel(0,j,k) = vel(1,j,k);
if (lowerBound.y && j == 0) vel(i,0,k) = vel(i,1,k);
if (lowerBound.z && k == 0) vel(i,j,0) = vel(i,j,1);
if (upperBound.x && i == maxX-1) vel(maxX-1,j,k) = vel(maxX-2,j,k);
if (upperBound.y && j == maxY-1) vel(i,maxY-1,k) = vel(i,maxY-2,k);
if (upperBound.z && k == maxZ-1) vel(i,j,maxZ-1) = vel(i,j,maxZ-2);
// set matrix stencils at boundary
if ((lowerBound.x && i<=1) || (upperBound.x && i>=maxX-2) ||
(lowerBound.y && j<=1) || (upperBound.y && j>=maxY-2) ||
(lowerBound.z && k<=1) || (upperBound.z && k>=maxZ-2)) {
A0(i,j,k) = vel.is3D() ? 6.0 : 4.0;
Ai(i,j,k) = -1.0;
Aj(i,j,k) = -1.0;
if (vel.is3D()) Ak(i,j,k) = -1.0;
}
}
inline Real doClampComponentMAC(const Vec3i& upperClamp, MACGrid& orig, Real dst, const Vec3i& posFwd) {
// clamp forward lookup to grid
const int i0 = clamp(posFwd.x, 0, upperClamp.x-1);
const int j0 = clamp(posFwd.y, 0, upperClamp.y-1);
const int k0 = clamp(posFwd.z, 0, (orig.is3D() ? (upperClamp.z-1) : 1) );
const int i1 = i0+1, j1 = j0+1, k1= (orig.is3D() ? (k0+1) : k0);
if (!orig.isInBounds(Vec3i(i0,j0,k0),1))
return dst;
// find min/max around fwd pos
Real minv = orig(i0,j0,k0)[c], maxv = minv;
getMinMax(minv, maxv, orig(i1,j0,k0)[c]);
getMinMax(minv, maxv, orig(i0,j1,k0)[c]);
getMinMax(minv, maxv, orig(i1,j1,k0)[c]);
getMinMax(minv, maxv, orig(i0,j0,k1)[c]);
getMinMax(minv, maxv, orig(i1,j0,k1)[c]);
getMinMax(minv, maxv, orig(i0,j1,k1)[c]);
getMinMax(minv, maxv, orig(i1,j1,k1)[c]);
return clamp(dst, minv, maxv);
}
//! Perform pressure projection of the velocity grid
PYTHON void solvePressure(MACGrid& vel, Grid<Real>& pressure, FlagGrid& flags,
Grid<Real>* phi = 0,
Grid<Real>* perCellCorr = 0,
Real ghostAccuracy = 0,
Real cgMaxIterFac = 1.5,
Real cgAccuracy = 1e-3,
string openBound = "",
string outflow = "",
int outflowHeight = 1,
int precondition = 0,
bool enforceCompatibility = false,
bool useResNorm = true )
{
//assertMsg(vel.is3D(), "Only 3D grids supported so far");
// parse strings
Vector3D<bool> loOpenBound, upOpenBound, loOutflow, upOutflow;
convertDescToVec(openBound, loOpenBound, upOpenBound);
convertDescToVec(outflow, loOutflow, upOutflow);
if (vel.is2D() && (loOpenBound.z || upOpenBound.z))
errMsg("open boundaries for z specified for 2D grid");
// reserve temp grids
Grid<Real> rhs(parent);
Grid<Real> residual(parent);
Grid<Real> search(parent);
Grid<Real> A0(parent);
Grid<Real> Ai(parent);
Grid<Real> Aj(parent);
Grid<Real> Ak(parent);
Grid<Real> tmp(parent);
Grid<Real> pca0(parent);
Grid<Real> pca1(parent);
Grid<Real> pca2(parent);
Grid<Real> pca3(parent);
// setup matrix and boundaries
MakeLaplaceMatrix (flags, A0, Ai, Aj, Ak);
SetOpenBound (A0, Ai, Aj, Ak, vel, loOpenBound, upOpenBound);
if (ghostAccuracy > 0) {
if (!phi) errMsg("solve_pressure: if ghostAccuracy>0, need to specify levelset phi=xxx");
ApplyGhostFluid (flags, A0, *phi, ghostAccuracy);
}
// compute divergence and init right hand side
MakeRhs kernMakeRhs (flags, rhs, vel, perCellCorr);
if (!outflow.empty())
SetOutflow (rhs, loOutflow, upOutflow, outflowHeight);
if (enforceCompatibility)
rhs += (Real)(-kernMakeRhs.sum / (Real)kernMakeRhs.cnt);
// CG
const int maxIter = (int)(cgMaxIterFac * flags.getSize().max());
GridCgInterface *gcg;
if (vel.is3D())
gcg = new GridCg<ApplyMatrix>(pressure, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak );
else
gcg = new GridCg<ApplyMatrix2D>(pressure, rhs, residual, search, flags, tmp, &A0, &Ai, &Aj, &Ak );
gcg->setAccuracy( cgAccuracy );
gcg->setUseResNorm( useResNorm );
// optional preconditioning
gcg->setPreconditioner( (GridCgInterface::PreconditionType)precondition, &pca0, &pca1, &pca2, &pca3);
for (int iter=0; iter<maxIter; iter++) {
if (!gcg->iterate()) iter=maxIter;
}
debMsg("FluidSolver::solvePressure iterations:"<<gcg->getIterations()<<", res:"<<gcg->getSigma(), 1);
delete gcg;
if(ghostAccuracy<=0.) {
// ghost fluid off, normal correction
CorrectVelocity (flags, vel, pressure );
} else {
CorrectVelGhostFluid (flags, vel, pressure);
}
}