fin[0, :, :] = fpost[0, :, :]
fin[1, 1:nxl, :] = fpost[1, 0:nxl-1, :]
fin[2, :, 0:nyl-1] = fpost[2, :, 1:nyl]
fin[3, 0:nxl-1, :] = fpost[3, 1:nxl, :]
fin[4, :, 1:nyl] = fpost[4, :, 0:nyl-1]
fin[5, 1:nxl, 0:nyl-1] = fpost[5, 0:nxl-1, 1:nyl]
fin[6, 0:nxl-1, 0:nyl-1] = fpost[6, 1:nxl, 1:nyl]
fin[7, 0:nxl-1, 1:nyl] = fpost[7, 1:nxl, 0:nyl-1]
fin[8, 1:nxl, 1:nyl] = fpost[8, 0:nxl-1, 0:nyl-1]
# Left wall: compute density from known populations
u[:, :, 0] = vel[:, :, 0]
rho[:, 0] = sumPopulations(fin[iCentV, 0, :])+2.*sumPopulations(fin[iTop, 0, :])
# complete the left wall treatement wrt Yu 2002
fin[iBot, 0, :] = - feq[iTop, 0, :] + (feq[iBot, 0, :] + fin[iTop, 0, :])
# fin[iBot, 0, :] = fin[iTop, 0, :] + 6 * dot(c, u.transpose(1, 0, 2)) c[iBot][0] * rho*t[iBot]
# wall boundary handling
for i in range(q):
fin[i, wall] = fin[noslip[i], wall]
# Visualization
if ( (time % plotEveryN == 0) & (liveUpdate | saveVTK | savePlot) & (time > skipFirstN) ):
if ( liveUpdate | savePlot ):
ax.clear()
ax.imshow(rho.transpose(), cmap=cm.afmhot, vmin=0.99, vmax=1.01)
###### Main time loop ##########################################################
for time in range(maxIterations):
# bounce back distributions at walls
finc = fin[:, solidDomain].copy()
for i in range(9):
fin[i, solidDomain] = finc[noslip[i], :]
# Right Wall: Produce zero pressure gradient for the outflow
fin[iLeft, -1, :] = fin[iLeft, -2, :]
# Calculate macroscopic density and velocity
(rho, u) = getMacroValues(fin)
# Left wall: compute density from known populations.
u[:, 0, :] = vel[:, 0, :]
rho[0, :] = 1./(1.-u[0, 0, :]) * (sumPopulations(fin[iCentV, 0, :])+2.*sumPopulations(fin[iLeft, 0, :]))
feq[:,0,:] = equilibrium(rho[0,:], u[:,0,:])
# complete the left wall treatement wrt Yu 2002
fin[iRight, 0, :] = feq[iLeft, 0, :] + (feq[iRight, 0, :] - fin[iLeft, 0, :])
# Collision step.
fpost[:,fluidDomain] = collisionFunction(fin[:,fluidDomain], rho[fluidDomain], u[:,fluidDomain], omega )
# Streaming step
fin = stream(fpost)
# Visualization
if ( (time % plotEveryN == 0) & (liveUpdate | savePlot) & (time > skipFirstN) ):
#right wall: pressure equal to one
fin[:,nxl,:] = cumulantBoundary(1, u[:,nxl-1,:])
#left wall:
fin[:,0,:] = cumulantBoundary(rho[0,:], vel[:,0,:])
# Collision step.
fpost[:,1:nx-1,1:ny-1] = collisionFunction(fin[:,1:nx-1,1:ny-1], rho[1:nx-1,1:ny-1], u[:,1:nx-1,1:ny-1], omega )
# Streaming step
fin = stream(fpost)
# Visualization
if ( (time % plotEveryN == 0) & (analysis | liveUpdate | savePlot) & (time > skipFirstN) ):
# Here, distributions are streamed into the obstacle -> compute drag and lift
scaling = preComputeFactorForScaling/sumPopulations(fin[:,completeBoundStencil])
scaledFin = fin.copy()
# just scale the populations which are used
for i in range(9):
scaledFin[i, completeBoundStencil] = scaledFin[i, completeBoundStencil]*scaling
dragCoeff = drag(scaledFin, obstacleBounds)
liftCoeff = lift(scaledFin, obstacleBounds)
if ( liveUpdate | savePlot ):
ax.clear()
velocityMag =sqrt(u[0]**2+u[1]**2)
velocityMag[obstacle] = NAN
ax.imshow(velocityMag.transpose(), cmap=cm.afmhot, vmin=0., vmax=0.1)
ax.set_title('velocity norm')
# bounce back distributions at obstacle
for i in range(q):
fin[i, obstacle] = fin[noslip[i], obstacle]
# and walls
for i in range(q):
fin[i, boundary] = fin[noslip[i], boundary]
# Right Wall: Produce zero pressure gradient for the outflow
fin[iLeft, -1, :] = fin[iLeft, -2, :]
# Calculate macroscopic density and velocity
(rho, u) = getMacroValues(fin)
# Left wall: compute density from known populations.
u[:, 0, :] = vel[:, 0, :]
rho[0, :] = 1./(1.-u[0, 0, :]) * (sumPopulations(fin[iCentV, 0, :])+2.*sumPopulations(fin[iLeft, 0, :]))
feq = equilibrium(rho, u)
# complete the left wall treatement wrt Yu 2002
fin[iRight, 0, :] = feq[iLeft, 0, :] + (feq[iRight, 0, :] - fin[iLeft, 0, :])
# Collision step.
#fpost = BGKCollide(fin, feq, omega)
fpost = cumulantCollide(fin, rho, u, omega)
# Streaming step
fin = stream(fpost)
# Visualization
if ( (time % plotEveryN == 0) & (liveUpdate | saveVTK | savePlot) & (time > skipFirstN) ):
###### Main time loop ##########################################################
for time in range(maxIterations):
# bounce back distributions at solid domains
finc = fin[:, solidDomain].copy()
for i in range(9):
fin[i, solidDomain] = finc[noslip[i], :]
# Right Wall: Produce zero pressure gradient for the outflow
fin[iLeft, -1, :] = fin[iLeft, -2, :]
# Calculate macroscopic density and velocity
(rho, u) = getMacroValues(fin)
# Left wall: compute density from known populations.
u[:, 0, :] = vel[:, 0, :]
rho[0, :] = 1./(1.-u[0, 0, :]) * (sumPopulations(fin[iCentV, 0, :])+2.*sumPopulations(fin[iLeft, 0, :]))
feq[:,0,:] = equilibrium(rho[0,:], u[:,0,:])
# complete the left wall treatement wrt Yu 2002
fin[iRight, 0, :] = feq[iLeft, 0, :] + (feq[iRight, 0, :] - fin[iLeft, 0, :])
# Collision step.
fpost[:,fluidDomain] = collisionFunction(fin[:,fluidDomain], rho[fluidDomain], u[:,fluidDomain], omega )
# Streaming step
fin = stream(fpost)
# Visualization
if ( (time % plotEveryN == 0) & (analysis | liveUpdate | savePlot) & (time > skipFirstN) ):
# Here, distributions are streamed into the obstacle -> compute drag and lift