def test_real(self):
N = 10
mesh = Mesh(N, mesh_type='clements', initialization='real', M=None)
print(mesh)
R = (np.random.random(
(N, 1)) - 0.5) #+ 1j*(np.random.random((N, 1)) - 0.5)
mesh.input_couple(R)
output_values = mesh.output_values
print(output_values)
class TestCoupling(unittest.TestCase):
""" Code for testing the MZI controllers"""
def setUp(self):
self.N = 10
self.mesh_t = Mesh(self.N,
mesh_type='triangular',
initialization='random',
M=None)
self.mesh_c_r = Mesh(self.N,
mesh_type='clements',
initialization='random',
M=None)
self.mesh_c_z = Mesh(self.N,
mesh_type='clements',
initialization='zeros',
M=None)
self.one = normalize_vec(np.ones((self.N, 1)))
self.top = np.zeros((self.N, 1))
self.top[0] = 1
self.mid = np.zeros((self.N, 1))
self.mid[self.N // 2] = 1
self.bot = np.zeros((self.N, 1))
self.bot[-1] = 1
def test_IO(self):
""" Tests basic coupling"""
# first on the zeros initialized clements mesh
input_values = normalize_vec(npr.random((self.N, 1)))
self.mesh_c_z.input_couple(input_values)
output_values = self.mesh_c_z.output_values
# because the matrix was initialized with zeros, output should be identical to input
np.testing.assert_array_almost_equal(input_values, output_values)
# same goes for the partial values within MZI
for partial_value in self.mesh_c_z.partial_values:
np.testing.assert_array_almost_equal(input_values, partial_value)
# then on the random initialized clements mesh
input_values = npr.random((self.N, ))
self.mesh_c_r.input_couple(input_values)
output_values = self.mesh_c_r.output_values
# should not be equal for random initialization
assert_array_compare(operator.__ne__, input_values, output_values)
# same goes for the partial values within MZI
for partial_value in self.mesh_c_r.partial_values:
assert_array_compare(operator.__ne__, input_values, output_values)
# finally on the random initialized triangular mesh
input_values = normalize_vec(npr.random((self.N, 1)))
self.mesh_t.input_couple(input_values)
output_values = self.mesh_t.output_values
# should not be equal for random initialization
assert_array_compare(operator.__ne__, input_values, output_values)
# same goes for the partial values within MZI
for partial_value in self.mesh_t.partial_values:
assert_array_compare(operator.__ne__, input_values, output_values)
def check_power(self, mesh, output_target):
# checks if output equals target
P_out = power_vec(mesh.output_values)
P_target = power_vec(output_target)
error = norm(P_out - P_target) / self.N
self.assertLess(error, EPSILON)
#### VARIOUS INPUTS TO UNIFORM OUTPUTS ####
def test_updown_1_1(self):
# uniform to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_bot_1(self):
# bottom input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_mid_1(self):
# middle input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_top_1(self):
# top input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_rand_1(self):
# random input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO BOTTOM OUTPUTS ####
def test_updown_1_bot(self):
# uniform to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_bot_bot(self):
# bottom input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_mid_bot(self):
# middle input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_top_bot(self):
# top input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_rand_bot(self):
# random input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO MIDDLE OUTPUTS ####
def test_updown_1_mid(self):
# uniform to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_bot_mid(self):
# bottom input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_mid_mid(self):
# middle input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_top_mid(self):
# top input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_rand_mid(self):
# random input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO TOP OUTPUTS ####
def test_updown_1_top(self):
# uniform to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_bot_top(self):
# bottom input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_mid_top(self):
# middle input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_top_top(self):
# top input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_rand_top(self):
# random input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO RANDOM OUTPUTS ####
def test_updown_1_rand(self):
# uniform to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_bot_rand(self):
# bottom input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_mid_rand(self):
# middle input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_top_rand(self):
# top input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_updown_rand_rand(self):
# random input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='up_down')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO UNIFORM OUTPUTS ####
def test_spread_1_1(self):
# uniform to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_bot_1(self):
# bottom input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_mid_1(self):
# middle input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_top_1(self):
# top input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_rand_1(self):
# random input to uniform
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.one
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO BOTTOM OUTPUTS ####
def test_spread_1_bot(self):
# uniform to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_bot_bot(self):
# bottom input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_mid_bot(self):
# middle input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_top_bot(self):
# top input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_rand_bot(self):
# random input to bottom
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.bot
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO MIDDLE OUTPUTS ####
def test_spread_1_mid(self):
# uniform to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_bot_mid(self):
# bottom input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_mid_mid(self):
# middle input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_top_mid(self):
# top input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_rand_mid(self):
# random input to middle
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.mid
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO TOP OUTPUTS ####
def test_spread_1_top(self):
# uniform to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_bot_top(self):
# bottom input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_mid_top(self):
# middle input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_top_top(self):
# top input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_rand_top(self):
# random input to top
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = self.top
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
#### VARIOUS INPUTS TO RANDOM OUTPUTS ####
def test_spread_1_rand(self):
# uniform to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.one
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_bot_rand(self):
# bottom input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.bot
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_mid_rand(self):
# middle input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.mid
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_top_rand(self):
# top input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = self.top
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
def test_spread_rand_rand(self):
# random input to rand
N = self.N
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
input_values = npr.random((N, 1))
output_target = normalize_vec(npr.random((N, 1)))
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
TO.optimize(algorithm='spread')
# mesh.plot_powers(); plt.show()
self.check_power(mesh, output_target)
""" FIRST OPTIMIZE A TRIANGULAR MESH """
# create a triangular mesh
N = 10
mesh = Mesh(N, mesh_type='triangular', initialization='random', M=None)
print(mesh)
# comlex valued input coupling vector
input_values = np.zeros((N, 1))
input_values[-1] = 1
input_values = npr.random((N, 1))
f, (ax1, ax2) = plt.subplots(2, constrained_layout=True, figsize=(5, 5))
# couple light in and look at powers throughout mesh
mesh.input_couple(input_values)
im1 = plot_powers(mesh, ax=ax1)
colorbar(im1)
ax1.set_title('power distribution before optimizing')
# target output complex amplitude
output_target = np.ones((N, 1))
# define an optimizer over the triangular mesh
TO = TriangleOptimizer(mesh,
input_values=input_values,
output_target=output_target)
# optimize the mesh by pushing power to top port and redistributing
TO.optimize(algorithm='up_down')
