def reinit(self, mesh):
self.femspace = LagrangeFiniteElementSpace(mesh, p=1)
self.uh = self.femspace.function()
self.uI = self.femspace.interpolation(self.pde.solution)
self.cellmeasure = mesh.entity_measure('cell')
self.integralalg = IntegralAlg(self.integrator, self.mesh,
self.cellmeasure)
def __init__(self, pde, mesh, p, integrator):
self.femspace = LagrangeFiniteElementSpace(mesh, p)
self.mesh = self.femspace.mesh
self.pde = pde
self.uh = self.femspace.function()
self.uI = self.femspace.interpolation(pde.solution)
self.cellmeasure = mesh.entity_measure('cell')
self.integrator = integrator
self.integralalg = IntegralAlg(self.integrator, self.mesh,
self.cellmeasure)
def __init__(self, pde, mesh, integrator):
self.space0 = VectorLagrangeFiniteElementSpace(mesh, 0, spacetype='D')
self.space1 = LagrangeFiniteElementSpace(mesh, 1, spacetype='C')
self.pde = pde
self.mesh = self.femspace.mesh
self.uh = self.space0.function()
self.ph = self.space1.function()
self.cellmeasure = mesh.entity_measure('cell')
self.integrator = integrator
self.lfem = DarcyP0P1(self.pde, self.mesh, p, integrator)
self.uh0,self.ph0 = self.lfem.solve()
self.integralalg = IntegralAlg(self.integrator, self.mesh, self.cellmeasure)
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()
mesh.add_plot(axes)
mesh.find_node(axes, index=isExtremeNode)
fig2 = plt.figure()
t = 0.7561523
p = 1
n = 3
#pde = SpaceMeasureDiracSourceData()
pde = TimeMeasureDiracSourceData()
mesh = pde.init_mesh(n)
node = mesh.entity('node')
cell = mesh.entity('cell')
print('cell', cell.shape)
bc = mesh.entity_barycenter('cell')
integrator = mesh.integrator(p + 2)
cellmeasure = mesh.entity_measure('cell')
space = LagrangeFiniteElementSpace(mesh, p, spacetype='C')
integralalg = FEMeshIntegralAlg(integrator, mesh)
uI = space.interpolation(lambda x: pde.solution(x, t))
#uI = pde.solution(node,p=node, t=t)
gu = pde.gradient
#uI = space.function()
guI = uI.grad_value
eta = integralalg.L2_error(gu, guI, celltype=True) # size = (cell.shape[0], 2)
eta = np.sum(eta, axis=-1)
print('eta', eta.shape)
tmesh = TriangleMesh(node, cell)
mark = mark(eta, 0.75)
options = tmesh.adaptive_options(method='mean',
maxrefine=10,
maxcoarsen=0,
'$\|\\nabla u - G(\\nabla u_h)\|$',
'$\|\Delta u - \\nabla\cdot G(\\nabla u_h)\|$',
'$\|\Delta u - G(\\nabla\cdot G(\\nabla u_h))\|$',
'$\|G(\\nabla\cdot G(\\nabla u_h)) - \\nabla\cdot G(\\nabla u_h)\|$'
]
errorMatrix = np.zeros((len(errorType), maxit), dtype=np.float)
for i in range(maxit):
if meshtype == 1: #fishbone mesh
mesh = fishbone(box,n)
integrator = mesh.integrator(3)
mesh.add_plot(plt,cellcolor='w')
V = LagrangeFiniteElementSpace(mesh,p=1)
V2 = VectorLagrangeFiniteElementSpace(mesh,p=1)
uh = FiniteElementFunction(V)
rgh = FiniteElementFunction(V2)
rlh = FiniteElementFunction(V)
fem = BiharmonicRecoveryFEMModel(mesh, pde,integrator,rtype=rtype)
bc = DirichletBC(V, pde.dirichlet)
solve(fem, uh, dirichlet=bc, solver='direct')
fem.recover_grad() #TODO
fem.recover_laplace()
eta1 = fem.grad_recover_estimate()
eta2 = fem.laplace_recover_estimate()
class DarcyForchheimerP0P1():
def __init__(self, pde, mesh, integrator):
self.space0 = VectorLagrangeFiniteElementSpace(mesh, 0, spacetype='D')
self.space1 = LagrangeFiniteElementSpace(mesh, 1, spacetype='C')
self.pde = pde
self.mesh = self.femspace.mesh
self.uh = self.space0.function()
self.ph = self.space1.function()
self.cellmeasure = mesh.entity_measure('cell')
self.integrator = integrator
self.lfem = DarcyP0P1(self.pde, self.mesh, p, integrator)
self.uh0,self.ph0 = self.lfem.solve()
self.integralalg = IntegralAlg(self.integrator, self.mesh, self.cellmeasure)
def get_left_matrix(self):
bc = np.array([1/3, 1/3, 1/3], dtype=self.ftype)
phi = self.space0.basis(bc)
gphi = self.space1.grad_basis(bc)
A21 = np.einsum('ijm, km, i->ijk', gphi, phi, self.cellmeasure)
cell2dof0 = self.space0.cell_to_dof()
ldof0 = self.space0.number_of_local_dofs()
cell2dof1 = self.space1.cell_to_dof()
ldof1 = space.number_of_local_dofs()
I = np.einsum('ij, k->ijk', cell2dof1, np.ones(ldof0))
J = np.einsum('ij, k->ikj', cell2dof0, np.ones(ldof1))
gdof = space.number_of_global_dofs()
# Construct the stiffness matrix
A21 = csr_matrix((A12.flat, (I.flat, J.flat)), shape=(gdof, gdof))
return A
def get_right_vector(self):
mesh = self.mesh
cellmeasure = self.cellmeasure
node = mesh.node
edge = mesh.ds.edge
cell = mesh.ds.cell
NN = mesh.number_of_nodes()
bc = mesh.entity_barycenter('cell')
ft = self.pde.f(bc)*np.c_[cellmeasure,cellmeasure]
f = np.ravel(ft,'F')
cell2edge = mesh.ds.cell_to_edge()
ec = mesh.entity_barycenter('edge')
mid1 = ec[cell2edge[:, 1],:]
mid2 = ec[cell2edge[:, 2],:]
mid3 = ec[cell2edge[:, 0],:]
bt1 = cellmeasure*(self.pde.g(mid2) + self.pde.g(mid3))/6
bt2 = cellmeasure*(self.pde.g(mid3) + self.pde.g(mid1))/6
bt3 = cellmeasure*(self.pde.g(mid1) + self.pde.g(mid2))/6
b = np.bincount(np.ravel(cell,'F'),weights=np.r_[bt1,bt2,bt3], minlength=NN)
isBDEdge = mesh.ds.boundary_edge_flag()
edge2node = mesh.ds.edge_to_node()
bdEdge = edge[isBDEdge,:]
ec = mesh.entity_barycenter('edge')
d = np.sqrt(np.sum((node[edge2node[isBDEdge,0],:]\
- node[edge2node[isBDEdge,1],:])**2,1))
mid = ec[isBDEdge,:]
ii = np.tile(d*self.pde.Neumann_boundary(mid)/2,(1,2))
g = np.bincount(np.ravel(bdEdge,'F'),\
weights=np.ravel(ii), minlength=NN)
g = g - b
return np.r_[f,g]
def solve(self):
mesh = self.mesh
node = mesh.node
edge = mesh.ds.edge
cell = mesh.ds.cell
cellmeasure = self.cellmeasure
NN = mesh.number_of_nodes()
NC = mesh.number_of_cells()
A = self.get_left_matrix()
A11 = A[:2*NC,:2*NC]
A12 = A[:2*NC,2*NC:]
A21 = A[2*NC:,:2*NC]
b = self.get_right_vector()
mu = self.pde.mu
rho = self.pde.rho
beta = self.pde.beta
alpha = self.pde.alpha
tol = self.pde.tol
maxN = self.pde.maxN
ru = 1
rp = 1
## P-R iteration for D-F equation
n = 0
r = np.ones((2,maxN),dtype=np.float)
area = np.r_[cellmeasure,cellmeasure]
## Knowing (u,p), explicitly compute the intermediate velocity u(n+1/2)
F = self.uh0/alpha - (mu/rho)*self.uh0 - ([email protected] - b[:2*NC])/area
FL = np.sqrt(F[:NC]**2 + F[NC:]**2)
gamma = 1.0/(2*alpha) + np.sqrt((1.0/alpha**2) + 4*(beta/rho)*FL)/2
uhalf = F/np.r_[gamma,gamma]
## Direct Solver
Aalpha = A11 + spdiags(area/alpha, 0, 2*NC,2*NC)
while ru+rp > tol and n < maxN:
## solve the linear Darcy equation
uhalfL = np.sqrt(uhalf[:NC]**2 + uhalf[NC:]**2)
fnew = b[:2*NC] + uhalf*area/alpha\
- beta/rho*uhalf*np.r_[uhalfL,uhalfL]*area
## Direct Solver
Aalphainv = inv(Aalpha)
Ap = A21@Aalphainv@A12
bp = A21@(Aalphainv@fnew) - b[2*NC:]
p = np.zeros(NN,dtype=np.float)
p[1:] = spsolve(Ap[1:,1:],bp[1:])
c = np.sum(np.mean(p[cell],1)*cellmeasure)/np.sum(cellmeasure)
p = p - c
u = Aalphainv@(fnew - A12@p)
## Step1:Solve the nonlinear Darcy equation
F = u/alpha - (mu/rho)*u - (A12@p - b[:2*NC])/area
FL = np.sqrt(F[:NC]**2 + F[NC:]**2)
gamma = 1.0/(2*alpha) + np.sqrt((1.0/alpha**2) + 4*(beta/rho)*FL)/2
uhalf = F/np.r_[gamma,gamma]
## Updated residual and error of consective iterations
n = n + 1
uLength = np.sqrt(u[:NC]**2 + u[NC:]**2)
Lu = A11@u + (beta/rho)*np.tile(uLength*cellmeasure,(1,2))*u + A12@p
ru = norm(b[:2*NC] - Lu)/norm(b[:2*NC])
if norm(b[2*NC:]) == 0:
rp = norm(b[2*NC:] - A21@u)
else:
rp = norm(b[2*NC:] - A21@u)/norm(b[2*NC:])
self.uh0 = u
self.ph0 = p
r[0,n] = ru
r[1,n] = rp
self.u = u
self.p = p
return u,p
def get_pL2_error(self):
p = self.pde.pressure
ph = self.ph.value
pL2 = self.integralalg.L2_error(p,ph)
return pL2
def get_uL2_error(self):
mesh = self.mesh
bc = mesh.entity_barycenter('cell')
uI = self.pde.velocity(bc)
uh = self.uh.value
u = self.pde.velocity
# self.integralalg = IntegralAlg(self.integrator, self.mesh, self.cellmeasure)
uL2 = self.integralalg.L2_error(u,uh)
return uL2
def get_H1_error(self):
mesh = self.mesh
gp = self.pde.grad_pressure
u,p = self.solve()
gph = p.grad_value
H1 = self.integralalg.L2_error(gp, gph)
return H1
class PoissonAdaptiveFEMModel(object):
def __init__(self, pde, mesh, p, integrator):
self.femspace = LagrangeFiniteElementSpace(mesh, p)
self.mesh = self.femspace.mesh
self.pde = pde
self.uh = self.femspace.function()
self.uI = self.femspace.interpolation(pde.solution)
self.cellmeasure = mesh.entity_measure('cell')
self.integrator = integrator
self.integralalg = IntegralAlg(self.integrator, self.mesh,
self.cellmeasure)
def reinit(self, mesh):
self.femspace = LagrangeFiniteElementSpace(mesh, p=1)
self.uh = self.femspace.function()
self.uI = self.femspace.interpolation(self.pde.solution)
self.cellmeasure = mesh.entity_measure('cell')
self.integralalg = IntegralAlg(self.integrator, self.mesh,
self.cellmeasure)
def recover_estimate(self):
if self.femspace.p > 1:
raise ValueError('This method only work for p=1!')
femspace = self.femspace
mesh = femspace.mesh
node2cell = mesh.ds.node_to_cell()
inv = 1 / self.cellmeasure
asum = node2cell @ inv
bc = np.array([1 / 3] * 3, dtype=np.float)
guh = self.uh.grad_value(bc)
rguh = self.femspace.function(dim=mesh.geo_dimension())
rguh[:] = np.asarray(
node2cell @ (guh * inv.reshape(-1, 1))) / asum.reshape(-1, 1)
qf = self.integrator
bcs, ws = qf.quadpts, qf.weights
val0 = rguh.value(bcs)
val1 = self.uh.grad_value(bcs)
l = np.sum((val1 - val0)**2, axis=-1)
e = np.einsum('i, ij->j', ws, l)
e *= self.cellmeasure
return np.sqrt(e)
def get_left_matrix(self):
return doperator.stiff_matrix(self.femspace, self.integrator,
self.cellmeasure)
def get_right_vector(self):
return doperator.source_vector(self.pde.source, self.femspace,
self.integrator, self.cellmeasure)
def solve(self):
bc = DirichletBC(self.femspace, self.pde.dirichlet)
self.A, b = solve(self, self.uh, dirichlet=bc, solver='direct')
def l2_error(self):
e = self.uh - self.uI
return np.sqrt(np.mean(e**2))
def L2_error(self):
u = self.pde.solution
uh = self.uh.value
return self.integralalg.L2_error(u, uh)
def H1_semi_error(self):
gu = self.pde.gradient
guh = self.uh.grad_value
return self.integralalg.L2_error(gu, guh)
import numpy as np from fealpy.functionspace.lagrange_fem_space import LagrangeFiniteElementSpace from fealpy.mesh import TriangleMesh 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) mesh = TriangleMesh(point, cell) V = LagrangeFiniteElementSpace(mesh, p=3) f = V.function(dim=3) c = np.random.rand(f.shape[0], f.shape[1]) f += c print(f.V)
from fealpy.functionspace.lagrange_fem_space import LagrangeFiniteElementSpace
from fealpy.mesh.TriangleMesh import TriangleMesh
degree = int(sys.argv[1])
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)
mesh = TriangleMesh(point, cell)
V = LagrangeFiniteElementSpace(mesh, degree)
bc = np.array([(0.1, 0.2, 0.7), (0.3, 0.4, 0.3)])
for b in bc:
print(V.basis(b))
#print(V.basis_einsum(bc))
ipoints = V.interpolation_points()
cell2dof = V.cell_to_dof()
fig, axes = plt.subplots(1, 3)
mesh.add_plot(axes[0])
mesh.find_node(axes[0], node=ipoints, showindex=True)
for ax in axes.reshape(-1)[1:]:
ax.axis('tight')
theta = 0.35
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(4)
integrator = mesh.integrator(3)
node = mesh.entity('node')
cell = mesh.entity('cell')
tmesh = Tritree(node, cell)
femspace = LagrangeFiniteElementSpace(mesh, p=1)
integralalg = FEMeshIntegralAlg(integrator, mesh)
qf = integrator
bcs, ws = qf.quadpts, qf.weights
u1 = femspace.interpolation(f1)
grad = femspace.grad_value(u1, bcs, cellidx=None)
eta1 = integralalg.L2_norm1(grad, celltype=True)
u2 = femspace.interpolation(f2)
grad = femspace.grad_value(u2, bcs, cellidx=None)
eta2 = integralalg.L2_norm1(grad, celltype=True)
isMarkedCell = tmesh.refine_marker(eta2, theta, "MAX")
tmesh.refine(isMarkedCell)