def __init__(self, degree):
b_degree = degree - 3
x = Symbol('x')
poly_set = leg.basis_functions(deg=degree)
pts0 = gauss_legendre_points(b_degree+1)[1:-1]
pts1 = np.array([-1., 1.])
# The coefficient matrix
B = np.zeros((degree+1, degree+1))
B[:, 0] = [(-1)**k for k in range(degree+1)] # Values are (-1)
B[:, 1] = np.ones(degree+1) # Values at (1)
# Val at -1, val at 1, dval at -1, dval at 1, the rest of polyevaluas.
for row, f in enumerate(poly_set):
vals = lambdify(x, f, 'numpy')(pts0)
if isinstance(vals, (int, float)): vals = vals*np.ones(len(pts0))
dvals = lambdify(x, f.diff(x, 1), 'numpy')(pts1)
if isinstance(dvals, (int, float)): dvals = dvals*np.ones(len(pts1))
B[row, 2:4] = dvals
B[row, 4:] = vals
# Invert to get the coefficients of the nodal basis
self.alpha = np.linalg.inv(B)
# Having coeffcient comes in handy if some matrix M is given w.r.t
# poly_set basis then alpha.M.alpha.T is the matrix represented in
# nodal basis
# Symbolic nodal basis
self.sym_basis = [sum(c*f for c, f in zip(row, poly_set))
for row in self.alpha]
# For numerical evaluation the row in alpha are coeffcients of Legendre
# polynomials so we can use legval
# Finally remember the dofs as coordinates val, val, dval, dval
self.dofs = np.hstack([pts1, pts1, pts0])
# And my finite element
self.cell = ReferenceIntervalCell()
# HACK computing df/dx without the derivatives. This is exact for P3 and
# lower. Represent the L(f) = df/dx(p) = \int Riesz(L) * f dx
# Riesz(L) = l is a polynomial of degree 3-compute its coeficients
# They are given by mass matrix of the nodal basis
xq, wq = np.polynomial.legendre.leggauss(degree+1)
M = self.alpha.dot(leg.mass_matrix(degree).dot(self.alpha.T))
beta = np.linalg.inv(M)
# Now I have expansion w.r.t nodal. Combine with alpha to get Legendre
# beta = beta.dot(self.alpha)
# beta[2:4] are the coefs of df/dx eval at -1 and 1. Need them only at
# quadrature points
self.riesz = (np.polynomial.legendre.legval(xq, beta[2].dot(self.alpha)),
np.polynomial.legendre.legval(xq, beta[3].dot(self.alpha)))
# Remember these for later evaluations
self.quad = xq, wq
def solve(n_cells, degree=3, with_plot=False):
# Space
# element = HermiteElement(degree)
poly_set = leg.basis_functions(degree)
dof_set = equidistant_points(degree)
element = LagrangeElement(poly_set, dof_set)
a, b = -1., 1.
mesh = IntervalMesh(a=a, b=b, n_cells=n_cells)
V = FunctionSpace(mesh, element)
# Need mass matrix to intefrate the rhs
Mget_geom_tensor = lambda cell: 1./cell.Jac
M = assemble_matrix(V, 'mass', Mget_geom_tensor, timer=0)
# Stiffness matrix for Laplacian
Aget_geom_tensor = lambda cell: cell.Jac
A = assemble_matrix(V, 'stiff', Aget_geom_tensor, timer=0)
print 'M sym', is_symmetric(M)
print 'A sym', is_symmetric(A)
ew, ev = eigh(A.toarray(), M.toarray())
ew = np.abs(ew)
# Now add inner(dot(grad(u), n), v)*ds
G = get_G(V)
# A = A - G
# print 'A sym', is_symmetric(A)
# ew, ev = eig(A.toarray())#, M.toarray())
# ew = np.sort(np.abs(ew))[:3]
# print ew
# from sympy import symbols, sqrt, S
# x = symbols('x')
# nullspace = map(Expression, [S(1/2.), sqrt(3/2.)*x])
# Z = [V.interpolate(f).vector for f in nullspace]
# print [np.inner(pi_z, A.dot(pi_z)) for pi_z in Z]
print 'xxx'
print M.toarray()
print
print A.toarray()
print
print G.toarray()
def get_bubble(deg):
x = Symbol('x')
poly_set = leg.basis_functions(deg=deg)
pts = np.r_[-1, 1, chebyshev_points(deg)[1:-1]]
A = np.zeros((deg+1, deg+1))
for col, f in enumerate(poly_set):
A[:, col] = lambdify(x, poly_set[col], 'numpy')(pts)
b = np.zeros(deg+1)
nodal_pt_index = -1 if deg % 2 else -deg/2
b[nodal_pt_index] = 1
bubble = np.linalg.solve(A, b)
bubble_dof = pts[nodal_pt_index] # Point eval here
# Return coefs of bubble w.r.t legendre and the node
return bubble, bubble_dof
from __future__ import division
import sys
sys.path.append('../')
import polynomials.legendre_basis as leg
from points import chebyshev_points
from sympy import lambdify, Symbol, integrate
from sympy.plotting import plot
import numpy as np
deg = 10
# Suppose I want to find some polynomial of degree 2 over -1, 1 that has
# 0 boundary values
x = Symbol('x')
poly_set = leg.basis_functions(deg=deg)
# f = a*l0 + b*l1 + c*l2
# Suppose we reure that the L-2 norm is 1
# [f(-1)=0] = [l0(-1), l1(-1), l2(-1) ] [a]
# [f(1)=0 ] = [l0(1), l1(1), l2(1) ] [b]
# [norm=1 ] = [(l0, l0), ... [c]
# suppose instead nodality at 0
# [f(0) = 1] = .....
A = np.zeros((deg+1, deg+1))
pts = np.r_[-1, 1, chebyshev_points(deg)[1:-1]]
for col, f in enumerate(poly_set):
A[:, col] = lambdify(x, poly_set[col], 'numpy')(pts)
return f.eval_cell(cell.map_from_reference(self.dofs[i]), cell)
def eval_dofs(self, f, cell=None):
'''Evaluate all dofs'''
return np.vstack([self.eval_dof(i, f, cell) for i in range(self.dim)])
# -----------------------------------------------------------------------------
if __name__ == '__main__':
from sympy import integrate
from numpy.polynomial.legendre import leggauss
from function import Expression
degree = 4
element = HermiteElement(degree)
poly_set = leg.basis_functions(degree)
x = Symbol('x')
from mesh import IntervalCell
import matplotlib.pyplot as plt
fig, (ax0, ax1) = plt.subplots(2, 1, sharex=True)
# Funcions and derivatives. Check continuity
for a, b in [(-1.4, -1), (-1, 1), (1, 2), (2, 4)]:
x = np.linspace(a, b, 100)
cell = IntervalCell(np.array([[a], [b]]))
for i, color in zip(range(element.dim), ['r', 'b', 'g', 'c', 'm', 'k']):
y = element.eval_basis(i, x, cell)
ax0.plot(x, y, color=color)
def cg_optimal_dofs_restricted(deg, vary=0):
'''
What are optimal dofs that give smallest condition number in L^2 norm.
By CG I mean that I constraint two dofs to be at (-1, 1). The remaining
deg-1 points are to be determined. For even degrees symmetry is dof at 0 is
also forced
For vary None: the symmetry is used and `all` the points are used for
search, i.e. this is multi-d problem.
For vary=int: that guy and its mirror are changed, i.e. this is
1-d optimization problem.
'''
poly_set = leg.basis_functions(deg)
M = leg.mass_matrix(deg)
# Only allow negative (make life easier for mirroring) and not midpoint or -1
if vary: assert 0 < vary < (deg/2 + 1 if deg % 2 else deg/2)
# Want to minimize this
def cond_number(x):
# 2: [-1, y0, -1]
# (3, 4): [-1, y0, -y0, -1], [-1, -y0, 0, y0, 1],
# (5, 6): [-1, y0, y1, -y1, -y0, -1], [-1, y0, y1, 0, -y1, -y0, -1]
# One-d optimzation
if vary:
x_ = chebyshev_points(deg)
x_[vary] = x
x_[deg-vary] = -x
dof_set = x_
# Multi-d optimization
else:
if deg == 2:
dof_set = np.r_[-1, x, 1]
# Combine no zero
elif deg % 2 == 1:
dof_set = np.r_[-1, x, -x[::-1], 1]
# Combine w/ zero
else:
dof_set = np.r_[-1, x, 0, -x[::-1], 1]
element = LagrangeElement(poly_set, dof_set)
alpha = element.alpha
M_ = alpha.dot(M.dot(alpha.T))
return np.linalg.cond(M_)
# Initial guess
# 1d optim
x0 = chebyshev_points(deg)
if vary:
x0 = x0[vary]
else:
# Multi-d optim
if deg == 2:
x0 = x0[1]
# Combine no zero
elif deg % 2 == 1:
x0 = x0[1:deg/2+1]
else:
x0 = x0[1:deg/2]
# Optimize
res = minimize(cond_number, x0)
return res, x0, cond_number(x0)
def _solve(mode, points, degree, n_cells, u, f):
'''
In mode == convergence:
Solve -u`` = f with dirichet bcs bdry of (-1, 1) given by exact solution.
The Vh space is CG_space of degree elements and n_cells. Return hmin, error
for convergence computation.
In mode == cond:
Just return h and the matrix A.
'''
# Element. The polynomial space is spanned by Legendre basis
poly_set = leg.basis_functions(degree)
dof_set = points(degree)
element = LagrangeElement(poly_set, dof_set)
# Mesh
mesh = IntervalMesh(a=-1, b=1, n_cells=n_cells)
# Space
V = FunctionSpace(mesh, element)
bc = DirichletBC(V, u)
# Need mass matrix to intefrate the rhs
Mpoly_matrix = leg.mass_matrix(degree)
Mget_geom_tensor = lambda cell: 1./cell.Jac
M = assemble_matrix(V, Mpoly_matrix, Mget_geom_tensor, timer=0)
# Stiffness matrix for Laplacian
Apoly_matrix = leg.stiffness_matrix(degree)
Aget_geom_tensor = lambda cell: cell.Jac
A = assemble_matrix(V, Apoly_matrix, Aget_geom_tensor, timer=0)
# Interpolant of source
fV = V.interpolate(f)
# Integrate in L2 to get the vector
b = M.dot(fV.vector)
# Apply boundary conditions
bc.apply(A, b, True)
x = spsolve(A, b)
if mode == 'condition':
return mesh.hmin(), A
# As function
uh = Function(V, x)
# Error norm
# Higher order DG element
fine_degree = degree + 3
poly_set = leg.basis_functions(fine_degree)
dof_set = chebyshev_points(fine_degree)
element = LagrangeElement(poly_set, dof_set)
# THe space
V_fine = FunctionSpace(mesh, element, 'L2')
# Interpolate exact solution to fine
u_fine = V_fine.interpolate(u)
# Interpolate approx solution fine
uh_fine = V_fine.interpolate(uh)
# Difference vector
e = u_fine.vector - uh_fine.vector
# Need matrix for integration of H10 norm
Apoly_matrix = leg.stiffness_matrix(fine_degree)
A_fine = assemble_matrix(V_fine, Apoly_matrix, Aget_geom_tensor, timer=1)
# Integrate the error
e = sqrt(np.sum(e*A_fine.dot(e)))
# Mesh size
hmin = mesh.hmin()
return hmin, e
def solve(n_cells, degree=3, with_plot=False):
# Problem
w = 3 * np.pi
x = Symbol("x")
u = sin(w * x)
f = -u.diff(x, 2)
# As Expr
u = Expression(u)
f = Expression(f)
# Space
# element = HermiteElement(degree)
poly_set = leg.basis_functions(degree)
dof_set = chebyshev_points(degree)
element = LagrangeElement(poly_set, dof_set)
mesh = IntervalMesh(a=-1, b=1, n_cells=n_cells)
V = FunctionSpace(mesh, element)
bc = DirichletBC(V, u)
# Need mass matrix to intefrate the rhs
M = assemble_matrix(V, "mass", get_geom_tensor=None, timer=0)
# NOTE We cannot you apply the alpha transform idea because the functions
# are mapped with this selective weight on 2nd, 3rd functions. So some rows
# of alpha would have to be multiplied by weights which are cell specific.
# And then on top of this there would be a dx = J*dy term. Better just to
# use the qudrature representations
# Mpoly_matrix = leg.mass_matrix(degree)
# M_ = assemble_matrix(V, Mpoly_matrix, Mget_geom_tensor, timer=0)
# Stiffness matrix for Laplacian
A = assemble_matrix(V, "stiffness", get_geom_tensor=None, timer=0)
# NOTE the above
# Apoly_matrix = leg.stiffness_matrix(degree)
# A_ = assemble_matrix(V, Apoly_matrix, Aget_geom_tensor, timer=0)
# Interpolant of source
fV = V.interpolate(f)
# Integrate in L2 to get the vector
b = M.dot(fV.vector)
# Apply boundary conditions
bc.apply(A, b, True)
x = spsolve(A, b)
# As function
uh = Function(V, x)
# This is a (slow) way of plotting the high order
if with_plot:
fig = plt.figure()
ax = fig.gca()
uV = V.interpolate(u)
for cell in Cells(mesh):
a, b = cell.vertices[0, 0], cell.vertices[1, 0]
x = np.linspace(a, b, 100)
y = uh.eval_cell(x, cell)
ax.plot(x, y, color=random.choice(["b", "g", "m", "c"]))
y = uV.eval_cell(x, cell)
ax.plot(x, y, color="r")
y = u.eval_cell(x, cell)
ax.plot(x, y, color="k")
plt.show()
# Error norm in CG high order
fine_degree = degree + 3
poly_set = leg.basis_functions(fine_degree)
dof_set = chebyshev_points(fine_degree)
element = LagrangeElement(poly_set, dof_set)
V_fine = FunctionSpace(mesh, element)
# Interpolate exact solution to fine
u_fine = V_fine.interpolate(u)
# Interpolate approx solution fine
uh_fine = V_fine.interpolate(uh)
# Difference vector
e = u_fine.vector - uh_fine.vector
# L2
if False:
Apoly_matrix = leg.mass_matrix(fine_degree)
get_geom_tensor = lambda cell: 1.0 / cell.Jac
# Need matrix for integration of H10 norm
else:
Apoly_matrix = leg.stiffness_matrix(fine_degree)
get_geom_tensor = lambda cell: cell.Jac
A_fine = assemble_matrix(V_fine, Apoly_matrix, get_geom_tensor, timer=0)
# Integrate the error
e = sqrt(np.sum(e * A_fine.dot(e)))
# Mesh size
hmin = mesh.hmin()
# Add the cond number
kappa = np.linalg.cond(A.toarray())
return hmin, e, kappa, A.shape[0]
