def test_apply():
N = 4
#a = [ConstFunction(1.0), SimpleFunction(np.sin), SimpleFunction(np.cos)]
mean_func = ConstFunction(2.0)
a = [ConstFunction(3.0), ConstFunction(4.0)]
rvs = [UniformRV(), NormalRV(mu=0.5)]
coeff_field = ListCoefficientField(mean_func, a, rvs)
A = MultiOperator(coeff_field, diag_assemble)
mis = [Multiindex([0]),
Multiindex([1]),
Multiindex([0, 1]),
Multiindex([0, 2])]
vecs = [FlatVector(np.random.random(N), SimpleProjectBasis(N)),
FlatVector(np.random.random(N), SimpleProjectBasis(N)),
FlatVector(np.random.random(N), SimpleProjectBasis(N)),
FlatVector(np.random.random(N), SimpleProjectBasis(N))]
w = MultiVectorWithProjection()
for i in range(len(mis)):
w[mis[i]] = vecs[i]
v = A * w
L = LegendrePolynomials(normalised=True)
H = StochasticHermitePolynomials(mu=0.5, normalised=True)
v0_ex = (2 * vecs[0] +
3 * (L.get_beta(0)[1] * vecs[1] - L.get_beta(0)[0] * vecs[0]) +
4 * (H.get_beta(0)[1] * vecs[2] - H.get_beta(0)[0] * vecs[0]))
v2_ex = (2 * vecs[2] + 4 * (H.get_beta(1)[1] * vecs[3] -
H.get_beta(1)[0] * vecs[2] +
H.get_beta(1)[-1] * vecs[0]))
assert_equal(v[mis[0]], v0_ex)
assert_equal(v[mis[2]], v2_ex)
def test_matrixization():
def mult_assemble(a, basis):
return MultiplicationOperator(a(0), basis)
mean_func = ConstFunction(2)
a = [ConstFunction(3), ConstFunction(4)]
rvs = [UniformRV(), NormalRV(mu=0.5)]
coeff_field = ListCoefficientField(mean_func, a, rvs)
A = MultiOperator(coeff_field, mult_assemble)
mis = [Multiindex([0]),
# Multiindex([1]),
# Multiindex([0, 1]),
Multiindex([0, 2])]
mesh = UnitSquare(1, 1)
fs = FunctionSpace(mesh, "CG", 2)
F = [interpolate(Expression("*".join(["x[0]"] * i)), fs) for i in range(1, 5)]
vecs = [FEniCSVector(f) for f in F]
w = MultiVector()
for mi, vec in zip(mis, vecs):
w[mi] = vec
P = w.to_euclidian_operator
Q = w.from_euclidian_operator
Pw = P.apply(w)
assert type(Pw) == np.ndarray and len(Pw) == sum((v for v in w.dim.values()))
QPw = Q.apply(Pw)
assert w.active_indices() == QPw.active_indices()
for mu in w.active_indices():
assert_equal(w[mu].array, QPw[mu].array)
A_linear = P * A * Q
A_mat = evaluate_operator_matrix(A_linear)
def test_init():
mean_func = ConstFunction(1.0)
a = [SimpleFunction(np.sin), SimpleFunction(np.cos)]
rvs = [UniformRV(), NormalRV()]
coeff_field = ListCoefficientField(mean_func, a, rvs)
MultiOperator(coeff_field, diag_assemble)
assert_raises(TypeError, MultiOperator, 3, diag_assemble)
assert_raises(TypeError, MultiOperator, coeff_field, 7)
domain = CanonicalBasis(3)
codomain = CanonicalBasis(5)
A = MultiOperator(coeff_field, diag_assemble, None, domain, codomain)
assert_equal(A.domain, domain)
assert_equal(A.codomain, codomain)
def test_estimator():
# setup solution multi vector
mis = [Multiindex([0]),
Multiindex([1]),
Multiindex([0, 1]),
Multiindex([0, 2])]
mesh = UnitSquare(4, 4)
fs = FunctionSpace(mesh, "CG", 1)
F = [interpolate(Expression("*".join(["x[0]"] * i)), fs) for i in range(1, 5)]
vecs = [FEniCSVector(f) for f in F]
w = MultiVectorWithProjection()
for mi, vec in zip(mis, vecs):
w[mi] = vec
# v = A * w
# define coefficient field
aN = 4
a = [Expression('2.+sin(20.*pi*I*x[0]*x[1])', I=i, degree=3, element=fs.ufl_element())
for i in range(1, aN)]
rvs = [UniformRV(), NormalRV(mu=0.5)]
coeff_field = ListCoefficientField(a[0], a[1:], rvs)
# define source term
f = Constant("1.0")
# evaluate residual and projection error estimators
resind, reserr = ResidualEstimator.evaluateResidualEstimator(w, coeff_field, f)
projind, projerr = ResidualEstimator.evaluateProjectionError(w, coeff_field)
print resind[mis[0]].as_array().shape, projind[mis[0]].as_array().shape
print "RESIDUAL:", resind[mis[0]].as_array()
print "PROJECTION:", projind[mis[0]].as_array()
print "residual error estimate for mu"
for mu in reserr:
print "\t eta", mu, " is ", reserr[mu]
print "\t delta", mu, " is ", projerr[mu]
assert_equal(w.active_indices(), resind.active_indices())
print "active indices are ", resind.active_indices()
def test_poly1d_func():
p4 = np.array([3.0, 4, 5, 6])
pf = Poly1dFunction(np.poly1d(p4))
assert_equal(pf(2), 24 + 16 + 10 + 6)
pf = Poly1dFunction.from_coeffs(p4)
assert_equal(pf(2), 24 + 16 + 10 + 6)
def test_poly1d_func_ops():
p1 = Poly1dFunction.from_coeffs([5.0, 4])
p2 = Poly1dFunction.from_coeffs([2.0, 3, 4])
assert_equal((p1 * p2)(3), 19 * 31)
assert_equal((p1 + p2)(3), 19 + 31)
def assert_operator_is_consistent(op):
vec = FooVector(np.random.random(op.domain.dim), op.domain)
res = op * vec
assert_equal(res.basis, op.codomain)
assert_equal(type(res), type(vec))
assert_vector_almost_equal((3.0 * op) * vec, 3.0 * res)
assert_vector_almost_equal((op * 3.0) * vec, 3.0 * res)
if hasattr(op, "inverse") and op.domain.dim == op.codomain.dim:
inv = op.inverse()
assert_vector_almost_equal(vec, inv * res)
assert_equal(inv.domain, op.codomain)
assert_equal(inv.codomain, op.domain)
iinv = inv.inverse()
assert_vector_almost_equal(res, iinv * vec)
assert_equal(inv.domain, op.domain)
assert_equal(inv.codomain, op.codomain)
if hasattr(op, "transpose"):
trans = op.transpose()
# assert_equal(vec, trans * res)
assert_equal(trans.domain, op.codomain)
assert_equal(trans.codomain, op.domain)
ttrans = trans.transpose()
assert_vector_almost_equal(res, ttrans * vec)
assert_equal(ttrans.domain, op.domain)
assert_equal(ttrans.codomain, op.codomain)
def assert_vector_almost_equal(vec1, vec2):
assert_equal(type(vec1), type(vec2))
assert_almost_equal(vec1.coeffs, vec2.coeffs)
