def draw_curves(obst, theta_low, theta_high, rad, dx):
curves = []
for i, x_c in enumerate(obst):
for theta_l in theta_low[i]:
dtheta = (np.array(theta_high[i])-theta_l) % (2*np.pi)
theta_h = theta_l + dtheta.min()
rad_pts = rad_points(x_c, rad, dx,
theta_start=theta_l,
theta_stop=theta_h)
curves.append(rad_pts)
return curves
def method(Lx=6.,
Ly=4.,
Lx_inner=4.,
num_obstacles=32,
rad=0.2,
R=0.3,
dx=0.05,
seed=121,
do_plot=True,
**kwargs):
N = int(np.ceil(Lx / dx))
x_min, x_max = -Lx / 2, Lx / 2
y_min, y_max = -Ly / 2, Ly / 2
y = np.linspace(y_min, y_max, N).flatten()
pts = np.zeros((num_obstacles, 2))
diam2 = 4 * R**2
np.random.seed(seed)
for i in range(num_obstacles):
while True:
pt = (np.random.rand(2) - 0.5) * np.array([Lx_inner, Ly])
if i == 0:
break
dist = pts[:i, :] - np.outer(np.ones(i), pt)
for j in range(len(dist)):
if abs(dist[j, 1]) > Ly / 2:
dist[j, 1] = abs(dist[j, 1]) - Ly
dist2 = dist[:, 0]**2 + dist[:, 1]**2
if all(dist2 > diam2):
break
pts[i, :] = pt
pts = pts[pts[:, 0].argsort(), :]
obstacles = [tuple(row) for row in pts]
line_segments_top = []
line_segments_btm = []
x_prev = x_min
curve_segments_top = []
curve_segments_btm = []
interior_obstacles = []
exterior_obstacles = []
for x_c in obstacles:
# Close to the top of the domain
if x_c[1] > y_max - rad:
# identify intersection
theta = np.arcsin((y_max - x_c[1]) / rad)
rx = rad * np.cos(theta)
x_left = x_c[0] - rx
x_right = x_c[0] + rx
line_segments_top.append(
line_points((x_prev, y_max), (x_left, y_max), dx))
line_segments_btm.append(
line_points((x_prev, y_min), (x_left, y_min), dx))
curve_btm = rad_points((x_c[0], x_c[1] - Ly),
rad,
dx,
theta_start=np.pi - theta,
theta_stop=theta)[1:-1]
curve_top = rad_points(x_c,
rad,
dx,
theta_start=np.pi - theta,
theta_stop=2 * np.pi + theta)[1:-1]
curve_segments_btm.append(curve_btm)
curve_segments_top.append(curve_top)
x_prev = x_right
exterior_obstacles.append(x_c)
exterior_obstacles.append((x_c[0], x_c[1] - Ly))
# Close to the bottom of the domain
elif x_c[1] < y_min + rad:
# identify intersection
theta = np.arcsin((-y_min + x_c[1]) / rad)
rx = rad * np.cos(theta)
x_left = x_c[0] - rx
x_right = x_c[0] + rx
line_segments_top.append(
line_points((x_prev, y_max), (x_left, y_max), dx))
line_segments_btm.append(
line_points((x_prev, y_min), (x_left, y_min), dx))
curve_btm = rad_points(x_c,
rad,
dx,
theta_start=np.pi + theta,
theta_stop=-theta)[1:-1]
curve_top = rad_points((x_c[0], x_c[1] + Ly),
rad,
dx,
theta_start=np.pi + theta,
theta_stop=2 * np.pi - theta)[1:-1]
curve_segments_btm.append(curve_btm)
curve_segments_top.append(curve_top)
x_prev = x_right
exterior_obstacles.append(x_c)
exterior_obstacles.append((x_c[0], x_c[1] + Ly))
else:
interior_obstacles.append(x_c)
line_segments_top.append(line_points((x_prev, y_max), (x_max, y_max), dx))
line_segments_btm.append(line_points((x_prev, y_min), (x_max, y_min), dx))
assert (len(line_segments_top) == len(curve_segments_top) + 1)
assert (len(line_segments_btm) == len(curve_segments_btm) + 1)
pts_top = line_segments_top[0]
for i in range(len(curve_segments_top)):
pts_top.extend(curve_segments_top[i])
pts_top.extend(line_segments_top[i + 1])
pts_top = pts_top[::-1]
pts_btm = line_segments_btm[0]
for i in range(len(curve_segments_btm)):
pts_btm.extend(curve_segments_btm[i])
pts_btm.extend(line_segments_btm[i + 1])
y_side = y[1:-1]
pts_right = zip(x_max * np.ones(N - 2), y_side)
pts_left = zip(x_min * np.ones(N - 2), y_side[::-1])
pts = pts_btm + pts_right + pts_top + pts_left
edges = round_trip_connect(0, len(pts) - 1)
for interior_obstacle in interior_obstacles:
pts_obstacle = rad_points(interior_obstacle, rad, dx)[1:]
edges_obstacle = round_trip_connect(len(pts),
len(pts) + len(pts_obstacle) - 1)
pts.extend(pts_obstacle)
edges.extend(edges_obstacle)
if do_plot:
plot_edges(pts, edges)
mi = tri.MeshInfo()
mi.set_points(pts)
mi.set_facets(edges)
mi.set_holes(interior_obstacles)
max_area = 0.5 * dx**2
mesh = tri.build(mi,
max_volume=max_area,
min_angle=25,
allow_boundary_steiner=False)
coords = np.array(mesh.points)
faces = np.array(mesh.elements)
# pp = [tuple(point) for point in mesh.points]
# print "Number of points:", len(pp)
# print "Number unique points:", len(set(pp))
if do_plot:
plot_faces(coords, faces)
msh = numpy_to_dolfin(coords, faces)
mesh_path = os.path.join(
MESHES_DIR, "periodic_porous_Lx{}_Ly{}_rad{}_N{}_dx{}".format(
Lx, Ly, rad, num_obstacles, dx))
store_mesh_HDF5(msh, mesh_path)
obstacles_path = os.path.join(
MESHES_DIR, "periodic_porous_Lx{}_Ly{}_rad{}_N{}_dx{}.dat".format(
Lx, Ly, rad, num_obstacles, dx))
all_obstacles = np.vstack(
(np.array(exterior_obstacles), np.array(interior_obstacles)))
np.savetxt(
obstacles_path,
np.hstack((all_obstacles, np.ones((len(all_obstacles), 1)) * rad)))
if do_plot:
df.plot(msh)
df.interactive()
def method(Lx=4.,
Ly=4.,
num_obstacles=25,
rad=0.25,
R=0.3,
dx=0.05,
seed=123,
show=False,
**kwargs):
x_min, x_max = -Lx / 2, Lx / 2
y_min, y_max = -Ly / 2, Ly / 2
np.random.seed(seed)
obstacles = place_obstacles(num_obstacles, Lx, Ly, R)
obstacles = correct_obstacles(obstacles, rad, x_min, x_max, y_min, y_max)
interior_obstacles, exterior_obstacles, obst = classify_obstacles(
obstacles, rad, x_min, x_max, y_min, y_max)
theta_low, theta_high = compute_intersections(obst, rad, x_min, x_max,
y_min, y_max)
curves = draw_curves(obst, theta_low, theta_high, rad, dx)
if len(curves) > 0:
curve_start, curve_stop = get_curve_intersection_points(
curves, x_min, x_max, y_min, y_max)
segments = construct_segments(curve_start, curve_stop, x_min, x_max,
y_min, y_max)
pt_start = curves[0][0]
else:
curve_start = []
curve_stop = []
segments = [((x_min, y_min), (x_max, y_min)),
((x_max, y_min), (x_max, y_max)),
((x_max, y_max), (x_min, y_max)),
((x_min, y_max), (x_min, y_min))]
segments = dict(segments)
pt_start = (x_min, y_min)
if show:
for x_a, x_b in segments.items():
x = np.array([x_a[0], x_b[0]])
y = np.array([x_a[1], x_b[1]])
plt.quiver(x[:-1],
y[:-1],
x[1:] - x[:-1],
y[1:] - y[:-1],
scale_units='xy',
angles='xy',
scale=1)
for curve in curves:
x = np.array(curve)
plt.quiver(x[:-1, 0],
x[:-1, 1],
x[1:, 0] - x[:-1, 0],
x[1:, 1] - x[:-1, 1],
scale_units='xy',
angles='xy',
scale=1)
pts = discretize_loop(pt_start, curve_start, curves, segments, dx)[::-1]
plt.show()
edges = round_trip_connect(0, len(pts) - 1)
for interior_obstacle in interior_obstacles:
pts_obstacle = rad_points(interior_obstacle, rad, dx)[1:]
edges_obstacle = round_trip_connect(len(pts),
len(pts) + len(pts_obstacle) - 1)
pts.extend(pts_obstacle)
edges.extend(edges_obstacle)
if show:
plot_edges(pts, edges)
mi = tri.MeshInfo()
mi.set_points(pts)
mi.set_facets(edges)
mi.set_holes(interior_obstacles)
max_area = 0.5 * dx**2
mesh = tri.build(mi,
max_volume=max_area,
min_angle=25,
allow_boundary_steiner=False)
coords = np.array(mesh.points)
faces = np.array(mesh.elements)
pp = [tuple(point) for point in mesh.points]
info("Number of points: {}".format(len(pp)))
info("Number unique points: {}".format(len(set(pp))))
if show:
plot_faces(coords, faces)
msh = numpy_to_dolfin(coords, faces)
mesh_path = os.path.join(
MESHES_DIR, "periodic_porous_Lx{}_Ly{}_rad{}_N{}_dx{}".format(
Lx, Ly, rad, num_obstacles, dx))
store_mesh_HDF5(msh, mesh_path)
obstacles_path = os.path.join(
MESHES_DIR, "periodic_porous_Lx{}_Ly{}_rad{}_N{}_dx{}.dat".format(
Lx, Ly, rad, num_obstacles, dx))
if len(obst) and len(interior_obstacles):
all_obstacles = np.vstack(
(np.array(obst), np.array(interior_obstacles)))
elif len(interior_obstacles):
all_obstacles = interior_obstacles
else:
all_obstacles = []
if len(all_obstacles):
np.savetxt(
obstacles_path,
np.hstack((all_obstacles, np.ones((len(all_obstacles), 1)) * rad)))