def test_GradientOperator_split_direct_adjoint(self):
# Test split for direct and adjoint in 2D + channels geometry
geom = self.ig_2D_chan
Grad2D_split_false = GradientOperator(geom,
split=False,
correlation="SpaceChannels")
Grad2D_split_true = GradientOperator(geom,
split=True,
correlation="SpaceChannels")
tmp_x = geom.allocate('random')
res1 = Grad2D_split_false.direct(tmp_x)
res2 = Grad2D_split_true.direct(tmp_x)
res1_adj = Grad2D_split_false.adjoint(res1)
res2_adj = Grad2D_split_true.adjoint(res2)
numpy.testing.assert_array_almost_equal(res1[0].array, res2[0].array)
numpy.testing.assert_array_almost_equal(res1[1].array,
res2[1][0].array)
numpy.testing.assert_array_almost_equal(res1[2].array,
res2[1][1].array)
numpy.testing.assert_array_almost_equal(res1_adj.array, res2_adj.array)
# Test split for direct and adjoint in 3D + channels geometry
geom = self.ig_3D_chan
Grad3D_split_false = GradientOperator(geom,
split=False,
correlation="SpaceChannels")
Grad3D_split_true = GradientOperator(geom,
split=True,
correlation="SpaceChannels")
tmp_x = geom.allocate('random')
res1 = Grad3D_split_false.direct(tmp_x)
res2 = Grad3D_split_true.direct(tmp_x)
res1_adj = Grad3D_split_false.adjoint(res1)
res2_adj = Grad3D_split_true.adjoint(res2)
numpy.testing.assert_array_almost_equal(res1[0].array, res2[0].array)
numpy.testing.assert_array_almost_equal(res1[1].array,
res2[1][0].array)
numpy.testing.assert_array_almost_equal(res1[2].array,
res2[1][1].array)
numpy.testing.assert_array_almost_equal(res1[3].array,
res2[1][2].array)
numpy.testing.assert_array_almost_equal(res1_adj.array, res2_adj.array)
def test_CompositionOperator_adjoint6(self):
ig = self.ig
data = self.data
G = GradientOperator(domain_geometry=ig)
Id1 = 3 * IdentityOperator(ig)
Id = ZeroOperator(ig)
d = G.compose(Id)
da = d.direct(data)
out1 = G.adjoint(da)
out2 = d.adjoint(da)
numpy.testing.assert_array_almost_equal(out2.as_array(),
0 * out1.as_array())
def test_GradientOperator_in_place_vs_allocate_adjoint(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)
tmp_x = Grad.range.allocate('random')
res_in_place = Grad.adjoint(tmp_x)
res_allocate = Grad.domain.allocate()
Grad.adjoint(tmp_x, out=res_allocate)
try:
numpy.testing.assert_array_almost_equal(
res_in_place.array, res_allocate.array)
except:
self.print_assertion_info(
geom, bnd, backend, corr, method, None)
raise
def test_CompositionOperator_adjoint2(self):
ig = self.ig
data = self.data
G = GradientOperator(domain_geometry=ig)
Id1 = 2 * IdentityOperator(ig)
Id2 = IdentityOperator(ig)
d = CompositionOperator(G, Id1)
da = d.direct(data)
out1 = G.adjoint(da)
out2 = d.adjoint(da)
numpy.testing.assert_array_almost_equal(out2.as_array(),
2 * out1.as_array())
def test_GradientOperator_4D_allocate(self):
nc, nz, ny, nx = 3, 4, 5, 6
size = nc * nz * ny * nx
dim = [nc, nz, ny, nx]
ig = ImageGeometry(voxel_num_x=nx, voxel_num_y=ny, voxel_num_z=nz, channels=nc)
arr = numpy.arange(size).reshape(dim).astype(numpy.float32)**2
data = ig.allocate()
data.fill(arr)
#numpy
grad1 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='numpy')
gold_direct = grad1.direct(data)
gold_adjoint = grad1.adjoint(gold_direct)
grad2 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='numpy')
out_direct = grad2.range_geometry().allocate()
out_adjoint = grad2.domain_geometry().allocate()
grad2.direct(data, out=out_direct)
grad2.adjoint(out_direct, out=out_adjoint)
#print("GradientOperatorOperator, 4D, bnd_cond='Neumann', direct")
numpy.testing.assert_array_equal(out_direct.get_item(0).as_array(), gold_direct.get_item(0).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(1).as_array(), gold_direct.get_item(1).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(2).as_array(), gold_direct.get_item(2).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(3).as_array(), gold_direct.get_item(3).as_array())
#print("GradientOperator, 4D, bnd_cond='Neumann', adjoint")
numpy.testing.assert_array_equal(out_adjoint.as_array(), gold_adjoint.as_array())
#c
grad1 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='c')
gold_direct = grad1.direct(data)
gold_adjoint = grad1.adjoint(gold_direct)
grad2 = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='c')
out_direct = grad2.range_geometry().allocate()
out_adjoint = grad2.domain_geometry().allocate()
grad2.direct(data, out=out_direct)
grad2.adjoint(out_direct, out=out_adjoint)
#print("GradientOperator, 4D, bnd_cond='Neumann', direct")
numpy.testing.assert_array_equal(out_direct.get_item(0).as_array(), gold_direct.get_item(0).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(1).as_array(), gold_direct.get_item(1).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(2).as_array(), gold_direct.get_item(2).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(3).as_array(), gold_direct.get_item(3).as_array())
#print("GradientOperator, 4D, bnd_cond='Neumann', adjoint")
numpy.testing.assert_array_equal(out_adjoint.as_array(), gold_adjoint.as_array())
def test_FiniteDifference(self):
print("test FiniteDifference")
##
N, M = 2, 3
numpy.random.seed(1)
ig = ImageGeometry(N, M)
Id = IdentityOperator(ig)
FD = FiniteDifferenceOperator(ig, direction=0, bnd_cond='Neumann')
u = FD.domain_geometry().allocate('random')
res = FD.domain_geometry().allocate(ImageGeometry.RANDOM)
FD.adjoint(u, out=res)
w = FD.adjoint(u)
self.assertNumpyArrayEqual(res.as_array(), w.as_array())
res = Id.domain_geometry().allocate(ImageGeometry.RANDOM)
Id.adjoint(u, out=res)
w = Id.adjoint(u)
self.assertNumpyArrayEqual(res.as_array(), w.as_array())
self.assertNumpyArrayEqual(u.as_array(), w.as_array())
G = GradientOperator(ig)
u = G.range_geometry().allocate(ImageGeometry.RANDOM)
res = G.domain_geometry().allocate()
G.adjoint(u, out=res)
w = G.adjoint(u)
self.assertNumpyArrayEqual(res.as_array(), w.as_array())
u = G.domain_geometry().allocate(ImageGeometry.RANDOM)
res = G.range_geometry().allocate()
G.direct(u, out=res)
w = G.direct(u)
self.assertBlockDataContainerEqual(res, w)
# 2D
M, N = 2, 3
ig = ImageGeometry(voxel_num_x=M,
voxel_num_y=N,
voxel_size_x=0.1,
voxel_size_y=0.4)
x = ig.allocate('random')
labels = ["horizontal_y", "horizontal_x"]
for i, dir in enumerate(labels):
FD1 = FiniteDifferenceOperator(ig, direction=i)
res1 = FD1.direct(x)
res1b = FD1.adjoint(x)
FD2 = FiniteDifferenceOperator(ig, direction=labels[i])
res2 = FD2.direct(x)
res2b = FD2.adjoint(x)
numpy.testing.assert_almost_equal(res1.as_array(), res2.as_array())
numpy.testing.assert_almost_equal(res1b.as_array(),
res2b.as_array())
print("Check 2D FiniteDiff for label {}".format(labels[i]))
# 2D + chan
M, N, K = 2, 3, 4
ig1 = ImageGeometry(voxel_num_x=M,
voxel_num_y=N,
channels=K,
voxel_size_x=0.1,
voxel_size_y=0.4)
print(ig1.dimension_labels)
x = ig1.allocate('random')
labels = ["channel", "horizontal_y", "horizontal_x"]
for i, dir in enumerate(labels):
FD1 = FiniteDifferenceOperator(ig1, direction=i)
res1 = FD1.direct(x)
res1b = FD1.adjoint(x)
FD2 = FiniteDifferenceOperator(ig1, direction=labels[i])
res2 = FD2.direct(x)
res2b = FD2.adjoint(x)
numpy.testing.assert_almost_equal(res1.as_array(), res2.as_array())
numpy.testing.assert_almost_equal(res1b.as_array(),
res2b.as_array())
print("Check for 2D chan for FiniteDiff label {}".format(
labels[i]))
def test_GradientOperator_split(self):
N, M, K = 2, 3, 4
channels = 10
numpy.random.seed(1)
ig1 = ImageGeometry(voxel_num_x = M, voxel_num_y = N)
ig2 = ImageGeometry(voxel_num_x = M, channels = channels)
ig3 = ImageGeometry(voxel_num_x = M, voxel_num_y = N, channels = channels)
ig4 = ImageGeometry(voxel_num_x = M, voxel_num_y = N, channels = channels, voxel_num_z= K)
data1 = ig1.allocate('random')
data2 = ig2.allocate('random')
data3 = ig3.allocate('random')
data4 = ig4.allocate('random')
G1 = GradientOperator(ig1, split=True, correlation='SpaceChannels')
out1 = G1.direct(data1)
ad1 = G1.adjoint(out1)
G1_gold = GradientOperator(ig1, split=False, correlation='SpaceChannels')
out1_gold = G1.direct(data1)
ad1_gold = G1.adjoint(out1_gold)
self.assertEquals(out1.shape, (2,1))
self.assertEquals(out1_gold.shape, (2,1))
numpy.testing.assert_allclose(ad1.array, ad1_gold.array, atol = 0.4)
G2 = GradientOperator(ig2, split=True, correlation='SpaceChannels')
out2 = G2.direct(data2)
ad2 = G2.adjoint(out2)
G2_gold = GradientOperator(ig2, split=False, correlation='SpaceChannels')
out2_gold = G2_gold.direct(data2)
ad2_gold = G2_gold.adjoint(out2_gold)
self.assertEquals(out2.shape, (2,1))
self.assertEquals(out2_gold.shape, (2,1))
numpy.testing.assert_allclose(ad2.array, ad2_gold.array, atol = 0.4)
numpy.testing.assert_allclose(out2[0].array, out2_gold[0].array, atol = 0.4)
numpy.testing.assert_allclose(out2[1][0].array, out2_gold[1].array, atol = 0.4)
G3 = GradientOperator(ig3, split=True, correlation='SpaceChannels')
out3 = G3.direct(data3)
ad3 = G3.adjoint(out3)
G3_gold = GradientOperator(ig3, split=False, correlation='SpaceChannels')
out3_gold = G3_gold.direct(data3)
ad3_gold = G3_gold.adjoint(out3_gold)
self.assertEquals(out3.shape, (2,1))
self.assertEquals(out3_gold.shape, (3,1))
numpy.testing.assert_allclose(ad3.array, ad3_gold.array, atol = 0.4)
numpy.testing.assert_allclose(out3[0].array, out3_gold[0].array, atol = 0.4)
numpy.testing.assert_allclose(out3[1][0].array, out3_gold[1].array, atol = 0.4)
numpy.testing.assert_allclose(out3[1][1].array, out3_gold[2].array, atol = 0.4)
G4 = GradientOperator(ig4, split=True, correlation='SpaceChannels')
out4 = G4.direct(data4)
ad4 = G4.adjoint(out4)
G4_gold = GradientOperator(ig4, split=False, correlation='SpaceChannels')
out4_gold = G4_gold.direct(data4)
ad4_gold = G4_gold.adjoint(out4_gold)
self.assertEquals(out4.shape, (2,1))
self.assertEquals(out4_gold.shape, (4,1))
numpy.testing.assert_allclose(ad4.array, ad4_gold.array, atol = 0.4)
numpy.testing.assert_allclose(out4[0].array, out4_gold[0].array, atol = 0.4)
numpy.testing.assert_allclose(out4[1][0].array, out4_gold[1].array, atol = 0.4)
numpy.testing.assert_allclose(out4[1][1].array, out4_gold[2].array, atol = 0.4)
numpy.testing.assert_allclose(out4[1][2].array, out4_gold[3].array, atol = 0.4)
#non default order
data4.reorder(['vertical','horizontal_x','channel','horizontal_y'])
G4 = GradientOperator(data4.geometry, split=True, correlation='SpaceChannels')
out4 = G4.direct(data4)
ad4 = G4.adjoint(out4)
G4_gold = GradientOperator(data4.geometry, split=False, correlation='SpaceChannels')
out4_gold = G4_gold.direct(data4)
ad4_gold = G4_gold.adjoint(out4_gold)
self.assertEquals(out4.shape, (2,1))
self.assertEquals(out4_gold.shape, (4,1))
numpy.testing.assert_allclose(ad4.array, ad4_gold.array, atol = 0.4)
numpy.testing.assert_allclose(out4[0].array, out4_gold[2].array, atol = 0.4)
numpy.testing.assert_allclose(out4[1][0].array, out4_gold[0].array, atol = 0.4)
numpy.testing.assert_allclose(out4[1][1].array, out4_gold[1].array, atol = 0.4)
numpy.testing.assert_allclose(out4[1][2].array, out4_gold[3].array, atol = 0.4)
def test_GradientOperator(self):
N, M, K = 20, 30, 40
channels = 10
numpy.random.seed(1)
# check range geometry, examples
ig1 = ImageGeometry(voxel_num_x = M, voxel_num_y = N)
ig3 = ImageGeometry(voxel_num_x = M, voxel_num_y = N, channels = channels)
ig4 = ImageGeometry(voxel_num_x = M, voxel_num_y = N, channels = channels, voxel_num_z= K)
G1 = GradientOperator(ig1, correlation = 'Space', backend='numpy')
print(G1.range_geometry().shape, '2D no channels')
G4 = GradientOperator(ig3, correlation = 'SpaceChannels', backend='numpy')
print(G4.range_geometry().shape, '2D with channels corr')
G5 = GradientOperator(ig3, correlation = 'Space', backend='numpy')
print(G5.range_geometry().shape, '2D with channels no corr')
G6 = GradientOperator(ig4, correlation = 'Space', backend='numpy')
print(G6.range_geometry().shape, '3D with channels no corr')
G7 = GradientOperator(ig4, correlation = 'SpaceChannels', backend='numpy')
print(G7.range_geometry().shape, '3D with channels with corr')
u = ig1.allocate(ImageGeometry.RANDOM)
w = G1.range_geometry().allocate(ImageGeometry.RANDOM)
LHS = (G1.direct(u)*w).sum()
RHS = (u * G1.adjoint(w)).sum()
numpy.testing.assert_approx_equal(LHS, RHS, significant = 1)
numpy.testing.assert_approx_equal(G1.norm(), numpy.sqrt(2*4), significant = 1)
u1 = ig3.allocate('random')
w1 = G4.range_geometry().allocate('random')
LHS1 = (G4.direct(u1) * w1).sum()
RHS1 = (u1 * G4.adjoint(w1)).sum()
numpy.testing.assert_approx_equal(LHS1, RHS1, significant=1)
numpy.testing.assert_almost_equal(G4.norm(), numpy.sqrt(3*4), decimal = 0)
u2 = ig4.allocate('random')
w2 = G7.range_geometry().allocate('random')
LHS2 = (G7.direct(u2) * w2).sum()
RHS2 = (u2 * G7.adjoint(w2)).sum()
numpy.testing.assert_approx_equal(LHS2, RHS2, significant = 3)
numpy.testing.assert_approx_equal(G7.norm(), numpy.sqrt(3*4), significant = 1)
#check direct/adjoint for space/channels correlation
ig_channel = ImageGeometry(voxel_num_x = 2, voxel_num_y = 3, channels = 2)
G_no_channel = GradientOperator(ig_channel, correlation = 'Space', backend='numpy')
G_channel = GradientOperator(ig_channel, correlation = 'SpaceChannels', backend='numpy')
u3 = ig_channel.allocate('random_int')
res_no_channel = G_no_channel.direct(u3)
res_channel = G_channel.direct(u3)
print(" Derivative for 3 directions, first is wrt Channel direction\n")
print(res_channel[0].as_array())
print(res_channel[1].as_array())
print(res_channel[2].as_array())
print(" Derivative for 2 directions, no Channel direction\n")
print(res_no_channel[0].as_array())
print(res_no_channel[1].as_array())
ig2D = ImageGeometry(voxel_num_x = 2, voxel_num_y = 3)
u4 = ig2D.allocate('random_int')
G2D = GradientOperator(ig2D, backend='numpy')
res = G2D.direct(u4)
print(res[0].as_array())
print(res[1].as_array())
M, N = 20, 30
ig = ImageGeometry(M, N)
# check direct of GradientOperator and sparse matrix
G = GradientOperator(ig, backend='numpy')
norm1 = G.norm(iterations=300)
print ("should be sqrt(8) {} {}".format(numpy.sqrt(8), norm1))
numpy.testing.assert_almost_equal(norm1, numpy.sqrt(8), decimal=1)
ig4 = ImageGeometry(M,N, channels=3)
G4 = GradientOperator(ig4, correlation="SpaceChannels", backend='numpy')
norm4 = G4.norm(iterations=300)
print("should be sqrt(12) {} {}".format(numpy.sqrt(12), norm4))
self.assertTrue((norm4 - numpy.sqrt(12))/norm4 < 0.2)
def test_Gradient_c_numpy_voxel(self):
numpy.random.seed(5)
print("Test GradientOperator for 2D Geometry, ")
ny, nx, nz = 3, 4, 5
ig = ImageGeometry(voxel_num_y = ny, voxel_num_x = nx, voxel_size_x=0.1, voxel_size_y=0.5)
GD_C = GradientOperator(ig, backend = 'c')
GD_numpy = GradientOperator(ig, backend = 'numpy')
id = ig.allocate('random')
direct_c = GD_C.direct(id)
direct_numpy = GD_numpy.direct(id)
numpy.testing.assert_allclose(direct_c[0].array, direct_numpy[0].array, atol=0.1)
numpy.testing.assert_allclose(direct_c[1].array, direct_numpy[1].array, atol=0.1)
direct_c *=0
direct_numpy *=0
GD_C.direct(id, out=direct_c)
GD_numpy.direct(id, out=direct_numpy)
numpy.testing.assert_allclose(direct_c[0].array, direct_numpy[0].array, atol=0.1)
numpy.testing.assert_allclose(direct_c[1].array, direct_numpy[1].array, atol=0.1)
adjoint_c = GD_C.adjoint(direct_c)
adjoint_numpy = GD_numpy.adjoint(direct_numpy)
numpy.testing.assert_allclose(adjoint_c.array, adjoint_numpy.array, atol=0.1)
numpy.testing.assert_allclose(adjoint_c.array, adjoint_numpy.array, atol=0.1)
adjoint_c *=0
adjoint_numpy *=0
GD_C.adjoint(direct_c, out=adjoint_c)
GD_numpy.adjoint(direct_numpy, out=adjoint_numpy)
numpy.testing.assert_allclose(adjoint_c.array, adjoint_numpy.array, atol=0.1)
numpy.testing.assert_allclose(adjoint_c.array, adjoint_numpy.array, atol=0.1)
print("Check Gradient_C, Gradient_numpy norms")
Gradient_C_norm = GD_C.norm()
Gradient_numpy_norm = GD_numpy.norm()
print(Gradient_C_norm, Gradient_numpy_norm)
numpy.testing.assert_allclose(Gradient_C_norm, Gradient_numpy_norm, rtol=0.1)
numpy.testing.assert_allclose(numpy.sqrt((2/ig.voxel_size_x)**2 + (2/ig.voxel_size_y)**2), Gradient_numpy_norm, rtol=0.1)
numpy.testing.assert_allclose(numpy.sqrt((2/ig.voxel_size_x)**2 + (2/ig.voxel_size_y)**2), Gradient_C_norm, rtol=0.1)
print("Test passed\n")
print("Check dot test")
self.assertTrue(GD_C.dot_test(GD_C))
self.assertTrue(GD_numpy.dot_test(GD_numpy))
print("Test passed\n")
print("Check dot test for Gradient Numpy with different method/bdn_cond")
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
print("Test passed\n")
print("Test GradientOperator for 2D Geometry passed\n")
###########################################################################
###########################################################################
###########################################################################
###########################################################################
print("Test GradientOperator for 3D Geometry, ")
ig = ImageGeometry(voxel_num_y = ny, voxel_num_x = nx, voxel_num_z = nz, voxel_size_x=0.1, voxel_size_y=0.5, voxel_size_z = 0.4)
GD_C = GradientOperator(ig, backend = 'c')
GD_numpy = GradientOperator(ig, backend = 'numpy')
numpy.random.seed(5)
print("Check Gradient_C, Gradient_numpy norms")
Gradient_C_norm = GD_C.norm()
Gradient_numpy_norm = GD_numpy.norm()
numpy.testing.assert_allclose(Gradient_C_norm, Gradient_numpy_norm, rtol=0.1)
numpy.testing.assert_allclose(numpy.sqrt((2/ig.voxel_size_z)**2 + (2/ig.voxel_size_x)**2 + (2/ig.voxel_size_y)**2), Gradient_numpy_norm, rtol=0.1)
numpy.testing.assert_allclose(numpy.sqrt((2/ig.voxel_size_z)**2 + (2/ig.voxel_size_x)**2 + (2/ig.voxel_size_y)**2), Gradient_C_norm, rtol=0.1)
print("Test passed\n")
print("Check dot test")
self.assertTrue(GD_C.dot_test(GD_C))
self.assertTrue(GD_numpy.dot_test(GD_numpy))
print("Test passed\n")
print("Check dot test for GradientOperator Numpy with different method/bdn_cond")
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
print("Test passed\n")
print("Test GradientOperator for 3D Geometry passed\n")
###########################################################################
###########################################################################
###########################################################################
###########################################################################
print("Test GradientOperator for 2D Geometry + channels, ")
ig = ImageGeometry(5,10, voxel_size_x=0.1, voxel_size_y=0.5, channels = 10)
GD_C = GradientOperator(ig, backend = 'c')
GD_numpy = GradientOperator(ig, backend = 'numpy')
print("Check Gradient_C, Gradient_numpy norms")
Gradient_C_norm = GD_C.norm()
Gradient_numpy_norm = GD_numpy.norm()
numpy.testing.assert_allclose(Gradient_C_norm, Gradient_numpy_norm, rtol=0.1)
print("Test passed\n")
print("Check dot test")
self.assertTrue(GD_C.dot_test(GD_C))
self.assertTrue(GD_numpy.dot_test(GD_numpy))
print("Test passed\n")
print("Check dot test for GradientOperator Numpy with different method/bdn_cond")
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
print("Test passed\n")
print("Test GradientOperator for 2D Geometry + channels passed\n")
###########################################################################
###########################################################################
###########################################################################
###########################################################################
print("Test GradientOperator for 3D Geometry + channels, ")
ig = ImageGeometry(voxel_num_x = nx, voxel_num_y = ny, voxel_num_z=nz, voxel_size_x=0.1, voxel_size_y=0.5, voxel_size_z = 0.3, channels = 10)
GD_C = GradientOperator(ig, backend = 'c')
GD_numpy = GradientOperator(ig, backend = 'numpy')
print("Check Gradient_C, Gradient_numpy norms")
Gradient_C_norm = GD_C.norm()
Gradient_numpy_norm = GD_numpy.norm()
numpy.testing.assert_allclose(Gradient_C_norm, Gradient_numpy_norm, rtol=0.1)
print("Test passed\n")
print("Check dot test")
self.assertTrue(GD_C.dot_test(GD_C))
self.assertTrue(GD_numpy.dot_test(GD_numpy))
print("Test passed\n")
print("Check dot test for Gradient Numpy with different method/bdn_cond")
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Neumann')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'forward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'backward', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
G_numpy1 = GradientOperator(ig, method = 'centered', bnd_cond = 'Periodic')
self.assertTrue(G_numpy1.dot_test(G_numpy1))
print("Test passed\n")
print("Test GradientOperator for 3D Geometry + channels passed\n")
def test_GradientOperator_4D(self):
nc, nz, ny, nx = 3, 4, 5, 6
size = nc * nz * ny * nx
dim = [nc, nz, ny, nx]
ig = ImageGeometry(voxel_num_x=nx, voxel_num_y=ny, voxel_num_z=nz, channels=nc)
arr = numpy.arange(size).reshape(dim).astype(numpy.float32)**2
data = ig.allocate()
data.fill(arr)
#neumann
grad_py = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='numpy')
gold_direct = grad_py.direct(data)
gold_adjoint = grad_py.adjoint(gold_direct)
grad_c = GradientOperator(ig, bnd_cond='Neumann', correlation='SpaceChannels', backend='c')
out_direct = grad_c.direct(data)
out_adjoint = grad_c.adjoint(out_direct)
#print("GradientOperator, 4D, bnd_cond='Neumann', direct")
numpy.testing.assert_array_equal(out_direct.get_item(0).as_array(), gold_direct.get_item(0).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(1).as_array(), gold_direct.get_item(1).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(2).as_array(), gold_direct.get_item(2).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(3).as_array(), gold_direct.get_item(3).as_array())
#print("GradientOperator, 4D, bnd_cond='Neumann', adjoint")
numpy.testing.assert_array_equal(out_adjoint.as_array(), gold_adjoint.as_array())
#periodic
grad_py = GradientOperator(ig, bnd_cond='Periodic', correlation='SpaceChannels', backend='numpy')
gold_direct = grad_py.direct(data)
gold_adjoint = grad_py.adjoint(gold_direct)
grad_c = GradientOperator(ig, bnd_cond='Periodic', correlation='SpaceChannels', backend='c')
out_direct = grad_c.direct(data)
out_adjoint = grad_c.adjoint(out_direct)
#print("GradientOperator, 4D, bnd_cond='Periodic', direct")
numpy.testing.assert_array_equal(out_direct.get_item(0).as_array(), gold_direct.get_item(0).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(1).as_array(), gold_direct.get_item(1).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(2).as_array(), gold_direct.get_item(2).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(3).as_array(), gold_direct.get_item(3).as_array())
#print("GradientOperator, 4D, bnd_cond='Periodic', adjoint")
numpy.testing.assert_array_equal(out_adjoint.as_array(), gold_adjoint.as_array())
#reordered
data.reorder(['vertical','horizontal_x','channel','horizontal_y'])
grad_py = GradientOperator(data.geometry, bnd_cond='Neumann', correlation='SpaceChannels', backend='numpy')
gold_direct = grad_py.direct(data)
gold_adjoint = grad_py.adjoint(gold_direct)
grad_c = GradientOperator(data.geometry, bnd_cond='Neumann', correlation='SpaceChannels', backend='c')
out_direct = grad_c.direct(data)
out_adjoint = grad_c.adjoint(out_direct)
#print("GradientOperator, 4D, bnd_cond='Neumann', direct")
numpy.testing.assert_array_equal(out_direct.get_item(0).as_array(), gold_direct.get_item(0).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(1).as_array(), gold_direct.get_item(1).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(2).as_array(), gold_direct.get_item(2).as_array())
numpy.testing.assert_array_equal(out_direct.get_item(3).as_array(), gold_direct.get_item(3).as_array())
#print("GradientOperator, 4D, bnd_cond='Neumann', adjoint")
numpy.testing.assert_array_equal(out_adjoint.as_array(), gold_adjoint.as_array())
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())
def test_Gradient_operator_numpy_vs_c(self):
for geom in self.list_geometries:
for bnd in self.bconditions:
for corr in self.correlation:
Grad_c = GradientOperator(geom,
bnd_cond=bnd,
correlation=corr,
backend='c')
Grad_numpy = GradientOperator(geom,
bnd_cond=bnd,
correlation=corr,
backend='numpy')
tmp_x = geom.allocate('random')
res1_c = Grad_c.direct(tmp_x)
res1_np = Grad_numpy.direct(tmp_x)
# Check direct of numpy vs c in place
for m in range(len(Grad_c.range.geometries)):
try:
numpy.testing.assert_array_almost_equal(
res1_c[m].array, res1_np[m].array)
except:
print("Check direct of numpy vs c in place")
self.print_assertion_info(geom, bnd, None, None,
corr, None)
raise
res1_c_out = Grad_c.range.allocate()
Grad_c.direct(tmp_x, out=res1_c_out)
res1_np_out = Grad_numpy.range.allocate()
Grad_numpy.direct(tmp_x, out=res1_np_out)
# Check direct of numpy vs c allocate
for m in range(len(Grad_c.range.geometries)):
try:
numpy.testing.assert_array_almost_equal(
res1_c_out[m].array, res1_np_out[m].array)
except:
print("Check direct of numpy vs c allocate")
self.print_assertion_info(geom, bnd, None, None,
corr, None)
raise
tmp_x = Grad_c.range.allocate('random')
res1_c = Grad_c.adjoint(tmp_x)
res1_np = Grad_numpy.adjoint(tmp_x)
# Check adjoint of numpy vs c in place
try:
numpy.testing.assert_array_almost_equal(res1_c.array,
res1_np.array,
decimal=5)
except:
print("Check adjoint of numpy vs c in place")
self.print_assertion_info(geom, bnd, None, None, corr,
None)
raise
res1_c_out = Grad_c.domain.allocate()
Grad_c.adjoint(tmp_x, out=res1_c_out)
res1_np_out = Grad_numpy.domain.allocate()
Grad_numpy.adjoint(tmp_x, out=res1_np_out)
# Check adjoint of numpy vs c allocate
try:
numpy.testing.assert_array_almost_equal(
res1_c_out.array, res1_np_out.array, decimal=5)
except:
print("Check adjoint of numpy vs c allocate")
self.print_assertion_info(geom, bnd, None, None, corr,
None)
raise
