void halfCircleSetup (
MultiBlockLattice2D<T,DESCRIPTOR>& lattice, plint N, plint radius,
OnLatticeBoundaryCondition2D<T,DESCRIPTOR>& boundaryCondition )
{
// The channel is pressure-driven, with a difference deltaRho
// between inlet and outlet.
T deltaRho = 1.e-2;
T rhoIn = 1. + deltaRho/2.;
T rhoOut = 1. - deltaRho/2.;
Box2D inlet (0, N/2, N/2, N/2);
Box2D outlet(N/2+1, N, N/2, N/2);
boundaryCondition.addPressureBoundary1P(inlet, lattice);
boundaryCondition.addPressureBoundary1P(outlet, lattice);
// Specify the inlet and outlet density.
setBoundaryDensity (lattice, inlet, rhoIn);
setBoundaryDensity (lattice, outlet, rhoOut);
// Create the initial condition.
Array<T,2> zeroVelocity((T)0.,(T)0.);
T constantDensity = (T)1;
initializeAtEquilibrium (
lattice, lattice.getBoundingBox(), constantDensity, zeroVelocity );
defineDynamics(lattice, lattice.getBoundingBox(),
new BounceBackNodes<T>(N, radius),
new BounceBack<T,DESCRIPTOR>);
lattice.initialize();
}
int main(int argc, char *argv[])
{
plbInit(&argc, &argv);
global::directories().setOutputDir("./tmp/");
// For the choice of the parameters G, rho0, and psi0, we refer to the book
// Michael C. Sukop and Daniel T. Thorne (2006),
// Lattice Boltzmann Modeling; an Introduction for Geoscientists and Engineers.
// Springer-Verlag Berlin/Heidelberg.
const T omega = 1.0;
const int nx = 400;
const int ny = 400;
const T G = -120.0;
const int maxIter = 100001;
const int saveIter = 100;
const int statIter = 100;
const T rho0 = 200.0;
const T deltaRho = 1.0;
const T psi0 = 4.0;
MultiBlockLattice2D<T, DESCRIPTOR> lattice (
nx,ny, new ExternalMomentBGKdynamics<T, DESCRIPTOR>(omega) );
lattice.periodicity().toggleAll(true);
// Use a random initial condition, to activate the phase separation.
applyProcessingFunctional(new RandomInitializer<T,DESCRIPTOR>(rho0,deltaRho),
lattice.getBoundingBox(),lattice);
// Add the data processor which implements the Shan/Chen interaction potential.
plint processorLevel = 1;
integrateProcessingFunctional (
new ShanChenSingleComponentProcessor2D<T,DESCRIPTOR> (
G, new interparticlePotential::PsiShanChen94<T>(psi0,rho0) ),
lattice.getBoundingBox(), lattice, processorLevel );
lattice.initialize();
pcout << "Starting simulation" << endl;
for (int iT=0; iT<maxIter; ++iT) {
if (iT%statIter==0) {
auto_ptr<MultiScalarField2D<T> > rho( computeDensity(lattice) );
pcout << iT << ": Average rho fluid one = " << computeAverage(*rho) << endl;
pcout << "Minimum density: " << computeMin(*rho) << endl;
pcout << "Maximum density: " << computeMax(*rho) << endl;
}
if (iT%saveIter == 0) {
ImageWriter<T>("leeloo").writeScaledGif (
createFileName("rho", iT, 6), *computeDensity(lattice) );
}
lattice.collideAndStream();
}
}
// Initialize the lattice at zero velocity and constant density, except
// for a slight density excess on a square sub-domain.
void defineInitialDensityAtCenter(MultiBlockLattice2D<T,DESCRIPTOR>& lattice)
{
// Initialize constant density everywhere.
initializeAtEquilibrium (
lattice, lattice.getBoundingBox(), rho0, u0 );
// And slightly higher density in the central box.
initializeAtEquilibrium (
lattice, lattice.getBoundingBox(), initializeRhoOnCircle );
lattice.initialize();
}
void createBoundariesFromVelocityField(MultiBlockLattice2D<T,DESCRIPTOR>& lattice,
MultiTensorField2D<T,2>& velocity)
{
applyProcessingFunctional( new BoundaryFromVelocityFunctional2D<T,DESCRIPTOR>,
lattice.getBoundingBox(),
lattice, velocity );
}
/// A functional, used to instantiate bounce-back nodes at the locations of the cylinder
void cylinderSetup( MultiBlockLattice2D<T,DESCRIPTOR>& lattice,
IncomprFlowParam<T> const& parameters,
OnLatticeBoundaryCondition2D<T,DESCRIPTOR>& boundaryCondition )
{
const plint nx = parameters.getNx();
const plint ny = parameters.getNy();
Box2D outlet(nx-1,nx-1, 1,ny-2);
// Create Velocity boundary conditions everywhere
boundaryCondition.setVelocityConditionOnBlockBoundaries (
lattice, Box2D(0, nx-1, 0, 0) );
boundaryCondition.setVelocityConditionOnBlockBoundaries (
lattice, Box2D(0, nx-1, ny-1, ny-1) );
boundaryCondition.setVelocityConditionOnBlockBoundaries (
lattice, Box2D(0,0, 1,ny-2) );
// .. except on right boundary, where we prefer a fixed-pressure condition.
boundaryCondition.setPressureConditionOnBlockBoundaries (
lattice, outlet );
setBoundaryVelocity (
lattice, lattice.getBoundingBox(),
PoiseuilleVelocity<T>(parameters) );
setBoundaryDensity (
lattice, outlet,
ConstantDensity<T>(1.) );
initializeAtEquilibrium (
lattice, lattice.getBoundingBox(),
PoiseuilleVelocityAndDensity<T,DESCRIPTOR>(parameters) );
plint cx = nx/4;
plint cy = ny/2+2;
plint r = cy/4;
DotList2D cylinderShape;
for (plint iX=0; iX<nx; ++iX) {
for (plint iY=0; iY<ny; ++iY) {
if ( (iX-cx)*(iX-cx) + (iY-cy)*(iY-cy) < r*r ) {
cylinderShape.addDot(Dot2D(iX,iY));
}
}
}
defineDynamics(lattice, cylinderShape, new BounceBack<T,DESCRIPTOR>);
lattice.initialize();
}
void cavitySetup( MultiBlockLattice2D<T,DESCRIPTOR>& lattice,
IncomprFlowParam<T> const& parameters,
OnLatticeBoundaryCondition2D<T,DESCRIPTOR>& boundaryCondition )
{
const plint nx = parameters.getNx();
const plint ny = parameters.getNy();
boundaryCondition.setVelocityConditionOnBlockBoundaries(lattice);
setBoundaryVelocity(lattice, lattice.getBoundingBox(), Array<T,2>(0.,0.) );
initializeAtEquilibrium(lattice, lattice.getBoundingBox(), 1., Array<T,2>(0.,0.) );
T u = parameters.getLatticeU();
setBoundaryVelocity(lattice, Box2D(1, nx-2, ny-1, ny-1), Array<T,2>(u,0.) );
initializeAtEquilibrium(lattice, Box2D(1, nx-2, ny-1, ny-1), 1., Array<T,2>(u,0.) );
lattice.initialize();
}
/*
void writeGif(MultiBlockLattice2D<PlbT,DESCRIPTOR>& lattice, plint iter)
{
ImageWriter<PlbT> imageWriter("leeloo");
imageWriter.writeScaledGif(createFileName("u", iter, 6),
*computeVelocityNorm(lattice) );
}
*/
void writeVTK(MultiBlockLattice2D<PlbT,DESCRIPTOR>& lattice,
IncomprFlowParam<PlbT> const& parameters, plint iter)
{
T dx = parameters.getDeltaX();
T dt = parameters.getDeltaT();
VtkImageOutput2D<T> vtkOut(createFileName("vtk", iter, 6), dx);
vtkOut.writeData<T>(*realPart<PlbT,T>(*computeVelocityNorm(lattice),lattice.getBoundingBox()), "velocityNorm", dx/dt);
//vtkOut.writeData<2,T>(*computeVelocity(lattice), "velocity", dx/dt);
}
/// A functional, used to instantiate bounce-back nodes at the locations of the cylinder
void cylinderSetup( MultiBlockLattice2D<PlbT,DESCRIPTOR>& lattice,
IncomprFlowParam<PlbT> const& parameters,
OnLatticeBoundaryCondition2D<PlbT,DESCRIPTOR>& boundaryCondition )
{
const plint nx = parameters.getNx();
const plint ny = parameters.getNy();
Box2D outlet(nx-1,nx-1, 1, ny-2);
// Create Velocity boundary conditions everywhere
boundaryCondition.setVelocityConditionOnBlockBoundaries (
lattice, Box2D(0, 0, 1, ny-2) );
boundaryCondition.setVelocityConditionOnBlockBoundaries (
lattice, Box2D(0, nx-1, 0, 0) );
boundaryCondition.setVelocityConditionOnBlockBoundaries (
lattice, Box2D(0, nx-1, ny-1, ny-1) );
// .. except on right boundary, where we prefer an outflow condition
// (zero velocity-gradient).
boundaryCondition.setVelocityConditionOnBlockBoundaries (
lattice, Box2D(nx-1, nx-1, 1, ny-2), boundary::outflow );
setBoundaryVelocity (
lattice, lattice.getBoundingBox(),
PoiseuilleVelocity<PlbT>(parameters) );
setBoundaryDensity (
lattice, outlet,
ConstantDensity<PlbT>(1.) );
initializeAtEquilibrium (
lattice, lattice.getBoundingBox(),
PoiseuilleVelocityAndDensity<PlbT>(parameters) );
plint cx = nx/4;
plint cy = ny/2+2; // cy is slightly offset to avoid full symmetry,
// and to get a Von Karman Vortex street.
plint radius = cy/4;
defineDynamics(lattice, lattice.getBoundingBox(),
new CylinderShapeDomain2D<T>(cx,cy,radius),
new plb::BounceBack<PlbT,DESCRIPTOR>);
lattice.initialize();
}
void channelSetup( MultiBlockLattice2D<T,NSDESCRIPTOR>& lattice,
IncomprFlowParam<T> const& parameters,
OnLatticeBoundaryCondition2D<T,NSDESCRIPTOR>& boundaryCondition,
T alpha, T frequency, T amplitude)
{
const plint nx = parameters.getNx();
const plint ny = parameters.getNy();
Box2D bottom( 0,nx-1, 0, 0);
Box2D top( 0,nx-1, ny-1, ny-1);
boundaryCondition.addVelocityBoundary1N(bottom, lattice);
boundaryCondition.addPressureBoundary1P(top, lattice);
Array<T,2> u((T)0.,(T)0.);
setBoundaryVelocity( lattice, lattice.getBoundingBox(), u );
initializeAtEquilibrium(lattice,lattice.getBoundingBox(),(T)1.0,u);
Array<T,NSDESCRIPTOR<T>::d> force(womersleyForce((T)0, amplitude, frequency, parameters),0.);
setExternalVector(lattice,lattice.getBoundingBox(),NSDESCRIPTOR<T>::ExternalField::forceBeginsAt,force);
lattice.initialize();
}
void setupInletAndBulk( MultiBlockLattice2D<T,DESCRIPTOR>& lattice,
IncomprFlowParam<T> const& parameters,
OnLatticeBoundaryCondition2D<T,DESCRIPTOR>& boundaryCondition )
{
const plint ny = parameters.getNy();
// Create Velocity boundary conditions on inlet
boundaryCondition.addVelocityBoundary0N(Box2D( 0, 0, 0,ny-1), lattice);
setBoundaryVelocity (
lattice, Box2D( 0, 0, 0,ny-1),
PoiseuilleVelocity<T>(parameters) );
initializeAtEquilibrium (
lattice, lattice.getBoundingBox(),
PoiseuilleVelocityAndDensity<T,DESCRIPTOR>(parameters) );
}
T computeRMSerror ( MultiBlockLattice2D<T,NSDESCRIPTOR>& lattice,
IncomprFlowParam<T> const& parameters,
T alpha, plint iT, bool createImage=false)
{
MultiTensorField2D<T,2> analyticalVelocity(lattice);
setToFunction( analyticalVelocity, analyticalVelocity.getBoundingBox(),
WomersleyVelocity<T>(parameters,alpha,(T)iT) );
MultiTensorField2D<T,2> numericalVelocity(lattice);
computeVelocity(lattice, numericalVelocity, lattice.getBoundingBox());
// Divide by lattice velocity to normalize the error
return 1./parameters.getLatticeU() *
// Compute RMS difference between analytical and numerical solution
std::sqrt( computeAverage( *computeNormSqr (
*subtract(analyticalVelocity, numericalVelocity)
) ) );
}
int main(int argc, char *argv[])
{
plbInit(&argc, &argv);
if (argc != 2)
{
pcout << "Error : Wrong parameters specified." << endl;
pcout << "1 : N." << endl;
exit(1);
}
const plint N = atoi(argv[1]);
const T Re = 1.0;
const T alpha = 1.0; // womersley number
const plint Nref = 10;
const T uMaxRef = 0.01;
const T uMax = uMaxRef /(T)N * (T)Nref; // needed to avoid compressibility errors.
const T lx = 100.0;
const T ly = 1.0;
pcout << "uMaxRef=" << uMaxRef << std::endl;
pcout << "uMax=" << uMax << std::endl;
global::directories().setOutputDir("./tmp/");
IncomprFlowParam<T> parameters(uMax, Re, N, lx, ly);
// The frequency of the force (lattice units)
T frequency = (T)4*alpha*alpha*parameters.getLatticeNu()
/ (T)(parameters.getResolution()*parameters.getResolution());
// The amplitude of the forcing term (lattice units)
T amplitude = 8. * parameters.getLatticeNu() * parameters.getLatticeU()
/ ( (T)(parameters.getResolution()*parameters.getResolution()) );
// Period of the force (lattice units)
plint tPeriod = (plint)((T)2*pi/frequency + 0.5);
writeLogFile(parameters,"palabos.log");
plint nx = parameters.getNx();
plint ny = parameters.getNy();
T omega = parameters.getOmega();
MultiBlockLattice2D<T, NSDESCRIPTOR> lattice (
nx,ny,new DYNAMICS );
OnLatticeBoundaryCondition2D<T,NSDESCRIPTOR>*
boundaryCondition = createLocalBoundaryCondition2D<T,NSDESCRIPTOR>();
lattice.periodicity().toggle(0,true);
channelSetup( lattice, parameters, *boundaryCondition, alpha, frequency, amplitude);
pcout << "Starting simulation" << endl;
const plint maxIter = tPeriod * 100;
//const plint tSave = tPeriod / 24;
T error = T();
lattice.getTimeCounter().resetTime(1);
pcout << "Omega = " << omega << ", it period = " << tPeriod << endl;
util::ValueTracer<T> converge(uMax,N,1.0e-3);
plint iT = 0;
for (iT = 0; iT < maxIter; ++iT) {
// Updating the force in the whole domain
Array<T,NSDESCRIPTOR<T>::d> force(womersleyForce((T)iT, amplitude, frequency, parameters),0.);
setExternalVector(lattice,lattice.getBoundingBox(),
NSDESCRIPTOR<T>::ExternalField::forceBeginsAt,force);
T errorTemp = computeRMSerror( lattice,parameters,alpha,iT);
error += errorTemp;
//if (iT % tSave == 0) {
// pcout << "Writing Gif at time : " << iT << std::endl;
// writeGif(lattice,iT);
//}
if (iT % tPeriod == 0)
{
// The error is averaged over one period
error /= (T)(tPeriod);
pcout << "For N = " << N << ", Error = " << error << endl;
converge.takeValue(error,true);
if (converge.hasConverged())
{
cout << "Simulation converged!\n";
break;
}
error = T();
}
lattice.collideAndStream();
}
pcout << "For N = " << N << ", Error = " << computeRMSerror ( lattice,parameters,alpha,iT, true) << endl;
}
