def test_pcg_matrix():
rand = np.random.mtrand.RandomState(1234).random_sample
N = 7
M = rand((N, N))
A = MatrixOperator(np.dot(M, M.T))
P = MultiplicationOperator(1, CanonicalBasis(N))
x = FlatVector(rand((N,)))
b = A * x
print
# solve with identity as preconditioner
x_ap, zeta, iter = pcg(A, b, P, 0 * x, eps=0.00001)
assert_array_almost_equal(x.coeffs, x_ap.coeffs)
assert_true( iter <= N + 3)
# solve with exact matrix inverse as preconditioner
# should converge in one step
P = MatrixSolveOperator(np.dot(M, M.T))
x_ap, zeta, iter = pcg(A, b, P, 0 * x, eps=0.00001)
assert_array_almost_equal(x.coeffs, x_ap.coeffs)
assert_true( iter <= 2)
P = MatrixOperator(P.as_matrix())
x_ap, zeta, iter = pcg(A, b, P, 0 * x, eps=0.00001)
#print iter
assert_array_almost_equal(x.coeffs, x_ap.coeffs)
P = DiagonalMatrixOperator(np.diag(A.as_matrix())).inverse()
x_ap, zeta, iter = pcg(A, b, P, 0 * x, eps=0.00001)
#print iter
assert_array_almost_equal(x.coeffs, x_ap.coeffs)
def pcg_solve(A, w, coeff_field, pde, stats, pcg_eps, pcg_maxiter):
b = prepare_rhs(A, w, coeff_field, pde)
P = PreconditioningOperator(coeff_field.mean_func,
pde.assemble_solve_operator)
w, zeta, numit = pcg(A, b, P, w0=w, eps=pcg_eps, maxiter=pcg_maxiter)
logger.info("PCG finished with zeta=%f after %i iterations", zeta, numit)
b2 = A * w
stats["RESIDUAL-L2"] = error_norm(b, b2, "L2")
stats["RESIDUAL-H1A"] = error_norm(b, b2, pde.energy_norm)
stats["DOFS"] = sum([b[mu]._fefunc.function_space().dim() for mu in b.keys()])
stats["CELLS"] = sum([b[mu]._fefunc.function_space().mesh().num_cells() for mu in b.keys()])
logger.info("[pcg] Residual = [%s (L2)] [%s (H1A)] with [%s dofs] and [%s cells]", stats["RESIDUAL-L2"], stats["RESIDUAL-H1A"], stats["DOFS"], stats["CELLS"])
return w, zeta
#coeff_field = CoefficientField(a, rvs)
a0 = Constant("1.0")
a = (Expression('A*cos(pi*I*x[0])*cos(pi*I*x[1])', A=1 / i ** 2, I=i, degree=2) for i in count(1))
rvs = (UniformRV() for _ in count())
coeff_field = ParametricCoefficientField(func_func=a, rv_func=rvs, mean_func=a0)
pde = FEMPoisson()
A = MultiOperator(coeff_field, pde.assemble_operator)
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
#P = MultiplicationOperator(1, vecs[0].basis)
P = PreconditioningOperator(a0, pde.assemble_solve_operator)
w2, zeta, numit = pcg(A, v, P, 0 * v)
print
print zeta, numit
print inner(w - w2, w - w2) / inner(w, w)
v2 = A * w2
print inner(v - v2, v - v2) / inner(v, v)
A = MultiOperator(coeff_field, pde.assemble_operator, pde.assemble_operator_inner_dofs, assembly_type=eval("ASSEMBLY_TYPE." + CONF_assembly_type))
# setup initial solution multivector
w = SampleProblem.setupMultiVector(dict([(mu, m) for mu, m in zip(mis, meshes)]), functools.partial(setup_vector, pde=pde, degree=CONF_FEM_degree))
logger.info("active indices of w after initialisation: %s", w.active_indices())
# ============================================================
# PART C: Assemble and Solve
# ============================================================
try:
# pcg solver
b = prepare_rhs(A, w, coeff_field, pde)
P = PreconditioningOperator(coeff_field.mean_func, pde.assemble_solve_operator)
w, zeta, numit = pcg(A, b, P, w0=w, eps=CONF_pcg_eps, maxiter=CONF_pcg_maxiter)
logger.info("PCG finished with zeta=%f after %i iterations", zeta, numit)
# raise Exception("TESTING")
except Exception as e:
print e
def get_exception_frame_data():
import sys
import traceback
tb = sys.exc_info()[2]
while tb.tb_next:
tb = tb.tb_next
frame = tb.tb_frame
return (frame, frame.f_code.co_name, frame.f_locals)
def do_debug(**kwargs):
# plot mesh
#import dolfin
#dolfin.plot(mesh, interactive=True)
# plot sparsity pattern
#fig = figure()
##spy(M)
#spy(K[0].as_matrix())
#show()
from spuq.application.egsz.pcg import pcg
P = TensorOperator([K0inv], [D[0]])
print 0*w
b = w.copy()
b._X += 1
v = pcg(A, b, P, 0*w )
print "v", v
if False:
import numpy as np
import scipy as sp
import scipy.sparse as spa
A=spa.csr_matrix(np.random.rand(7,3))
B=np.random.rand(3,5)
print A
print B
