def init_mesh(self, n=0, meshtype='tri'):
""" generate the initial mesh
"""
node = 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)
mesh = TriangleMesh(node, cell)
mesh.uniform_refine(2)
NN = mesh.number_of_nodes()
node = np.zeros((NN + 3, 2), dtype=np.float64)
node[:NN] = mesh.entity('node')
node[NN:] = node[[5], :]
cell = mesh.entity('cell')
cell[13][cell[13] == 5] = NN
cell[18][cell[18] == 5] = NN
cell[19][cell[19] == 5] = NN + 1
cell[12][cell[12] == 5] = NN + 1
cell[6][cell[6] == 5] = NN + 2
mesh = TriangleMesh(node, cell)
mesh.uniform_refine(n)
return mesh
def test_triangle_mesh():
from fealpy.mesh import TriangleMesh
node = np.array(
[
(0.0, 0.0), # 0 号点
(1.0, 0.0), # 1 号点
(1.0, 1.0), # 2 号点
(0.0, 1.0), # 3 号点
],
dtype=np.float64)
cell = np.array(
[
(1, 2, 0), # 0 号单元
(3, 0, 2), # 1 号单元
],
dtype=np.int_)
mesh = TriangleMesh(node, cell)
# 获取测试
assert id(node) == id(mesh.entity('node'))
assert id(cell) == id(mesh.entity('cell'))
edge = np.array([
[0, 1],
[2, 0],
[3, 0],
[1, 2],
[2, 3],
], dtype=np.int_)
assert np.all(edge == mesh.entity('edge'))
isBdNode = mesh.ds.boundary_node_flag()
assert np.all(isBdNode)
isBdEdge = mesh.ds.boundary_edge_flag()
assert isBdEdge.sum() == 4
assert isBdEdge[1] == False
cell2node = mesh.ds.cell_to_node()
cell2edge = mesh.ds.cell_to_edge()
cell2cell = mesh.ds.cell_to_cell()
edge2node = mesh.ds.edge_to_node()
edge2edge = mesh.ds.edge_to_edge()
edge2cell = mesh.ds.edge_to_cell()
node2node = mesh.ds.node_to_node()
node2edge = mesh.ds.node_to_edge()
node2cell = mesh.ds.node_to_cell()
# 加密测试
mesh.uniform_refine()
def init_mesh(self, n=2):
from ..mesh import TriangleMesh
node = 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)
mesh = TriangleMesh(node, cell)
mesh.uniform_refine(n)
NN = mesh.number_of_nodes()
node = np.zeros((NN + 3, 2), dtype=np.float64)
node[:NN] = mesh.entity('node')
node[NN:] = node[[5], :]
cell = mesh.entity('cell')
cell[13][cell[13] == 5] = NN
cell[18][cell[18] == 5] = NN
cell[19][cell[19] == 5] = NN + 1
cell[12][cell[12] == 5] = NN + 1
cell[6][cell[6] == 5] = NN + 2
return TriangleMesh(node, cell)
def peak(p):
x = p[..., 0]
y = p[..., 1]
val = 3 * (1 - x)**2 * np.exp(-(x**2) - (y + 1)**2) - 10 * (
x / 5 - pow(x, 3) -
pow(y, 5)) * np.exp(-x**2 - y**2) - 1 / 3 * np.exp(-(x + 1)**2 - y**2)
return val
node = np.array([(-5, -5), (5, -5), (5, 5), (-5, 5)], dtype=np.float)
cell = np.array([(1, 2, 0), (3, 0, 2)], dtype=np.int)
mesh = TriangleMesh(node, cell)
mesh.uniform_refine(5)
node = mesh.entity('node')
cell = mesh.entity('cell')
tmesh = Tritree(node, cell)
femspace = LagrangeFiniteElementSpace(mesh, p=1)
uI = femspace.interpolation(peak)
estimator = Estimator(uI[:], mesh, 0.2, 0.5)
isExtremeNode = estimator.is_extreme_node()
print(isExtremeNode.sum())
tmesh.adaptive_refine(estimator)
mesh = estimator.mesh
isExtremeNode = estimator.is_extreme_node()
fig = plt.figure()
axes = fig.gca()
def refine_tri(self, maxit=2, method='rg', plot=True, rb=True):
cell = np.array([[0, 1, 2], [0, 2, 3], [1, 4, 5], [2, 1, 5]],
dtype=np.int)
node = np.array([[0, 0], [1, 0], [1, 1], [0, 1], [2, 0], [2, 1]],
dtype=np.float)
if False:
mesh = TriangleMesh(node, cell)
mesh = HalfEdgeMesh.from_mesh(mesh)
mesh.ds.cell2hedge = np.array([0, 3, 2, 11, 10])
isMarkedCell = np.array([0, 1, 0, 0, 1], dtype=np.bool_)
#mesh.refine_triangle_rbg(isMarkedCell)
mesh.ds.NV = 3
cell = mesh.ds.cell_to_node()
node = mesh.entity('node')
mesh = TriangleMesh(node, cell)
mesh = HalfEdgeMesh2d.from_mesh(mesh)
mesh.init_level_info()
if False:
fig = plt.figure()
axes = fig.gca()
mesh.add_plot(axes)
mesh.add_halfedge_plot(axes, showindex=True)
mesh.find_node(axes, showindex=True)
mesh.find_cell(axes, showindex=True)
plt.show()
NE = mesh.ds.NE
color = np.zeros(NE * 2, dtype=np.int_)
if method == 'rg':
color[[4, 13, 17, 28]] = 1
color[[23, 27]] = 2
color[[22, 26]] = 3
mesh.hedgecolor = color
isMarkedCell = np.array(
[0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.bool_)
mesh.refine_triangle_rg(isMarkedCell)
else:
color[[2, 3, 10, 11]] = 1
mesh.hedgecolor = color
isMarkedCell = np.array([0, 1, 1, 0, 0], dtype=np.bool_)
#isMarkedCell = np.array([0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ,0],
# dtype=np.bool_)
mesh.refine_triangle_nvb(isMarkedCell)
mesh.print()
if plot:
fig = plt.figure()
axes = fig.gca()
mesh.add_plot(axes)
mesh.add_halfedge_plot(axes, showindex=True)
mesh.find_node(axes, showindex=True)
mesh.find_cell(axes, showindex=True)
plt.show()
if True:
mesh = TriangleMesh(node, cell)
mesh = HalfEdgeMesh2d.from_mesh(mesh)
mesh.init_level_info()
NE = mesh.ds.NE
color = np.zeros(NE * 2, dtype=np.int_)
if method == 'nvb':
color[[2, 3, 10, 11]] = 1
mesh.hedgecolor = color
c = np.array([0.8, 0.8])
r = 0.9
h = 1e-2
k = 0
NB = 0
start = time.time()
while k < maxit:
halfedge = mesh.ds.halfedge
halfedge1 = halfedge[:, 3]
node = mesh.node
flag = node - c
flag = flag[:, 0]**2 + flag[:, 1]**2
flag = flag <= r**2
flag1 = flag[halfedge[:, 0]].astype(int)
flag2 = flag[halfedge[halfedge1, 0]].astype(int)
markedge = flag1 + flag2 == 1
markedcell = halfedge[markedge, 1]
markedcell = np.unique(markedcell)
cell = np.unique(halfedge[:, 1])
nc = cell.shape[0]
markedcell1 = np.zeros(nc)
markedcell1[markedcell] = 1
if method == 'rg':
mesh.refine_triangle_rg(markedcell1.astype(np.bool_))
else:
mesh.refine_triangle_nvb(markedcell1.astype(np.bool_))
k += 1
print('循环', k, '次***************************')
end = time.time()
print('用时', end - start)
if plot:
fig = plt.figure()
axes = fig.gca()
nindex = mesh.nodedata['level']
mesh.add_plot(axes)
#mesh.add_halfedge_plot(axes, showindex=True)
#mesh.find_node(axes, showindex=True, multiindex=nindex)
#mesh.find_cell(axes, showindex=True)
#print(np.c_[np.arange(len(mesh.hedgecolor)), mesh.hedgecolor])
plt.show()
def test_interpolation_plane(self):
def u(p):
x = p[..., 0]
y = p[..., 1]
return x * y
node = 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)
mesh = TriangleMesh(node, cell)
node = mesh.entity('node')
cell = mesh.entity('cell')
tritree = Tritree(node, cell)
mesh = tritree.to_conformmesh()
space = LagrangeFiniteElementSpace(mesh, p=2)
uI = space.interpolation(u)
error0 = space.integralalg.L2_error(u, uI)
fig = plt.figure()
axes = fig.gca()
mesh.add_plot(axes)
mesh.find_node(axes, node=space.interpolation_points(), showindex=True)
data = tritree.interpolation(uI)
options = tritree.adaptive_options(method='numrefine',
data={"q": data},
maxrefine=1,
p=2)
if 1:
#eta = space.integralalg.integral(lambda x : uI.grad_value(x)**2, celltype=True, barycenter=True)
#eta = eta.sum(axis=-1)
eta = np.array([1, 0], dtype=np.int)
tritree.adaptive(eta, options)
else:
tritree.uniform_refine(options=options)
fig = plt.figure()
axes = fig.gca()
tritree.add_plot(axes)
tritree.find_node(axes, showindex=True)
mesh = tritree.to_conformmesh(options)
space = LagrangeFiniteElementSpace(mesh, p=2)
data = options['data']['q']
uh = space.to_function(data)
error1 = space.integralalg.L2_error(u, uh)
data = tritree.interpolation(uh)
isLeafCell = tritree.is_leaf_cell()
fig = plt.figure()
axes = fig.gca()
tritree.add_plot(axes)
tritree.find_node(axes,
node=space.interpolation_points(),
showindex=True)
tritree.find_cell(axes, index=isLeafCell, showindex=True)
options = tritree.adaptive_options(method='numrefine',
data={"q": data},
maxrefine=1,
maxcoarsen=1,
p=2)
if 1:
#eta = space.integralalg.integral(lambda x : uI.grad_value(x)**2, celltype=True, barycenter=True)
#eta = eta.sum(axis=-1)
eta = np.array([-1, -1, -1, -1, 0, 1], dtype=np.int)
tritree.adaptive(eta, options)
else:
tritree.uniform_refine(options=options)
mesh = tritree.to_conformmesh(options)
space = LagrangeFiniteElementSpace(mesh, p=2)
data = options['data']['q']
uh = space.to_function(data)
fig = plt.figure()
axes = fig.gca()
mesh.add_plot(axes)
mesh.find_node(axes, node=space.interpolation_points(), showindex=True)
mesh.find_cell(axes, showindex=True)
error2 = space.integralalg.L2_error(u, uh)
print(error0)
print(error1)
print(error2)
plt.show()
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
import numpy as np
import matplotlib.pyplot as plt
from fealpy.mesh import TriangleMesh
node = 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(node, cell)
tmesh.uniform_refine(2)
node = tmesh.entity('node')
cell = tmesh.entity('cell')
fig = plt.figure()
axes = fig.gca()
tmesh.add_plot(axes)
tmesh.find_node(axes, showindex=True)
tmesh.find_edge(axes, showindex=True)
tmesh.find_cell(axes, showindex=True)
plt.show()
node = np.array([
[0.0, 0.0],
[1.0, 0.0],
[1.0, 1.0],
[0.0, 1.0]], dtype=np.float) # (NN, 2)
cell = np.array([[1, 2, 0], [3, 0, 2]], dtype=np.int) # (NC, 3)
mesh = TriangleMesh(node, cell)
NN = mesh.number_of_nodes()
NE = mesh.number_of_edges()
NC = mesh.number_of_cells()
node = mesh.entity('node')
edge = mesh.entity('edge')
cell = mesh.entity('cell')
ebc = mesh.entity_barycenter('edge')
cbc = mesh.entity_barycenter('cell')
area = mesh.entity_measure('cell')
eh = mesh.entity_measure('edge')
cell2node = mesh.ds.cell_to_node() # cell
cell2edge = mesh.ds.cell_to_edge() # (NC, 3)
cell2cell = mesh.ds.cell_to_cell() # (NC, 3)
edge2cell = mesh.ds.edge_to_cell() # (NE, 4)
edge2node = mesh.ds.edge_to_node() # edge
