def test_mesh(self):
""" prints out some meshes for debugging MZI mesh"""
# triangular mesh
print('')
N = 10
M = Mesh(N, mesh_type='triangular', initialization='random', M=None)
print('Triangular, N = {}, M = None:'.format(N))
print(M)
# full clements mesh
M = Mesh(N, mesh_type='clements', initialization='random', M=None)
print('Clements, N = {}, M = None:'.format(N))
print(M)
# clements mesh with custom number of layers
M_temp = 50
M = Mesh(N - 1,
mesh_type='clements',
initialization='random',
M=M_temp)
print('Clements, N = {}, M = {}:'.format(N - 1, M_temp))
# check if unitary with random initialization
self.is_unitary(M.full_matrix)
N = 4
# check if identity matrix with zero initialization
M = Mesh(N, mesh_type='clements', initialization='zeros', M=1)
np.testing.assert_array_almost_equal(M.full_matrix,
np.eye(N, dtype=np.complex64))
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)
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_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_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)
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_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_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)
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)
import numpy as np
import numpy.random as npr
import matplotlib.pylab as plt
from DLA_Control import Mesh
from DLA_Control import TriangleOptimizer, ClementsOptimizer
from DLA_Control.plots import plot_bar_3d, colorbar, plot_powers
""" 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
from DLA_Control import TriangleOptimizer, ClementsOptimizer
from DLA_Control.plots import plot_bar_3d, colorbar, plot_powers, apply_sublabels
NR = 1
NC = 2
fig, (axes) = plt.subplots(nrows=NR, ncols=NC)#, figsize=(8.5, 5))
# # create a clements mesh
N = 30
M = 10
vmax = 3/N
uniform_vals = np.ones((N, 1))
mesh = Mesh(N, mesh_type='clements', initialization='random', M=M)
print(mesh)
for i, ax in enumerate(axes.flat):
print("working on {}/{}".format(i+1, NR*NC))
random_vals = npr.random((N, 1))
mesh = Mesh(N, mesh_type='clements', initialization='random', M=M)
CO = ClementsOptimizer(mesh, input_values=random_vals, output_target=uniform_vals)
CO.optimize(algorithm='smart', verbose=False)
im = plot_powers(mesh, ax=ax)
im.set_clim(0,vmax)
