jan/meanas
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

snapshot 2025-02-07 01:30:37.661917

Browse source
This commit is contained in:
Jan Petykiewicz 2025-02-07 01:30:37 -08:00
commit d0e3fae4b7
17 changed files with 14862 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

61
examples/bend.py Normal file
View file

@ -0,0 +1,61 @@
import numpy
from numpy import pi
import gridlock
from meanas.fdfd import waveguide_2d, waveguide_cyl
from matplotlib import pyplot
wl = 1310
dx = 10
radius = 25e3
width = 400
thf = 161
thp = 77
eps_si = 3.51 ** 2
eps_ox = 1.453 ** 2
x0 = (width / 2) % dx
omega = 2 * pi / wl
grid = gridlock.Grid([
numpy.arange(-3000, 3000 + dx, dx),
numpy.arange(-1500, 1500 + dx, dx),
numpy.arange(-1 * dx, 1 * dx + dx, dx)],
periodic=True,
)
epsilon = grid.allocate(eps_ox)
grid.draw_cuboid(epsilon, center=[x0, thf / 2, 0], dimensions=[width, thf, 1e6], foreground=eps_si)
grid.draw_cuboid(epsilon, center=[x0, thp / 2, 0], dimensions=[width + 3e3, thp, 1e6], foreground=eps_si)
grid.draw_cuboid(epsilon, center=[x0 + width / 2 + 2e3, thf / 2, 0], dimensions=[1e3, thf, 1e6], foreground=eps_si)
grid.draw_cuboid(epsilon, center=[x0 - width / 2 - 2e3, thf / 2, 0], dimensions=[1e3, thf, 1e6], foreground=eps_si)
tilt = (1 + grid.xyz[0] / radius)
se = tilt[None, :, None, None] * epsilon
#print(tilt)
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
dxes_2d = [[d[0], d[1]] for d in dxes]
mode_numbers = numpy.arange(6)
args = dict(dxes=dxes_2d, omega=omega, mode_numbers=numpy.arange(6))
e_xys, wavenumbers = waveguide_2d.solve_modes(epsilon=se[:, :, :, 1].ravel(), **args)
ee, hh = waveguide_2d.normalized_fields_e(e_xys[0], wavenumber=wavenumbers[0], dxes=dxes_2d, omega=omega, epsilon=se[:, :, :, 1].ravel())
#print('tilted baseline:' wavenumbers * wl / pi / 2)
rmin = radius + grid.xyz[0].min()
epsv = epsilon[:, :, :, 1].ravel()
e2, angular_wavenumbers2 = waveguide_cyl.solve_modes(epsilon=epsv, rmin=rmin, **args)
print('cylindrical:', angular_wavenumbers2 * wl / pi / 2 / radius)
wavenumbers_2 = waveguide_cyl.linear_wavenumbers(e_xys=e2, angular_wavenumbers=angular_wavenumbers2, rmin=rmin, epsilon=epsv, dxes=dxes_2d)
print('cyl_auto:', wavenumbers_2 * wl / pi / 2)

65
examples/eme.py Normal file
View file

