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