def domain(self, domaintype='meshpy'):
if domaintype == 'meshpy':
from meshpy.triangle import MeshInfo
domain = MeshInfo()
points = np.array([(0, 0), (48, 44), (48, 60), (0, 44)],
dtype=np.float)
facets = np.array([(0, 1), (1, 2), (2, 3), (3, 0)], dtype=np.int)
domain.set_points(points)
domain.set_facets(facets)
return domain
if domaintype == 'halfedge':
return None
def triangle_polygon_domain(points, facets, h, meshtype='tri'):
from meshpy.triangle import MeshInfo, build
mesh_info = MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(facets)
mesh = build(mesh_info, max_volume=h**2)
node = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
if meshtype is 'tri':
return TriangleMesh(node, cell)
elif meshtype is 'polygon':
mesh = TriangleMeshWithInfinityNode(TriangleMesh(node, cell))
pnode, pcell, pcellLocation = mesh.to_polygonmesh()
return PolygonMesh(pnode, pcell, pcellLocation)
def triangle(box, h, meshtype='tri'):
from meshpy.triangle import MeshInfo, build
mesh_info = MeshInfo()
mesh_info.set_points([(box[0], box[2]), (box[1], box[2]), (box[1], box[3]), (box[0], box[3])])
mesh_info.set_facets([[0,1], [1,2], [2,3], [3,0]])
mesh = build(mesh_info, max_volume=h**2)
node = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
if meshtype is 'tri':
return TriangleMesh(node, cell)
elif meshtype is 'polygon':
mesh = TriangleMeshWithInfinityNode(TriangleMesh(node, cell))
pnode, pcell, pcellLocation = mesh.to_polygonmesh()
return PolygonMesh(pnode, pcell, pcellLocation)
def get_mesh_example(): area = rect((0.,0.),(1.,1.)) init = rect((0.1,0.1),(0.2,0.2)) goal1 = rect((0.8,0.8),(0.9,0.9)) goal2 = rect((0.2,0.8),(0.3,0.9)) env = area + goal1 + goal2 + init info = MeshInfo() info.set_points(env) info.set_facets(loop(0,4) + loop(4,8) + loop(8,12) + loop(12,16), facet_markers = [0]*4 + [1]*4 + [2]*4 + [3]*4) # Create 8 facets and apply markers 1-8 on them info.regions.resize(4) s = 0.05 info.regions[0] = [0.15, 0.15, 0, s] # Replace 0.1 by a smaller value to produce a finer mesh info.regions[1] = [0.25, 0.85, 1, s] # Fourth item specifies maximum area of triangles as a region attribute info.regions[2] = [0.85, 0.85, 2, s] # Replace 0.1 by a smaller value to produce a finer mesh info.regions[3] = [0.5, 0.5, 3, s] # Fourth item specifies maximum area of triangles as a region attribute mesh = build(info, volume_constraints=True, attributes=True, generate_faces=True, min_angle=20, mesh_order=1) return mesh
def make_mesh_triangle_meshpy(self, **params):
"""make_mesh_meshpy_triangle
create mesh using meshpy.triangle.MeshInfo
"""
c = params['c']
mesh_info = MeshInfo()
# generate vertices and facets
if params['obj'] == 'line':
points, facets, faces = make_vertex_facets_line(params)
elif params['obj'] == 'hexagon':
points, facets, faces = make_vertex_facets_hexagon(params)
elif params['obj'] == 'rect':
points, facets = make_vertex_facets_rect(params)
print('points = {0}\nfacets = {1}'.format(pformat(points),
pformat(facets)))
# print('mesh_info.unit = {0}'.format(mesh_info.unit))
# copy points data into mesh
mesh_info.set_points(points)
# copy facets data into mesh
mesh_info.set_facets(facets)
# build the mesh
mesh = build(mesh_info)
# writing objects
# mesh.write_vtk("trigrid.vtk")
# f = open('trigrid.pkl', 'wb')
# pickle.dump(mesh, f)
# f.close()
# joblib.dump(mesh, 'trigrid.pkl')
# sys.exit()
return mesh
def uniform_refine_triangles(points, elements, factor=2):
new_points = points[:]
new_elements = []
old_face_to_new_faces = {}
face_point_dict = {}
points_per_edge = factor+1
def get_refined_face(a, b):
if a > b:
a, b = b, a
flipped = True
else:
flipped = False
try:
face_points = face_point_dict[a, b]
except KeyError:
a_pt, b_pt = [points[idx] for idx in [a, b]]
dx = (b_pt - a_pt)/factor
# build subdivided facet
face_points = [a]
for i in range(1, points_per_edge-1):
face_points.append(len(new_points))
new_points.append(a_pt + dx*i)
face_points.append(b)
face_point_dict[a, b] = face_points
# build old_face_to_new_faces
old_face_to_new_faces[frozenset([a, b])] = [
(face_points[i], face_points[i+1])
for i in range(factor)]
if flipped:
return face_points[::-1]
else:
return face_points
for a, b, c in elements:
a_pt, b_pt, c_pt = [points[idx] for idx in [a, b, c]]
dr = (b_pt - a_pt)/factor
ds = (c_pt - a_pt)/factor
ab_refined, bc_refined, ac_refined = [
get_refined_face(*pt_indices)
for pt_indices in [(a, b), (b, c), (a, c)]]
el_point_dict = {}
# fill out edges of el_point_dict
for i in range(points_per_edge):
el_point_dict[i, 0] = ab_refined[i]
el_point_dict[0, i] = ac_refined[i]
el_point_dict[points_per_edge-1-i, i] = bc_refined[i]
# fill out interior of el_point_dict
for i in range(1, points_per_edge-1):
for j in range(1, points_per_edge-1-i):
el_point_dict[i, j] = len(new_points)
new_points.append(a_pt + dr*i + ds*j)
# generate elements
for i in range(0, points_per_edge-1):
for j in range(0, points_per_edge-1-i):
new_elements.append((
el_point_dict[i, j],
el_point_dict[i+1, j],
el_point_dict[i, j+1],
))
if i+1+j+1 <= factor:
new_elements.append((
el_point_dict[i+1, j+1],
el_point_dict[i+1, j],
el_point_dict[i, j+1],
))
from meshpy.triangle import MeshInfo
mi = MeshInfo()
mi.set_points(new_points)
mi.elements.resize(len(new_elements))
for i, el in enumerate(new_elements):
mi.elements[i] = el
from meshpy.triangle import write_gnuplot_mesh
write_gnuplot_mesh("mesh.dat", mi)
return new_points, new_elements, old_face_to_new_faces
from fealpy.functionspace.mixed_fem_space import RaviartThomasFiniteElementSpace2d
from fealpy.functionspace.mixed_fem_space import BDMFiniteElementSpace2d
from fealpy.functionspace.mixed_fem_space import FirstNedelecFiniteElement2d
def mesh_2dpy(mesh_info, h):
mesh = build(mesh_info, max_volume=(h)**2)
point = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
tmesh = TriangleMesh(point, cell)
return tmesh
mesh_info = MeshInfo()
mesh_info.set_points([(0, 0), (1, 0), (1, 1), (0, 1)])
mesh_info.set_facets([[0, 1], [1, 2], [2, 3], [3, 0]])
h = 0.5
tmesh = mesh_2dpy(mesh_info, h)
#point = np.array([
# (0, 0),
# (1, 0),
# (1, 1),
# (0, 1)], dtype=np.float)
#cell = np.array([
# (1, 2, 0),
# (3, 0, 2)], dtype=np.int)
#tmesh = TriangleMesh(point, cell)
space = RaviartThomasFiniteElementSpace2d(tmesh)
import numpy as np
import matplotlib.pyplot as plt
from meshpy.triangle import MeshInfo, build
# Utility function to create lists of the form [(1,2), (2,3), (3,4),
# (4,1)], given two numbers 1 and 4
from itertools import islice, cycle
def loop(a, b):
return list(
zip(list(range(a, b)), islice(cycle(list(range(a, b))), 1, None)))
info = MeshInfo()
info.set_points([(0, 0), (1, 0), (1, 1), (0, 1), (2, 0), (3, 0), (3, 1),
(2, 1)])
info.set_facets(loop(0, 4) + loop(4, 8), list(range(
1, 9))) # Create 8 facets and apply markers 1-8 on them
info.regions.resize(2)
info.regions[0] = [
0.5,
0.5,
1,
0.1,
] # Fourth item specifies maximum area of triangles as a region attribute
info.regions[1] = [
2.5,
0.5,
2,
0.1,
] # Replace 0.1 by a smaller value to produce a finer mesh
# Quadratic element demo, by Aravind Alwan from numpy import * from matplotlib.pyplot import * from meshpy.triangle import MeshInfo, build # Utility function to create lists of the form [(1,2), (2,3), (3,4), # (4,1)], given two numbers 1 and 4 from itertools import islice, cycle from six.moves import range from six.moves import zip loop = lambda a, b: list(zip(list(range(a, b)), islice(cycle(list(range(a, b))), 1, None))) info = MeshInfo() info.set_points([(0, 0), (1, 0), (1, 1), (0, 1), (2, 0), (3, 0), (3, 1), (2, 1)]) info.set_facets(loop(0, 4) + loop(4, 8), list(range(1, 9))) # Create 8 facets and apply markers 1-8 on them info.regions.resize(2) info.regions[0] = [0.5, 0.5, 1, 0.1] # Fourth item specifies maximum area of triangles as a region attribute info.regions[1] = [2.5, 0.5, 2, 0.1] # Replace 0.1 by a smaller value to produce a finer mesh mesh = build(info, volume_constraints=True, attributes=True, generate_faces=True, min_angle=33, mesh_order=2) pts = vstack(mesh.points) # (npoints, 2)-array of points elements = vstack(mesh.elements) # (ntriangles, 6)-array specifying element connectivity # Matplotlib's Triangulation module uses only linear elements, so use only first 3 columns when plotting triplot(pts[:, 0], pts[:, 1], elements[:, :3]) plot(pts[:, 0], pts[:, 1], "ko") # Manually plot all points including the ones at the midpoints of triangle faces
def uniform_refine_triangles(points, elements, factor=2):
new_points = points[:]
new_elements = []
old_face_to_new_faces = {}
face_point_dict = {}
points_per_edge = factor + 1
def get_refined_face(a, b):
if a > b:
a, b = b, a
flipped = True
else:
flipped = False
try:
face_points = face_point_dict[a, b]
except KeyError:
a_pt, b_pt = [points[idx] for idx in [a, b]]
dx = (b_pt - a_pt) / factor
# build subdivided facet
face_points = [a]
for i in range(1, points_per_edge - 1):
face_points.append(len(new_points))
new_points.append(a_pt + dx * i)
face_points.append(b)
face_point_dict[a, b] = face_points
# build old_face_to_new_faces
old_face_to_new_faces[frozenset([a, b])] = [
(face_points[i], face_points[i + 1]) for i in range(factor)
]
if flipped:
return face_points[::-1]
else:
return face_points
for a, b, c in elements:
a_pt, b_pt, c_pt = [points[idx] for idx in [a, b, c]]
dr = (b_pt - a_pt) / factor
ds = (c_pt - a_pt) / factor
ab_refined, bc_refined, ac_refined = [
get_refined_face(*pt_indices)
for pt_indices in [(a, b), (b, c), (a, c)]
]
el_point_dict = {}
# fill out edges of el_point_dict
for i in range(points_per_edge):
el_point_dict[i, 0] = ab_refined[i]
el_point_dict[0, i] = ac_refined[i]
el_point_dict[points_per_edge - 1 - i, i] = bc_refined[i]
# fill out interior of el_point_dict
for i in range(1, points_per_edge - 1):
for j in range(1, points_per_edge - 1 - i):
el_point_dict[i, j] = len(new_points)
new_points.append(a_pt + dr * i + ds * j)
# generate elements
for i in range(0, points_per_edge - 1):
for j in range(0, points_per_edge - 1 - i):
new_elements.append((
el_point_dict[i, j],
el_point_dict[i + 1, j],
el_point_dict[i, j + 1],
))
if i + 1 + j + 1 <= factor:
new_elements.append((
el_point_dict[i + 1, j + 1],
el_point_dict[i + 1, j],
el_point_dict[i, j + 1],
))
from meshpy.triangle import MeshInfo
mi = MeshInfo()
mi.set_points(new_points)
mi.elements.resize(len(new_elements))
for i, el in enumerate(new_elements):
mi.elements[i] = el
from meshpy.triangle import write_gnuplot_mesh
write_gnuplot_mesh("mesh.dat", mi)
return new_points, new_elements, old_face_to_new_faces
from meshpy.triangle import MeshInfo, build, refine
import numpy as np
mesh_info = MeshInfo()
mesh_info.set_points([
(0,0),
(0,1),
(1,1),
(1,0)
])
mesh_info.set_facets([
[0,1],
[1,2],
[2,3],
[3,0]
])
def refinement_func(tri_points, area):
max_area=0.001
return bool(area>max_area);
mesh = build(mesh_info, refinement_func = refinement_func)
'''
print "Mesh Points:"
for i, p in enumerate(mesh.points):
print i, p
print "Point numbers in tetrahedra:"
nodes_remove_ID = np.unique(elements.simplices[coarsenIds][0])
#redraw the delaunay triangles
return findDelaunayTriangles(nodepts)
if __name__ == '__main__':
#Create the intial mesh node pts
nodepts = createInitialTriGridPts(4, 4)
#Define the element triangles that link the nodes
elements = defineElementConnectivity(nodepts)
mesh_info = MeshInfo()
print(nodepts)
mesh_info.set_points(nodepts)
print(elements.simplices)
mesh_info.set_facets(elements.simplices)
mesh = build(mesh_info)
#mesh.triangle.
write_gnuplot_mesh("test.vtk", mesh_info.points, facets=False)
#triangle=showMesh(nodepts,elements.simplices)
print(elements)
print(elements.simplices)
print(elements.points)
nodepts, elements = refineMesh(nodepts, elements, 7)
nodepts, elements = refineMesh(nodepts, elements, 20)
#nodepts,elements = refineMesh(nodepts,elements,100)
#nodepts,elements = refineMesh(nodepts,elements,50)
from meshpy.triangle import MeshInfo, build
import numpy as np
import matplotlib.pyplot as plt
from fealpy.mesh import TriangleMesh
domain = MeshInfo()
domain.set_points([(0,0),(1,0),(1,1),(0,1)])
domain.set_facets([(0,1),(1,2),(2,3),(3,0)], facet_markers=[1, 2, 3, 4])
mesh = build(domain, max_volume = 0.1**2, attributes=True)
node = np.array(mesh.points, dtype = np.float)
cell = np.array(mesh.elements, dtype = np.int)
tmesh = TriangleMesh(node, cell)
fig = plt.figure()
axes = fig.gca()
tmesh.add_plot(axes)
cell = tmesh.entity('cell')
node = tmesh.entity('node')
NN = tmesh.number_of_nodes()
isBdNode = tmesh.ds.boundary_node_flag()
newNode = np.zeros((NN, 2), dtype=np.float)
degree = np.zeros(NN, dtype=np.int)
np.add.at(degree, cell, 1)
for i in range(10):
#bc = tmesh.entity_barycenter('cell')
bc, R = tmesh.circumcenter()
np.add.at(newNode, (cell, np.s_[:]), bc[:, np.newaxis, :])
newNode /= degree[:, np.newaxis]
node[~isBdNode] = newNode[~isBdNode]
newNode[:] = 0
def discretise_faces(vertices, faces, target, min_angle=15, factor=3):
""" Make discretised triangles from input coarse triangles data.
Parameters
----------
vertices : list
Co-ordinates of coarse vertices.
faces : list
Vertex indices of each face of the coarse triangles.
target : float
Target edge length of each triangle.
min_angle : float
Minimum internal angle of triangles.
factor : float
Factor on the maximum area of each triangle.
Returns
-------
list
Vertices of the discretised trianlges.
list
Vertex numbers of the discretised trianlges.
Notes
-----
- An experimental script.
"""
points_all = []
faces_all = []
Amax = factor * 0.5 * target**2
for count, face in enumerate(faces):
# Seed
face.append(face[0])
points = []
facets = []
for u, v in zip(face[:-1], face[1:]):
sp = vertices[u]
ep = vertices[v]
vec = subtract_vectors(ep, sp)
l = length_vector(vec)
div = l / target
n = max([1, int(div)])
for j in range(n):
points.append(add_vectors(sp, scale_vector(vec, j / n)))
facets = [[i, i + 1] for i in range(len(points) - 1)]
facets.append([len(points) - 1, 0])
# Starting orientation
cent = centroid_points(points)
vec1 = subtract_vectors(points[1], points[0])
vec2 = subtract_vectors(cent, points[0])
vecn = cross_vectors(vec1, vec2)
# Rotate about x
points = array(points).transpose()
phi = -arctan2(vecn[2], vecn[1]) + 0.5 * pi
Rx = array([[1, 0, 0], [0, cos(phi), -sin(phi)],
[0, sin(phi), cos(phi)]])
vecn_x = dot(Rx, array(vecn)[:, newaxis])
points_x = dot(Rx, points)
Rx_inv = inv(Rx)
# Rotate about y
psi = +arctan2(vecn_x[2, 0], vecn_x[0, 0]) - 0.5 * pi
Ry = array([[cos(psi), 0, sin(psi)], [0, 1, 0],
[-sin(psi), 0, cos(psi)]])
points_y = dot(Ry, points_x)
Ry_inv = inv(Ry)
V = points_y.transpose()
try:
new_points = [list(i) for i in list(V[:, :2])]
info = MeshInfo_tri()
info.set_points(new_points)
info.set_facets(facets)
tris = build_tri(info,
allow_boundary_steiner=False,
min_angle=min_angle,
max_volume=Amax)
new_points = [list(j) + [V[0, 2]] for j in tris.points]
new_tris = [list(j) for j in tris.elements]
V = array(new_points)
points = dot(Ry_inv, V.transpose())
points_all.append(
[list(i) for i in list(dot(Rx_inv, points).transpose())])
faces_all.append(new_tris)
except:
print('***** ERROR discretising face {0} *****'.format(count))
return points_all, faces_all
newParent[:, 0] = np.repeat(idx, 4)
newParent[:, 1] = ranges(4 * np.ones(NCC, dtype=np.int))
child[idx, :] = np.arange(NC, NC + 4 * NCC).reshape(NCC, 4)
cell = np.concatenate((cell, newCell), axis=0)
self.node = np.concatenate((node, edgeCenter, cellCenter), axis=0)
self.parent = np.concatenate((parent, newParent), axis=0)
self.child = np.concatenate((child, newChild), axis=0)
self.ds.reinit(N + NEC + NCC, cell)
return True
else:
return False
mesh_info = MeshInfo()
mesh_info.set_points([(-1, -1), (0, -1), (0, 0), (1, 0), (1, 1), (0, 1),
(1, 1), (-1, 0)])
mesh_info.set_facets([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7],
[7, 0]])
h = 0.05
mesh = build(mesh_info, max_volume=h**2)
node = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
ttree = Tritree(node, cell)
mesh = ttree.to_mesh()
pde = LShapeRSinData()
integrator = mesh.integrator(3)
fem = PoissonFEMModel(pde, mesh, 1, integrator)
fem.solve()
eta = fem.recover_estimate()
