def vphi_y_hedge_c(self, c, mx, my, alpha, dt):
fy_c = Fields_2d(self.mesh, ftype='hedge') #flux of c in y direction
for j in range(1, self.mesh.ny + 1):
for i in range(1, self.mesh.nx + 1):
if self.value[j, i] > 0:
if (c.value[j, i] - 0.) > 0.001 and (
1 - c.value[j, i]) > 0.001: #surface cell
#compute flux of c from lower to upper
#use cell at lower side of this edge to compute flux
fy_c.value[j, i] = compute_flux_c_lu(
mx.value[j, i], my.value[j, i], alpha.value[j, i],
self.value[j, i] * dt, self.mesh.dx, self.mesh.dy)
elif (c.value[j, i] - 0.) < 0.001: #empty cell
fy_c.value[j, i] = 0
elif (1 - c.value[j, i]) < 0.001: #full cell
fy_c.value[j,
i] = (self.value[j, i] * dt * self.mesh.dx
) / (self.mesh.dx * self.mesh.dy)
elif self.value[j, i] < 0: #v[i,j+1/2]<0
#compute flux of c from upper to lower
#use cell at upper side of this edge to compute flux
if (c.value[j + 1, i] - 0.) > 0.001 and (
1 - c.value[j + 1, i]) > 0.001: #surface cell
fy_c.value[j, i] = compute_flux_c_ul(
mx.value[j + 1, i], my.value[j + 1, i],
alpha.value[j + 1, i], self.value[j, i] * dt,
self.mesh.dx, self.mesh.dy)
elif (c.value[j + 1, i] - 0.) < 0.001: #empty cell
fy_c.value[j, i] = 0
elif (1 - c.value[j + 1, i]) < 0.001: #full cell
fy_c.value[j,
i] = (self.value[j, i] * dt * self.mesh.dx
) / (self.mesh.dx * self.mesh.dy)
return fy_c
def get_alpha_field(c, mx, my): #c,mx,my are Fields_2d objects
alpha = Fields_2d(c.mesh, ftype='center', name='alpha')
for j in range(1, c.mesh.ny + 1):
for i in range(1, c.mesh.nx + 1):
if (1 - c.value[j, i]) > 0.001 and (c.value[j, i] -
0) > 0.001: #surface cell
if mx.value[j, i] > 0 and my.value[j, i] > 0:
alpha.value[j, i] = compute_alpha(c.mesh, mx.value[j, i],
my.value[j, i],
c.value[j, i])
elif mx.value[j, i] > 0 and my.value[j, i] < 0:
alpha_bar = compute_alpha(c.mesh, mx.value[j, i],
-1 * my.value[j, i], c.value[j,
i])
alpha.value[j, i] = alpha_bar - 2 * (
-1) * my.value[j, i] * c.mesh.dy / 2.
elif mx.value[j, i] < 0 and my.value[j, i] > 0:
alpha_bar = compute_alpha(c.mesh, -1 * mx.value[j, i],
my.value[j, i], c.value[j, i])
alpha.value[j, i] = alpha_bar - 2 * (
-1) * mx.value[j, i] * c.mesh.dx / 2.
elif mx.value[j, i] < 0 and my.value[j, i] < 0:
alpha_bar = compute_alpha(c.mesh, -1 * mx.value[j, i],
-1 * my.value[j, i], c.value[j,
i])
alpha.value[j, i] = alpha_bar - 2 * (
-1) * mx.value[j, i] * c.mesh.dx / 2. - 2 * (
-1) * my.value[j, i] * c.mesh.dy / 2.
#else:
# print "There may be something wrong with input mx and my"
# sys.exit()
return alpha
def uphi_x_vedge_c(self, c, mx, my, alpha, dt):
fx_c = Fields_2d(self.mesh, ftype='vedge') #flux of c in x direction
for j in range(1, self.mesh.ny + 1):
for i in range(1, self.mesh.nx + 1):
if self.value[j, i] > 0:
if (c.value[j, i] - 0.) > 0.001 and (
1 - c.value[j, i]) > 0.001: #surface cell
#compute flux of c from left to right
#use cell at left side of this edge to compute flux
fx_c.value[j, i] = compute_flux_c_lr(
mx.value[j, i], my.value[j, i], alpha.value[j, i],
self.value[j, i] * dt, self.mesh.dx, self.mesh.dy)
elif (c.value[j, i] - 0.) < 0.001: #empty cell
fx_c.value[j, i] = 0
elif (1 - c.value[j, i]) < 0.001: #full cell
fx_c.value[j,
i] = (self.value[j, i] * dt * self.mesh.dy
) / (self.mesh.dx * self.mesh.dy)
elif self.value[j, i] < 0: #u[i+1/2,j]<0
#compute flux of c from right to left
#use cell at right side of this edge to compute flux
if (c.value[j, i + 1] - 0.) > 0.001 and (
1 - c.value[j, i + 1]) > 0.001: #surface cell
fx_c.value[j, i] = compute_flux_c_rl(
mx.value[j, i + 1], my.value[j, i + 1],
alpha.value[j, i + 1], self.value[j, i] * dt,
self.mesh.dx, self.mesh.dy)
elif (c.value[j, i + 1] - 0.) < 0.001: #empty cell
fx_c.value[j, i] = 0
elif (1 - c.value[j, i + 1]) < 0.001: #full cell
fx_c.value[j,
i] = (self.value[j, i] * dt * self.mesh.dy
) / (self.mesh.dx * self.mesh.dy)
return fx_c
def vphi_y_hedge(self,
phi): #\frac{\partial v*phi}{\partial y} on vertical edge
vphiy = Fields_2d(self.mesh, ftype='hedge')
self.compute_center()
phi.compute_center()
for j in range(0, self.mesh.ny + 1):
vphiy.value[j, :] = 1. / self.mesh.dy * (
self.center[j + 1, :] * phi.center[j + 1, :] -
self.center[j, :] * phi.center[j, :])
return vphiy
def uphi_x_hedge(
self, phi): #\frac{\partial u*phi}{\partial x} on horizontal edge
#phi prefered to be defined on horizontal edge
uphix = Fields_2d(self.mesh, ftype='hedge')
self.compute_corner()
phi.compute_corner()
for i in range(1, self.mesh.nx + 2):
uphix.value[:, i] = 1. / self.mesh.dx * (
self.corner[:, i] * phi.corner[:, i] -
self.corner[:, i - 1] * phi.corner[:, i - 1])
return uphix
def uphi_x_vedge(self,
phi): #\frac{\partial u*phi}{\partial x} on vertical edge
#phi is prefered to be defined on vertical edge
uphix = Fields_2d(self.mesh, ftype='vedge')
self.compute_center()
phi.compute_center()
for i in range(0, self.mesh.nx + 1):
uphix.value[:, i] = 1. / self.mesh.dx * (
self.center[:, i + 1] * phi.center[:, i + 1] -
self.center[:, i] * phi.center[:, i])
return uphix
meshx.plot_centerVsIndex()
meshy.plot_edgeVsIndex()
meshy.plot_centerVsIndex()
mesh = Mesh_2d(meshx, meshy,
'mesh') #create a 2d mesh from two 1d meshes created above
print "Mesh created.\n"
print "Mesh size: (", mesh.nx, ', ', mesh.ny, ")"
mesh.write()
CFL = 0.8
u_inf = 1
max_iterations = 10000
u = U(mesh, BC_flatplate_u, IC_flatplate_u
) #create a velocity field u with specified B.C. and I.C. passed in
v = V(mesh, BC_flatplate_v, IC_flatplate_v) #create a velocity field v
p = Fields_2d(mesh, BC_p, IC_flatplate_p, name='p') #create pressure field
fields_list = [u, v, p]
output_interval = 20 #Interval that u,v and p are write
tolerance = 0.001
Re = 100.0 #Reynolds number
#nu=1e-6
mu = 0.05
rho = para['rho']
t = 0.0
dt = CFL * mesh.min_delta / u_inf / Re
para['dt'] = dt
#write all fields into time directory
for i, item in enumerate(fields_list):
item.write(str(t))
#!/usr/bin/python
from mesh import Mesh_1d, Mesh_2d
from fields import Fields_2d
from boundary_conditions import *
from initial_conditions import *
from poisson_solver import *
from multiphase import *
from fields_2d_velocity import *
meshx = Mesh_1d(0., 50., 0.5, 0.5, 'mesh_x')
meshy = Mesh_1d(0., 50., 0.5, 0.5, 'mesh_y')
mesh = Mesh_2d(meshx, meshy, 'mesh_for_reconstruct_circle')
print "Mesh created.\n"
print "Mesh size: (", mesh.nx, ', ', mesh.ny, ")"
mesh.write()
c = Fields_2d(mesh, ftype='center', IC=IC_simple_reconstruct_test, name='c')
[mx, my] = get_normal_young(c) #compute mx and my of each cell
alpha = get_alpha_field(c, mx, my) #compute alpha of each cell
draw_surface(c, mx, my, alpha, 'circle_origin') #draw reconstructed circle
CFL = 0.25
u_inf = 1
max_iterations = 500
u = U(mesh, IC=IC_circle_u)
u.value = fixed_value(mesh, -1.)
v = V(mesh, IC=IC_circle_v)
t = 0.0
#dt=CFL*mesh.min_delta/u_inf
dt = 0.1
frame = 0
output_interval = 20 #Interval that fields are written
def __init__(self, mesh_2d, BC=None, IC='default', name='U'):
Fields_2d.__init__(self, mesh_2d, BC, IC, ftype='vedge', name='U')
def __init__(self, mesh_2d, BC=None, IC='default', name='V'):
Fields_2d.__init__(self, mesh_2d, BC, IC, ftype='hedge', name='V')
self.BC = BC
def __init__(self,mesh_2d, BC = None, IC = 'default', name = 'U'):
Fields_2d.__init__(self,mesh_2d,BC,IC, ftype = 'vedge',name = 'U')
def __init__(self,mesh_2d, BC = None, IC = 'default', name = 'V'):
Fields_2d.__init__(self,mesh_2d,BC, IC, ftype = 'hedge',name = 'V')
self.BC = BC
#!/usr/bin/python
from mesh import Mesh_1d, Mesh_2d
from fields import Fields_2d
from boundary_conditions import *
from initial_conditions import *
from poisson_solver import *
from multiphase import *
from fields_2d_velocity import *
meshx = Mesh_1d(0., 1., 0.025, 0.025, 'mesh_x')
meshy = Mesh_1d(0., 1., 0.025, 0.025, 'mesh_y')
mesh = Mesh_2d(meshx, meshy, 'mesh_for_translation_test')
print "Mesh created.\n"
print "Mesh size: (", mesh.nx, ', ', mesh.ny, ")"
mesh.write()
c = Fields_2d(mesh, ftype='center', IC=IC_translation_test, name='c')
[mx, my] = get_normal_young(c) #compute mx and my of each cell
alpha = get_alpha_field(c, mx, my) #compute alpha of each cell
draw_surface(c, mx, my, alpha,
'translation_test_origin') #draw reconstructed circle
CFL = 0.25
u_inf = 1
max_iterations = 500000
u = U(mesh, IC=IC_translation_test_u_1)
v = V(mesh, IC=IC_translation_test_v_1)
t = 0.0
u_max = max(np.amax(np.fabs(u.value)), np.amax(np.fabs(v.value)))
#dt=CFL*mesh.min_delta/u_max
dt = 0.005
CFL = u_max * dt / mesh.min_delta