def get_geometry(dx_s=0.03, dx_f=0.03, hdx=1.3, r_f=100.0, r_s=100.0,
wall_l=4.0, wall_h=2.0, fluid_l=1., fluid_h=2., cube_s=0.25):
wall_y1 = np.arange(dx_s, wall_h, dx_s)
wall_xlayer = np.ones_like(wall_y1) * 2.0
wall_x1 = []
wall_x2 = []
num_layers = 3
for i in range(num_layers):
wall_x1.append(wall_xlayer + i * dx_s)
wall_x2.append(wall_xlayer - i * dx_s + wall_l / 4.0)
wall_x1, wall_x2 = np.ravel(wall_x1), np.ravel(wall_x2)
wall_y1 = np.tile(wall_y1, num_layers)
wall_y2 = wall_y1
w_center = np.array([wall_l / 2.0, 0.0])
wall_x3, wall_y3 = get_2d_wall(dx_s, w_center, wall_l, num_layers, False)
w_center = np.array([2.5, wall_h + dx_s / 2.0])
wall_x4, wall_y4 = get_2d_wall(dx_s, w_center, 1.0, num_layers)
wall_x = np.concatenate([wall_x1, wall_x2, wall_x3, wall_x4])
wall_y = np.concatenate([wall_y1, wall_y2, wall_y3, wall_y4])
r1 = np.ones_like(wall_x) * r_s
m1 = r1 * dx_s * dx_s
h1 = np.ones_like(wall_x) * dx_s * hdx
cs1 = np.zeros_like(wall_x)
rad1 = np.ones_like(wall_x) * dx_s
wall = get_particle_array(name='wall', x=wall_x, y=wall_y, h=h1, rho=r1,
m=m1, cs=cs1, rad_s=rad1)
f_center = np.array([3.0 * wall_l / 8.0, wall_h / 2.0])
x2, y2 = get_2d_block(dx_f, fluid_l, fluid_h, f_center)
r2 = np.ones_like(x2) * r_f
m2 = r2 * dx_f * dx_f
h2 = np.ones_like(x2) * dx_f * hdx
cs2 = np.zeros_like(x2)
rad2 = np.ones_like(x2) * dx_f
fluid = get_particle_array(name='fluid', x=x2, y=y2, h=h2, rho=r2, m=m2,
cs=cs2, rad_s=rad2)
center1 = np.array([wall_l / 8.0 + cube_s / 2.0,
wall_h / 4.0 + cube_s / 2.0])
cube1_x, cube1_y = get_2d_block(dx_s, cube_s, cube_s, center1)
b1 = np.zeros_like(cube1_x, dtype=int)
center2 = np.array([3.0 * wall_l / 4.0 + cube_s / 2.0 + 3.0 * dx_s,
wall_h + cube_s / 2.0 + (num_layers + 1) * dx_s])
cube2_x, cube2_y = get_2d_block(dx_s, cube_s, cube_s, center2)
b2 = np.ones_like(cube2_x, dtype=int)
b = np.concatenate([b1, b2])
x3 = np.concatenate([cube1_x, cube2_x])
y3 = np.concatenate([cube1_y, cube2_y])
r3 = np.ones_like(x3) * r_s * 0.5
m3 = r3 * dx_s * dx_s
h3 = np.ones_like(x3) * dx_s * hdx
cs3 = np.zeros_like(x3)
rad3 = np.ones_like(x3) * dx_s
cube = get_particle_array_rigid_body(
name='cube', x=x3, y=y3, h=h3, cs=cs3, rho=r3, m=m3, rad_s=rad3,
body_id=b)
remove_overlap_particles(fluid, wall, dx_s, 2)
return fluid, wall, cube
def get_tsunami_geometry(dx_solid=0.01, dx_fluid=0.01, r_solid=100.0,
r_fluid=100.0, hdx=1.3, l_wall=9.5, h_wall=4.0,
angle=26.565051, h_fluid=3.5, l_obstacle=0.91,
flat_l=2.25):
x1, y1, x2, y2 = get_beach_geometry_2d(dx_solid, l_wall, h_wall, flat_l,
angle, 4)
wall_x = np.concatenate([x1, x2])
wall_y = np.concatenate([y1, y2])
r_wall = np.ones_like(wall_x) * r_solid
m_wall = r_wall * dx_solid * dx_solid
h_w = np.ones_like(wall_x) * dx_solid * hdx
wall = get_particle_array(name='wall', x=wall_x, y=wall_y, h=h_w,
rho=r_wall, m=m_wall)
theta = np.pi * angle / 180.0
h_obstacle = l_obstacle * np.tan(theta)
obstacle_x1, obstacle_y1 = get_2d_block(dx_solid, l_obstacle, h_obstacle)
obstacle_x = []
obstacle_y = []
for x, y in zip(obstacle_x1, obstacle_y1):
if (y >= (-x * np.tan(theta))):
obstacle_x.append(x)
obstacle_y.append(y)
x_translate = (l_wall - flat_l) * 0.8
y_translate = x_translate * np.tan(theta)
obstacle_x = np.asarray(obstacle_x) - x_translate
obstacle_y = np.asarray(obstacle_y) + y_translate + dx_solid
h_obstacle = np.ones_like(obstacle_x) * dx_solid * hdx
r_obstacle = np.ones_like(obstacle_x) * r_solid
m_obstacle = r_obstacle * dx_solid * dx_solid
obstacle = get_particle_array(name='obstacle', x=obstacle_x,
y=obstacle_y, rho=r_obstacle,
m=m_obstacle, h=h_obstacle)
fluid_center = np.array([flat_l - l_wall / 2.0, h_fluid / 2.0])
x_fluid, y_fluid = get_2d_block(dx_fluid, l_wall, h_fluid, fluid_center)
x3 = []
y3 = []
for i, xi in enumerate(x_fluid):
if y_fluid[i] >= np.tan(-theta) * xi:
x3.append(xi)
y3.append(y_fluid[i])
fluid_x = np.array(x3)
fluid_y = np.array(y3)
h_f = np.ones_like(fluid_x) * dx_fluid * hdx
r_f = np.ones_like(fluid_x) * r_fluid
m_f = r_f * dx_fluid * dx_fluid
fluid = get_particle_array(name='fluid', x=fluid_x, y=fluid_y,
h=h_f, m=m_f, rho=r_f)
remove_overlap_particles(fluid, obstacle, dx_solid * 1.1, 2)
remove_overlap_particles(fluid, wall, dx_solid * 1.1, 2)
return fluid, wall, obstacle
def create_particles(self):
fluid_x, fluid_y = get_2d_block(
dx=dx, length=Lx, height=Ly, center=np.array([0., 0.]))
rho_fluid = np.ones_like(fluid_x) * rho0
m_fluid = rho_fluid * volume
h_fluid = np.ones_like(fluid_x) * h0
cs_fluid = np.ones_like(fluid_x) * c0
wall_x, wall_y = get_2d_block(
dx=dx, length=Lx+6*dx, height=Ly+6*dx, center=np.array([0., 0.]))
rho_wall = np.ones_like(wall_x) * rho0
m_wall = rho_wall * volume
h_wall = np.ones_like(wall_x) * h0
cs_wall = np.ones_like(wall_x) * c0
additional_props = ['V', 'color', 'scolor', 'cx', 'cy', 'cz',
'cx2', 'cy2', 'cz2', 'nx', 'ny', 'nz', 'ddelta',
'uhat', 'vhat', 'what', 'auhat', 'avhat', 'awhat',
'ax', 'ay', 'az', 'wij', 'vmag2', 'N', 'wij_sum',
'rho0', 'u0', 'v0', 'w0', 'x0', 'y0', 'z0',
'kappa', 'arho', 'nu', 'wg', 'ug', 'vg',
'pi00', 'pi01', 'pi10', 'pi11', 'alpha']
consts = {'max_ddelta': np.zeros(1, dtype=float)}
fluid = get_particle_array(
name='fluid', x=fluid_x, y=fluid_y, h=h_fluid, m=m_fluid,
rho=rho_fluid, cs=cs_fluid, additional_props=additional_props)
for i in range(len(fluid.x)):
if (fluid.x[i]*fluid.x[i] + fluid.y[i]*fluid.y[i]) < 0.04:
fluid.color[i] = 1.0
else:
fluid.color[i] = 0.0
fluid.alpha[:] = sigma
wall = get_particle_array(
name='wall', x=wall_x, y=wall_y, h=h_wall, m=m_wall,
rho=rho_wall, cs=cs_wall, additional_props=additional_props)
wall.color[:] = 0.0
remove_overlap_particles(wall, fluid, dx_solid=dx, dim=2)
fluid.add_output_arrays(['V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta',
'kappa', 'N', 'scolor', 'p'])
wall.add_output_arrays(['V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta',
'kappa', 'N', 'scolor', 'p'])
for i in range(len(fluid.x)):
R = sqrt(r(fluid.x[i], fluid.y[i]) + 0.0001*fluid.h[i]*fluid.h[i])
fluid.u[i] = v0*fluid.x[i] * \
(1.0 - (fluid.y[i]*fluid.y[i])/(r0*R))*np.exp(-R/r0)/r0
fluid.v[i] = -v0*fluid.y[i] * \
(1.0 - (fluid.x[i]*fluid.x[i])/(r0*R))*np.exp(-R/r0)/r0
fluid.nu[:] = nu0
return [fluid, wall]
def create_particles(self):
dx = self.dx
h0 = self.h0
volume = dx * dx
m = rho * volume
xt, yt = get_2d_tank(dx=dx,
length=L,
height=0.2 * L,
num_layers=n_layers,
base_center=[L / 2, -dx])
xf, yf = get_2d_block(dx=dx,
length=L - 2 * dx,
height=h,
center=[L / 2, h / 2])
fluid = get_particle_array(name='fluid',
x=xf,
y=yf,
h=h0,
m=m,
rho=rho)
solid = get_particle_array(name='solid',
x=xt,
y=yt,
h=h0,
m=m,
rho=rho)
fluid.u = -amp * omega * np.ones_like(xf)
self.scheme.setup_properties([fluid, solid])
particles = [fluid, solid]
return particles
def setUp(self):
self.l = l = 1.0
n = 20
dx = l / n
hdx = 1.5
x, y, z = G.get_3d_block(dx, l, l, l)
h = np.ones_like(x) * hdx * dx
m = np.ones_like(x) * dx * dx * dx
V = np.zeros_like(x)
fluid = get_particle_array(name='fluid', x=x, y=y, z=z, h=h, m=m, V=V)
x, y = G.get_2d_block(dx, l, l)
z = np.ones_like(x) * (l + 5 * dx) / 2.0
z = np.concatenate([z, -z])
x = np.tile(x, 2)
y = np.tile(y, 2)
m = np.ones_like(x) * dx * dx * dx
h = np.ones_like(x) * hdx * dx
V = np.zeros_like(x)
channel = get_particle_array(name='channel',
x=x,
y=y,
z=z,
h=h,
m=m,
V=V)
self.particles = [fluid, channel]
self.kernel = get_compiled_kernel(Gaussian(dim=3))
def create_particles(self):
dx = self.dx
h0 = self.hdx * self.dx
m = rho * dx * dx
xt, yt = get_2d_tank(dx=dx,
length=length,
height=h_tank,
num_layers=n_layers,
base_center=[0.0, -dx])
xf, yf = get_2d_block(dx=dx,
length=length - 2 * dx,
height=h_liquid,
center=[0.0, h_liquid * 0.5])
fluid = get_particle_array(name='fluid',
x=xf,
y=yf,
h=h0,
m=m,
rho=rho)
solid = get_particle_array(name='solid',
x=xt,
y=yt,
h=h0,
m=m,
rho=rho)
self.scheme.setup_properties([fluid, solid])
particles = [fluid, solid]
return particles
def get_wavespaddle_geometry(hdx=1.,
dx_f=0.02,
dx_s=0.02,
r_f=100.,
r_s=100.,
length=13.,
height=0.8,
flat_l=1.48,
h_fluid=0.43,
angle=2.8624):
x1, y1, x2, y2 = get_beach_geometry_2d(dx_s, length, height, flat_l, angle,
3)
theta = np.pi * angle / 180.0
p1x = flat_l - 9.605
p1y = 0.40625
p2x = flat_l - 10.065
p2y = 0.6085
theta1 = np.arctan((p2y - p1y) / (p2x - p1x))
p3x = flat_l - 10.28
p3y = 0.6085
theta2 = np.arctan((p3y - p2y) / (p3x - p2x))
p4x = flat_l - 10.62
p4y = 0.457
theta3 = np.arctan((p4y - p3y) / (p4x - p3x))
obs_x1 = np.arange(p2x, p1x, dx_s / 2.0)
obs_y1 = p1y + (obs_x1 - p1x) * np.tan(theta1)
obs_x2 = np.arange(p3x, p2x, dx_s / 2.0)
obs_y2 = p2y + (obs_x2 - p2x) * np.tan(-theta2)
obs_x3 = np.arange(p4x, p3x, dx_s / 2.0)
obs_y3 = p3y + (obs_x3 - p3x) * np.tan(theta3)
x1 = np.concatenate([x1, obs_x1, obs_x2, obs_x3])
y1 = np.concatenate([y1, obs_y1, obs_y2, obs_y3])
r1 = np.ones_like(x1) * r_s
m1 = r1 * dx_s * dx_s
h1 = np.ones_like(x1) * hdx * dx_s
wall = get_particle_array(name='wall', x=x1, y=y1, rho=r1, m=m1, h=h1)
r2 = np.ones_like(x2) * r_s
m2 = r2 * dx_s * dx_s
h2 = np.ones_like(x2) * hdx * dx_s
paddle = get_particle_array(name='paddle', x=x2, y=y2, rho=r2, m=m2, h=h2)
fluid_center = np.array([flat_l - length / 2.0, h_fluid / 2.0])
x_fluid, y_fluid = get_2d_block(dx_f, length, h_fluid, fluid_center)
x3 = []
y3 = []
for i, xi in enumerate(x_fluid):
if y_fluid[i] >= np.tan(-theta) * xi:
x3.append(xi)
y3.append(y_fluid[i])
x3 = np.array(x3)
y3 = np.array(y3)
r3 = np.ones_like(x3) * r_f
m3 = r3 * dx_f * dx_f
h3 = np.ones_like(x3) * hdx * dx_f
fluid = get_particle_array(name='fluid', x=x3, y=y3, rho=r3, m=m3, h=h3)
remove_overlap_particles(fluid, wall, dx_s, 2)
remove_overlap_particles(fluid, paddle, dx_s, 2)
return fluid, wall, paddle
def get_dam_geometry(dx_tank=0.03,
dx_fluid=0.03,
r_tank=100.0,
h_f=2.0,
l_f=1.0,
r_fluid=100.0,
hdx=1.5,
l_tank=4.0,
h_tank=4.0,
h_f2=1.0):
tank_x, tank_y = get_2d_tank(dx_tank,
length=l_tank,
height=h_tank,
num_layers=4)
rho_tank = np.ones_like(tank_x) * r_tank
m_tank = rho_tank * dx_tank * dx_tank
h_t = np.ones_like(tank_x) * dx_tank * hdx
tank = get_particle_array(name='dam',
x=tank_x,
y=tank_y,
h=h_t,
rho=rho_tank,
m=m_tank)
center = np.array([(l_f - l_tank) / 2.0, h_f / 2.0])
fluid_x1, fluid_y1 = get_2d_block(dx_fluid, l_f, h_f, center)
center = np.array([l_f / 2.0, h_f2 / 2.0])
fluid_x2, fluid_y2 = get_2d_block(dx_fluid, l_tank - l_f - 2.0 * dx_fluid,
h_f2, center)
fluid_x = np.concatenate([fluid_x1, fluid_x2])
fluid_y = np.concatenate([fluid_y1, fluid_y2])
h_fluid = np.ones_like(fluid_x) * dx_fluid * hdx
r_f = np.ones_like(fluid_x) * r_fluid
m_f = r_f * dx_fluid * dx_fluid
fluid = get_particle_array(name='fluid',
x=fluid_x,
y=fluid_y,
h=h_fluid,
rho=r_f,
m=m_f)
remove_overlap_particles(fluid, tank, dx_tank, 2)
return fluid, tank
def test_get_2d_block(self):
dx = (10.0)**(np.random.uniform(-2, -1))
center = np.random.random_sample(2)
length = np.random.randint(50, 200) * dx
height = np.random.randint(50, 200) * dx
x, y = get_2d_block(dx, length, height, center)
len_x = max(x) - min(x)
len_y = max(y) - min(y)
new_center = np.array([(max(x) + min(x)) / 2.0,
(max(y) + min(y)) / 2.0])
self.assertAlmostEqual(len_x, length)
self.assertAlmostEqual(len_y, height)
assert np.allclose(new_center, center)
def test_get_2d_block(self):
dx = 0.05
length = 5.0
height = 4.0
center = np.array([0.4, 10.3])
x, y = G.get_2d_block(dx, length, height, center)
len_x = max(x) - min(x)
len_y = max(y) - min(y)
new_center = np.array([(max(x) + min(x)) / 2.0,
(max(y) + min(y)) / 2.0])
assert len_x == pytest.approx(length)
assert len_y == pytest.approx(height)
assert np.allclose(new_center, center)
def create_particles(self):
if self.options.staggered_grid:
nboundary_layers = 2
nfluid_offset = 2
wall_hex_pack = True
else:
nboundary_layers = 4
nfluid_offset = 1
wall_hex_pack = False
xt, yt = get_2d_tank(dx=self.dx, length=container_width,
height=container_height, base_center=[2, 0],
num_layers=nboundary_layers)
xf, yf = get_2d_block(dx=self.dx, length=fluid_column_width,
height=fluid_column_height, center=[0.5, 1])
xf += self.dx
yf += self.dx
fluid = get_particle_array(name='fluid', x=xf, y=yf, h=h, m=m, rho=ro)
boundary = get_particle_array(name='boundary', x=xt, y=yt, h=h, m=m,
rho=ro)
self.scheme.setup_properties([fluid, boundary])
if self.options.scheme == 'iisph':
# the default position tends to cause the particles to be pushed
# away from the wall, so displacing it by a tiny amount helps.
fluid.x += self.dx / 4
# Adding extra properties for kernel correction
corr = self.kernel_corr
if corr == 'kernel-corr' or corr == 'mixed-corr':
fluid.add_property('cwij')
boundary.add_property('cwij')
if corr == 'mixed-corr' or corr == 'grad-corr':
fluid.add_property('m_mat', stride=9)
boundary.add_property('m_mat', stride=9)
elif corr == 'crksph':
fluid.add_property('ai')
boundary.add_property('ai')
fluid.add_property('gradbi', stride=9)
boundary.add_property('gradbi', stride=9)
for prop in ['gradai', 'bi']:
fluid.add_property(prop, stride=3)
boundary.add_property(prop, stride=3)
return [fluid, boundary]
def create_particles(self):
if self.options.staggered_grid:
nboundary_layers = 2
nfluid_offset = 2
wall_hex_pack = True
else:
nboundary_layers = 4
nfluid_offset = 1
wall_hex_pack = False
xt, yt = get_2d_tank(dx=self.dx,
length=container_width,
height=container_height,
base_center=[container_width / 2, 0],
num_layers=nboundary_layers)
xf, yf = get_2d_block(
dx=self.dx,
length=fluid_column_width,
height=fluid_column_height,
center=[fluid_column_width / 2, fluid_column_height / 2])
xf += self.dx
yf += self.dx
fluid = get_particle_array(name='fluid', x=xf, y=yf, h=h, m=m, rho=ro)
boundary = get_particle_array(name='boundary',
x=xt,
y=yt,
h=h,
m=m,
rho=ro)
self.scheme.setup_properties([fluid, boundary])
if self.options.scheme == 'iisph':
# the default position tends to cause the particles to be pushed
# away from the wall, so displacing it by a tiny amount helps.
fluid.x += self.dx / 4
self.kernel_corrections(fluid, boundary)
return [fluid, boundary]
def create_particles(self):
fluid_x, fluid_y = get_2d_block(dx=dx,
length=Lx - dx,
height=Ly - dx,
center=np.array([0., 0.5 * Ly]))
rho_fluid = np.ones_like(fluid_x) * rho0
m_fluid = rho_fluid * volume
h_fluid = np.ones_like(fluid_x) * h0
cs_fluid = np.ones_like(fluid_x) * c0
additional_props = [
'V', 'color', 'scolor', 'cx', 'cy', 'cz', 'cx2', 'cy2', 'cz2',
'nx', 'ny', 'nz', 'ddelta', 'uhat', 'vhat', 'what', 'auhat',
'avhat', 'awhat', 'ax', 'ay', 'az', 'wij', 'vmag2', 'N', 'wij_sum',
'rho0', 'u0', 'v0', 'w0', 'x0', 'y0', 'z0', 'kappa', 'arho', 'nu',
'pi00', 'pi01', 'pi02', 'pi10', 'pi11', 'pi12', 'pi20', 'pi21',
'pi22'
]
fluid = get_particle_array(name='fluid',
x=fluid_x,
y=fluid_y,
h=h_fluid,
m=m_fluid,
rho=rho_fluid,
cs=cs_fluid,
additional_props=additional_props)
for i in range(len(fluid.x)):
if fluid.y[i] > 0.25 and fluid.y[i] < 0.75:
fluid.color[i] = 1.0
else:
fluid.color[i] = 0.0
fluid.V[:] = 1. / volume
fluid.add_output_arrays([
'V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta', 'kappa', 'N',
'scolor', 'p'
])
angles = np.random.random_sample((len(fluid.x), )) * 2 * np.pi
vel = np.sqrt(2 * KE / fluid.m)
fluid.u = vel
fluid.v = vel
fluid.nu[:] = 0.0
return [fluid]
def create_particles(self):
fluid_x, fluid_y = get_2d_block(dx=dx,
length=Lx - dx,
height=Ly - dx,
center=np.array([0., 0.]))
rho_fluid = np.ones_like(fluid_x) * rho1
m_fluid = rho_fluid * volume
h_fluid = np.ones_like(fluid_x) * h0
cs_fluid = np.ones_like(fluid_x) * c0
additional_props = [
'V', 'color', 'scolor', 'cx', 'cy', 'cz', 'cx2', 'cy2', 'cz2',
'nx', 'ny', 'nz', 'ddelta', 'uhat', 'vhat', 'what', 'auhat',
'avhat', 'awhat', 'ax', 'ay', 'az', 'wij', 'vmag2', 'N', 'wij_sum',
'rho0', 'u0', 'v0', 'w0', 'x0', 'y0', 'z0', 'kappa', 'arho', 'nu'
]
consts = {'max_ddelta': np.zeros(1, dtype=float)}
fluid = get_particle_array(name='fluid',
x=fluid_x,
y=fluid_y,
h=h_fluid,
m=m_fluid,
rho=rho_fluid,
cs=cs_fluid,
additional_props=additional_props,
constants=consts)
for i in range(len(fluid.x)):
if (fluid.x[i] * fluid.x[i] + fluid.y[i] * fluid.y[i]) < 0.0625:
fluid.color[i] = 1.0
else:
fluid.color[i] = 0.0
fluid.V[:] = 1. / volume
fluid.add_output_arrays([
'V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta', 'kappa', 'N',
'scolor', 'p'
])
# angles = np.random.random_sample((len(fluid.x),))*2*np.pi
# vel = np.sqrt(2 * KE / fluid.m)
# fluid.u = vel*2.0*np.cos(angles)
# fluid.v = vel*2.0*np.sin(angles)
fluid.nu[:] = nu0
return [fluid]
def create_particles(self):
fluid_x, fluid_y = get_2d_block(dx=dx,
length=Lx - dx,
height=Ly - dx,
center=np.array([0., 0.]))
rho_fluid = np.ones_like(fluid_x) * rho0
m_fluid = rho_fluid * volume
h_fluid = np.ones_like(fluid_x) * h0
cs_fluid = np.ones_like(fluid_x) * c0
additional_props = [
'V', 'color', 'scolor', 'cx', 'cy', 'cz', 'cx2', 'cy2', 'cz2',
'nx', 'ny', 'nz', 'ddelta', 'uhat', 'vhat', 'what', 'auhat',
'avhat', 'awhat', 'ax', 'ay', 'az', 'wij', 'vmag2', 'N', 'wij_sum',
'rho0', 'u0', 'v0', 'w0', 'x0', 'y0', 'z0', 'kappa', 'arho', 'nu',
'pi00', 'pi01', 'pi02', 'pi10', 'pi11', 'pi12', 'pi20', 'pi21',
'pi22', 'alpha'
]
fluid = get_particle_array(name='fluid',
x=fluid_x,
y=fluid_y,
h=h_fluid,
m=m_fluid,
rho=rho_fluid,
cs=cs_fluid,
additional_props=additional_props)
fluid.alpha[:] = sigma
for i in range(len(fluid.x)):
if (fluid.x[i] * fluid.x[i] + fluid.y[i] * fluid.y[i]) < 0.0625:
fluid.color[i] = 1.0
else:
fluid.color[i] = 0.0
fluid.V[:] = 1. / volume
fluid.add_output_arrays([
'V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta', 'kappa', 'N',
'scolor', 'p'
])
fluid.nu[:] = nu
return [fluid]
def get_wavespaddle_geometry(hdx=1.5,
dx_f=0.1,
dx_s=0.1,
r_f=100.,
r_s=100.,
length=3.75,
height=0.3,
flat_l=1.,
angle=4.2364,
h_fluid=0.2):
x1, y1, x2, y2 = get_beach_geometry_2d(dx_s, length, height, flat_l, angle,
5)
r1 = np.ones_like(x1) * r_s
m1 = r1 * dx_s * dx_s
h1 = np.ones_like(x1) * hdx * dx_s
wall = get_particle_array(name='wall', x=x1, y=y1, rho=r1, m=m1, h=h1)
r2 = np.ones_like(x2) * r_s
m2 = r2 * dx_s * dx_s
h2 = np.ones_like(x2) * hdx * dx_s
paddle = get_particle_array(name='paddle', x=x2, y=y2, rho=r2, m=m2, h=h2)
fluid_center = np.array([flat_l - length / 2.0, h_fluid / 2.0])
x_fluid, y_fluid = get_2d_block(dx_f, length, h_fluid, fluid_center)
x3 = []
y3 = []
theta = np.pi * angle / 180.0
for i, xi in enumerate(x_fluid):
if y_fluid[i] >= np.tan(-theta) * xi:
x3.append(xi)
y3.append(y_fluid[i])
x3 = np.array(x3)
y3 = np.array(y3)
r3 = np.ones_like(x3) * r_f
m3 = r3 * dx_f * dx_f
h3 = np.ones_like(x3) * hdx * dx_f
fluid = get_particle_array(name='fluid', x=x3, y=y3, rho=r3, m=m3, h=h3)
remove_overlap_particles(fluid, wall, dx_s, 2)
remove_overlap_particles(fluid, paddle, dx_s, 2)
return fluid, wall, paddle
def test_remove_overlap_particles(self):
dx_1 = 0.1
dx_2 = 0.15
length = 4.5
height = 3.0
radius = 2.0
x1, y1 = G.get_2d_block(dx_1, length, height)
x2, y2 = G.get_2d_circle(dx_2, radius)
r1 = np.ones_like(x1) * 100.0
m1 = r1 * dx_1 * dx_1
h1 = np.ones_like(x1) * dx_1 * 1.5
fluid = get_particle_array(name='fluid',
x=x1,
y=y1,
h=h1,
rho=r1,
m=m1)
r2 = np.ones_like(x2) * 100.0
m2 = r2 * dx_2 * dx_2
h2 = np.ones_like(x2) * dx_2 * 1.5
solid = get_particle_array(name='solid',
x=x2,
y=y2,
h=h2,
rho=r2,
m=m2)
G.remove_overlap_particles(fluid, solid, dx_2, 2)
x1 = fluid.x
y1 = fluid.y
count = 0
for i in range(len(x1)):
point = np.array([x1[i], y1[i]])
dist = G.distance_2d(point)
if dist <= radius:
count += 1
assert count == 0
def get_dam_geometry(dx_tank=0.03,
dx_fluid=0.03,
r_tank=100.0,
h_f=2.0,
l_f=1.0,
r_fluid=100.0,
hdx=1.5,
l_tank=4.0,
h_tank=4.0):
tank_x, tank_y = get_2d_tank(dx_tank,
length=l_tank,
height=h_tank,
num_layers=5)
rho_tank = np.ones_like(tank_x) * r_tank
m_tank = rho_tank * dx_tank * dx_tank
h_t = np.ones_like(tank_x) * dx_tank * hdx
tank = get_particle_array(name='dam',
x=tank_x,
y=tank_y,
h=h_t,
rho=rho_tank,
m=m_tank)
center = np.array([(l_f - l_tank) / 2.0, h_f / 2.0])
fluid_x, fluid_y = get_2d_block(dx_fluid, l_f, h_f, center)
fluid_x += dx_tank
fluid_y += dx_tank
h_fluid = np.ones_like(fluid_x) * dx_fluid * hdx
r_f = np.ones_like(fluid_x) * r_fluid
m_f = r_f * dx_fluid * dx_fluid
fluid = get_particle_array(name='fluid',
x=fluid_x,
y=fluid_y,
h=h_fluid,
rho=r_f,
m=m_f)
return fluid, tank
def test_remove_overlap_particles(self):
dx_1 = (10)**(np.random.randint(-2, -1))
dx_2 = (10)**(np.random.randint(-2, -1))
length = np.random.randint(20, 40) * dx_1
height = np.random.randint(20, 40) * dx_1
radius = np.random.randint(20, 40) * dx_2
x1, y1 = get_2d_block(dx_1, length, height)
x2, y2 = get_2d_circle(dx_2, radius)
r1 = np.ones_like(x1) * 100.0
m1 = r1 * dx_1 * dx_1
h1 = np.ones_like(x1) * dx_1 * 1.5
fluid = get_particle_array(name='fluid',
x=x1,
y=y1,
h=h1,
rho=r1,
m=m1)
r2 = np.ones_like(x2) * 100.0
m2 = r2 * dx_2 * dx_2
h2 = np.ones_like(x2) * dx_2 * 1.5
solid = get_particle_array(name='solid',
x=x2,
y=y2,
h=h2,
rho=r2,
m=m2)
remove_overlap_particles(fluid, solid, dx_2, 2)
x1 = fluid.x
y1 = fluid.y
count = 0
for i in range(len(x1)):
point = np.array([x1[i], y1[i]])
dist = distance_2d(point)
if dist <= radius:
count += 1
assert count == 0
def get_wavespaddle_geometry(hdx=1.5,
dx_f=0.1,
dx_s=0.05,
r_f=100.,
r_s=100.,
length=3.75,
height=0.3,
flat_l=1.,
angle=4.2364,
h_fluid=0.2,
obstacle_side=0.06):
x1, y1, x2, y2 = get_beach_geometry_2d(dx_s, length, height, flat_l, angle,
3)
r1 = np.ones_like(x1) * r_s
m1 = r1 * dx_s * dx_s
h1 = np.ones_like(x1) * hdx * dx_s
cs1 = np.zeros_like(x1)
rad1 = np.ones_like(x1) * dx_s
wall = get_particle_array(name='wall',
x=x1,
y=y1,
rho=r1,
m=m1,
h=h1,
cs=cs1,
rad_s=rad1)
r2 = np.ones_like(x2) * r_s
m2 = r2 * dx_s * dx_s
h2 = np.ones_like(x2) * hdx * dx_s
paddle = get_particle_array(name='paddle', x=x2, y=y2, rho=r2, m=m2, h=h2)
fluid_center = np.array([flat_l - length / 2.0, h_fluid / 2.0])
x_fluid, y_fluid = get_2d_block(dx_f, length, h_fluid, fluid_center)
x3 = []
y3 = []
theta = np.pi * angle / 180.0
for i, xi in enumerate(x_fluid):
if y_fluid[i] >= np.tan(-theta) * xi:
x3.append(xi)
y3.append(y_fluid[i])
x3 = np.array(x3)
y3 = np.array(y3)
r3 = np.ones_like(x3) * r_f
m3 = r3 * dx_f * dx_f
h3 = np.ones_like(x3) * hdx * dx_f
cs3 = np.zeros_like(x3)
rad3 = np.ones_like(x3) * dx_f
fluid = get_particle_array(name='fluid', x=x3, y=y3, rho=r3, m=m3, h=h3)
square_center = np.array([-0.38, 0.16])
x4, y4 = get_2d_block(dx_s, obstacle_side, obstacle_side, square_center)
b1 = np.zeros_like(x4, dtype=int)
square_center = np.array([-0.7, 0.16])
x5, y5 = get_2d_block(dx_s, obstacle_side, obstacle_side, square_center)
b2 = np.ones_like(x5, dtype=int)
square_center = np.array([-1.56, 0.22])
x6, y6 = get_2d_block(dx_s, obstacle_side, obstacle_side, square_center)
b3 = np.ones_like(x5, dtype=int) * 2
b = np.concatenate([b1, b2, b3])
x4 = np.concatenate([x4, x5, x6])
y4 = np.concatenate([y4, y5, y6])
r4 = np.ones_like(x4) * r_s * 0.5
m4 = r4 * dx_s * dx_s
h4 = np.ones_like(x4) * hdx * dx_s
cs4 = np.zeros_like(x4)
rad4 = np.ones_like(x4) * dx_s
obstacle = get_particle_array_rigid_body(name='obstacle',
x=x4,
y=y4,
h=h4,
rho=r4,
m=m4,
cs=cs4,
rad_s=rad4,
body_id=b)
remove_overlap_particles(fluid, wall, dx_s, 2)
remove_overlap_particles(fluid, paddle, dx_s, 2)
remove_overlap_particles(fluid, obstacle, dx_s, 2)
return fluid, wall, paddle, obstacle
def windtunnel_airfoil_model(dx_wall=0.01,
dx_airfoil=0.01,
dx_fluid=0.01,
r_solid=100.0,
r_fluid=100.0,
airfoil='2412',
hdx=1.1,
chord=1.0,
h_tunnel=1.0,
l_tunnel=10.0):
"""
Generates a geometry which can be used for wind tunnel like simulations.
Parameters
----------
dx_wall : a number which is the dx of the wind tunnel wall
dx_airfoil : a number which is the dx of the airfoil used
dx_fluid : a number which is the dx of the fluid used
r_solid : a number which is the initial density of the solid particles
r_fluid : a number which is the initial density of the fluid particles
airfoil : 4 or 5 digit string which is the airfoil name
hdx : a number which is the hdx for the particle arrays
chord : a number which is the chord of the airfoil
h_tunnel : a number which is the height of the wind tunnel
l_tunnel : a number which is the length of the wind tunnel
Returns
-------
wall : pysph wcsph particle array for the wind tunnel walls
wing : pysph wcsph particle array for the airfoil
fluid : pysph wcsph particle array for the fluid
"""
wall_center_1 = np.array([0.0, h_tunnel / 2.])
wall_center_2 = np.array([0.0, -h_tunnel / 2.])
x_wall_1, y_wall_1 = get_2d_wall(dx_wall, wall_center_1, l_tunnel)
x_wall_2, y_wall_2 = get_2d_wall(dx_wall, wall_center_2, l_tunnel)
x_wall = np.concatenate([x_wall_1, x_wall_2])
y_wall = np.concatenate([y_wall_1, y_wall_2])
y_wall_1 = y_wall_1 + dx_wall
y_wall_2 = y_wall_2 - dx_wall
y_wall = np.concatenate([y_wall, y_wall_1, y_wall_2])
y_wall_1 = y_wall_1 + dx_wall
y_wall_2 = y_wall_2 - dx_wall
y_wall = np.concatenate([y_wall, y_wall_1, y_wall_2])
y_wall_1 = y_wall_1 + dx_wall
y_wall_2 = y_wall_2 - dx_wall
x_wall = np.concatenate([x_wall, x_wall, x_wall, x_wall])
y_wall = np.concatenate([y_wall, y_wall_1, y_wall_2])
h_wall = np.ones_like(x_wall) * dx_wall * hdx
rho_wall = np.ones_like(x_wall) * r_solid
mass_wall = rho_wall * dx_wall * dx_wall
wall = get_particle_array_wcsph(name='wall',
x=x_wall,
y=y_wall,
h=h_wall,
rho=rho_wall,
m=mass_wall)
if len(airfoil) == 4:
x_airfoil, y_airfoil = get_4digit_naca_airfoil(dx_airfoil, airfoil,
chord)
else:
x_airfoil, y_airfoil = get_5digit_naca_airfoil(dx_airfoil, airfoil,
chord)
x_airfoil = x_airfoil - 0.5
h_airfoil = np.ones_like(x_airfoil) * dx_airfoil * hdx
rho_airfoil = np.ones_like(x_airfoil) * r_solid
mass_airfoil = rho_airfoil * dx_airfoil * dx_airfoil
wing = get_particle_array_wcsph(name='wing',
x=x_airfoil,
y=y_airfoil,
h=h_airfoil,
rho=rho_airfoil,
m=mass_airfoil)
x_fluid, y_fluid = get_2d_block(dx_fluid, 1.6, h_tunnel)
h_fluid = np.ones_like(x_fluid) * dx_fluid * hdx
rho_fluid = np.ones_like(x_fluid) * r_fluid
mass_fluid = rho_fluid * dx_fluid * dx_fluid
fluid = get_particle_array_wcsph(name='fluid',
x=x_fluid,
y=y_fluid,
h=h_fluid,
rho=rho_fluid,
m=mass_fluid)
remove_overlap_particles(fluid, wall, dx_wall, 2)
remove_overlap_particles(fluid, wing, dx_airfoil, 2)
return wall, wing, fluid
def create_particles(self):
fluid_x, fluid_y = get_2d_block(dx=dx,
length=Lx,
height=Ly,
center=np.array([0., 0.]))
rho_fluid = np.ones_like(fluid_x) * rho2
m_fluid = rho_fluid * volume
h_fluid = np.ones_like(fluid_x) * h0
cs_fluid = np.ones_like(fluid_x) * c0
circle_x, circle_y = get_2d_circle(dx=dx,
r=0.2,
center=np.array([0.0, 0.0]))
rho_circle = np.ones_like(circle_x) * rho1
m_circle = rho_circle * volume
h_circle = np.ones_like(circle_x) * h0
cs_circle = np.ones_like(circle_x) * c0
wall_x, wall_y = get_2d_block(dx=dx,
length=Lx + 6 * dx,
height=Ly + 6 * dx,
center=np.array([0., 0.]))
rho_wall = np.ones_like(wall_x) * rho2
m_wall = rho_wall * volume
h_wall = np.ones_like(wall_x) * h0
cs_wall = np.ones_like(wall_x) * c0
additional_props = [
'V', 'color', 'scolor', 'cx', 'cy', 'cz', 'cx2', 'cy2', 'cz2',
'nx', 'ny', 'nz', 'ddelta', 'uhat', 'vhat', 'what', 'auhat',
'avhat', 'awhat', 'ax', 'ay', 'az', 'wij', 'vmag2', 'N', 'wij_sum',
'rho0', 'u0', 'v0', 'w0', 'x0', 'y0', 'z0', 'kappa', 'arho', 'nu',
'wg', 'ug', 'vg', 'pi00', 'pi01', 'pi10', 'pi11'
]
consts = {'max_ddelta': np.zeros(1, dtype=float)}
gas = get_particle_array(name='gas',
x=fluid_x,
y=fluid_y,
h=h_fluid,
m=m_fluid,
rho=rho_fluid,
cs=cs_fluid,
additional_props=additional_props,
constants=consts)
gas.nu[:] = nu2
gas.color[:] = 0.0
liquid = get_particle_array(name='liquid',
x=circle_x,
y=circle_y,
h=h_circle,
m=m_circle,
rho=rho_circle,
cs=cs_circle,
additional_props=additional_props,
constants=consts)
liquid.nu[:] = nu1
liquid.color[:] = 1.0
wall = get_particle_array(name='wall',
x=wall_x,
y=wall_y,
h=h_wall,
m=m_wall,
rho=rho_wall,
cs=cs_wall,
additional_props=additional_props)
wall.color[:] = 0.0
remove_overlap_particles(wall, liquid, dx_solid=dx, dim=2)
remove_overlap_particles(wall, gas, dx_solid=dx, dim=2)
remove_overlap_particles(gas, liquid, dx_solid=dx, dim=2)
gas.add_output_arrays([
'V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta', 'kappa', 'N',
'scolor', 'p'
])
liquid.add_output_arrays([
'V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta', 'kappa', 'N',
'scolor', 'p'
])
wall.add_output_arrays([
'V', 'color', 'cx', 'cy', 'nx', 'ny', 'ddelta', 'kappa', 'N',
'scolor', 'p'
])
for i in range(len(gas.x)):
R = sqrt(r(gas.x[i], gas.y[i]) + 0.0001 * gas.h[i] * gas.h[i])
gas.u[i] = v0 * gas.x[i] * (1.0 - (gas.y[i] * gas.y[i]) /
(r0 * R)) * np.exp(-R / r0) / r0
gas.v[i] = -v0 * gas.y[i] * (1.0 - (gas.x[i] * gas.x[i]) /
(r0 * R)) * np.exp(-R / r0) / r0
for i in range(len(liquid.x)):
R = sqrt(
r(liquid.x[i], liquid.y[i]) +
0.0001 * liquid.h[i] * liquid.h[i])
liquid.u[i] = v0*liquid.x[i] * \
(1.0 - (liquid.y[i]*liquid.y[i])/(r0*R))*np.exp(-R/r0)/r0
liquid.v[i] = -v0*liquid.y[i] * \
(1.0 - (liquid.x[i]*liquid.x[i])/(r0*R))*np.exp(-R/r0)/r0
return [liquid, gas, wall]
