def find_modes(filename, wvl=1.55, bw=0.05):
# Read in the ring structure
geometry = mp.get_GDSII_prisms(Si, filename, RING_LAYER, -100, 100)
cell = mp.GDSII_vol(filename, SIMULATION_LAYER, zmin, zmax)
src_vol0 = mp.GDSII_vol(filename, SOURCE0_LAYER, zmin, zmax)
src_vol1 = mp.GDSII_vol(filename, SOURCE1_LAYER, zmin, zmax)
mon_vol = mp.GDSII_vol(filename, MONITOR_LAYER, zmin, zmax)
fcen = 1 / wvl
df = bw * fcen
src = [
mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Hz,
volume=src_vol0),
mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Hz,
volume=src_vol1,
amplitude=-1)
]
sim = mp.Simulation(cell_size=cell.size,
geometry=geometry,
sources=src,
resolution=resolution,
boundary_layers=[mp.PML(dpml)],
default_material=SiO2)
h = mp.Harminv(mp.Hz, mon_vol.center, fcen, df)
sim.run(mp.after_sources(h), until_after_sources=100)
plt.figure()
sim.plot2D(fields=mp.Hz)
plt.savefig('ring_resonator_Hz.png')
wvl = np.array([1 / m.freq for m in h.modes])
Q = np.array([m.Q for m in h.modes])
sim.reset_meep()
return wvl, Q
# geometry = []
# geometry.append(mp.Cylinder(material=silicon, center=mp.Vector3(0,-1*ring_radius,0), radius=ring_radius + ring_width/2, height=0))
# geometry.append(mp.Cylinder(material=oxide, center=mp.Vector3(0,-1*ring_radius,0), radius=ring_radius - ring_width/2, height=0))
# geometry.append(mp.Block(material=oxide, center=mp.Vector3(-0.5*ring_radius,0,0), size=mp.Vector3(ring_radius,2*ring_radius,0)))
# geometry.append(mp.Block(material=oxide, center=mp.Vector3(ring_radius,-1.5*ring_radius,0), size=mp.Vector3(2*ring_radius,ring_radius,0)))
si_layer = mp.get_GDSII_prisms(silicon, gdsII_file, Si_LAYER, si_zmin, si_zmax)
# # Later objects get priority : fix
final_geometry = []
# for fix in geometry:
# final_geometry.append(fix)
for fix in si_layer:
final_geometry.append(fix)
cell = mp.GDSII_vol(gdsII_file, CELL_LAYER, cell_zmin, cell_zmax)
src_vol = mp.GDSII_vol(gdsII_file, SOURCE_LAYER, si_zmin, si_zmax)
p1 = mp.GDSII_vol(gdsII_file, 20, si_zmin, si_zmax)
p2 = mp.GDSII_vol(gdsII_file, 21, si_zmin, si_zmax)
sources = [
mp.EigenModeSource(src=mp.GaussianSource(fcen, fwidth=df),
size=src_vol.size,
center=src_vol.center,
eig_band=1,
eig_parity=mp.EVEN_Y + mp.ODD_Z,
eig_match_freq=True)
]
# Display simulation object
sim = mp.Simulation(resolution=res,
def main(args):
cell_zmax = 0.5 * cell_thickness if args.three_d else 0
cell_zmin = -0.5 * cell_thickness if args.three_d else 0
si_zmax = t_Si if args.three_d else 0
# read cell size, volumes for source region and flux monitors,
# and coupler geometry from GDSII file
upper_branch = mp.get_GDSII_prisms(silicon, gdsII_file, UPPER_BRANCH_LAYER,
si_zmin, si_zmax)
lower_branch = mp.get_GDSII_prisms(silicon, gdsII_file, LOWER_BRANCH_LAYER,
si_zmin, si_zmax)
cell = mp.GDSII_vol(gdsII_file, CELL_LAYER, cell_zmin, cell_zmax)
p1 = mp.GDSII_vol(gdsII_file, PORT1_LAYER, si_zmin, si_zmax)
p2 = mp.GDSII_vol(gdsII_file, PORT2_LAYER, si_zmin, si_zmax)
p3 = mp.GDSII_vol(gdsII_file, PORT3_LAYER, si_zmin, si_zmax)
p4 = mp.GDSII_vol(gdsII_file, PORT4_LAYER, si_zmin, si_zmax)
src_vol = mp.GDSII_vol(gdsII_file, SOURCE_LAYER, si_zmin, si_zmax)
# displace upper and lower branches of coupler (as well as source and flux regions)
if args.d != default_d:
delta_y = 0.5 * (args.d - default_d)
delta = mp.Vector3(y=delta_y)
p1.center += delta
p2.center -= delta
p3.center += delta
p4.center -= delta
src_vol.center += delta
cell.size += 2 * delta
for np in range(len(lower_branch)):
lower_branch[np].center -= delta
for nv in range(len(lower_branch[np].vertices)):
lower_branch[np].vertices[nv] -= delta
for np in range(len(upper_branch)):
upper_branch[np].center += delta
for nv in range(len(upper_branch[np].vertices)):
upper_branch[np].vertices[nv] += delta
geometry = upper_branch + lower_branch
if args.three_d:
oxide_center = mp.Vector3(z=-0.5 * t_oxide)
oxide_size = mp.Vector3(cell.size.x, cell.size.y, t_oxide)
oxide_layer = [
mp.Block(material=oxide, center=oxide_center, size=oxide_size)
]
geometry = geometry + oxide_layer
sources = [
mp.EigenModeSource(
src=mp.GaussianSource(fcen, fwidth=df),
volume=src_vol,
eig_band=1,
eig_parity=mp.NO_PARITY if args.three_d else mp.EVEN_Y + mp.ODD_Z,
eig_match_freq=True)
]
sim = mp.Simulation(resolution=args.res,
cell_size=cell.size,
boundary_layers=[mp.PML(dpml)],
sources=sources,
geometry=geometry)
mode1 = sim.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(volume=p1))
mode2 = sim.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(volume=p2))
mode3 = sim.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(volume=p3))
mode4 = sim.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(volume=p4))
sim.run(until_after_sources=100)
# S parameters
p1_coeff = sim.get_eigenmode_coefficients(
mode1, [1],
eig_parity=mp.NO_PARITY if args.three_d else mp.EVEN_Y +
mp.ODD_Z).alpha[0, 0, 0]
p2_coeff = sim.get_eigenmode_coefficients(
mode2, [1],
eig_parity=mp.NO_PARITY if args.three_d else mp.EVEN_Y +
mp.ODD_Z).alpha[0, 0, 1]
p3_coeff = sim.get_eigenmode_coefficients(
mode3, [1],
eig_parity=mp.NO_PARITY if args.three_d else mp.EVEN_Y +
mp.ODD_Z).alpha[0, 0, 0]
p4_coeff = sim.get_eigenmode_coefficients(
mode4, [1],
eig_parity=mp.NO_PARITY if args.three_d else mp.EVEN_Y +
mp.ODD_Z).alpha[0, 0, 0]
# transmittance
p2_trans = abs(p2_coeff)**2 / abs(p1_coeff)**2
p3_trans = abs(p3_coeff)**2 / abs(p1_coeff)**2
p4_trans = abs(p4_coeff)**2 / abs(p1_coeff)**2
print("trans:, {:.2f}, {:.6f}, {:.6f}, {:.6f}".format(
args.d, p2_trans, p3_trans, p4_trans))
def get_transmission_2ports(
component: Component,
extend_ports_length: Optional[float] = 4.0,
layer_core: int = 1,
layer_source: int = 110,
layer_monitor1: int = 101,
layer_monitor2: int = 102,
layer_simulation_region: int = 2,
res: int = 20,
t_clad_bot: float = 1.0,
t_core: float = 0.22,
t_clad_top: float = 1.0,
dpml: int = 1,
clad_material: Medium = mp.Medium(epsilon=2.25),
core_material: Medium = mp.Medium(epsilon=12),
is_3d: bool = False,
run: bool = True,
wavelengths: ndarray = np.linspace(1.5, 1.6, 50),
field_monitor_point: Tuple[int, int, int] = (0, 0, 0),
dfcen: float = 0.2,
) -> Dict[str, Any]:
"""Returns dict with Sparameters for a 2port gf.component
requires source and port monitors in the GDS
based on meep directional coupler example
https://meep.readthedocs.io/en/latest/Python_Tutorials/GDSII_Import/
https://support.lumerical.com/hc/en-us/articles/360042095873-Metamaterial-S-parameter-extraction
Args:
component: gf.Component
extend_ports_function: function to extend the ports for a component to ensure it goes beyond the PML
layer_core: GDS layer for the Component material
layer_source: for the source monitor
layer_monitor1: monitor layer for port 1
layer_monitor2: monitor layer for port 2
layer_simulation_region: for simulation region
res: resolution (pixels/um) For example: (10: 100nm step size)
t_clad_bot: thickness for cladding below core
t_core: thickness of the core material
t_clad_top: thickness for cladding above core
dpml: PML thickness (um)
clad_material: material for cladding
core_material: material for core
is_3d: if True runs in 3D
run: if True runs simulation, False only build simulation
wavelengths: iterable of wavelengths to simulate
field_monitor_point: monitors the field and stops simulation after field decays by 1e-9
dfcen: delta frequency
Returns:
Dict:
sim: simulation object
Make sure you visualize the simulation region with gf.before you simulate a component
.. code::
import gdsfactory as gf
import gmeep as gm
component = gf.components.bend_circular()
margin = 2
cm = gm.add_monitors(component)
cm.show()
"""
assert isinstance(
component, Component
), f"component needs to be a Component, got Type {type(component)}"
if extend_ports_length:
component = gf.components.extension.extend_ports(
component=component, length=extend_ports_length, centered=True
)
component.flatten()
gdspath = component.write_gds()
gdspath = str(gdspath)
freqs = 1 / wavelengths
fcen = np.mean(freqs)
frequency_width = dfcen * fcen
cell_thickness = dpml + t_clad_bot + t_core + t_clad_top + dpml
cell_zmax = 0.5 * cell_thickness if is_3d else 0
cell_zmin = -0.5 * cell_thickness if is_3d else 0
core_zmax = 0.5 * t_core if is_3d else 10
core_zmin = -0.5 * t_core if is_3d else -10
geometry = mp.get_GDSII_prisms(
core_material, gdspath, layer_core, core_zmin, core_zmax
)
cell = mp.GDSII_vol(gdspath, layer_core, cell_zmin, cell_zmax)
sim_region = mp.GDSII_vol(gdspath, layer_simulation_region, cell_zmin, cell_zmax)
cell.size = mp.Vector3(
sim_region.size[0] + 2 * dpml, sim_region.size[1] + 2 * dpml, sim_region.size[2]
)
cell_size = cell.size
zsim = t_core + t_clad_top + t_clad_bot + 2 * dpml
m_zmin = -zsim / 2
m_zmax = +zsim / 2
src_vol = mp.GDSII_vol(gdspath, layer_source, m_zmin, m_zmax)
sources = [
mp.EigenModeSource(
src=mp.GaussianSource(fcen, fwidth=frequency_width),
size=src_vol.size,
center=src_vol.center,
eig_band=1,
eig_parity=mp.NO_PARITY if is_3d else mp.EVEN_Y + mp.ODD_Z,
eig_match_freq=True,
)
]
sim = mp.Simulation(
resolution=res,
cell_size=cell_size,
boundary_layers=[mp.PML(dpml)],
sources=sources,
geometry=geometry,
default_material=clad_material,
)
sim_settings = dict(
resolution=res,
cell_size=cell_size,
fcen=fcen,
field_monitor_point=field_monitor_point,
layer_core=layer_core,
t_clad_bot=t_clad_bot,
t_core=t_core,
t_clad_top=t_clad_top,
is_3d=is_3d,
dmp=dpml,
)
m1_vol = mp.GDSII_vol(gdspath, layer_monitor1, m_zmin, m_zmax)
m2_vol = mp.GDSII_vol(gdspath, layer_monitor2, m_zmin, m_zmax)
m1 = sim.add_mode_monitor(
freqs,
mp.ModeRegion(center=m1_vol.center, size=m1_vol.size),
)
m1.z = 0
m2 = sim.add_mode_monitor(
freqs,
mp.ModeRegion(center=m2_vol.center, size=m2_vol.size),
)
m2.z = 0
# if 0:
# ''' Useful for debugging. '''
# sim.run(until=50)
# sim.plot2D(fields=mp.Ez)
# plt.show()
# quit()
r = dict(sim=sim, cell_size=cell_size, sim_settings=sim_settings)
if run:
sim.run(
until_after_sources=mp.stop_when_fields_decayed(
dt=50, c=mp.Ez, pt=field_monitor_point, decay_by=1e-9
)
)
# call this function every 50 time spes
# look at simulation and measure component that we want to measure (Ez component)
# when field_monitor_point decays below a certain 1e-9 field threshold
# Calculate the mode overlaps
m1_results = sim.get_eigenmode_coefficients(m1, [1]).alpha
m2_results = sim.get_eigenmode_coefficients(m2, [1]).alpha
# Parse out the overlaps
a1 = m1_results[:, :, 0] # forward wave
b1 = m1_results[:, :, 1] # backward wave
a2 = m2_results[:, :, 0] # forward wave
# b2 = m2_results[:, :, 1] # backward wave
# Calculate the actual scattering parameters from the overlaps
s11 = np.squeeze(b1 / a1)
s12 = np.squeeze(a2 / a1)
s22 = s11.copy()
s21 = s12.copy()
# s22 and s21 requires another simulation, with the source on the other port
# Luckily, if the device is symmetric, we can assume that s22=s11 and s21=s12.
# visualize results
plt.figure()
plt.plot(
wavelengths,
10 * np.log10(np.abs(s11) ** 2),
"-o",
label="Reflection",
)
plt.plot(
wavelengths,
10 * np.log10(np.abs(s12) ** 2),
"-o",
label="Transmission",
)
plt.ylabel("Power (dB)")
plt.xlabel(r"Wavelength ($\mu$m)")
plt.legend()
plt.grid(True)
r.update(dict(s11=s11, s12=s12, s21=s21, s22=s22, wavelengths=wavelengths))
keys = [key for key in r.keys() if key.startswith("S")]
s = {f"{key}a": list(np.unwrap(np.angle(r[key].flatten()))) for key in keys}
s_mod = {f"{key}m": list(np.abs(r[key].flatten())) for key in keys}
s.update(**s_mod)
s = pd.DataFrame(s)
return r
def main(args):
d = args.d
cell_thickness = dpml + t_oxide + t_Si + t_air + dpml
cell_zmax = 0.5 * cell_thickness if args.three_d else 0
cell_zmin = -0.5 * cell_thickness if args.three_d else 0
si_zmin = 0
si_zmax = t_Si if args.three_d else 0
# read cell size, volumes for source region and flux monitors,
# and coupler geometry from GDSII file
upper_branch = mp.get_GDSII_prisms(silicon, gdsII_file, UPPER_BRANCH_LAYER,
si_zmin, si_zmax)
lower_branch = mp.get_GDSII_prisms(silicon, gdsII_file, LOWER_BRANCH_LAYER,
si_zmin, si_zmax)
cell = mp.GDSII_vol(gdsII_file, CELL_LAYER, cell_zmin, cell_zmax)
p1 = mp.GDSII_vol(gdsII_file, PORT1_LAYER, si_zmin, si_zmax)
p2 = mp.GDSII_vol(gdsII_file, PORT2_LAYER, si_zmin, si_zmax)
p3 = mp.GDSII_vol(gdsII_file, PORT3_LAYER, si_zmin, si_zmax)
p4 = mp.GDSII_vol(gdsII_file, PORT4_LAYER, si_zmin, si_zmax)
src_vol = mp.GDSII_vol(gdsII_file, SOURCE_LAYER, si_zmin, si_zmax)
# displace upper and lower branches of coupler (as well as source and flux regions)
if d != default_d:
delta_y = 0.5 * (d - default_d)
delta = mp.Vector3(y=delta_y)
p1.center += delta
p2.center -= delta
p3.center += delta
p4.center -= delta
src_vol.center += delta
cell.size += 2 * delta
for np in range(len(lower_branch)):
lower_branch[np].center -= delta
for nv in range(len(lower_branch[np].vertices)):
lower_branch[np].vertices[nv] -= delta
for np in range(len(upper_branch)):
upper_branch[np].center += delta
for nv in range(len(upper_branch[np].vertices)):
upper_branch[np].vertices[nv] += delta
geometry = upper_branch + lower_branch
if args.three_d:
oxide_center = mp.Vector3(z=-0.5 * t_oxide)
oxide_size = mp.Vector3(cell.size.x, cell.size.y, t_oxide)
oxide_layer = [
mp.Block(material=oxide, center=oxide_center, size=oxide_size)
]
geometry = geometry + oxide_layer
sources = [
mp.EigenModeSource(
src=mp.GaussianSource(fcen, fwidth=df),
size=src_vol.size,
center=src_vol.center,
eig_band=1,
eig_parity=mp.NO_PARITY if args.three_d else mp.ODD_Z,
eig_match_freq=True)
]
sim = mp.Simulation(resolution=resolution,
cell_size=cell.size,
boundary_layers=[mp.PML(dpml)],
sources=sources,
geometry=geometry)
p1_region = mp.FluxRegion(volume=p1)
flux1 = sim.add_flux(fcen, 0, 1, p1_region)
p2_region = mp.FluxRegion(volume=p2)
flux2 = sim.add_flux(fcen, 0, 1, p2_region)
p3_region = mp.FluxRegion(volume=p3)
flux3 = sim.add_flux(fcen, 0, 1, p3_region)
p4_region = mp.FluxRegion(volume=p4)
flux4 = sim.add_flux(fcen, 0, 1, p4_region)
sim.run(until_after_sources=mp.stop_when_fields_decayed(
50, mp.Ez, p3.center, 1e-9))
p1_flux = mp.get_fluxes(flux1)
p2_flux = mp.get_fluxes(flux2)
p3_flux = mp.get_fluxes(flux3)
p4_flux = mp.get_fluxes(flux4)
mp.master_printf("data:, {}, {}, {}, {}".format(d,
-p2_flux[0] / p1_flux[0],
p3_flux[0] / p1_flux[0],
p4_flux[0] / p1_flux[0]))
def main(args):
SIM_CELL = pya.LayerInfo(0, 0)
Si = pya.LayerInfo(1, 0)
MEEP_SOURCE = pya.LayerInfo(10, 0)
MEEP_PORT1 = pya.LayerInfo(20, 0)
MEEP_PORT2 = pya.LayerInfo(21, 0)
MEEP_PORT3 = pya.LayerInfo(22, 0)
MEEP_PORT4 = pya.LayerInfo(23, 0)
# ## Simulation Parameters
# In[3]:
ring_radius = 8 # um
ring_width = 0.5 # um
pml_width = 1.0 # um
gap = args.gap # um
src_port_gap = 0.2 # um
straight_wg_length = pml_width + 1 # um
# Simulation resolution
res = 100 # pixels/μm
# ## Step 1. Drawing a waveguide coupler and saving into a temporary .gds file
# In[4]:
from zeropdk.layout import layout_arc, layout_waveguide, layout_path, layout_box
from tempfile import NamedTemporaryFile
from math import sqrt
# Create a temporary filename
temp_file = NamedTemporaryFile(delete=False, suffix='.gds')
filename = temp_file.name
# temp_file = None
# filename = "test.gds"
# Instantiate a layout and a top cell
layout = pya.Layout()
layout.dbu = 0.001
TOP = layout.create_cell("TOP")
sqrt2 = sqrt(2)
# Unit vectors
ex = pya.DVector(1, 0)
ey = pya.DVector(0, 1)
e45 = (ex + ey) / sqrt2
e135 = (-ex + ey) / sqrt2
# Draw circular bend
layout_arc(TOP, Si, - ring_radius*ey, ring_radius, ring_width, 0, np.pi/2)
# Extend the bend to avoid discontinuities
layout_waveguide(TOP, Si, [0*ex, - straight_wg_length*ex], ring_width)
layout_waveguide(TOP, Si, [-1*ring_radius*ey + ring_radius*ex,
-straight_wg_length * ey - ring_radius*ey + ring_radius*ex], ring_width)
# Add the ports as 0-width paths
port_size = ring_width * 4.0
# Draw add/drop waveguide
coupling_point = (ring_radius + gap + ring_width) * e45 - ring_radius * ey
add_drop_length = (ring_radius + gap + ring_width) * sqrt2
layout_waveguide(TOP, Si, [coupling_point + (add_drop_length + 0.4) * e135,
coupling_point - (add_drop_length + 0.4) * e135],
ring_width)
# Source at port 1
layout_path(TOP, MEEP_SOURCE, [coupling_point - port_size/2*ex + (add_drop_length / 2 + src_port_gap) * e135,
coupling_point + port_size/2*ex + (add_drop_length / 2 + src_port_gap) * e135], 0)
# Source at port 2 (alternative)
# layout_path(TOP, MEEP_SOURCE, [-port_size/2*ey - src_port_gap*ex, port_size/2*ey - 0.2*ex], 0)
# Port 1
layout_path(TOP, MEEP_PORT1, [coupling_point - port_size/2*ex + (add_drop_length / 2) * e135,
coupling_point + port_size/2*ex + (add_drop_length / 2) * e135], 0)
# Port 2
layout_path(TOP, MEEP_PORT2, [-port_size/2*ey, port_size/2*ey], 0)
# Port 3
layout_path(TOP, MEEP_PORT3, [coupling_point - port_size/2*ey - (add_drop_length / 2) * e135,
coupling_point + port_size/2*ey - (add_drop_length / 2) * e135], 0)
# Port 4
layout_path(TOP, MEEP_PORT4, [-1*ring_radius*ey + ring_radius*ex - port_size/2*ex,
-1*ring_radius*ey + ring_radius*ex + port_size/2*ex], 0)
# Draw simulation region
layout_box(TOP, SIM_CELL,
-1.0*ring_radius*ey - (pml_width + src_port_gap) * (ex + ey), # Bottom left point
coupling_point + (add_drop_length / 2 + src_port_gap) * e45 + pml_width * (ex + ey), # Top right point
ex)
# Write to file
layout.write(filename)
print(f"Produced file {filename}.")
# ## Step 2. Load gds file into meep
#
# ### Visualization and simulation
#
# If you choose a normal filename (not temporary), you can download the GDSII file from the cluster (see Files in MyAdroit dashboard) to see it with your local Klayout. Otherwise, let's get simulating:
# In[5]:
def round_vector(vector, decimal_places=3):
x = round(vector.x, decimal_places)
y = round(vector.y, decimal_places)
z = round(vector.z, decimal_places)
return mp.Vector3(x, y, z)
# In[6]:
gdsII_file = filename
CELL_LAYER = 0
SOURCE_LAYER = 10
Si_LAYER = 1
PORT1_LAYER = 20
PORT2_LAYER = 21
PORT3_LAYER = 22
PORT4_LAYER = 23
t_oxide = 1.0
t_Si = 0.22
t_SiO2 = 0.78
oxide = mp.Medium(epsilon=2.25)
silicon=mp.Medium(epsilon=12)
lcen = 1.55
fcen = 1/lcen
df = 0.2*fcen
nfreq = 25
cell_zmax = 0
cell_zmin = 0
si_zmax = 10
si_zmin = -10
# read cell size, volumes for source region and flux monitors,
# and coupler geometry from GDSII file
# WARNING: Once the file is loaded, the prism contents is cached and cannot be reloaded.
# SOLUTION: Use a different filename or restart the kernel
si_layer = mp.get_GDSII_prisms(silicon, gdsII_file, Si_LAYER, si_zmin, si_zmax)
cell = mp.GDSII_vol(gdsII_file, CELL_LAYER, cell_zmin, cell_zmax)
src_vol = mp.GDSII_vol(gdsII_file, SOURCE_LAYER, si_zmin, si_zmax)
p1 = mp.GDSII_vol(gdsII_file, PORT1_LAYER, si_zmin, si_zmax)
p2 = mp.GDSII_vol(gdsII_file, PORT2_LAYER, si_zmin, si_zmax)
p3 = mp.GDSII_vol(gdsII_file, PORT3_LAYER, si_zmin, si_zmax)
p4 = mp.GDSII_vol(gdsII_file, PORT4_LAYER, si_zmin, si_zmax)
sources = [mp.EigenModeSource(src=mp.GaussianSource(fcen,fwidth=df),
size=round_vector(src_vol.size),
center=round_vector(src_vol.center),
direction=mp.NO_DIRECTION,
eig_kpoint=mp.Vector3(1, -1, 0), # -45 degree angle
eig_band=1,
eig_parity=mp.NO_PARITY,
eig_match_freq=True)]
# Display simulation object
sim = mp.Simulation(resolution=res,
default_material=oxide,
eps_averaging=False,
cell_size=cell.size,
geometry_center=round_vector(cell.center,2),
boundary_layers=[mp.PML(pml_width)],
sources=sources,
geometry=si_layer)
# Delete file created in previous cell
import os
if temp_file:
temp_file.close()
os.unlink(filename)
# ## Step 3. Setup simulation environment
#
# This will load the python-defined parameters from the previous cell and instantiate a fast, C++ based, simulation environment using meep. It will also compute the eigenmode of the source, in preparation for the FDTD simulation.
# In[7]:
sim.reset_meep()
# Could add monitors at many frequencies by looping over fcen
# Means one FDTD for many results!
mode1 = sim.add_mode_monitor(fcen, df, nfreq, mp.ModeRegion(volume=p1))
mode2 = sim.add_mode_monitor(fcen, df, nfreq, mp.ModeRegion(volume=p2))
mode3 = sim.add_mode_monitor(fcen, df, nfreq, mp.ModeRegion(volume=p3))
mode4 = sim.add_mode_monitor(fcen, df, nfreq, mp.ModeRegion(volume=p4))
# Let's store the frequencies that were generated by this mode monitor
mode1_freqs = np.array(mp.get_eigenmode_freqs(mode1))
mode2_freqs = np.array(mp.get_eigenmode_freqs(mode2))
mode3_freqs = np.array(mp.get_eigenmode_freqs(mode3))
mode4_freqs = np.array(mp.get_eigenmode_freqs(mode4))
sim.init_sim()
# ### Verify if there are numerical errors.
# - You should see a clean black and white plot.
# - If there are other weird structures, try increasing the resolution.
# In[8]:
eps_data = sim.get_array(center=cell.center, size=cell.size, component=mp.Dielectric)
plt.figure(dpi=res)
plt.imshow(eps_data.transpose(), interpolation='none', cmap='binary', origin='lower')
plt.colorbar()
plt.show()
# ### Verify that the structure makes sense.
#
# Things to check:
# - Are the sources and ports outside the PML?
# - Are dimensions correct?
# - Is the simulation region unnecessarily large?
# In[9]:
# If there is a warning that reads "The specified user volume
# is larger than the simulation domain and has been truncated",
# It has to do with some numerical errors between python and meep.
# Ignore.
# sim.init_sim()
f = plt.figure(dpi=100)
sim.plot2D(ax=f.gca())
plt.show()
# Looks pretty good. Simulations at the high enough resolution required to avoid spurious reflections in the bend are very slow! This can be sped up quite a bit by running the code in parallel from the terminal. Later, we will put this notebook's code into a script and run it in parallel.
# ## Step 4. Simulate FDTD and Animate results
#
# More detailed meep documentation available [here](https://meep.readthedocs.io/en/latest/Python_Tutorials/Basics/#transmittance-spectrum-of-a-waveguide-bend).
# In[10]:
# Set to true to compute animation (may take a lot of memory)
# Turn this off if you don't need to visualize.
compute_animation = False
# In[11]:
# Setup and run the simulation
# The following line defines a stopping condition depending on the square
# of the amplitude of the Ez field at the port 2.
print(f"Stop condition: decay to 0.1% of peak value in the last {2.0/df:.1f} time units.")
stop_condition = mp.stop_when_fields_decayed(2.0/df,mp.Ez,p3.center,1e-3)
if compute_animation:
f = plt.figure(dpi=100)
animate = mp.Animate2D(sim,mp.Ez,f=f,normalize=True)
sim.run(mp.at_every(1,animate), until_after_sources=stop_condition)
plt.close()
animate.to_mp4(10, 'media/coupler1.mp4')
else:
sim.run(until_after_sources=stop_condition)
# ### Visualize results
#
# Things to check:
# - Was the simulation time long enough for the pulse to travel through the output port in its entirety? Given the automatic stop condition, this should be the case.
# In[12]:
from IPython.display import Video, display
if compute_animation:
display(Video('media/coupler1.mp4'))
# ## Step 5. Compute S parameters of the coupler
# In[13]:
# Every mode monitor measures the power flowing through it in either the forward or backward direction
# This time, the monitor is at an oblique angle to the waveguide. This is because meep
# can only compute fluxes in either the x, y, or z planes. In order to correctly measure
# the flux, we need to provide a k-vector at an angle.
# So we compute a unit vector at a -45 angle like so:
kpoint135 = mp.Vector3(x=1).rotate(mp.Vector3(z=1), np.radians(-45))
# In this simulation, the ports 1 and 3 are on an angled waveguide, and
# 2 and 4 are perpendicular to the waveguide.
eig_mode1 = sim.get_eigenmode_coefficients(mode1, [1], eig_parity=mp.NO_PARITY,
direction=mp.NO_DIRECTION, kpoint_func=lambda f,n: kpoint135)
eig_mode2 = sim.get_eigenmode_coefficients(mode2, [1], eig_parity=mp.NO_PARITY)
eig_mode3 = sim.get_eigenmode_coefficients(mode3, [1], eig_parity=mp.NO_PARITY,
direction=mp.NO_DIRECTION, kpoint_func=lambda f,n: kpoint135)
eig_mode4 = sim.get_eigenmode_coefficients(mode4, [1], eig_parity=mp.NO_PARITY)
# We proceed like last time.
# First, we need to figure out which direction the "dominant planewave" k-vector is
# We can pick the first frequency (0) for that, assuming that for all simulated frequencies,
# The dominant k-vector will point in the same direction.
k1 = eig_mode1.kdom[0]
k2 = eig_mode2.kdom[0]
k3 = eig_mode3.kdom[0]
k4 = eig_mode4.kdom[0]
# eig_mode.alpha[0,0,0] corresponds to the forward direction, whereas
# eig_mode.alpha[0,0,1] corresponds to the backward direction
# For port 1, we are interested in the -y direction, so if k1.y is positive, select 1, otherwise 0
idx = (k1.y > 0) * 1
p1_thru_coeff = eig_mode1.alpha[0,:,idx]
p1_reflected_coeff = eig_mode1.alpha[0,:,1-idx]
# For port 3, we are interestred in the +x direction
idx = (k3.x < 0) * 1
p3_thru_coeff = eig_mode3.alpha[0,:,idx]
p3_reflected_coeff = eig_mode3.alpha[0,:,1-idx]
# For port 2, we are interested in the -x direction
idx = (k2.x > 0) * 1
p2_thru_coeff = eig_mode2.alpha[0,:,idx]
p2_reflected_coeff = eig_mode2.alpha[0,:,1-idx]
# For port 4, we are interested in the -y direction
idx = (k4.y > 0) * 1
p4_thru_coeff = eig_mode4.alpha[0,:,idx]
p4_reflected_coeff = eig_mode4.alpha[0,:,1-idx]
# transmittance
S41 = p4_thru_coeff/p1_thru_coeff
S31 = p3_thru_coeff/p1_thru_coeff
S21 = p2_thru_coeff/p1_thru_coeff
S11 = p1_reflected_coeff/p1_thru_coeff
print("----------------------------------")
print(f"Parameters: radius={ring_radius:.1f}")
print(f"Frequencies: {mode1_freqs}")
# In[20]:
#Write to csv file
import csv
with open(f'sparams1.gap{gap:.2f}um.csv', mode='w') as sparams_file:
sparam_writer = csv.writer(sparams_file, delimiter=',')
sparam_writer.writerow(['f(Hz)',
'real(S11)','imag(S11)',
'real(S21)','imag(S21)',
'real(S31)','imag(S31)',
'real(S41)','imag(S41)'
])
for i in range(len(mode1_freqs)):
sparam_writer.writerow([mode1_freqs[i] * 3e14,
np.real(S11[i]),np.imag(S11[i]),
np.real(S21[i]),np.imag(S21[i]),
np.real(S31[i]),np.imag(S31[i]),
np.real(S41[i]),np.imag(S41[i])
])
lcen = 1.55
fcen = 1/lcen
df = 0.2*fcen
cell_zmax = 0.5*cell_thickness if three_d else 0
cell_zmin = -0.5*cell_thickness if three_d else 0
si_zmax = 0.5*t_Si if three_d else 10
si_zmin = -0.5*t_Si if three_d else -10
# read cell size, volumes for source region and flux monitors,
# and coupler geometry from GDSII file
upper_branch = mp.get_GDSII_prisms(silicon, gdsII_file, UPPER_BRANCH_LAYER, si_zmin, si_zmax)
lower_branch = mp.get_GDSII_prisms(silicon, gdsII_file, LOWER_BRANCH_LAYER, si_zmin, si_zmax)
cell = mp.GDSII_vol(gdsII_file, CELL_LAYER, cell_zmin, cell_zmax)
p1 = mp.GDSII_vol(gdsII_file, PORT1_LAYER, si_zmin, si_zmax)
p2 = mp.GDSII_vol(gdsII_file, PORT2_LAYER, si_zmin, si_zmax)
p3 = mp.GDSII_vol(gdsII_file, PORT3_LAYER, si_zmin, si_zmax)
p4 = mp.GDSII_vol(gdsII_file, PORT4_LAYER, si_zmin, si_zmax)
src_vol = mp.GDSII_vol(gdsII_file, SOURCE_LAYER, si_zmin, si_zmax)
# displace upper and lower branches of coupler (as well as source and flux regions)
if d != default_d:
delta_y = 0.5*(d-default_d)
delta = mp.Vector3(y=delta_y)
p1.center += delta
p2.center -= delta
p3.center += delta
p4.center -= delta
src_vol.center += delta
def main(args):
SIM_CELL = pya.LayerInfo(0, 0)
Si = pya.LayerInfo(1, 0)
MEEP_SOURCE1 = pya.LayerInfo(10, 0)
MEEP_PORT1 = pya.LayerInfo(20, 0)
MEEP_PORT2 = pya.LayerInfo(21, 0)
# ## Simulation Parameters
# In[3]:
ring_radius = args.radius # um
ring_width = 0.5 # um
pml_width = 1.0 # um
straight_wg_length = pml_width + 0.2 # um
# Simulation resolution
res = 100 # pixels/μm
# ## Step 1. Drawing a bent waveguide and saving into a temporary .gds file
# In[4]:
from zeropdk.layout import layout_arc, layout_waveguide, layout_path, layout_box
from tempfile import NamedTemporaryFile
# Create a temporary filename
temp_file = NamedTemporaryFile(delete=False, suffix='.gds')
filename = temp_file.name
# Instantiate a layout and a top cell
layout = pya.Layout()
layout.dbu = 0.001
TOP = layout.create_cell("TOP")
# Unit vectors
ex = pya.DVector(1, 0)
ey = pya.DVector(0, 1)
# Draw circular bend
layout_arc(TOP, Si, -ring_radius * ey, ring_radius, ring_width, 0,
np.pi / 2)
# Extend the bend to avoid discontinuities
layout_waveguide(TOP, Si, [0 * ex, -straight_wg_length * ex], ring_width)
layout_waveguide(TOP, Si, [
-1 * ring_radius * ey + ring_radius * ex,
-straight_wg_length * ey - ring_radius * ey + ring_radius * ex
], ring_width)
# Add the ports as 0-width paths
port_size = ring_width * 4.0
# Source port
layout_path(
TOP, MEEP_SOURCE1,
[-port_size / 2 * ey - 0.2 * ex, port_size / 2 * ey - 0.2 * ex], 0)
# Input port (immediately at the start of the bend)
layout_path(TOP, MEEP_PORT1, [-port_size / 2 * ey, port_size / 2 * ey], 0)
# Output port (immediately at the end of the bend)
layout_path(TOP, MEEP_PORT2, [
-1 * ring_radius * ey + ring_radius * ex - port_size / 2 * ex,
-1 * ring_radius * ey + ring_radius * ex + port_size / 2 * ex
], 0)
# Draw simulation region
layout_box(
TOP,
SIM_CELL,
-1.0 * ring_radius * ey - straight_wg_length *
(ex + ey), # Bottom left point
1.0 * ring_radius * ex + (straight_wg_length + port_size / 2) *
(ex + ey), # Top right point
ex)
# Write to file
layout.write(filename)
print(f"Produced file {filename}.")
# ## Step 2. Load gds file into meep
#
# ### Visualization and simulation
#
# If you choose a normal filename (not temporary), you can download the GDSII file from the cluster (see Files in MyAdroit dashboard) to see it with your local Klayout. Otherwise, let's get simulating:
# In[5]:
gdsII_file = filename
CELL_LAYER = 0
SOURCE_LAYER = 10
Si_LAYER = 1
PORT1_LAYER = 20
PORT2_LAYER = 21
t_oxide = 1.0
t_Si = 0.22
t_SiO2 = 0.78
oxide = mp.Medium(epsilon=2.25)
silicon = mp.Medium(epsilon=12)
lcen = 1.55
fcen = 1 / lcen
df = 0.2 * fcen
nfreq = 25
cell_zmax = 0
cell_zmin = 0
si_zmax = 10
si_zmin = -10
# read cell size, volumes for source region and flux monitors,
# and coupler geometry from GDSII file
# WARNING: Once the file is loaded, the prism contents is cached and cannot be reloaded.
# SOLUTION: Use a different filename or restart the kernel
si_layer = mp.get_GDSII_prisms(silicon, gdsII_file, Si_LAYER, si_zmin,
si_zmax)
cell = mp.GDSII_vol(gdsII_file, CELL_LAYER, cell_zmin, cell_zmax)
src_vol = mp.GDSII_vol(gdsII_file, SOURCE_LAYER, si_zmin, si_zmax)
p1 = mp.GDSII_vol(gdsII_file, PORT1_LAYER, si_zmin, si_zmax)
p2 = mp.GDSII_vol(gdsII_file, PORT2_LAYER, si_zmin, si_zmax)
sources = [
mp.EigenModeSource(src=mp.GaussianSource(fcen, fwidth=df),
size=src_vol.size,
center=src_vol.center,
eig_band=1,
eig_parity=mp.NO_PARITY,
eig_match_freq=True)
]
# Display simulation object
sim = mp.Simulation(resolution=res,
default_material=oxide,
eps_averaging=False,
cell_size=cell.size,
boundary_layers=[mp.PML(pml_width)],
sources=sources,
geometry=si_layer,
geometry_center=cell.center)
# Delete file created in previous cell
import os
temp_file.close()
os.unlink(filename)
# ## Step 3. Setup simulation environment
#
# This will load the python-defined parameters from the previous cell and instantiate a fast, C++ based, simulation environment using meep. It will also compute the eigenmode of the source, in preparation for the FDTD simulation.
# In[6]:
sim.reset_meep()
# Could add monitors at many frequencies by looping over fcen
# Means one FDTD for many results!
mode1 = sim.add_mode_monitor(fcen, df, nfreq, mp.ModeRegion(volume=p1))
mode2 = sim.add_mode_monitor(fcen, df, nfreq, mp.ModeRegion(volume=p2))
# Let's store the frequencies that were generated by this mode monitor
mode1_freqs = np.array(mp.get_eigenmode_freqs(mode1))
mode2_freqs = np.array(mp.get_eigenmode_freqs(mode2))
sim.init_sim()
# ### Verify that the structure makes sense.
#
# Things to check:
# - Are the sources and ports outside the PML?
# - Are dimensions correct?
# - Is the simulation region unnecessarily large?
# In[7]:
# If there is a warning that reads "The specified user volume
# is larger than the simulation domain and has been truncated",
# It has to do with some numerical errors between python and meep.
# Ignore.
# f = plt.figure(dpi=100)
# sim.plot2D(ax=f.gca())
# plt.show()
# Looks pretty good. Simulations at the high enough resolution required to avoid spurious reflections in the bend are very slow! This can be sped up quite a bit by running the code in parallel from the terminal. Later, we will put this notebook's code into a script and run it in parallel.
# ## Step 4. Simulate FDTD and Animate results
#
# More detailed meep documentation available [here](https://meep.readthedocs.io/en/latest/Python_Tutorials/Basics/#transmittance-spectrum-of-a-waveguide-bend).
# In[8]:
# Set to true to compute animation (may take a lot of memory)
compute_animation = False
# In[9]:
# Setup and run the simulation
# The following line defines a stopping condition depending on the square
# of the amplitude of the Ez field at the port 2.
print(
f"Stop condition: decay to 0.1% of peak value in the last {2.0/df:.1f} time units."
)
stop_condition = mp.stop_when_fields_decayed(2.0 / df, mp.Ez, p2.center,
1e-3)
if compute_animation:
f = plt.figure(dpi=100)
animate = mp.Animate2D(sim, mp.Ez, f=f, normalize=True)
sim.run(mp.at_every(1, animate), until_after_sources=stop_condition)
plt.close()
# Save video as mp4
animate.to_mp4(10, 'media/bend.mp4')
else:
sim.run(until_after_sources=stop_condition)
# ### Visualize results
#
# Things to check:
# - Was the simulation time long enough for the pulse to travel through port2 in its entirety? Given the automatic stop condition, this should be the case.
# In[10]:
from IPython.display import Video, display
# display(Video('media/bend.mp4'))
# ## Step 5. Compute loss and reflection of the bend
# In[11]:
# Every mode monitor measures the power flowing through it in either the forward or backward direction
eig_mode1 = sim.get_eigenmode_coefficients(mode1, [1],
eig_parity=mp.NO_PARITY)
eig_mode2 = sim.get_eigenmode_coefficients(mode2, [1],
eig_parity=mp.NO_PARITY)
# First, we need to figure out which direction the "dominant planewave" k-vector is
# We can pick the first frequency (0) for that, assuming that for all simulated frequencies,
# The dominant k-vector will point in the same direction.
k1 = eig_mode1.kdom[0]
k2 = eig_mode2.kdom[0]
# eig_mode.alpha[0,0,0] corresponds to the forward direction, whereas
# eig_mode.alpha[0,0,1] corresponds to the backward direction
# For port 1, we are interested in the +x direction, so if k1.x is positive, select 0, otherwise 1
idx = (k1.x < 0) * 1
p1_thru_coeff = eig_mode1.alpha[0, :, idx]
p1_reflected_coeff = eig_mode1.alpha[0, :, 1 - idx]
# For port 2, we are interestred in the -y direction
idx = (k2.y > 0) * 1
p2_thru_coeff = eig_mode2.alpha[0, :, idx]
p2_reflected_coeff = eig_mode2.alpha[0, :, 1 - idx]
# transmittance
p2_trans = abs(p2_thru_coeff / p1_thru_coeff)**2
p2_reflected = abs(p1_reflected_coeff / p1_thru_coeff)**2
print("----------------------------------")
print(f"Parameters: radius={ring_radius:.1f}")
print(f"Frequencies: {mode1_freqs}")
print(f"Transmitted fraction: {p2_trans}")
print(f"Reflected fraction: {p2_reflected}")
# In[1]:
S21 = p2_thru_coeff / p1_thru_coeff
S11 = p1_reflected_coeff / p1_thru_coeff
S21_mag = np.abs(S21)
S21_phase = np.unwrap(np.angle(S21))
S11_mag = np.abs(S11)
S11_phase = np.unwrap(np.angle(S11))
# In[13]:
# # Plot S21
# f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(5, 8))
# ax1.plot(1/mode1_freqs, 10 * np.log10(S21_mag), '.-')
# ax1.set_title("S21")
# ax1.set_xlabel(r"$\lambda$ (um)")
# ax1.set_ylabel("Magnitude (dB)")
# ax1.set_ylim(None, 0)
# ax1.grid()
# ax2.plot(1/mode1_freqs, S21_phase, '.-')
# ax2.set_xlabel(r"$\lambda$ (um)")
# ax2.set_ylabel("Phase (rad)")
# ax2.grid()
# plt.tight_layout()
# # In[14]:
# # Plot S11
# f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(5, 8))
# ax1.plot(1/mode1_freqs, 10 * np.log10(S11_mag), '.-')
# ax1.set_title("S11")
# ax1.set_xlabel(r"$\lambda$ (um)")
# ax1.set_ylabel("Magnitude (dB)")
# ax1.set_ylim(None, 0)
# ax1.grid()
# ax2.plot(1/mode1_freqs, S11_phase, '.-')
# ax2.set_xlabel(r"$\lambda$ (um)")
# ax2.set_ylabel("Phase (rad)")
# ax2.grid()
# plt.tight_layout()
# # Milestones
#
# Goal: Compute the transmission profile for bend radii between 1.5um and 10um.
#
# - Q: Is the reflection significant for any radius? What explain the loss?
# - Q: What is the formula total size of the simulation region? How many pixels are there?
# - Q: If each pixel can host 3-dimensional E-field and H-field vectors with 64bit complex float stored in each dimension, how many megabytes of data needs to be stored at each time step? Is it feasible to save all this information throughout the FDTD simulation?
# - Bonus: Collect the simulation runtime for each radius. How does it change with different radii?
# - Bonus: At what resolution does the accuracy of the simulation start degrading? In other words, if halving the resolution only results in a 1% relative difference in the most important target metric, it is still a good resolution.
# In[2]:
#Write to csv file
import csv
with open(f'sparams.r{ring_radius:.1f}um.csv', mode='w') as sparams_file:
sparam_writer = csv.writer(sparams_file, delimiter=',')
sparam_writer.writerow(
['f(Hz)', 'real(S11)', 'imag(S11)', 'real(S21)', 'imag(S21)'])
for i in range(len(mode1_freqs)):
sparam_writer.writerow([
mode1_freqs[i] * 3e14,
np.real(S11[i]),
np.imag(S11[i]),
np.real(S21[i]),
np.imag(S21[i])
])
