int main(){
cout<<"LPM Chai test.."<<endl;
int nx = 3;
int ny = 65;
int tMax = 5000;
double l0 = 1e-5/(ny-1);
double V0 = -50e-3;
double dt = 1.0;
double T = 273; //temperature [K]
double cinf = 1e-4; //ion concentration at inf. [Mol]
double epsilon = 80*PHYS_EPS0; //absolute permittivity [F/m]
CollisionD2Q9LPMChai1to1 *cm = new CollisionD2Q9LPMChai1to1();
StreamD2Q9Periodic *sm = new StreamD2Q9Periodic();
LatticeModel *lm = new Lattice2D(nx, ny);
UnitHandlerLPM *uh = new UnitHandlerLPM();
uh->setCharLength(l0);
uh->setCharVoltage(V0);
uh->setTimeStep(dt);
cm->setUnitHandler(uh);
cm->setW(1.0);
cm->setC(1.0);
cm->setPermittivity(epsilon);
cm->setTemperature(T);
cm->setInfConcentration(cinf);
LBM *lbm = new LBM(lm, cm, sm);
/* Boundaries */
HeZouLPMChaiNodes *bds = new HeZouLPMChaiNodes();
bds->setCollisionModel(cm);
for(int i = 0; i < nx; i++){
bds->addNode(i, 0, 0, 1.0/1.8);
bds->addNode(i, ny-1, 0, 1.0/1.8);
}
lbm->addBoundaryNodes(bds);
/* Initialize solver */
lbm->init();
bds->init();
/* Main loop */
for(int t = 0; t < tMax; t++){
cout<<t<<endl;
lbm->collideAndStream();
//lbm->handleBoundaries();
}
//lbm->calcMacroscopicVars();
cm->dataToFile();
cout<<"done LPM."<<endl;
return 0;
}
int main(){
cout<<"LPM Chai test.."<<endl;
int nx = 32;
int ny = 8;
int tMax = 25000;
double l0 = 0.8e-6/nx;
double V0 = -10e-3;
CollisionD2Q9LPMChai *cm = new CollisionD2Q9LPMChai();
StreamD2Q9Periodic *sm = new StreamD2Q9Periodic();
LatticeModel *lm = new Lattice2D(nx, ny);
UnitHandlerLPM *uh = new UnitHandlerLPM();
uh->setCharLength(l0);
uh->setCharVoltage(V0);
cm->setUnitHandler(uh);
cm->setW(0.5);
cm->setC(1.0);
LBM *lbm = new LBM(lm, cm, sm);
/* Boundaries */
HeZouPressureNodes *bds = new HeZouPressureNodes();
//bds->setCollisionModel(cm);
for(int i = 0; i < ny; i++){
bds->addNode(0, i, 0, 1.0/1.8);
bds->addNode(nx-1, i, 0, 1.0/1.8);
}
lbm->addBoundaryNodes(bds);
//NeumannLPMNodes *iobds = new NeumannLPMNodes();
//iobds->setCollisionModel(cm);
for(int j = 0; j < ny; j++){
//iobds->addNode(0, j, 0.0);
//iobds->addNode(nx-1, j, 0.0);
}
//lbm->addBoundaryNodes(iobds);
/* Initialize solver */
lbm->init();
/* Main loop */
for(int t = 0; t < tMax; t++){
cout<<t<<endl;
lbm->collideAndStream();
lbm->handleBoundaries();
}
//lbm->calcMacroscopicVars();
cm->dataToFile();
cout<<"done LPM."<<endl;
return 0;
}
void CollisionD2Q9LPMChai::collide() {
UnitHandlerLPM *uh = dynamic_cast<UnitHandlerLPM*>(unitHandler);
//cout<<"Chai collision"<<endl;
for (int j = 0; j < n.y; j++) {
for (int i = 0; i < n.x; i++) {
psi[j][i] = getPsi(f[0][j][i], i, j);
//if(skip != NULL && skip[j][i]) continue;
//cout<<"psi: "<<psi[j][i]<<endl;
for (int d = 0; d < 9; d++) {
f[0][j][i][d] += w * (fEq(d, psi[j][i]) - f[0][j][i][d])
+ (0.5 - 1.0 / w) / 3.0 * Wa[d] * g_rhs(i, j) * uh->getTimeStep()
* uh->getTimeStep();
}
psi[j][i] = getPsi(f[0][j][i], i, j);
}
}
}
int main() {
cout << "2D, NS <-> PE <-> NP" << endl;
/* Parameter definitions */
int nx = 201;
int ny = 201;
// int sd = 51;
int tNP = 150;
int tPE = 10000;
int tNS = tNP; //tNP;
int tMain = 20;
int tMod = 1; //undersök i detalj.... ok.
double l0 = 10e-6 / (ny - 1); //PE, NP
double C0 = 1e-4 * PHYS_N_A; //NP
double u0 = 1e-3; //NP, NS
double dt = 1.0;
double V0 = -50e-3; //PE
double rho0 = 1e3; //NS
double nu = 1.0e-7; //m^2/s
double D = 1.0e-10; //m^2/s
double u0x = 0.0;
double T = 293;
double eps_r = 80;
double rho_surface = -0.5e-1; //-50e-3*eps_r*PHYS_EPS0/1e-7/V0*l0;
rho_surface = 0.0;
double bulk_charge = 1.0;
double gamma = PHYS_E_CHARGE / (PHYS_KB * T);
double dPdx = 0.005e-3; //1e3 * l0/(rho0 * u0 * u0); //lattice units
double bulkConductivity = 1.5e-3; //conductivity [S/m]
double Pe = u0 * l0 / D;
double Re = u0 * 1e4 * l0 / nu;
double wNP = 1.0 / (3.0 / Pe + 0.5);
double wPE = 1.0;
double wNS = 1.0 / (3.0 / Re + 0.5);
/*print parameters*/
printLine(20);
cout << "DIM = (" << nx << ", " << ny << ")" << endl;
cout << "T = " << T << endl;
cout << "RHO_SURFACE = " << rho_surface << ", "
<< rho_surface * V0 / l0 * PHYS_EPS0 * eps_r << " C/M^2" << endl;
cout << "BULK_CHARGE = " << bulk_charge << endl;
cout << "PE = " << Pe << endl;
cout << endl;
cout << "w_np = " << wNP << endl;
cout << "w_pe = " << wPE << endl;
cout << "w_ns = " << wNS << endl;
cout << endl;
cout << "l0 = " << l0 << endl;
cout << "V0 = " << V0 << endl;
cout << "GAMMA: " << gamma << endl;
cout << "l0*gamma/Pe *V0/l0 = " << l0 * gamma / Pe * V0 / l0 << endl;
cout << "l0^2*gamma/Pe *V0/l0^2 = " << l0 * l0 * gamma / Pe * V0 / l0 / l0
<< endl;
cout << "1/Pe = " << 1 / Pe << endl;
cout << "dPdx = " << dPdx << endl;
printLine(20);
/* Allocate memory for velocity and grad. potential arrays */
double **ux = allocate2DArray(ny, nx);
double **uy = allocate2DArray(ny, nx);
double **dPsix = allocate2DArray(ny, nx);
double **dPsiy = allocate2DArray(ny, nx);
double **rho_eps = allocate2DArray(ny, nx);
double **fx = allocate2DArray(ny, nx);
double **fy = allocate2DArray(ny, nx);
for (int j = 0; j < ny; j++) {
for (int i = 0; i < nx; i++) {
ux[j][i] = 0;
uy[j][i] = 0;
fx[j][i] = 0;
fy[j][i] = 0;
dPsix[j][i] = 0.0;
dPsiy[j][i] = 0.0;
rho_eps[j][i] = 0.0; //-l0*l0/V0*2*PHYS_E_CHARGE*C0/(eps_r *PHYS_EPS0)*\
(cos(j*2*M_PI/(ny-1)) + 1)*0.5;
}
}
/* Poisson eq. solver */
CollisionD2Q9BGKPE *cmPE = new CollisionD2Q9BGKPE();
StreamD2Q9Periodic *smPE = new StreamD2Q9Periodic();
Lattice2D *lmPE = new Lattice2D(nx, ny);
UnitHandlerLPM *uhPE = new UnitHandlerLPM();
cmPE->setRHS(rho_eps);
cmPE->setW(wPE);
cmPE->setC(1.0);
cmPE->setUnitHandler(uhPE);
uhPE->setCharLength(l0);
uhPE->setCharVoltage(V0);
uhPE->setTimeStep(1.0);
LBM *lbmPE = new LBM(lmPE, cmPE, smPE);
lbmPE->init();
// HeZouLPMChaiNodes *bds = new HeZouLPMChaiNodes();
// bds->setCollisionModel(cmPE);
// for(int i = 0; i < nx; i++){
// bds->addNode(i, 0, 0, 1.0/1.8);
// bds->addNode(i, ny-1, 0, 1.0/1.8);
// }
/* Boundary conds. for Poission solver */
NeumannNodesPESlip *bds = new NeumannNodesPESlip();
lbmPE->addBoundaryNodes(bds);
bds->setCollisionModel(cmPE);
/* Nernst Planck solver */
CollisionD2Q9AD *cmNPneg = new CollisionD2Q9AD();
CollisionD2Q9AD *cmNPpos = new CollisionD2Q9AD();
StreamD2Q9Periodic *sm = new StreamD2Q9Periodic();
LatticeModel *lm = new Lattice2D(nx, ny);
StreamD2Q9Periodic *sm2 = new StreamD2Q9Periodic();
LatticeModel *lm2 = new Lattice2D(nx, ny);
cmNPneg->setW(wNP);
cmNPneg->setC(1);
cmNPneg->setZ(-1);
cmNPneg->setInitC(bulk_charge);
cmNPneg->setUx(ux);
cmNPneg->setUy(uy);
cmNPneg->setDPsix(dPsix);
cmNPneg->setDPsiy(dPsiy);
cmNPneg->setT(T);
cmNPneg->setPe(Pe);
//cmNPneg->setRHS(rho_eps);
cmNPpos->setW(wNP);
cmNPpos->setC(1);
cmNPpos->setZ(1);
cmNPpos->setInitC(bulk_charge);
cmNPpos->setUx(ux);
cmNPpos->setUy(uy);
cmNPpos->setDPsix(dPsix);
cmNPpos->setDPsiy(dPsiy);
cmNPpos->setT(T);
cmNPpos->setPe(Pe);
//cmNPpos->setRHS(rho_eps);
LBM *lbmNPneg = new LBM(lm, cmNPneg, sm);
LBM *lbmNPpos = new LBM(lm2, cmNPpos, sm2);
/* Boundary conds for NP solver*/
SlipNodes<CollisionD2Q9AD> *bbnNeg = new SlipNodes<CollisionD2Q9AD>();
lbmNPneg->addBoundaryNodes(bbnNeg);
bbnNeg->setCollisionModel(cmNPneg);
// for(int i = start + 1 ; i < nx - start - 1; i++){
// bbnNeg->addNode(i, start, 0, 2);
// bbnNeg->addNode(i, ny-1-start, 0, 4);
//
// bbnNeg->addNode(start, i, 0, 1);
// bbnNeg->addNode(nx-1-start, i, 0, 3);
// }
// //corner nodes
// bbnNeg->addNode(start, start, 0, 6);
// bbnNeg->addNode(start, ny-1-start, 0, 7);
// bbnNeg->addNode(nx-1-start, start, 0, 5);
// bbnNeg->addNode(nx-1-start, ny-1-start, 0, 8);
SlipNodes<CollisionD2Q9AD> *bbnPos = new SlipNodes<CollisionD2Q9AD>();
lbmNPpos->addBoundaryNodes(bbnPos);
bbnPos->setCollisionModel(cmNPpos);
// for(int i = start + 1; i < nx - start - 1; i++){
// bbnPos->addNode(i, start, 0, 2);
// bbnPos->addNode(i, ny-1-start, 0, 4);
//
// bbnPos->addNode(start, i, 0, 1);
// bbnPos->addNode(nx-1-start, i, 0, 3);
// }
// bbnPos->addNode(start, start, 0, 6);
// bbnPos->addNode(start, ny-1-start, 0, 7);
// bbnPos->addNode(nx-1-start, start, 0, 5);
// bbnPos->addNode(nx-1-start, ny-1-start, 0, 8);
/* Initialize solver */
lbmNPneg->init();
lbmNPpos->init();
/* NS Solver */
CollisionD2Q9BGKNSF *cmNS = new CollisionD2Q9BGKNSF();
StreamD2Q9Periodic *smNS = new StreamD2Q9Periodic();
Lattice2D *lmNS = new Lattice2D(nx, ny);
cmNS->setW(wNS);
cmNS->setC(1.0);
LBM *lbmNS = new LBM(lmNS, cmNS, smNS);
/* Set boundary conditions for flow */
BounceBackNodes<CollisionD2Q9BGKNSF> *bbNS = new BounceBackNodes<
CollisionD2Q9BGKNSF>();
bbNS->setCollisionModel(cmNS);
lbmNS->addBoundaryNodes(bbNS);
//vertical rod
// int verRod = ny/5;
// for(int j = 0; j < verRod+1; j++){
// bbNS->addNode(nx/2, j, 0);
// bbNS->addNode(nx/2+10, j, 0);
//
// bbNS->addNode(nx/2, ny - 1 -j, 0);
// bbNS->addNode(nx/2+10, ny - 1 - j, 0);
// }
//
// for(int i = nx/2+1; i < nx/2 + 10; i++){
// bbNS->addNode(i, verRod, 0);
// bbNS->addNode(i, ny - 1 - verRod, 0);
// }
//small square
addRect(nx * 3 / 4, 0, nx / 10, ny / 5, rho_surface, bbNS, bds, bbnNeg,
bbnPos);
addRect(nx * 3 / 4, ny - 1 - ny / 5, nx / 10, ny / 6, rho_surface, bbNS, bds,
bbnNeg, bbnPos);
addRect(nx / 6, ny / 4, nx / 4, ny / 4, rho_surface, bbNS, bds, bbnNeg,
bbnPos);
addRect(nx / 8, ny * 3 / 4, nx / 4, ny / 8, rho_surface, bbNS, bds, bbnNeg,
bbnPos);
addRect(nx * 3 / 6, ny / 6, nx / 6, ny / 8, rho_surface, bbNS, bds, bbnNeg,
bbnPos);
addRect(nx * 3 / 5 - 5, ny / 2, nx / 8, ny / 4, rho_surface, bbNS, bds,
bbnNeg, bbnPos);
addRect(4, ny / 2, nx / 20, ny / 3 - 1, rho_surface, bbNS, bds, bbnNeg,
bbnPos);
addRect(nx * 3 / 4 + 5, ny / 3, nx / 20, ny / 20, rho_surface, bbNS, bds,
bbnNeg, bbnPos);
//addRect(nx - nx/6, ny/2, nx/10, ny/3, rho_surface, bbNS, bds, bbnNeg, bbnPos);
//addRect(nx/2 - 10, 2*ny/3, nx/5, ny/5, rho_surface, bbNS, bds, bbnNeg, bbnPos);
//addRect(nx/4, ny/4, nx/2, ny/2, rho_surface, bbNS, bds, bbnNeg, bbnPos);
bds->init();
bbnPos->init();
bbnNeg->init();
lbmNS->init();
cmNS->setForce(fx, fy);
/* Main loops */
for (int tt = 0; tt < tMain; tt++) {
cout << "TT: " << tt << endl;
// if(tt == 12){ tNP = 8; tNS = 8;}
// /* Update net charge density */
// updateRho(rho_eps, cmNPneg, cmNPpos, lm, eps_r, V0, l0, C0);
// cmPE->reset();
//
// for(int t = 0; t < tPE; t++){
// //cout<<"tPE "<<t<<endl;
// lbmPE->collideAndStream();
// }
// cmPE->getDPsi(dPsix, dPsiy);
//
// //scale potential gradients to SI units *l0
// rescale2DArray(dPsix, V0, ny, nx);
// rescale2DArray(dPsiy, V0, ny, nx);
//
// for(int t = 0; t < tNP; t++){
// lbmNPneg->collideAndStream();
// lbmNPpos->collideAndStream();
// }
//
//
updateForce(fx, fy, ux, uy, rho_eps, lmNS, eps_r, u0, l0, V0, C0,
bulkConductivity, dPdx, cmNPpos, cmNPneg);
for (int t = 0; t < tNS; t++) {
lbmNS->collideAndStream();
}
/* update velocities */
cmNS->getU(ux, uy);
/*write result to file*/
stringstream ss;
string base = "vis_scripts/data";
if (tt % tMod == 0) {
//dPsiY
ss.str("");
ss << base << "PSI";
ss << tt / tMod << "/";
createDirectory(ss.str());
ss << "dpsiy.csv";
write2DArray(dPsiy, NULL, ss.str(), nx, ny);
//potential
ss.str("");
ss << base << "PE";
ss << tt / tMod << "/";
createDirectory(ss.str());
ss << "rho.csv";
cmPE->dataToFile(ss.str());
//C_neg
ss.str("");
ss << base << "NP";
ss << tt / tMod << "/";
createDirectory(ss.str());
ss << "ni_neg.csv";
cmNPneg->dataToFile(ss.str());
//C_pos
ss.str("");
ss << base << "NP";
ss << tt / tMod << "/";
ss << "ni_pos.csv";
cmNPpos->dataToFile(ss.str());
//U and rho_m
ss.str("");
ss << base << "NS";
ss << tt / tMod << "/";
createDirectory(ss.str());
cmNS->dataToFile(ss.str());
//fx
ss.str("");
ss << base << "FX";
ss << tt / tMod << "/";
createDirectory(ss.str());
ss << "fx.csv";
write2DArray(fx, NULL, ss.str(), nx, ny);
}
}
cout << "done LNP." << endl;
return 0;
}
int main(){
cout<<"LPM Wang Helmholtz..."<<endl;
int nx = 101;
int ny = 101;
int tMax = 20000;
double l0 = 1;
double V0 = 1;
double lambda = 2.0;
double dt = 1.0/(nx-1)/(nx-1);
double dx = 1.0/(nx-1);
double c = dx/dt;
double omega = 1.0/(1.5*dt/dx/dx + 0.5);
cout<<"dx: "<<dx<<", dt: "<<dt<<endl;
cout<<"OMEGA: "<<omega<<endl;
CollisionD2Q9WangHelmholtz *cm = new CollisionD2Q9WangHelmholtz();
UnitHandlerLPM *uh = new UnitHandlerLPM();
StreamD2Q9Periodic *sm = new StreamD2Q9Periodic();//todo
LatticeModel *lm = new Lattice2D(nx, ny);
LBM *lbm = new LBM(lm, cm, sm);
cm->setW(omega);
cm->setC(c);
cm->setUnitHandler(uh);
cm->setLambda(lambda);
uh->setCharLength(l0);
uh->setCharVoltage(V0);
uh->setTimeStep(dt);
/* Boundaries */
double mu = sqrt(lambda*lambda + M_PI*M_PI);
DirichletLPMNodes<CollisionD2Q9WangHelmholtz> *bds =
new DirichletLPMNodes<CollisionD2Q9WangHelmholtz>();
bds->setCollisionModel(cm);
for(int i = 0; i < nx; i++){
bds->addNode(i, 0, cos(M_PI/(nx-1)*i));
cout<<cos(M_PI/(nx-1)*i)<<endl;
bds->addNode(i, ny-1, 0.0);
}
for(int j = 1; j < ny-1; j++){//no redundancy on corners..
bds->addNode(0, j, YBDR(j));
bds->addNode(nx-1, j, -YBDR(j));
}
lbm->addBoundaryNodes(bds);
/* Initialize solver */
lbm->init();
/* Main loop */
for(int t = 0; t < tMax; t++){
cout<<t<<endl;
lbm->collideAndStream();
lbm->handleBoundaries();
}
cm->dataToFile();
cout<<"done LPM."<<endl;
return 0;
}
