def test_SurfaceParabolicFEMModel_time(self, maxit=2):
from fealpy.pde.surface_parabolic_model_3d import SinSinSinExpDataSphere
pde = SinSinSinExpDataSphere()
mesh = pde.init_mesh(n=5)
timeline = pde.time_mesh(0, 1, 2)
errorType = ['$||u-u_h||_0$']
error = np.zeros((len(errorType), maxit), dtype=mesh.ftype)
Ndof = np.zeros(maxit, dtype=mesh.itype)
for i in range(maxit):
print(i)
dmodel = SurfaceParabolicFEMModel(pde, mesh)
Ndof[i] = dmodel.space.number_of_global_dofs()
uh = dmodel.init_solution(timeline)
timeline.time_integration(uh, dmodel, self.solver.divide)
u = lambda x:dmodel.pde.solution(x, 1.0)
uh = dmodel.space.function(array=uh[:, -1])
error[0, i] = dmodel.space.integralalg.L2_error(u, uh)
# timeline.uniform_refine()
mesh.uniform_refine(surface=pde.surface)
show_error_table(Ndof, errorType, error)
showmultirate(plt, 0, Ndof, error, errorType)
plt.show()
def test_SurfaceParabolicFEMModel_sdc_time(self, maxit=4):
from fealpy.pde.surface_parabolic_model_3d import SinSinSinExpDataSphere
pde = SinSinSinExpDataSphere()
mesh = pde.init_mesh(n=5)
timeline = pde.time_mesh(0, 1, 2, timeline='chebyshev')
errorType = ['$|| u - u_h ||_\infty$', '$||u-u_h||_0$']
errorMatrix = np.zeros((len(errorType), maxit), dtype=mesh.ftype)
Ndof = np.zeros(maxit, dtype=mesh.itype)
for i in range(maxit):
print(i)
dmodel = SurfaceParabolicFEMModel(pde, mesh, p=1)
Ndof[i] = dmodel.space.number_of_global_dofs()
uh = dmodel.init_solution(timeline)
timeline.time_integration(uh, dmodel, self.solver.divide, nupdate=1)
uI = dmodel.interpolation(pde.solution, timeline)
errorMatrix[0, i] = np.max(np.abs(uI - uh))
u = lambda x:dmodel.pde.solution(x, 1.0)
uh = dmodel.space.function(array=uh[:, -1])
errorMatrix[1, i] = dmodel.space.integralalg.L2_error(u, uh)
print(errorMatrix)
timeline.uniform_refine()
mesh.uniform_refine(surface=pde.surface)
show_error_table(Ndof, errorType, errorMatrix)
showmultirate(plt, 0, Ndof, errorMatrix, errorType)
plt.show()
def test_polation_interoperator(self):
pde = CosCosData()
maxit = 4
errorType = ['$|u_I - u_h|_{max}$']
Maxerror = np.zeros((len(errorType), maxit), dtype=np.float)
NE = np.zeros(maxit, )
for i in range(maxit):
start3 = time.time()
mesh = self.mesh
isBDEdge = mesh.ds.boundary_edge_flag()
NE[i] = mesh.number_of_edges()
h = mesh.hx
bc = mesh.entity_barycenter('cell')
ec = mesh.entity_barycenter('edge')
uI = mesh.polation_interoperator(pde.solution(bc))
uh = pde.solution(ec)
Maxerror[0, i] = np.sqrt(np.sum(h**2 * (uh - uI)**2))
# Maxerror[0, i] = max(abs(uh - uI))
end3 = time.time()
print('time of %d iteration' % i, end3 - start3)
if i < maxit - 1:
mesh.uniform_refine()
showmultirate(plt, 0, NE, Maxerror, errorType)
print('Maxerror', Maxerror)
plt.show()
def test_ParabolicFEMModel_time(self, maxit=4):
pde = CosCosExpData(0.1)
mesh = pde.init_mesh(n=0)
timeline = UniformTimeLine(0, 1, 2)
errorType = ['$|| u - u_h ||_\infty$', '$||u-u_h||_0$']
errorMatrix = np.zeros((len(errorType), maxit), dtype=mesh.ftype)
Ndof = np.zeros(maxit, dtype=mesh.itype)
for i in range(maxit):
print(i)
model = ParabolicFEMModel(pde, mesh, p=1)
Ndof[i] = model.space.number_of_global_dofs()
uh = model.init_solution(timeline)
timeline.time_integration(uh, model, spsolve)
uI = model.interpolation(pde.solution, timeline)
errorMatrix[0, i] = np.max(np.abs(uI - uh))
u = lambda x: model.pde.solution(x, 1.0)
uh = model.space.function(array=uh[:, -1])
errorMatrix[1, i] = model.space.integralalg.L2_error(u, uh)
print(errorMatrix)
timeline.uniform_refine()
mesh.uniform_refine(surface=pde.surface)
show_error_table(Ndof, errorType, errorMatrix)
showmultirate(plt, 0, Ndof, errorMatrix, errorType)
plt.show()
NDof[i] = space.number_of_global_dofs()
bc = DirichletBC(space, pde.dirichlet)
uh = space.function()
A, F = bc.apply(A, F, uh)
uh[:] = spsolve(A, F)
errorMatrix[0, i] = space.integralalg.error(pde.solution,
uh.value,
power=2)
errorMatrix[1, i] = space.integralalg.error(pde.gradient,
uh.grad_value,
power=2)
errorMatrix[2, i] = space.integralalg.error(pde.gradient,
rguh.value,
power=2)
eta = space.recovery_estimate(uh)
errorMatrix[3, i] = np.sqrt(np.sum(eta**2))
if i < maxit - 1:
isMarkedCell = mark(eta, theta=theta)
mesh.bisect(isMarkedCell)
mesh.add_plot(plt)
plt.savefig('./test-' + str(i + 1) + '.png')
plt.close()
mesh.add_plot(plt)
showmultirate(plt, maxit - 5, NDof, errorMatrix, errorType)
plt.show()
Dp1eL2 = fdm.get_Dp1L2_error()
error[0, i] = ueL2
error[1, i] = peL2
error[2, i] = DpeL2
error[3, i] = Dp1eL2
error[4, i] = normuL2
# showsolution(plt, mesh, pde, uh, ph)
x = np.arange(count[i])
fig = plt.figure()
ax1 = fig.add_subplot(121)
ax1.set_title('rp')
ax1.scatter(x, r[0, :count[i]], c='r', marker='.')
ax2 = fig.add_subplot(122)
ax2.set_title('ru')
ax2.scatter(x, r[1, :count[i]], c='b', marker='.')
if i < maxit - 1:
nx = 2 * nx
ny = 2 * ny
tottime = time.time() - t1
print('Total time:', tottime)
print('Solve time:', Stime)
print('err', err)
print('error', error)
print('iter', count)
#mesh.add_plot(plt,cellcolor='w')
#showmultirate(plt,0,Ndof,err,errorType)
showmultirate(plt, 0, Ndof, error, errorType)
plt.show()
'rp = %e' % r[0, count[i] - 1],
ha='center')
plt.yscale('symlog')
ax1.set_yticks([-0.001, 0, 0.0002, 0.0008, 0.0009])
plt.ylim([-0.0001, 0.0009])
ax2 = fig.add_subplot(122)
ax2.set_title('ru')
ax2.scatter(x, r[1, :count[i]], c='b', marker='.')
if i < maxit - 1:
hx = hx / 2
hx = hx.repeat(2)
hy = hy / 2
hy = hy.repeat(2)
tottime = time.time() - t1
print('Total time:', tottime)
print('Solve time:', Stime)
print('err', err)
print('error1', error1)
print('error2', error2)
print('iter', count)
print('Ndof', Ndof)
print('M4P4b30t9')
#mesh.add_plot(plt,cellcolor='w')
#showmultirate(plt,0,Ndof,err,errorType)
showmultirate(plt, 0, Ndof, error1, errorType1)
#plt.savefig("/home/liao/Desktop/M4P4b30t9updp.eps",dpi=None)
showmultirate(plt, 0, Ndof, error2, errorType2)
#plt.savefig("/home/liao/Desktop/M4P4b30t9ucu.eps",dpi=None)
plt.show()
#ruh = curl_recover(uh)
space = LagrangeFiniteElementSpace(mesh, p=1)
rcuh = space.function(dim=1)
rcuh[:] = spr(uh, edge_curl_value) # curl
ruh = space.function(dim=2)
ruh[:, 0] = spr(uh, edge_value_0) #
ruh[:, 1] = spr(uh, edge_value_1)
errorMatrix[0, i] = space.integralalg.L2_error(pde.solution, uh)
errorMatrix[1, i] = space.integralalg.L2_error(pde.curl, uh.curl_value)
errorMatrix[2, i] = space.integralalg.L2_error(pde.solution, ruh)
errorMatrix[3, i] = space.integralalg.L2_error(pde.curl, rcuh)
# 计算单元上的恢复型误差
eta0 = space.integralalg.error(uh.curl_value, rcuh, power=2,
celltype=True) # eta_K
eta1 = space.integralalg.error(uh.value, ruh, power=2,
celltype=True) # xi_K
eta = np.sqrt(eta0**2 + eta1**2) # S_K
errorMatrix[4, i] = np.sqrt(np.sum(eta**2)) # S_h
if i < args.maxit - 1:
isMarkedCell = mark(eta, theta=args.theta)
mesh.bisect(isMarkedCell)
mesh.add_plot(plt)
plt.savefig('./test-' + str(i + 1) + '.eps')
plt.close()
showmultirate(plt, args.maxit - 10, NDof, errorMatrix, errorType, propsize=20)
plt.show()
vem.solve()
eta = vem.recover_estimate(rtype='inv_area', residual=True)
Ndof[i] = vem.space.number_of_global_dofs()
errorMatrix[0, i] = vem.l2_error()
errorMatrix[1, i] = vem.uIuh_error()
errorMatrix[2, i] = vem.L2_error()
if m == 1:
errorMatrix[3, i] = vem.H1_semi_error_Kellogg_1()
else:
errorMatrix[3, i] = vem.H1_semi_error()
errorMatrix[4, i] = np.sqrt(np.sum(eta**2))
if i < maxit - 1:
isMarkedCell = quadtree.refine_marker(eta, theta, method="L2")
quadtree.refine(isMarkedCell)
mesh = quadtree.to_pmesh()
mesh.add_plot(plt, showaxis=True)
fig2 = plt.figure()
fig2.set_facecolor('white')
axes = fig2.gca(projection='3d')
x = mesh.node[:, 0]
y = mesh.node[:, 1]
tri = quadtree.leaf_cell(celltype='tri')
axes.plot_trisurf(x, y, tri, vem.uh[:len(x)], cmap=plt.cm.jet, lw=0.0)
showmultirate(plt, k, Ndof, errorMatrix[2:, :], errorType[2:])
plt.show()
e = fem.recover_estimate()
bc = mesh.barycenter()
e = 1 / np.exp(bc[:, 2]**2)**2
h, ch = node_sizing(mesh, e, eta=1, smooth=6)
errorMatrix[3, i] = np.sqrt(np.sum(e**2))
if i < maxit - 1:
mesh.uniform_refine(1, surface)
fem.reinit(mesh)
meshio.write_obj_mesh(mesh, 'spheretrimesh.obj')
np.savetxt('size.txt', h)
fig = plt.figure()
fig.set_facecolor('white')
axes = fig.gca(projection='3d')
x = mesh.point[:, 0]
y = mesh.point[:, 1]
z = mesh.point[:, 2]
mesh.add_plot(axes, cellcolor=ch, showcolorbar=True)
#axes.plot_trisurf(x, y, z, triangles=mesh.ds.cell, cmap=plt.cm.jet, lw=0.0)
fig = plt.figure()
fig.set_facecolor('white')
axes = fig.gca()
optionlist = [
'k-*', 'b-o', 'r--^', 'g->', 'm-8', 'c-D', 'y-x', 'y-+', 'y-h', 'y-p'
]
showmultirate(axes, 0, Ndof, errorMatrix[:4, :], optionlist[:4], errorType[:4])
axes.legend(loc=3, prop={'size': 30})
plt.show()
Ndof = np.zeros((maxit,), dtype=np.int)
errorMatrix = np.zeros((len(errorType), maxit), dtype=np.float)
marker = AdaptiveMarker2d(model.interface, maxh=0.1, maxa=2)
alg = QuadtreeInterfaceMesh2d(quadtree, marker)
pmesh= alg.get_interface_mesh()
pmesh.add_plot(plt, cellcolor='w')
integrator = TriangleQuadrature(3)
vem = PoissonInterfaceVEMModel(model, pmesh, p=1, integrator=integrator)
for i in range(maxit):
print('step:', i)
vem.solve()
Ndof[i] = vem.vemspace.number_of_global_dofs()
errorMatrix[0, i] = vem.l2_error()
errorMatrix[1, i] = vem.uIuh_error()
errorMatrix[2, i] = vem.L2_error()
errorMatrix[3, i] = vem.H1_semi_error()
errorMatrix[4, i] = np.sqrt(np.sum(eta**2))
if i < maxit - 1:
quadtree.uniform_refine()
pmesh = alg.get_interface_mesh()
vem.reinit(pmesh)
k,l = 0, 4
showmultirate(plt, k, Ndof, errorMatrix[:l, :], errorType[:l])
plt.show()
fig2 = plt.figure()
fig2.set_facecolor('white')
axes = fig2.gca(projection='3d')
x = mesh.point[:, 0]
y = mesh.point[:, 1]
s = axes.plot_trisurf(x,
y,
fem.uh,
triangles=mesh.ds.cell,
cmap=plt.cm.jet,
lw=0.0)
fig2.colorbar(s)
fig2.savefig(d + '/solution.pdf')
fig3 = plt.figure(figsize=(40, 40), facecolor='w')
axes = fig3.gca()
optionlist = [
'k-*', 'b-o', 'r--^', 'g->', 'm-8', 'c-D', 'y-x', 'y-+', 'y-h', 'y-p'
]
showmultirate(axes, k, Ndof, errorMatrix, optionlist, errorType)
#optionlist = ['k-*', 'r-^']
#showmultirate(axes, k, Ndof, errorMatrix[4:7:2], optionlist, errorType[4:7:2])
axes.legend(loc=3, prop={'size': 60})
axes.tick_params(labelsize=60)
axes.axis('tight')
fig3.savefig(d + '/error.pdf')
plt.show()
from fealpy.pde.poisson_2d import CosCosData
from fealpy.fem.PoissonFEMModel import PoissonFEMModel
from fealpy.tools.show import showmultirate
p = int(sys.argv[1])
q = int(sys.argv[2])
n = int(sys.argv[3])
pde = CosCosData()
mesh = pde.init_mesh(n=n, meshtype='tri')
integrator = mesh.integrator(q)
maxit = 4
errorType = ['$|| u - u_h||_{0}$', '$||\\nabla u - \\nabla u_h||_{0}$']
Ndof = np.zeros((maxit,), dtype=np.int)
errorMatrix = np.zeros((len(errorType), maxit), dtype=np.float)
for i in range(maxit):
fem = PoissonFEMModel(pde, mesh, p, integrator)
fem.solve()
Ndof[i] = fem.femspace.number_of_global_dofs()
errorMatrix[0, i] = fem.get_L2_error()
errorMatrix[1, i] = fem.get_H1_error()
if i < maxit - 1:
mesh.uniform_refine()
print('Ndof:', Ndof)
print('error:', errorMatrix)
showmultirate(plt, 0, Ndof, errorMatrix[:3, :], errorType[:3])
plt.show()
mesh = rectangledomainmesh([-2, 2, -2, 2],
nx=n,
ny=n,
meshtype='polygon')
vem.reinit(mesh)
data['errorMatrix'] = errorMatrix
data['Ndof'] = Ndof
fo = 'uh{}.mat'.format(p)
sio.matlab.savemat(fo.format(i + 1), data)
mesh.add_plot(plt, cellcolor='w')
show_error_table(Ndof, errorType, errorMatrix)
#fig2 = plt.figure()
#fig2.set_facecolor('white')
#axes = fig2.gca(projection='3d')
#x = mesh.point[:, 0]
#y = mesh.point[:, 1]
#tri = quadtree.leaf_cell(celltype='tri')
#s = axes.plot_trisurf(x, y, tri, vem.uh[:len(x)], cmap=plt.cm.jet, lw=0.0)
#fig2.colorbar(s)
#
#fig3 = plt.figure()
#fig3.set_facecolor('white')
#axes = fig3.gca(projection='3d')
#s = axes.plot_trisurf(x, y, tri, vem.uI-vem.gI, cmap=plt.cm.jet, lw=0.0)
#fig3.colorbar(s)
showmultirate(plt, 0, Ndof, errorMatrix, errorType)
plt.show()
]
errorMatrix = np.zeros((2, maxit), dtype=np.float)
NDof = np.zeros(maxit, dtype=np.float)
for i in range(maxit):
mesh = mf.boxmesh2d(box, nx=n, ny=n, meshtype='poly')
space = ConformingVirtualElementSpace2d(mesh, p=p)
NDof[i] = space.number_of_global_dofs()
uh = space.function()
bc = DirichletBC(space, pde.dirichlet)
A = space.stiff_matrix()
F = space.source_vector(pde.source)
A, F = bc.apply(A, F, uh)
uh[:] = spsolve(A, F)
sh = space.project_to_smspace(uh)
errorMatrix[0, i] = space.integralalg.error(pde.solution, sh.value)
errorMatrix[1, i] = space.integralalg.error(pde.gradient, sh.grad_value)
uI = space.interpolation(pde.solution)
n *= 2
mesh.add_plot(plt)
uh.add_plot(plt, cmap='rainbow')
showmultirate(plt, 0, NDof, errorMatrix, errorType, propsize=20, lw=2, ms=4)
plt.show()
uh = space.function()
A = space.stiff_matrix()
F = space.source_vector(pde.source)
bc = NeumannBC(space, pde.neumann)
A, F = bc.apply(
F, A=A) # Here is the case for pure Neumann bc, we also need modify A
# bc.apply(F) # Not pure Neumann bc case
uh[:] = spsolve(A, F)[:-1] # we add a addtional dof
# Here can not work
#ml = pyamg.ruge_stuben_solver(A)
#x = ml.solve(F, tol=1e-12, accel='cg').reshape(-1)
#uh[:] = x[-1]
errorMatrix[0, i] = space.integralalg.L2_error(pde.solution, uh)
errorMatrix[1, i] = space.integralalg.L2_error(pde.gradient, uh.grad_value)
if i < maxit - 1:
mesh.uniform_refine()
if d == 2:
fig = plt.figure()
axes = fig.gca(projection='3d')
uh.add_plot(axes, cmap='rainbow')
elif d == 3:
print('The 3d function plot is not been implemented!')
showmultirate(plt, 0, NDof, errorMatrix, errorType, propsize=20)
plt.show()
markedCell = mark(eta1, theta)
if i < maxit - 1:
mesh.bisect(markedCell)
fig2 = plt.figure()
fig2.set_facecolor('white')
axes = fig2.gca(projection='3d')
node = mesh.entity('node')
x = mesh.node[:, 0]
y = mesh.node[:, 1]
s = axes.plot_trisurf(x,
y,
fem.uh,
triangles=mesh.ds.cell,
cmap=plt.cm.jet,
lw=0.0)
fig2.colorbar(s)
fig2.savefig(d + '/solution.pdf')
fig3 = plt.figure(figsize=(40, 40), facecolor='w')
axes = fig3.gca()
axes = showmultirate(axes, k, Ndof, errorMatrix[4:7:2, :], errorType[4:7:2])
#optionlist = ['k-*', 'r-^']
#showmultirate(axes, k, Ndof, errorMatrix[4:7:2], optionlist, errorType[4:7:2])
axes.legend(loc=3, prop={'size': 60})
axes.tick_params(labelsize=60)
axes.axis('tight')
fig3.savefig(d + '/error.pdf')
plt.show()
