hm.info_contour(a6),
{'btypes': {1: 40}, 'Nnodes': 40, 'subcont': [40], 'Nedges': 40})
print "rectangle grid from 2 straight contours: linear algo"
left_line = hm.create_contour([[0, 0], [0, 1]], 1)
bottom_line = hm.create_contour([[0, 0], [2, 0]], 2)
left_line_part = hm.partition_contour(left_line, "const", 0.2)
bottom_line_part = hm.partition_contour(
bottom_line, "ref_points",
[0.2, [0, 0], 0.01, [1, 0], 0.08, [2, 0]])
g1 = hm.add_custom_rect_grid("linear", left_line_part, bottom_line_part)
check(hm.info_contour(g1)['btypes'] == {1: 10, 2: 90})
print "rectangle grid from 4 straight contours: linear algo"
[top_line_part] = hm.copy_geom(bottom_line_part)
hm.move_geom(top_line_part, 0, 1.0)
hm.set_boundary_type(top_line_part, 3)
right_line = hm.create_contour([[2, 0], [2, 1]], 4)
right_line_part = hm.partition_contour(right_line, "ref_points",
[0.1, [2, 0], 0.3, [2, 1]])
g1 = hm.add_custom_rect_grid(
"linear",
left_line_part, bottom_line_part,
right_line_part, top_line_part)
check(hm.info_contour(g1)['btypes'] == {1: 5, 2: 45, 3: 45, 4: 5})
print "linear with disconnected right side"
pts = []
for i in range(100):
x = 2 + 0.05 * math.sin(4.0 * math.pi * i / 99)
from hybmeshpack import hmscript as hm
hm.check_compatibility('0.5.0')
# create a substrate 20x20 square grid
sqr = hm.add_unf_rect_grid([0, 0], [1, 1], 20, 20)
# create tube grids
# 1) create a prototype
tube_proto = hm.add_unf_rect_grid([0, 0], [0.15, 0.5], 10, 20)
# 2) copy, replace and rotate to build left, right, bottom tubes.
[tube_left, tube_right, tube_bot] = hm.copy_geom([tube_proto] * 3)
hm.move_geom([tube_left, tube_right], 0.425, 1.0)
hm.move_geom([tube_bot], 0.425, -0.5)
hm.rotate_geom([tube_left], -45, [0.5, 0.5])
hm.rotate_geom([tube_right], 45, [0.5, 0.5])
# exclude pentagon from base grid
cont5 = hm.create_contour([[0.3, 0.6], [0.35, 0.4], [0.65, 0.4],
[0.7, 0.6], [0.5, 0.7], [0.3, 0.6]])
exsqr = hm.exclude_contours(sqr, [cont5], "inner")
# ******* see fig2
# make series of grid superpositions with defined buffer sizes
imposed = hm.unite_grids(exsqr, [(tube_left, 0.05),
(tube_right, 0.05),
(tube_bot, 0.1)])
# ******* see fig3
# create a boundary grid prototype around the pentagon.
# 1) make partition of pentagon contour with constant step
cont5 = hm.partition_contour(cont5, "const", 0.02)
# step sizes
step0 = 0.03 # lowest step in the walls boundary layers
step1 = 0.03 # step in the boudary layer straight behind the rib
step2 = 0.02 # outer rib boundary region step
step3 = 0.15 # maximum wake region step, maximum wall boundary step
step4 = 0.25 # largest step
# ======================= Meshing procedure
# 1. channel region
region_channel = hm.add_rect_contour([-Lx1, 0], [Lx2, Ly],
[bbottom, boutput, btop, binput])
# 2. rib boundary layer region
cyl = hm.add_circ_contour([0, 0], hcyl / 2, 128, brib)
[bcyl] = hm.copy_geom([cyl])
xpc = 100. * (hcyl + Lx1_rib_blay + Lx2_rib_blay) / (hcyl)
ypc = 100. * (hcyl + 2 * Ly_rib_blay) / (hcyl)
hm.scale_geom(bcyl, xpc, ypc)
xmv = (Lx2_rib_blay - Lx1_rib_blay) / 2.
hm.move_geom(bcyl, xmv, 0.)
region_blay = hm.unite_contours([cyl, bcyl])
region_blay = hm.clip_domain(region_blay, region_channel, "intersection")
# 3. wake region
x0 = 1.1 * hcyl / 2
x1 = Lx_wake_reg
y0 = 0
y10 = 0.9 * (Ly_rib_blay + hcyl / 2)
y11 = Ly_wake_reg
region_wake = hm.create_contour([[x0, y0], [x1, y0], [x1, y11], [x0, y10],
hmdbg.check(all(a == b for a, b in zip(zg2, hm.registered_grids())))
hmdbg.check(all(a == b for a, b in zip(zs3, hm.registered_surfaces())))
hmdbg.check(all(a == b for a, b in zip(zg3, hm.registered_grids3d())))
hmdbg.check(hm.registered_btypes() == [(0,
'default-boundary'), (15,
'boundary15')])
hm.load_project("../external_files/empty.hmp")
print "export 2d to fluent"
bleft = hm.add_boundary_type(1, "bleft")
bright = hm.add_boundary_type(2, "bright")
bbot = hm.add_boundary_type(3, "bbot")
btop = hm.add_boundary_type(4, "btop")
g1 = hm.add_unf_rect_grid([0, 0], [1, 1], 10, 10)
g2 = hm.add_triangle_grid([0.3, -0.4], [0.5, 0.2], [0.7, -0.4], 10)
[g3] = hm.copy_geom(g2)
hm.reflect_geom(g3, [0, 0.5], [1, 0.5])
g4 = hm.unite_grids(g1, [(g2, 0.05), (g3, 0.05)])
hm.set_boundary_type(g4,
bfun=lambda x0, y0, x1, y1, b: {
True: 0,
x0 + x1 == 0: 1,
x0 + x1 == 2: 2,
y0 + y1 == -0.8: 3,
y0 + y1 == 2.8: 4
}[True])
hm.export_grid_vtk(g4, "g1.vtk")
hm.export_contour_vtk(g4, "c1.vtk")
hmdbg.check_ascii_file(15697319238564148717, "g1.vtk", "dev")
hmdbg.check_ascii_file(16408920837426241157, "c1.vtk", "dev")
hm.export_grid_msh(g4, "g1.msh")
start_point=[5, -0.5],
end_point=[5.45, -0.36],
project_to="corner")
# shut down acute angle algorithm in order to obtain grid which lies strictly
# within body contour at the bottom point
btopt.range_angles[0] = 0
jgrid = hm.build_boundary_grid(btopt)
# gills areas are constructed by a boundary grid built around
# contours which are constructed by two circles intersection
circ1 = hm.add_circ_contour3([2.7, -0.4], [2.7, 0.4], 0.4, ncirc)
circ2 = hm.add_circ_contour3([2.7, -0.4], [2.7, 0.4], 1.2, ncirc)
gillc = hm.clip_domain(circ2, circ1, "difference")
gillc = hm.partition_contour(gillc, "const", 0.1)
gills = hm.build_boundary_grid1(gillc, [0, 0.1], "right")
[gills2, gills3] = hm.copy_geom([gills] * 2)
hm.move_geom(gills2, -0.5, 0)
hm.move_geom(gills3, 0.5, 0)
# since gills grids have no intersection area, their union
# does nothing but assembling three grids into single connectivity table.
gills = hm.unite_grids(gills, [(gills2, 0), (gills3, 0)])
# an eye is built as a ring grid.
eye = hm.add_unf_ring_grid([4.7, 0.3], 0.05, 0.1, 5, 1)
# II. Coupling grids **********************************************************
# Fins and the body are not tightly connected and direct superposition
# procedure may give bad results. To fix that we snap body grid to those fins.
p1 = hm.get_point(fin1, vclosest=[-1.2, 1.4])
p2 = hm.get_point(fin1, vclosest=[0.5, 1.4])
hm.move_geom(gtube, 0.7, 0.9) # after combining of 'house_wroof' and 'gtube' the resulting grid # boundary edges will get their features from both parent grids house_wtube = hm.unite_grids(house_wroof, [(gtube, 0.05)]) # first we create an outer window frame by building an external # boundary grid around square contour win_cont = hm.add_rect_contour([-0.15, -0.15], [0.15, 0.15]) op1 = hm.BoundaryGridOptions(win_cont, bnd_step=0.02, direction='right') op1.uniform_partition(0.03, 2) win_frame1 = hm.build_boundary_grid([op1]) # now we create a internal window frames win_frame2 = hm.add_unf_rect_grid([-0.02, -0.15], [0.02, 0.15], 3, 30) [win_frame3] = hm.copy_geom([win_frame2]) hm.rotate_geom(win_frame2, 90) # to assemble a window we make an superposition of internal frames to outer one # and assigns 'Window' boundary type to the whole resulting grid. window = hm.unite_grids(win_frame1, [(win_frame2, 0.02), (win_frame3, 0.02)]) hm.set_boundary_type(window, bwindow) # finally we move window to its position according to house and # impose it to it. Note that in order to purge area within window spans # option 'empty_holes=True' is used. hm.move_geom(window, 0.5, 0.4) house_final = hm.unite_grids(house_wtube, [(window, 0.05)], empty_holes=True) # now we can check quality of resulting grid by calculating its skewness skew = hm.skewness(house_final)
# hm.export_contour_vtk(g3, "c3.vtk") # hm.export_grid_vtk(g4, "g4.vtk") # hm.export_contour_vtk(g4, "c4.vtk") # hm.export_grid_vtk(g5, "g5.vtk") # hm.export_contour_vtk(g5, "c5.vtk") # hm.export_grid_vtk(g6, "g6.vtk") # hm.export_contour_vtk(g6, "c6.vtk") check(hm.skewness(g3)['ok']) check(hm.skewness(g4)['ok']) check(hm.info_grid(g5)['cell_types'].keys() == [4]) check(hm.info_grid(g6)['cell_types'].keys() == [4]) hm.remove_all() g1 = hm.add_unf_rect_grid([0, 0], [10, 3], 50, 15) g2 = hm.add_unf_rect_grid([0, -1], [2, 0], 10, 5) [g3] = hm.copy_geom(g2) hm.move_geom(g3, 8, 0) g1 = hm.unite_grids(g1, [(g2, 0), (g3, 0)]) hm.set_boundary_type(g1, 1) g2 = hm.add_unf_rect_grid([0, -2], [10, -0.5], 15, 3) hm.set_boundary_type(g2, 2) hm.rotate_geom([g1, g2], 37) g3 = hm.unite_grids(g1, [(g2, 0.1)]) g4 = hm.unite_grids(g1, [(g2, 0.5)]) g5 = hm.unite_grids(g1, [(g2, 1)]) g6 = hm.unite_grids(g1, [(g2, 2)]) check(hm.info_grid(g3)['cell_types'][4] == 835) check(hm.info_grid(g4)['cell_types'][4] == 795) check(hm.info_grid(g5)['cell_types'][4] == 711) check(hm.info_grid(g6)['cell_types'][4] == 509)
ali, [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0.5]],
[c[15], c[16], p1, p2, [-590, 1477]],
project_to="vertex",
algo="inverse_laplace")
# right input: g3
p0 = hm.get_point(g1cont, eclosest=c[18])
p1 = hm.get_point(c_bot, vclosest=[1785.79, 1489.68])
p2 = hm.get_point(c_bot, vclosest=[1776.04, 1489.65])
p3 = hm.get_point(g1cont, eclosest=c[17])
p4 = hm.get_point(g1cont, eclosest=[1748.54, 1481.69])
p5 = hm.get_point(g1cont, eclosest=[1742, 1482])
[c0, c1, c2, c4] = hm.extract_subcontours(c_bot, [p0, p1, p2, p3, p4], "line")
c3 = hm.create_contour([p0, p3])
c5 = hm.create_contour([p4, p5])
[c6] = hm.copy_geom(c4)
hm.scale_geom([c6], 150, 250)
ar1 = hm.connect_subcontours([c3, c0, c1, c2], fix=[0, 2], close="yes")
ar2 = hm.connect_subcontours([c3, c4, c5, c6], fix=[0, 2], close="yes")
go = hm.add_unf_rect_grid(nx=3, ny=10)
gb = hm.add_rect_contour([0, 0], [1, 1], [0, 0, binput_right2, 0])
go = hm.exclude_contours(go, gb, "outer")
g31 = hm.map_grid(go,
ar1, [[0, 0], [1, 0], [1, 1], [0, 1], [1, 0.5]],
[p3, p0, p1, p2, [1774.22, 1483.7]],
project_to="vertex",
algo="inverse_laplace")
go = hm.add_unf_rect_grid(nx=3, ny=15)
g32 = hm.map_grid(go,
ar2, [[0, 0], [1, 0], [1, 1], [0, 1]], [p4, p5, p0, p3],
project_to="vertex",
hm.set_boundary_type(g2, 1)
hm.set_boundary_type(g3, 4)
g2 = hm.unite_grids(g2, [(g3, 0)])
# main area
bot = hm.create_contour([[0, 0], pbef, paft, [x2, 0]])
bot = hm.partition_contour(bot, algo="const", step=hmain, angle0=-1)
left = map(
lambda x: [0, x], blay[:-1] +
hm.partition_segment(layheight, y2, hblayer, hmin,
[y2 / 2., hmain, y2 - layheight, hblayer]))
left = hm.create_contour(left)
outh = hm.get_point(left,
vclosest=[0,
paft[1] + layheight + shiftlay + 2 * hmain])[1]
[right] = hm.copy_geom(left)
[top] = hm.copy_geom(bot)
hm.set_boundary_type(left, 2)
hm.set_boundary_type(right, 3)
hm.set_boundary_type(bot, 4)
hm.set_boundary_type(top, 5)
gmain = hm.add_custom_rect_grid("linear", left, bot, right, top)
outcont = hm.add_rect_contour(pbef, [paft[0], outh])
gmain = hm.exclude_contours(gmain, outcont, "inner")
#final unite
gout = hm.unite_grids(gmain, [(g2, 0)])
hm.export_contour_vtk(gout, "c2.vtk")
cc = hm.simplify_contour(gout, simplify=False, separate=True)
filler = hm.pick_contour([pc[0], outh], cc)
