def test_dot_test(self):
Grad3 = GradientOperator(self.ig3,
correlation='Space',
backend='numpy')
# self.assertAlmostEqual(lhs3, rhs3)
self.assertTrue(LinearOperator.dot_test(Grad3, verbose=True,
decimal=4))
self.assertTrue(LinearOperator.dot_test(Grad3, verbose=True,
decimal=4))
def test_GradientOperator_linearity(self):
nc, nz, ny, nx = 3, 4, 5, 6
ig = ImageGeometry(voxel_num_x=nx, voxel_num_y=ny, voxel_num_z=nz, channels=nc)
grad = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='c')
self.assertTrue(LinearOperator.dot_test(grad))
grad = GradientOperator(ig, bnd_cond='Periodic', correlation='SpaceChannels', backend='c')
self.assertTrue(LinearOperator.dot_test(grad))
grad = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='numpy')
self.assertTrue(LinearOperator.dot_test(grad))
grad = GradientOperator(ig, bnd_cond='Periodic', correlation='SpaceChannels', backend='numpy')
self.assertTrue(LinearOperator.dot_test(grad))
def test_SymmetrisedGradientOperator3b(self):
###########################################################################
# 3D geometry no channels
#ig3 = ImageGeometry(N, M, K)
Grad3 = GradientOperator(self.ig3, correlation='Space')
E3 = SymmetrisedGradientOperator(Grad3.range_geometry())
numpy.random.seed(1)
u3 = E3.domain_geometry().allocate('random')
w3 = E3.range_geometry().allocate('random', symmetry=True)
#
lhs3 = E3.direct(u3).dot(w3)
rhs3 = u3.dot(E3.adjoint(w3))
# with numpy 1.11 and py 3.5 decimal = 3
decimal = 4
npv = version.parse(numpy.version.version)
if npv.major == 1 and npv.minor == 11:
print("########## SETTING decimal to 3 ###########")
decimal = 3
numpy.testing.assert_almost_equal(lhs3, rhs3, decimal=decimal)
# self.assertAlmostEqual(lhs3, rhs3, )
print("*******", lhs3, rhs3, abs((rhs3 - lhs3) / rhs3), 1.5 * 10**(-4),
abs((rhs3 - lhs3) / rhs3) < 1.5 * 10**(-4))
self.assertTrue(
LinearOperator.dot_test(E3,
range_init=w3,
domain_init=u3,
decimal=decimal))
def test_dot_test2(self):
Grad3 = GradientOperator(self.ig3,
correlation='SpaceChannel',
backend='c')
# self.assertAlmostEqual(lhs3, rhs3)
# self.assertTrue( LinearOperator.dot_test(Grad3 , verbose=True))
self.assertTrue(LinearOperator.dot_test(Grad3, decimal=4,
verbose=True))
def test_GradientOperator_complex_data(self):
# make complex dtype
self.ig_2D.dtype = numpy.complex
x = self.ig_2D.allocate('random')
Grad = GradientOperator(domain_geometry=self.ig_2D)
res1 = Grad.direct(x)
res2 = Grad.range.allocate()
Grad.direct(x, out=res2)
numpy.testing.assert_array_almost_equal(res1[0].as_array(),
res2[0].as_array())
numpy.testing.assert_array_almost_equal(res1[1].as_array(),
res2[1].as_array())
# check dot_test
for sd in [5, 10, 15]:
self.assertTrue(LinearOperator.dot_test(Grad, seed=sd))
def test_GradientOperator_linearity(self):
for geom in self.list_geometries:
for bnd in self.bconditions:
for backend in self.backend:
for corr in self.correlation:
for method in self.method:
Grad = GradientOperator(geom,
bnd_cond=bnd,
backend=backend,
correlation=corr,
method=method)
try:
for sd in [5, 10, 15]:
self.assertTrue(
LinearOperator.dot_test(Grad, seed=sd))
except:
self.print_assertion_info(
geom, bnd, backend, corr, method, None)
raise
def test_SymmetrisedGradientOperator3b(self):
###########################################################################
# 3D geometry no channels
#ig3 = ImageGeometry(N, M, K)
Grad3 = GradientOperator(self.ig3, correlation='Space')
E3 = SymmetrisedGradientOperator(Grad3.range_geometry())
numpy.random.seed(1)
u3 = E3.domain_geometry().allocate('random')
w3 = E3.range_geometry().allocate('random', symmetry=True)
#
lhs3 = E3.direct(u3).dot(w3)
rhs3 = u3.dot(E3.adjoint(w3))
numpy.testing.assert_almost_equal(lhs3, rhs3, decimal=3)
print("*******", lhs3, rhs3, abs((rhs3 - lhs3) / rhs3), 1.5 * 10**(-4),
abs((rhs3 - lhs3) / rhs3) < 1.5 * 10**(-4))
self.assertTrue(
LinearOperator.dot_test(E3,
range_init=w3,
domain_init=u3,
decimal=3))
def test_GradientOperator_for_pseudo_2D_geometries(self):
numpy.random.seed(1)
# ImageGeometry shape (5,5,1)
ig1 = ImageGeometry(voxel_num_x=1,
voxel_num_y=5,
voxel_num_z=5,
voxel_size_x=0.4,
voxel_size_y=0.2,
voxel_size_z=0.6)
# ImageGeometry shape (1,5,5)
ig2 = ImageGeometry(voxel_num_x=5,
voxel_num_y=5,
voxel_num_z=1,
voxel_size_x=0.1,
voxel_size_y=0.2,
voxel_size_z=0.4)
# ImageGeometry shape (5,1,5)
ig3 = ImageGeometry(voxel_num_x=5,
voxel_num_y=1,
voxel_num_z=5,
voxel_size_x=0.6,
voxel_size_y=0.4,
voxel_size_z=0.3)
data1 = ig1.allocate('random')
data2 = ig2.allocate('random')
data3 = ig3.allocate('random')
data = [data1, data2, data3]
ig = [ig1, ig2, ig3]
for i in range(3):
########################################
##### Test Gradient numpy backend #####
########################################
Grad_numpy = GradientOperator(ig[i], backend='numpy')
res1 = Grad_numpy.direct(data[i])
res2 = Grad_numpy.range_geometry().allocate()
Grad_numpy.direct(data[i], out=res2)
# test direct with and without out
numpy.testing.assert_array_almost_equal(res1[0].as_array(),
res2[0].as_array())
numpy.testing.assert_array_almost_equal(res1[1].as_array(),
res2[1].as_array())
# test adjoint with and without out
res3 = Grad_numpy.adjoint(res1)
res4 = Grad_numpy.domain_geometry().allocate()
Grad_numpy.adjoint(res2, out=res4)
numpy.testing.assert_array_almost_equal(res3.as_array(),
res4.as_array())
# test dot_test
for sd in [5, 10, 15]:
self.assertTrue(LinearOperator.dot_test(Grad_numpy, seed=sd))
# test shape of output of direct
self.assertEqual(res1[0].shape, ig[i].shape)
self.assertEqual(res1.shape, (2, 1))
########################################
##### Test Gradient c backend #####
########################################
Grad_c = GradientOperator(ig[i], backend='c')
# test direct with and without out
res5 = Grad_c.direct(data[i])
res6 = Grad_c.range_geometry().allocate() * 0.
Grad_c.direct(data[i], out=res6)
numpy.testing.assert_array_almost_equal(res5[0].as_array(),
res6[0].as_array())
numpy.testing.assert_array_almost_equal(res5[1].as_array(),
res6[1].as_array())
# test adjoint
res7 = Grad_c.adjoint(res5)
res8 = Grad_c.domain_geometry().allocate() * 0.
Grad_c.adjoint(res5, out=res8)
numpy.testing.assert_array_almost_equal(res7.as_array(),
res8.as_array())
# test dot_test
for sd in [5, 10, 15]:
self.assertTrue(LinearOperator.dot_test(Grad_c, seed=sd))
# test direct numpy vs direct c backends (with and without out)
numpy.testing.assert_array_almost_equal(res5[0].as_array(),
res1[0].as_array())
numpy.testing.assert_array_almost_equal(res6[1].as_array(),
res2[1].as_array())