def test6():
ex = Expression('sin(2*a*pi*x[0])*cos(2*b*pi*x[1])', a=13, b=13)
#V0 = FEniCSBasis(FunctionSpace(UnitSquare(5, 5), 'CG', 1))
V0 = FEniCSBasis(FunctionSpace(UnitSquare(40, 40), 'CG', 1))
F0 = FEniCSVector.from_basis(V0).interpolate(ex)
for num in [5, 10, 20, 40]:
for degree in [1, 2, 3, 4, 5, 6, 7, 8]:
V1 = FEniCSBasis(FunctionSpace(UnitSquare(num, num), 'CG', degree))
F1 = FEniCSVector.from_basis(V1).interpolate(F0._fefunc)
F0d = FEniCSVector.from_basis(V0).interpolate(F1._fefunc) - F0
print "num=%2d, deg=%s, norm=%7.4f" % (num, degree, norm(F0d._fefunc))
print
def test5():
ex = Expression('sin(2*a*pi*x[0])*cos(2*b*pi*x[1])', a=10, b=10)
for num in [5, 10, 20, 40]:
for degree in [1, 2, 3, 4, 5, 6]:
V1 = FEniCSBasis(FunctionSpace(UnitSquare(num, num), 'CG', degree))
F1 = FEniCSVector.from_basis(V1).interpolate(ex)
print "num=%2d, deg=%s, norm=%7.4f" % (num, degree, norm(F1._fefunc))
print
def test4():
print "TEST 4"
mis = (Multiindex(), Multiindex([1]), Multiindex([0, 1]), Multiindex([1, 1]))
mv = MultiVectorWithProjection()
V1 = FEniCSBasis(FunctionSpace(UnitSquare(5, 5), 'CG', 1))
V2, _, _ = V1.refine()
V3, _, _ = V2.refine()
V4 = V1.refine_maxh(1 / 30, uniform=True)
print "mesh1", V1.mesh, "maxh,minh=", V1.maxh, V1.minh
print "mesh2", V2.mesh, "maxh,minh=", V2.maxh, V2.minh
print "mesh3", V3.mesh, "maxh,minh=", V3.maxh, V3.minh
print "mesh4", V4.mesh, "maxh,minh=", V4.maxh, V4.minh
F2 = FEniCSVector.from_basis(V2)
F3 = FEniCSVector.from_basis(V3)
F4 = FEniCSVector.from_basis(V4)
mv[mis[0]] = FEniCSVector.from_basis(V1)
mv[mis[1]] = F2
mv[mis[2]] = F3
mv[mis[3]] = F4
for j, ex in enumerate(EX):
print "ex[", j, "] =================="
for degree in range(1, 4):
print "\t=== degree ", degree, "==="
F2.interpolate(ex)
F3.interpolate(ex)
F4.interpolate(ex)
err1 = mv.get_projection_error_function(mis[1], mis[0], degree, refine_mesh=False)
err2 = mv.get_projection_error_function(mis[2], mis[0], degree, refine_mesh=False)
err3 = mv.get_projection_error_function(mis[3], mis[0], degree, refine_mesh=False)
print "\t[NO DESTINATION MESH REFINEMENT]"
print "\t\tV2 L2", norm(err1._fefunc, 'L2'), "H1", norm(err1._fefunc, 'H1')
print "\t\tV3 L2", norm(err2._fefunc, 'L2'), "H1", norm(err2._fefunc, 'H1')
print "\t\tV4 L2", norm(err3._fefunc, 'L2'), "H1", norm(err3._fefunc, 'H1')
err1 = mv.get_projection_error_function(mis[1], mis[0], degree, refine_mesh=True)
err2 = mv.get_projection_error_function(mis[2], mis[0], degree, refine_mesh=True)
err3 = mv.get_projection_error_function(mis[3], mis[0], degree, refine_mesh=True)
print "\t[WITH DESTINATION MESH REFINEMENT]"
print "\t\tV2 L2", norm(err1._fefunc, 'L2'), "H1", norm(err1._fefunc, 'H1')
print "\t\tV3 L2", norm(err2._fefunc, 'L2'), "H1", norm(err2._fefunc, 'H1')
print "\t\tV4 L2", norm(err3._fefunc, 'L2'), "H1", norm(err3._fefunc, 'H1')
def _euclidian_to_multivec(self, vec):
assert vec.dim == self._dimsum
if not self._last_vec:
new_vec = MultiVector()
for mu in self._basis.active_indices():
vec_mu = FEniCSVector.from_basis(self._basis._basis[mu])
new_vec[mu] = vec_mu
self._last_vec = new_vec
else:
new_vec = self._last_vec
start = 0
basis = self._basis
for mu in basis.active_indices():
vec_mu = new_vec[mu]
dim = basis._basis[mu].dim
vec_mu.coeffs = vec.coeffs[start:start + dim]
new_vec[mu] = vec_mu
start += dim
return new_vec
def get_ainfty(m, V):
a0_f = coeff_field.mean_func
if isinstance(a0_f, tuple):
a0_f = a0_f[0]
# determine min \overline{a} on D (approximately)
f = FEniCSVector.from_basis(V, sub_spaces=0)
f.interpolate(a0_f)
min_a0 = f.min_val
am_f, _ = coeff_field[m]
if isinstance(am_f, tuple):
am_f = am_f[0]
# determine ||a_m/\overline{a}||_{L\infty(D)} (approximately)
try:
# use exact bounds if defined
max_am = am_f.max_val
except:
# otherwise interpolate
f.interpolate(am_f)
max_am = f.max_val
ainftym = max_am / min_a0
assert isinstance(ainftym, float)
return ainftym
def prepare_ainfty(Lambda, M):
ainfty = []
a0_f = coeff_field.mean_func
if isinstance(a0_f, tuple):
a0_f = a0_f[0]
# retrieve (sufficiently fine) function space for maximum norm evaluation
# NOTE: we use the deterministic mesh since it is assumed to be the finest
V, _, _, _ = w[Multiindex()].basis.refine_maxh(maxh)
# determine min \overline{a} on D (approximately)
f = FEniCSVector.from_basis(V, sub_spaces=0)
f.interpolate(a0_f)
min_a0 = f.min_val
for m in range(M):
am_f, am_rv = coeff_field[m]
if isinstance(am_f, tuple):
am_f = am_f[0]
# determine ||a_m/\overline{a}||_{L\infty(D)} (approximately)
f.interpolate(am_f)
max_am = f.max_val
ainftym = max_am / min_a0
assert isinstance(ainftym, float)
ainfty.append(ainftym)
return ainfty
