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)