@ -0,0 +1,65 @@
import numpy
from numpy import pi
import gridlock
from gridlock import XYZExtent
from meanas.fdfd import waveguide_2d, waveguide_cyl
from matplotlib import pyplot
wl = 1310
dx = 10
radius = 25e3
width = 400
thf = 161
thp = 77
eps_si = 3.51 ** 2
eps_ox = 1.453 ** 2
x0 = (width / 2) % dx
omega = 2 * pi / wl
grid = gridlock.Grid([
numpy.arange(-3000, 3000 + dx, dx),
numpy.arange(-1500, 1500 + dx, dx),
numpy.arange(-5 * dx, 5 * dx + dx, dx)],
periodic=True,
)
epsilon = grid.allocate(eps_ox)
grid.draw_cuboid(epsilon, extent=XYZExtent(xctr=x0, lx=width + 5e3, ymin=0, ymax=thf, zmin=-1e6, zmax=0), foreground=eps_si)
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax=-width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zmax=0), foreground=eps_ox)
grid.draw_cuboid(epsilon, extent=XYZExtent(xmin= width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zmax=0), foreground=eps_ox)
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax=-(width / 2 + 2.5e3), lx=1e3, ymin=0, ymax=thf, zmin=0, zmax=1e6), foreground=eps_si)
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax= width / 2 + 2.5e3, lx=1e3, ymin=0, ymax=thf, zmin=0, zmax=1e6), foreground=eps_si)
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
dxes_2d = [[d[0], d[1]] for d in dxes]
mode_numbers = numpy.arange(20)
args = dict(dxes=dxes_2d, omega=omega, mode_numbers=mode_numbers)
eps1 = epsilon[:, :, :, 1].ravel()
eps2 = epsilon[:, :, :, -2].ravel()
eL_xys, wavenumbers_L = waveguide_2d.solve_modes(epsilon=eps1, **args)
eR_xys, wavenumbers_R = waveguide_2d.solve_modes(epsilon=eps2, **args)
eh_L = [
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps1)
for e_xy, wavenumber in zip(eL_xys, wavenumbers_L)]
eh_R = [
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps2)
for e_xy, wavenumber in zip(eR_xys, wavenumbers_R)]
eh_R = [
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps2)
for e_xy, wavenumber in zip(eR_xys, wavenumbers_R)]
ss = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_R, wavenumbers_R, dxes=dxes_2d)
ss11 = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_L, wavenumbers_L, dxes=dxes_2d)
ss22 = waveguide_2d.get_s(eh_R, wavenumbers_R, eh_R, wavenumbers_R, dxes=dxes_2d)

105
examples/eme_bend.py Normal file
View file

@ -0,0 +1,105 @@
import numpy
from numpy import pi
import gridlock
from gridlock import XYZExtent
from meanas.fdfd import waveguide_2d, waveguide_cyl
from meanas.fdmath import vec, unvec
from matplotlib import pyplot, colors
from scipy import sparse
import skrf
from skrf import Network
wl = 1310
dx = 10
radius = 25e3
width = 400
thf = 161
thp = 77
eps_si = 3.51 ** 2
eps_ox = 1.453 ** 2
x0 = (width / 2) % dx
omega = 2 * pi / wl
grid = gridlock.Grid([
numpy.arange(-3000, 3000 + dx, dx),
numpy.arange(-1500, 1500 + dx, dx),
numpy.arange(-5 * dx, 5 * dx + dx, dx)],
periodic=True,
)
epsilon = grid.allocate(eps_ox)
grid.draw_cuboid(epsilon, extent=XYZExtent(xctr=x0, lx=width + 5e3, ymin=0, ymax=thf, zmin=-1e6, zmax=0), foreground=eps_si)
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax=-width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zctr=0), foreground=eps_ox)
grid.draw_cuboid(epsilon, extent=XYZExtent(xmin= width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zctr=0), foreground=eps_ox)
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
dxes_2d = [[d[0], d[1]] for d in dxes]
mode_numbers = numpy.arange(20)
args = dict(dxes=dxes_2d, omega=omega, mode_numbers=mode_numbers)
eps = epsilon[:, :, :, 2].ravel()
rmin = radius + grid.xyz[0].min()
eL_xys, wavenumbers_L = waveguide_2d.solve_modes(epsilon=eps, **args)
eR_xys, ang_wavenumbers_R = waveguide_cyl.solve_modes(epsilon=eps, **args, rmin=rmin)
linear_wavenumbers_R = waveguide_cyl.linear_wavenumbers(e_xys=eR_xys, angular_wavenumbers=ang_wavenumbers_R, rmin=rmin, epsilon=eps, dxes=dxes_2d)
eh_L = [
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps)
for e_xy, wavenumber in zip(eL_xys, wavenumbers_L)]
eh_R = [
waveguide_cyl.normalized_fields_e(e_xy, angular_wavenumber=ang_wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps, rmin=rmin)
for e_xy, ang_wavenumber in zip(eR_xys, ang_wavenumbers_R)]
ss = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_R, linear_wavenumbers_R, dxes=dxes_2d)
ss11 = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_L, wavenumbers_L, dxes=dxes_2d)
ss22 = waveguide_2d.get_s(eh_R, linear_wavenumbers_R, eh_R, linear_wavenumbers_R, dxes=dxes_2d)
fig, axes = pyplot.subplots(2, 2)
mb0 = axes[0, 0].pcolormesh(numpy.abs(ss[::-1])**2, cmap='hot', vmin=0)
fig.colorbar(mb0)
axes[1, 0].set_title('S Abs^2')
mb2 = axes[1, 0].pcolormesh(ss[::-1].real, cmap='bwr', norm=colors.CenteredNorm())
fig.colorbar(mb2)
axes[1, 0].set_title('S Real')
mb3 = axes[1, 1].pcolormesh(ss[::-1].imag, cmap='bwr', norm=colors.CenteredNorm())
fig.colorbar(mb3)
axes[1, 1].set_title('S Imag')
pyplot.show(block=False)
e1, h1 = eh_L[2]
e2, h2 = eh_R[2]
figE, axesE = pyplot.subplots(3, 2)
figH, axesH = pyplot.subplots(3, 2)
esqmax = max(numpy.abs(e1).max(), numpy.abs(e2).max()) ** 2
hsqmax = max(numpy.abs(h1).max(), numpy.abs(h2).max()) ** 2
for mm, (ee, hh) in enumerate(zip((e1, e2), (h1, h2))):
E = unvec(ee, grid.shape[:2])
H = unvec(hh, grid.shape[:2])
for aa in range(3):
axesE[aa, mm].pcolormesh((numpy.abs(E[aa]) ** 2).T, cmap='bwr', norm=colors.CenteredNorm(halfrange=esqmax))
axesH[aa, mm].pcolormesh((numpy.abs(H[aa]) ** 2).T, cmap='bwr', norm=colors.CenteredNorm(halfrange=hsqmax))
pyplot.show(block=False)
net_wb = Network(f=[1 / wl], s = ss)
net_bw = net_wb.copy()
net_bw.renumber(numpy.arange(40), numpy.roll(numpy.arange(40), 20))
wg_phase = sparse.diags_array(numpy.exp(-1j * wavenumbers_L * 100e3))
bend_phase = sparse.diags_array(numpy.exp(-1j * ang_wavenumbers_R * pi / 2))
net_propwg = Network(f=[1 / wl], s = sparse.block_array(([None, wg_phase], [wg_phase, None])).toarray()[None, ...])
net_propbend = Network(f=[1 / wl], s = sparse.block_array(([None, bend_phase], [bend_phase, None])).toarray()[None, ...])
cir = skrf.network.cascade_list([net_propwg, net_wb, net_propbend, net_bw, net_propwg])

