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_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