def test_pointwise_inner_adjoint_weighted():
# Weighted product space only
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2), dtype=complex)
vfspace = ProductSpace(fspace, 3, weighting=[2, 4, 6])
array = np.array([[[-1 - 1j, -3], [2, 2j]], [[-1j, 0], [0, 1]],
[[-1, 1 + 2j], [1, 1]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[1 + 1j, 2], [3, 4 - 2j]])
true_inner_adj = testarr[None, :, :] * array # same as unweighted case
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj, true_inner_adj)
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj)
# Using different weighting in the inner product
pwinner = PointwiseInner(vfspace, vecfield=array, weighting=[4, 8, 12])
testarr = np.array([[1 + 1j, 2], [3, 4 - 2j]])
true_inner_adj = 2 * testarr[None, :, :] * array # w / v = (2, 2, 2)
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj, true_inner_adj)
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj)
def test_pointwise_inner_real():
# 1d
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 1)
array = np.array([[[-1, -3],
[2, 0]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[[1, 2],
[3, 4]]])
true_inner = np.sum(testarr * array, axis=0)
func = vfspace.element(testarr)
func_pwinner = pwinner(func)
assert all_almost_equal(func_pwinner, true_inner.reshape(-1))
out = fspace.element()
pwinner(func, out=out)
assert all_almost_equal(out, true_inner.reshape(-1))
# 3d
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 3)
array = np.array([[[-1, -3],
[2, 0]],
[[0, 0],
[0, 1]],
[[-1, 1],
[1, 1]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[[1, 2],
[3, 4]],
[[0, -1],
[0, 1]],
[[1, 1],
[1, 1]]])
true_inner = np.sum(testarr * array, axis=0)
func = vfspace.element(testarr)
func_pwinner = pwinner(func)
assert all_almost_equal(func_pwinner, true_inner.reshape(-1))
out = fspace.element()
pwinner(func, out=out)
assert all_almost_equal(out, true_inner.reshape(-1))
def test_pointwise_inner_weighted():
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 3)
array = np.array([[[-1, -3],
[2, 0]],
[[0, 0],
[0, 1]],
[[-1, 1],
[1, 1]]])
weight = np.array([1.0, 2.0, 3.0])
pwinner = PointwiseInner(vfspace, vecfield=array, weighting=weight)
testarr = np.array([[[1, 2],
[3, 4]],
[[0, -1],
[0, 1]],
[[1, 1],
[1, 1]]])
true_inner = np.sum(weight[:, None, None] * testarr * array, axis=0)
func = vfspace.element(testarr)
func_pwinner = pwinner(func)
assert all_almost_equal(func_pwinner, true_inner.reshape(-1))
out = fspace.element()
pwinner(func, out=out)
assert all_almost_equal(out, true_inner.reshape(-1))
def test_pointwise_inner_complex():
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2), dtype=complex)
vfspace = ProductSpace(fspace, 3)
array = np.array([[[-1 - 1j, -3],
[2, 2j]],
[[-1j, 0],
[0, 1]],
[[-1, 1 + 2j],
[1, 1]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[[1 + 1j, 2],
[3, 4 - 2j]],
[[0, -1],
[0, 1]],
[[1j, 1j],
[1j, 1j]]])
true_inner = np.sum(testarr * array.conj(), axis=0)
func = vfspace.element(testarr)
func_pwinner = pwinner(func)
assert all_almost_equal(func_pwinner, true_inner.reshape(-1))
out = fspace.element()
pwinner(func, out=out)
assert all_almost_equal(out, true_inner.reshape(-1))
def test_pointwise_inner_adjoint():
# 1d
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2), dtype=complex)
vfspace = ProductSpace(fspace, 1)
array = np.array([[[-1, -3],
[2, 0]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[1 + 1j, 2],
[3, 4 - 2j]])
true_inner_adj = testarr[None, :, :] * array
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj,
true_inner_adj.reshape([1, -1]))
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj.reshape([1, -1]))
# 3d
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2), dtype=complex)
vfspace = ProductSpace(fspace, 3)
array = np.array([[[-1 - 1j, -3],
[2, 2j]],
[[-1j, 0],
[0, 1]],
[[-1, 1 + 2j],
[1, 1]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[1 + 1j, 2],
[3, 4 - 2j]])
true_inner_adj = testarr[None, :, :] * array
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj,
true_inner_adj.reshape([3, -1]))
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj.reshape([3, -1]))
def _call(self, x, out):
xvf = x[functional.N:]
P = PointwiseInner(functional.vf_space, xvf[i - 1])
ret = functional.lagr_mult[i - 1] - functional.tau * (
P(functional.grad(functional.lagr_mult[i - 1])) -
functional.lagr_mult[i - 1] * functional.grad.adjoint(
xvf[i - 1])) - functional.lagr_mult[i]
ret /= functional.tau
out.assign(ret)
def _call(self, x, out):
xim = x[:functional.N]
xvf = x[functional.N:]
res = functional.residual(xim[-1], xim[-2], xvf[-2])
P = PointwiseInner(functional.vf_space, xvf[-2])
tmp = (res - functional.tau *
(P(functional.grad(res)) -
functional.grad.adjoint(xvf[-2]) * res))
tmp *= functional.alpha
out.assign(tmp)
def test_pointwise_inner_init_properties():
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2))
vfspace = ProductSpace(fspace, 3, exponent=2)
# Make sure the code runs and test the properties
pwinner = PointwiseInner(vfspace, vfspace.one())
assert pwinner.base_space == fspace
assert all_equal(pwinner.weights, [1, 1, 1])
assert not pwinner.is_weighted
repr(pwinner)
pwinner = PointwiseInner(vfspace, vfspace.one(), weighting=[1, 2, 3])
assert all_equal(pwinner.weights, [1, 2, 3])
assert pwinner.is_weighted
# Bad input
with pytest.raises(TypeError):
PointwiseInner(odl.rn(3), odl.rn(3).one()) # No power space
# TODO: Does not raise currently, although bad_vecfield not in vfspace!
"""
def __call__(self, x):
ret = 0
xim = x[:self.N]
xvf = x[self.N:]
lam = self.lagr_mult
for i in range(0, self.N - 1):
P = PointwiseInner(self.vf_space, xvf[i])
ret += lam[i].inner(xim[i + 1] - xim[i] +
self.tau * P(self.grad(xim[i + 1])))
ret /= self.tau
return ret
def _call(self, x, out):
xim = x[:functional.N]
xvf = x[functional.N:]
resi = functional.residual(xim[i], xim[i - 1],
xvf[i - 1])
resii = functional.residual(xim[i + 1], xim[i], xvf[i])
P = PointwiseInner(functional.vf_space, xvf[i])
tmp = (resi - functional.tau *
(P(functional.grad(resi)) -
functional.grad.adjoint(xvf[i - 1]) * resi))
tmp -= resii
tmp *= functional.alpha
out.assign(tmp)
def test_pointwise_inner_adjoint():
# 1d
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2), dtype=complex)
vfspace = ProductSpace(fspace, 1)
array = np.array([[[-1, -3],
[2, 0]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[1 + 1j, 2],
[3, 4 - 2j]])
true_inner_adj = testarr[None, :, :] * array
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj,
true_inner_adj.reshape([1, -1]))
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj.reshape([1, -1]))
# 3d
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2), dtype=complex)
vfspace = ProductSpace(fspace, 3)
array = np.array([[[-1 - 1j, -3],
[2, 2j]],
[[-1j, 0],
[0, 1]],
[[-1, 1 + 2j],
[1, 1]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[1 + 1j, 2],
[3, 4 - 2j]])
true_inner_adj = testarr[None, :, :] * array
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj,
true_inner_adj.reshape([3, -1]))
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj.reshape([3, -1]))
def test_pointwise_inner_adjoint_weighted():
# Weighted product space only
fspace = odl.uniform_discr([0, 0], [1, 1], (2, 2), dtype=complex)
vfspace = ProductSpace(fspace, 3, weighting=[2, 4, 6])
array = np.array([[[-1 - 1j, -3],
[2, 2j]],
[[-1j, 0],
[0, 1]],
[[-1, 1 + 2j],
[1, 1]]])
pwinner = PointwiseInner(vfspace, vecfield=array)
testarr = np.array([[1 + 1j, 2],
[3, 4 - 2j]])
true_inner_adj = testarr[None, :, :] * array # same as unweighted case
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj,
true_inner_adj.reshape([3, -1]))
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj.reshape([3, -1]))
# Using different weighting in the inner product
pwinner = PointwiseInner(vfspace, vecfield=array, weighting=[4, 8, 12])
testarr = np.array([[1 + 1j, 2],
[3, 4 - 2j]])
true_inner_adj = 2 * testarr[None, :, :] * array # w / v = (2, 2, 2)
testfunc = fspace.element(testarr)
testfunc_pwinner_adj = pwinner.adjoint(testfunc)
assert all_almost_equal(testfunc_pwinner_adj,
true_inner_adj.reshape([3, -1]))
out = vfspace.element()
pwinner.adjoint(testfunc, out=out)
assert all_almost_equal(out, true_inner_adj.reshape([3, -1]))
def residual(self, im1, im2, vf):
P = PointwiseInner(self.vf_space, vf)
res = im1 - im2 + self.tau * P(self.grad(im1))
return res