168
examples/fdtd.py
View file

@ -6,13 +6,20 @@ See main() for simulation setup.
import sys
import time
import copy
import numpy
import h5py
from numpy.linalg import norm
from meanas import fdtd
from meanas.fdtd import cpml_params, updates_with_cpml
from masque import Pattern, shapes
from meanas.fdtd.misc import gaussian_packet
from meanas.fdfd.operators import e_full
from meanas.fdfd.scpml import stretch_with_scpml
from meanas.fdmath import vec
from masque import Pattern, Circle, Polygon
import gridlock
import pcgen
@ -41,50 +48,51 @@ def perturbed_l3(a: float, radius: float, **kwargs) -> Pattern:
`masque.Pattern` object containing the L3 design
"""
default_args = {'hole_dose': 1,
'trench_dose': 1,
'hole_layer': 0,
'trench_layer': 1,
'shifts_a': (0.15, 0, 0.075),
'shifts_r': (1.0, 1.0, 1.0),
'xy_size': (10, 10),
'perturbed_radius': 1.1,
'trench_width': 1.2e3,
}
default_args = {
'hole_layer': 0,
'trench_layer': 1,
'shifts_a': (0.15, 0, 0.075),
'shifts_r': (1.0, 1.0, 1.0),
'xy_size': (10, 10),
'perturbed_radius': 1.1,
'trench_width': 1.2e3,
}
kwargs = {**default_args, **kwargs}
xyr = pcgen.l3_shift_perturbed_defect(mirror_dims=kwargs['xy_size'],
perturbed_radius=kwargs['perturbed_radius'],
shifts_a=kwargs['shifts_a'],
shifts_r=kwargs['shifts_r'])
xyr = pcgen.l3_shift_perturbed_defect(
mirror_dims=kwargs['xy_size'],
perturbed_radius=kwargs['perturbed_radius'],
shifts_a=kwargs['shifts_a'],
shifts_r=kwargs['shifts_r'],
)
xyr *= a
xyr[:, 2] *= radius
pat = Pattern()
pat.name = f'L3p-a{a:g}r{radius:g}rp{kwargs["perturbed_radius"]:g}'
pat.shapes += [shapes.Circle(radius=r, offset=(x, y),
dose=kwargs['hole_dose'],
layer=kwargs['hole_layer'])
for x, y, r in xyr]
#pat.name = f'L3p-a{a:g}r{radius:g}rp{kwargs["perturbed_radius"]:g}'
pat.shapes[(kwargs['hole_layer'], 0)] += [
Circle(radius=r, offset=(x, y))
for x, y, r in xyr]
maxes = numpy.max(numpy.fabs(xyr), axis=0)
pat.shapes += [shapes.Polygon.rectangle(
lx=(2 * maxes[0]), ly=kwargs['trench_width'],
offset=(0, s * (maxes[1] + a + kwargs['trench_width'] / 2)),
dose=kwargs['trench_dose'], layer=kwargs['trench_layer'])
for s in (-1, 1)]
pat.shapes[(kwargs['trench_layer'], 0)] += [
Polygon.rectangle(
lx=(2 * maxes[0]), ly=kwargs['trench_width'],
offset=(0, s * (maxes[1] + a + kwargs['trench_width'] / 2))
)
for s in (-1, 1)]
return pat
def main():
dtype = numpy.float32
max_t = 8000 # number of timesteps
max_t = 3600 # number of timesteps
dx = 40 # discretization (nm/cell)
pml_thickness = 8 # (number of cells)
wl = 1550 # Excitation wavelength and fwhm
dwl = 200
dwl = 100
# Device design parameters
xy_size = numpy.array([10, 10])
@ -107,69 +115,89 @@ def main():
# #### Create the grid, mask, and draw the device ####
grid = gridlock.Grid(edge_coords)
epsilon = grid.allocate(n_air**2, dtype=dtype)
grid.draw_slab(epsilon,
surface_normal=2,
center=[0, 0, 0],
thickness=th,
eps=n_slab**2)
epsilon = grid.allocate(n_air ** 2, dtype=dtype)
grid.draw_slab(
epsilon,
slab = dict(axis='z', center=0, span=th),
foreground = n_slab ** 2,
)
mask = perturbed_l3(a, r)
grid.draw_polygons(
epsilon,
slab = dict(axis='z', center=0, span=2 * th),
foreground = n_air ** 2,
offset2d = (0, 0),
polygons = mask.as_polygons(library=None),
)
grid.draw_polygons(epsilon,
surface_normal=2,
center=[0, 0, 0],
thickness=2 * th,
eps=n_air**2,
polygons=mask.as_polygons())
print(f'{grid.shape=}')
print(grid.shape)
dt = .99/numpy.sqrt(3)
e = [numpy.zeros_like(epsilon[0], dtype=dtype) for _ in range(3)]
h = [numpy.zeros_like(epsilon[0], dtype=dtype) for _ in range(3)]
dt = dx * 0.99 / numpy.sqrt(3)
ee = numpy.zeros_like(epsilon, dtype=dtype)
hh = numpy.zeros_like(epsilon, dtype=dtype)
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
# PMLs in every direction
pml_params = [[cpml_params(axis=dd, polarity=pp, dt=dt,
thickness=pml_thickness, epsilon_eff=1.0**2)
for pp in (-1, +1)]
for dd in range(3)]
update_E, update_H = updates_with_cpml(cpml_params=pml_params, dt=dt,
dxes=dxes, epsilon=epsilon)
pml_params = [
[cpml_params(axis=dd, polarity=pp, dt=dt, thickness=pml_thickness, epsilon_eff=n_air ** 2)
for pp in (-1, +1)]
for dd in range(3)]
update_E, update_H = updates_with_cpml(cpml_params=pml_params, dt=dt, dxes=dxes, epsilon=epsilon)
# sample_interval = numpy.floor(1 / (2 * 1 / wl * dt)).astype(int)
# print(f'Save time interval would be {sample_interval} * dt = {sample_interval * dt:3g}')
# Source parameters and function
w = 2 * numpy.pi * dx / wl
fwhm = dwl * w * w / (2 * numpy.pi * dx)
alpha = (fwhm ** 2) / 8 * numpy.log(2)
delay = 7/numpy.sqrt(2 * alpha)
source_phasor, _delay = gaussian_packet(wl=wl, dwl=100, dt=dt, turn_on=1e-5)
aa, cc, ss = source_phasor(numpy.arange(max_t))
srca_real = aa * cc
src_maxt = numpy.argwhere(numpy.diff(aa < 1e-5))[-1]
assert aa[src_maxt - 1] >= 1e-5
phasor_norm = dt / (aa * cc * cc).sum()
def field_source(i):
t0 = i * dt - delay
return numpy.sin(w * t0) * numpy.exp(-alpha * t0**2)
Jph = numpy.zeros_like(epsilon, dtype=complex)
Jph[1, *(grid.shape // 2)] = epsilon[1, *(grid.shape // 2)]
Eph = numpy.zeros_like(Jph)
# #### Run a bunch of iterations ####
output_file = h5py.File('simulation_output.h5', 'w')
start = time.perf_counter()
for t in range(max_t):
update_E(e, h, epsilon)
for tt in range(max_t):
update_E(ee, hh, epsilon)
e[1][tuple(grid.shape//2)] += field_source(t)
update_H(e, h)
if tt < src_maxt:
ee[1, *(grid.shape // 2)] -= srca_real[tt]
update_H(ee, hh)
avg_rate = (t + 1)/(time.perf_counter() - start))
print(f'iteration {t}: average {avg_rate} iterations per sec')
avg_rate = (tt + 1) / (time.perf_counter() - start)
sys.stdout.flush()
if t % 20 == 0:
r = sum([(f * f * e).sum() for f, e in zip(e, epsilon)])
print('E sum', r)
if tt % 200 == 0:
print(f'iteration {tt}: average {avg_rate} iterations per sec')
E_energy_sum = (ee * ee * epsilon).sum()
print(f'{E_energy_sum=}')
# Save field slices
if (t % 20 == 0 and (max_t - t <= 1000 or t <= 2000)) or t == max_t-1:
print('saving E-field')
for j, f in enumerate(e):
output_file['/E{}_t{}'.format('xyz'[j], t)] = f[:, :, round(f.shape[2]/2)]
if (tt % 20 == 0 and (max_t - tt <= 1000 or tt <= 2000)) or tt == max_t - 1:
print(f'saving E-field at iteration {tt}')
output_file[f'/E_t{tt}'] = ee[:, :, :, ee.shape[3] // 2]
Eph += (cc[tt] - 1j * ss[tt]) * phasor_norm * ee
omega = 2 * pi / wl
Eph *= numpy.exp(-1j * dt / 2 * omega)
b = -1j * omega * Jph
dxes_fdfd = copy.deepcopy(dxes)
for pp in (-1, +1):
for dd in range(3):
stretch_with_scpml(dxes_fdfd, axis=dd, polarity=pp, omega=omega, epsilon_effective=n_air ** 2, thickness=pml_thickness)
A = e_full(omega=omega, dxes=dxes, epsilon=epsilon)
residual = norm(A @ vec(ee) - vec(b)) / norm(vec(b))
print(f'FDFD residual is {residual}')
if __name__ == '__main__':
main()

284
examples/nom.py Normal file
View file

@ -0,0 +1,284 @@
from simphony.elements import Model
from simphony.netlist import Subcircuit
from simphony.simulation import SweepSimulation
from matplotlib import pyplot as plt
class PeriodicLayer(Model):
def __init__(self, left_modes, right_modes, s_params):
self.left_modes = left_modes
self.right_modes = right_modes
self.left_ports = len(self.left_modes)
self.right_ports = len(self.right_modes)
self.normalize_fields()
self.s_params = s_params
def normalize_fields(self):
for mode in range(len(self.left_modes)):
self.left_modes[mode].normalize()
for mode in range(len(self.right_modes)):
self.right_modes[mode].normalize()
class PeriodicEME:
def __init__(self, layers=[], num_periods=1):
self.layers = layers
self.num_periods = num_periods
self.wavelength = wavelength
def propagate(self):
wl = self.wavelength
if not len(self.layers):
raise Exception("Must place layers before propagating")
num_modes = max([l.num_modes for l in self.layers])
iface = InterfaceSingleMode if num_modes == 1 else InterfaceMultiMode
eme = EME(layers=self.layers)
left, right = eme.propagate()
self.single_period = eme.s_matrix
period_layer = PeriodicLayer(left.modes, right.modes, self.single_period)
current_layer = PeriodicLayer(left.modes, right.modes, self.single_period)
interface = iface(right, left)
for _ in range(self.num_periods - 1):
current_layer.s_params = cascade(current_layer, interface, wl)
current_layer.s_params = cascade(current_layer, period_layer, wl)
self.s_params = current_layer.s_params
class EME:
def __init__(self, layers=[]):
self.layers = layers
self.wavelength = None
def propagate(self):
layers = self.layers
wl = layers[0].wavelength if self.wavelength is None else self.wavelength
if not len(layers):
raise Exception("Must place layers before propagating")
num_modes = max([l.num_modes for l in layers])
iface = InterfaceSingleMode if num_modes == 1 else InterfaceMultiMode
first_layer = layers[0]
current = Current(wl, first_layer)
interface = iface(first_layer, layers[1])
current.s = cascade(current, interface, wl)
current.right_pins = interface.right_pins
for index in range(1, len(layers) - 1):
layer1 = layers[index]
layer2 = layers[index + 1]
interface = iface(layer1, layer2)
current.s = cascade(current, layer1, wl)
current.right_pins = layer1.right_pins
current.s = cascade(current, interface, wl)
current.right_pins = interface.right_pins
last_layer = layers[-1]
current.s = cascade(current, last_layer, wl)
current.right_pins = last_layer.right_pins
self.s_matrix = current.s
return first_layer, last_layer
def stack(sa, sb):
qab = numpy.eye() - sa.r11 @ sb.r11
qba = numpy.eye() - sa.r11 @ sb.r11
#s.t12 = sa.t12 @ numpy.pinv(qab) @ sb.t12
#s.r21 = sa.t12 @ numpy.pinv(qab) @ sb.r22 @ sa.t21 + sa.r22
#s.r12 = sb.t21 @ numpy.pinv(qba) @ sa.r11 @ sb.t12 + sb.r11
#s.t21 = sb.t21 @ numpy.pinv(qba) @ sa.t21
s.t12 = sa.t12 @ numpy.linalg.solve(qab, sb.t12)
s.r21 = sa.t12 @ numpy.linalg.solve(qab, sb.r22 @ sa.t21) + sa.r22
s.r12 = sb.t21 @ numpy.linalg.solve(qba, sa.r11 @ sb.t12) + sb.r11
s.t21 = sb.t21 @ numpy.linalg.solve(qba, sa.t21)
return s
def cascade(first, second, wavelength):
circuit = Subcircuit("Device")
circuit.add([(first, "first"), (second, "second")])
for port in range(first.right_ports):
circuit.connect("first", "right" + str(port), "second", "left" + str(port))
simulation = SweepSimulation(circuit, wavelength, wavelength, num=1)
result = simulation.simulate()
return result.s
class InterfaceSingleMode(Model):
def __init__(self, layer1, layer2, num_modes=1):
self.num_modes = num_modes
self.num_ports = 2 * num_modes
self.s = self.solve(layer1, layer2, num_modes)
def solve(self, layer1, layer2, num_modes):
nm = num_modes
s = numpy.zeros((2 * nm, 2 * nm), dtype=complex)
for ii, left_mode in enumerate(layer1.modes):
for oo, right_mode in enumerate(layer2.modes):
r, t = get_rt(left_mode, right_mode)
s[ oo, ii] = r
s[nm + oo, ii] = t
for ii, right_mode in enumerate(layer2.modes):
for oo, left_mode in enumerate(layer1.modes):
r, t = get_rt(right_mode, left_mode)
s[ oo, nm + ii] = t
s[nm + oo, nm + ii] = r
return s
class InterfaceMultiMode(Model):
def __init__(self, layer1, layer2):
self.s = self.solve(layer1, layer2)
def solve(self, layer1, layer2):
n1p = layer1.num_modes
n2p = layer2.num_modes
num_ports = n1p + n2p
s = numpy.zeros((num_ports, num_ports), dtype=complex)
for l1p in range(n1p):
ts = get_t(l1p, layer1, layer2)
rs = get_r(l1p, layer1, layer2, ts)
s[n1p:, l1p] = ts
s[:n1p, l1p] = rs
for l2p in range(n2p):
ts = get_t(l2p, layer2, layer1)
rs = get_r(l2p, layer2, layer1, ts)
s[:n1p, n1p + l2p] = ts
s[n1p:, n1p + l2p] = rs
return s
def get_t(p, left, right):
A = numpy.empty(left.shape[0], right.shape[0], dtype=complex)
for ll in range(left.shape[0]):
for rr in range(right.shape[0]):
# TODO optimize loop?
A[i, k] = inner_product(right[rr], left[ll]) + inner_product(left[ll], right[rr])
b = numpy.zeros(left.shape[0i])
b[p] = 2 * inner_product(left[p], left[p])
x = numpy.linalg.solve(A, b)
# NOTE: `A` does not depend on `p`, so it might make sense to partially precompute
# the solution (pinv(A), or LU decomposition?)
# Actually solve() can take multiple vectors, so just pass it something with the full diagonal?
xx = numpy.matmul(numpy.linalg.pinv(A), b) #TODO verify
assert(numpy.allclose(xx, x))
return x
def get_r(p, left, right, t):
r = numpy.empty(left.num_modes, dtype=complex)
for ii in range(left.num_modes):
r[ii] = sum((inner_product(right[kk], left[ii]) - inner_product(left[ii], right[kk])) * t[kk]
for kk in range(right.num_modes)
) / (2 * inner_product(left[ii], left[ii]))
return r
def get_rt(left, right):
s = 0.5 * (inner_product(left, right) + inner_product(right, left))
d = 0.5 * (inner_product(left, right) - inner_product(right, left))
t = (s * s - d * d) / s
r = 1 - t / (s + d)
return -r, t
def inner_product(left_E, right_H, dxes):
cross_z = left_E[0] * right_H.conj()[1] - left_E[1] * right_H[0].conj()
# cross_z = numpy.cross(left_E, numpy.conj(right_H), axisa=0, axisb=0, axisc=0)[2]
return numpy.trapz(numpy.trapz(cross_z, dxes[0][0]), dxes[0][1]) / 2 # TODO might need cumsum on dxes
def propagation_matrix(self, modes, wavelength, distance):
eigenv = numpy.array([mode.neff for mode in modes]) * 2 * numpy.pi / wavelength
prop_diag = numpy.diag(numpy.exp(distance * 1j * numpy.hstack((eigenv, eigenv))))
prop_matrix = numpy.roll(prop_diag, len(eigenv), axis=0)
return prop_matrix
def connect_s(A: numpy.ndarray, k: int, B: numpy.ndarray, l: int):
"""
TODO
connect two n-port networks' s-matrices together.
specifically, connect port `k` on network `A` to port `l` on network
`B`. The resultant network has nports = (A.rank + B.rank-2).
Args:
A: S-parameter matrix of `A`, shape is fxnxn
k: port index on `A` (port indices start from 0)
B: S-parameter matrix of `B`, shape is fxnxn
l: port index on `B`
Returns:
C: new S-parameter matrix
"""
if k > A.shape[-1] - 1 or l > B.shape[-1] - 1:
raise (ValueError("port indices are out of range"))
C = scipy.sparse.block_diag((A, B), dtype=complex)
return innerconnect_s(C, k, A.shape[0] + l)
def innerconnect_s(A, k, l):
"""
TODO
n x n x freq
connect two ports of a single n-port network's s-matrix.
Specifically, connect port `k` to port `l` on `A`. This results in
a (n-2)-port network.
Args:
A: S-parameter matrix of `A`, shape is fxnxn
k: port index on `A` (port indices start from 0)
l: port index on `A`
Returns:
C: new S-parameter matrix
Notes:
Relevant papers:
- Compton, R.C.; , "Perspectives in microwave circuit analysis," Circuits and Systems, 1989., Proceedings of the 32nd Midwest Symposium on , vol., no., pp.716-718 vol.2, 14-16 Aug 1989. URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=101955&isnumber=3167
- Filipsson, Gunnar; , "A New General Computer Algorithm for S-Matrix Calculation of Interconnected Multiports," Microwave Conference, 1981. 11th European , vol., no., pp.700-704, 7-11 Sept. 1981. URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4131699&isnumber=4131585
"""
if k > A.shape[-1] - 1 or l > A.shape[-1] - 1:
raise (ValueError("port indices are out of range"))
l = [l]
k = [k]
mkl = 1 - A[k, l]
mlk = 1 - A[l, k]
C = A + (A[k, :] * A[:, l] * mlk
+ A[l, :] * A[:, k] * mkk
+ A[k, :] * A[l, l] * A[:, k]
+ A[l, :] * A[k, k] * A[:, l]
) / (
mlk * mkl - A[k, k] * A[l, l]
)
# remove connected ports
C = npy.delete(C, (k, l), 1)
C = npy.delete(C, (k, l), 2)
return C