start work on tutorial
jan
3 years ago
parent
7aa850a239
commit
9b3b30b141
@ -0,0 +1,77 @@
|
||||
from typing import Tuple, Sequence
|
||||
|
||||
import numpy # type: ignore
|
||||
from numpy import pi
|
||||
|
||||
from masque import layer_t, Pattern, SubPattern, Label
|
||||
from masque.shapes import Circle, Arc
|
||||
from masque.builder import Device, Port
|
||||
from masque.library import Library, DeviceLibrary
|
||||
import masque.file.gdsii
|
||||
|
||||
import pcgen
|
||||
|
||||
|
||||
def hole(radius: float,
|
||||
layer: layer_t = (1, 0),
|
||||
) -> Pattern:
|
||||
"""
|
||||
Generate a pattern containing a single circular hole.
|
||||
|
||||
Args:
|
||||
layer: Layer to draw the circle on.
|
||||
radius: Circle radius.
|
||||
|
||||
Returns:
|
||||
Pattern, named `'hole'`
|
||||
"""
|
||||
pat = Pattern('hole', shapes=[
|
||||
Circle(radius=radius, offset=(0, 0), layer=layer)
|
||||
])
|
||||
return pat
|
||||
|
||||
|
||||
def smile(radius: float,
|
||||
layer: layer_t = (1, 0),
|
||||
secondary_layer: layer_t = (1, 2)
|
||||
) -> Pattern:
|
||||
"""
|
||||
Generate a pattern containing a single smiley face.
|
||||
|
||||
Args:
|
||||
radius: Boundary circle radius.
|
||||
layer: Layer to draw the outer circle on.
|
||||
secondary_layer: Layer to draw eyes and smile on.
|
||||
|
||||
Returns:
|
||||
Pattern, named `'smile'`
|
||||
"""
|
||||
# Make an empty pattern
|
||||
pat = Pattern('smile')
|
||||
|
||||
# Add all the shapes we want
|
||||
pat.shapes += [
|
||||
Circle(radius=radius, offset=(0, 0), layer=layer), # Outer circle
|
||||
Circle(radius=radius / 10, offset=(radius / 3, radius / 3), layer=secondary_layer),
|
||||
Circle(radius=radius / 10, offset=(-radius / 3, radius / 3), layer=secondary_layer),
|
||||
Arc(radii=(radius * 2 / 3, radius * 2 / 3), # Underlying ellipse radii
|
||||
angles=(7 / 6 * pi, 11 / 6 * pi), # Angles limiting the arc
|
||||
width=radius / 10,
|
||||
offset=(0, 0),
|
||||
layer=secondary_layer),
|
||||
]
|
||||
|
||||
return pat
|
||||
|
||||
|
||||
def _main() -> None:
|
||||
hole_pat = hole(1000)
|
||||
smile_pat = smile(1000)
|
||||
|
||||
masque.file.gdsii.writefile([hole_pat, smile_pat], 'basic.gds', 1e-9, 1e-3)
|
||||
|
||||
smile_pat.visualize()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
_main()
|
||||
@ -0,0 +1,313 @@
|
||||
"""
|
||||
Routines for creating normalized 2D lattices and common photonic crystal
|
||||
cavity designs.
|
||||
"""
|
||||
from typing import Sequence, Tuple
|
||||
|
||||
import numpy # type: ignore
|
||||
|
||||
|
||||
def triangular_lattice(dims: Tuple[int, int],
|
||||
asymmetric: bool = False,
|
||||
origin: str = 'center',
|
||||
) -> numpy.ndarray:
|
||||
"""
|
||||
Return an ndarray of `[[x0, y0], [x1, y1], ...]` denoting lattice sites for
|
||||
a triangular lattice in 2D.
|
||||
|
||||
Args:
|
||||
dims: Number of lattice sites in the [x, y] directions.
|
||||
asymmetric: If true, each row will contain the same number of
|
||||
x-coord lattice sites. If false, every other row will be
|
||||
one site shorter (to make the structure symmetric).
|
||||
origin: If 'corner', the least-(x,y) lattice site is placed at (0, 0)
|
||||
If 'center', the center of the lattice (not necessarily a
|
||||
lattice site) is placed at (0, 0).
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, 1], ...]` denoting lattice sites.
|
||||
"""
|
||||
sx, sy = numpy.meshgrid(numpy.arange(dims[0], dtype=float),
|
||||
numpy.arange(dims[1], dtype=float), indexing='ij')
|
||||
|
||||
sx[sy % 2 == 1] += 0.5
|
||||
sy *= numpy.sqrt(3) / 2
|
||||
|
||||
if not asymmetric:
|
||||
which = sx != sx.max()
|
||||
sx = sx[which]
|
||||
sy = sy[which]
|
||||
|
||||
xy = numpy.column_stack((sx.flat, sy.flat))
|
||||
|
||||
if origin == 'center':
|
||||
xy -= (xy.max(axis=0) - xy.min(axis=0)) / 2
|
||||
elif origin == 'corner':
|
||||
pass
|
||||
else:
|
||||
raise Exception(f'Invalid value for `origin`: {origin}')
|
||||
|
||||
return xy[xy[:, 0].argsort(), :]
|
||||
|
||||
|
||||
def square_lattice(dims: Tuple[int, int]) -> numpy.ndarray:
|
||||
"""
|
||||
Return an ndarray of `[[x0, y0], [x1, y1], ...]` denoting lattice sites for
|
||||
a square lattice in 2D. The lattice will be centered around (0, 0).
|
||||
|
||||
Args:
|
||||
dims: Number of lattice sites in the [x, y] directions.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, 1], ...]` denoting lattice sites.
|
||||
"""
|
||||
xs, ys = numpy.meshgrid(range(dims[0]), range(dims[1]), 'xy')
|
||||
xs -= dims[0]/2
|
||||
ys -= dims[1]/2
|
||||
xy = numpy.vstack((xs.flatten(), ys.flatten())).T
|
||||
return xy[xy[:, 0].argsort(), ]
|
||||
|
||||
|
||||
# ### Photonic crystal functions ###
|
||||
|
||||
|
||||
def nanobeam_holes(a_defect: float,
|
||||
num_defect_holes: int,
|
||||
num_mirror_holes: int
|
||||
) -> numpy.ndarray:
|
||||
"""
|
||||
Returns a list of `[[x0, r0], [x1, r1], ...]` of nanobeam hole positions and radii.
|
||||
Creates a region in which the lattice constant and radius are progressively
|
||||
(linearly) altered over num_defect_holes holes until they reach the value
|
||||
specified by a_defect, then symmetrically returned to a lattice constant and
|
||||
radius of 1, which is repeated num_mirror_holes times on each side.
|
||||
|
||||
Args:
|
||||
a_defect: Minimum lattice constant for the defect, as a fraction of the
|
||||
mirror lattice constant (ie., for no defect, a_defect = 1).
|
||||
num_defect_holes: How many holes form the defect (per-side)
|
||||
num_mirror_holes: How many holes form the mirror (per-side)
|
||||
|
||||
Returns:
|
||||
Ndarray `[[x0, r0], [x1, r1], ...]` of nanobeam hole positions and radii.
|
||||
"""
|
||||
a_values = numpy.linspace(a_defect, 1, num_defect_holes, endpoint=False)
|
||||
xs = a_values.cumsum() - (a_values[0] / 2) # Later mirroring makes center distance 2x as long
|
||||
mirror_xs = numpy.arange(1, num_mirror_holes + 1, dtype=float) + xs[-1]
|
||||
mirror_rs = numpy.ones_like(mirror_xs)
|
||||
return numpy.vstack((numpy.hstack((-mirror_xs[::-1], -xs[::-1], xs, mirror_xs)),
|
||||
numpy.hstack((mirror_rs[::-1], a_values[::-1], a_values, mirror_rs)))).T
|
||||
|
||||
|
||||
def waveguide(length: int, num_mirror: int) -> numpy.ndarray:
|
||||
"""
|
||||
Line defect waveguide in a triangular lattice.
|
||||
|
||||
Args:
|
||||
length: waveguide length (number of holes in x direction)
|
||||
num_mirror: Mirror length (number of holes per side; total size is
|
||||
`2 * n + 1` holes.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, y1], ...]` for all the holes
|
||||
"""
|
||||
p = triangular_lattice([length + 2, 2 * num_mirror + 1])
|
||||
p = p[p[:, 1] != 0, :]
|
||||
|
||||
p = p[numpy.abs(p[:, 0]) <= length / 2]
|
||||
return p
|
||||
|
||||
|
||||
def wgbend(num_mirror: int) -> numpy.ndarray:
|
||||
"""
|
||||
Line defect waveguide bend in a triangular lattice.
|
||||
|
||||
Args:
|
||||
num_mirror: Mirror length (number of holes per side; total size is
|
||||
approximately `2 * n + 1`
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, y1], ...]` for all the holes
|
||||
"""
|
||||
p = triangular_lattice([4 * num_mirror + 1, 4 * num_mirror + 1])
|
||||
left_horiz = (p[:, 1] == 0) & (p[:, 0] <= 0)
|
||||
p = p[~left_horiz, :]
|
||||
|
||||
right_diag = numpy.isclose(p[:, 1], p[:, 0] * numpy.sqrt(3)) & (p[:, 0] >= 0)
|
||||
p = p[~right_diag, :]
|
||||
|
||||
edge_left = p[:, 0] < -num_mirror
|
||||
edge_bot = p[:, 1] < -num_mirror
|
||||
p = p[~edge_left & ~edge_bot, :]
|
||||
|
||||
edge_diag_up = p[:, 0] * numpy.sqrt(3) > p[:, 1] + 2 * num_mirror + 0.1
|
||||
edge_diag_dn = p[:, 0] / numpy.sqrt(3) > -p[:, 1] + num_mirror + 1.1
|
||||
p = p[~edge_diag_up & ~edge_diag_dn, :]
|
||||
return p
|
||||
|
||||
|
||||
def y_splitter(num_mirror: int) -> numpy.ndarray:
|
||||
"""
|
||||
Line defect waveguide y-splitter in a triangular lattice.
|
||||
|
||||
Args:
|
||||
num_mirror: Mirror length (number of holes per side; total size is
|
||||
approximately `2 * n + 1` holes.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, y1], ...]` for all the holes
|
||||
"""
|
||||
p = triangular_lattice([4 * num_mirror + 1, 4 * num_mirror + 1])
|
||||
left_horiz = (p[:, 1] == 0) & (p[:, 0] <= 0)
|
||||
p = p[~left_horiz, :]
|
||||
|
||||
# y = +-sqrt(3) * x
|
||||
right_diag_up = numpy.isclose(p[:, 1], p[:, 0] * numpy.sqrt(3)) & (p[:, 0] >= 0)
|
||||
right_diag_dn = numpy.isclose(p[:, 1], -p[:, 0] * numpy.sqrt(3)) & (p[:, 0] >= 0)
|
||||
p = p[~right_diag_up & ~right_diag_dn, :]
|
||||
|
||||
edge_left = p[:, 0] < -num_mirror
|
||||
p = p[~edge_left, :]
|
||||
|
||||
edge_diag_up = p[:, 0] / numpy.sqrt(3) > p[:, 1] + num_mirror + 1.1
|
||||
edge_diag_dn = p[:, 0] / numpy.sqrt(3) > -p[:, 1] + num_mirror + 1.1
|
||||
p = p[~edge_diag_up & ~edge_diag_dn, :]
|
||||
return p
|
||||
|
||||
|
||||
def ln_defect(mirror_dims: Tuple[int, int],
|
||||
defect_length: int,
|
||||
) -> numpy.ndarray:
|
||||
"""
|
||||
N-hole defect in a triangular lattice.
|
||||
|
||||
Args:
|
||||
mirror_dims: [x, y] mirror lengths (number of holes). Total number of holes
|
||||
is 2 * n + 1 in each direction.
|
||||
defect_length: Length of defect. Should be an odd number.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, y1], ...]` for all the holes
|
||||
"""
|
||||
if defect_length % 2 != 1:
|
||||
raise Exception('defect_length must be odd!')
|
||||
p = triangular_lattice([2 * d + 1 for d in mirror_dims])
|
||||
half_length = numpy.floor(defect_length / 2)
|
||||
hole_nums = numpy.arange(-half_length, half_length + 1)
|
||||
holes_to_keep = numpy.in1d(p[:, 0], hole_nums, invert=True)
|
||||
return p[numpy.logical_or(holes_to_keep, p[:, 1] != 0), ]
|
||||
|
||||
|
||||
def ln_shift_defect(mirror_dims: Tuple[int, int],
|
||||
defect_length: int,
|
||||
shifts_a: Sequence[float] = (0.15, 0, 0.075),
|
||||
shifts_r: Sequence[float] = (1, 1, 1)
|
||||
) -> numpy.ndarray:
|
||||
"""
|
||||
N-hole defect with shifted holes (intended to give the mode a gaussian profile
|
||||
in real- and k-space so as to improve both Q and confinement). Holes along the
|
||||
defect line are shifted and altered according to the shifts_* parameters.
|
||||
|
||||
Args:
|
||||
mirror_dims: [x, y] mirror lengths (number of holes). Total number of holes
|
||||
is `2 * n + 1` in each direction.
|
||||
defect_length: Length of defect. Should be an odd number.
|
||||
shifts_a: Percentage of a to shift (1st, 2nd, 3rd,...) holes along the defect line
|
||||
shifts_r: Factor to multiply the radius by. Should match length of shifts_a
|
||||
|
||||
Returns:
|
||||
`[[x0, y0, r0], [x1, y1, r1], ...]` for all the holes
|
||||
"""
|
||||
if not hasattr(shifts_a, "__len__") and shifts_a is not None:
|
||||
shifts_a = [shifts_a]
|
||||
if not hasattr(shifts_r, "__len__") and shifts_r is not None:
|
||||
shifts_r = [shifts_r]
|
||||
|
||||
xy = ln_defect(mirror_dims, defect_length)
|
||||
|
||||
# Add column for radius
|
||||
xyr = numpy.hstack((xy, numpy.ones((xy.shape[0], 1))))
|
||||
|
||||
# Shift holes
|
||||
# Expand shifts as necessary
|
||||
n_shifted = max(len(shifts_a), len(shifts_r))
|
||||
|
||||
tmp_a = numpy.array(shifts_a)
|
||||
shifts_a = numpy.ones((n_shifted, ))
|
||||
shifts_a[:len(tmp_a)] = tmp_a
|
||||
|
||||
tmp_r = numpy.array(shifts_r)
|
||||
shifts_r = numpy.ones((n_shifted, ))
|
||||
shifts_r[:len(tmp_r)] = tmp_r
|
||||
|
||||
x_removed = numpy.floor(defect_length / 2)
|
||||
|
||||
for ind in range(n_shifted):
|
||||
for sign in (-1, 1):
|
||||
x_val = sign * (x_removed + ind + 1)
|
||||
which = numpy.logical_and(xyr[:, 0] == x_val, xyr[:, 1] == 0)
|
||||
xyr[which, ] = (x_val + numpy.sign(x_val) * shifts_a[ind], 0, shifts_r[ind])
|
||||
|
||||
return xyr
|
||||
|
||||
|
||||
def r6_defect(mirror_dims: Tuple[int, int]) -> numpy.ndarray:
|
||||
"""
|
||||
R6 defect in a triangular lattice.
|
||||
|
||||
Args:
|
||||
mirror_dims: [x, y] mirror lengths (number of holes). Total number of holes
|
||||
is 2 * n + 1 in each direction.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, y1], ...]` specifying hole centers.
|
||||
"""
|
||||
xy = triangular_lattice([2 * d + 1 for d in mirror_dims])
|
||||
|
||||
rem_holes_plus = numpy.array([[1, 0],
|
||||
[0.5, +numpy.sqrt(3)/2],
|
||||
[0.5, -numpy.sqrt(3)/2]])
|
||||
rem_holes = numpy.vstack((rem_holes_plus, -rem_holes_plus))
|
||||
|
||||
for rem_xy in rem_holes:
|
||||
xy = xy[(xy != rem_xy).any(axis=1), ]
|
||||
|
||||
return xy
|
||||
|
||||
|
||||
def l3_shift_perturbed_defect(
|
||||
mirror_dims: Tuple[int, int],
|
||||
perturbed_radius: float = 1.1,
|
||||
shifts_a: Sequence[float] = (),
|
||||
shifts_r: Sequence[float] = ()
|
||||
) -> numpy.ndarray:
|
||||
"""
|
||||
3-hole defect with perturbed hole sizes intended to form an upwards-directed
|
||||
beam. Can also include shifted holes along the defect line, intended
|
||||
to give the mode a more gaussian profile to improve Q.
|
||||
|
||||
Args:
|
||||
mirror_dims: [x, y] mirror lengths (number of holes). Total number of holes
|
||||
is 2 * n + 1 in each direction.
|
||||
perturbed_radius: Amount to perturb the radius of the holes used for beam-forming
|
||||
shifts_a: Percentage of a to shift (1st, 2nd, 3rd,...) holes along the defect line
|
||||
shifts_r: Factor to multiply the radius by. Should match length of shifts_a
|
||||
|
||||
Returns:
|
||||
`[[x0, y0, r0], [x1, y1, r1], ...]` for all the holes
|
||||
"""
|
||||
xyr = ln_shift_defect(mirror_dims, 3, shifts_a, shifts_r)
|
||||
|
||||
abs_x, abs_y = (numpy.fabs(xyr[:, i]) for i in (0, 1))
|
||||
|
||||
# Sorted unique xs and ys
|
||||
# Ignore row y=0 because it might have shifted holes
|
||||
xs = numpy.unique(abs_x[abs_x != 0])
|
||||
ys = numpy.unique(abs_y)
|
||||
|
||||
# which holes should be perturbed? (xs[[3, 7]], ys[1]) and (xs[[2, 6]], ys[2])
|
||||
perturbed_holes = ((xs[a], ys[b]) for a, b in ((3, 1), (7, 1), (2, 2), (6, 2)))
|
||||
for row in xyr:
|
||||
if numpy.fabs(row) in perturbed_holes:
|
||||
row[2] = perturbed_radius
|
||||
return xyr
|
||||
@ -0,0 +1,245 @@
|
||||
from typing import Tuple, Sequence
|
||||
|
||||
import numpy # type: ignore
|
||||
from numpy import pi
|
||||
|
||||
from masque import layer_t, Pattern, SubPattern, Label
|
||||
from masque.shapes import Polygon, Circle
|
||||
from masque.builder import Device, Port
|
||||
from masque.library import Library, DeviceLibrary
|
||||
from masque.file.gdsii import writefile
|
||||
|
||||
import pcgen
|
||||
import basic
|
||||
|
||||
|
||||
def perturbed_l3(lattice_constant: float,
|
||||
hole: Pattern,
|
||||
trench_dose: float = 1.0,
|
||||
trench_layer: layer_t = (1, 0),
|
||||
shifts_a: Sequence[float] = (0.15, 0, 0.075),
|
||||
shifts_r: Sequence[float] = (1.0, 1.0, 1.0),
|
||||
xy_size: Tuple[int, int] = (10, 10),
|
||||
perturbed_radius: float = 1.1,
|
||||
trench_width: float = 1200,
|
||||
) -> Device:
|
||||
"""
|
||||
Generate a `Device` representing a perturbed L3 cavity.
|
||||
|
||||
Args:
|
||||
lattice_constant: Distance between nearest neighbor holes
|
||||
hole: `Pattern` object containing a single hole
|
||||
trench_dose: Dose for the trenches. Default 1.0. (Hole dose is 1.0.)
|
||||
trench_layer: Layer for the trenches, default `(1, 0)`.
|
||||
shifts_a: passed to `pcgen.l3_shift`; specifies lattice constant
|
||||
(1 - multiplicative factor) for shifting holes adjacent to
|
||||
the defect (same row). Default `(0.15, 0, 0.075)` for first,
|
||||
second, third holes.
|
||||
shifts_r: passed to `pcgen.l3_shift`; specifies radius for perturbing
|
||||
holes adjacent to the defect (same row). Default 1.0 for all holes.
|
||||
Provided sequence should have same length as `shifts_a`.
|
||||
xy_size: `(x, y)` number of mirror periods in each direction; total size is
|
||||
`2 * n + 1` holes in each direction. Default (10, 10).
|
||||
perturbed_radius: radius of holes perturbed to form an upwards-driected beam
|
||||
(multiplicative factor). Default 1.1.
|
||||
trench width: Width of the undercut trenches. Default 1200.
|
||||
|
||||
Returns:
|
||||
`Device` object representing the L3 design.
|
||||
"""
|
||||
xyr = pcgen.l3_shift_perturbed_defect(mirror_dims=xy_size,
|
||||
perturbed_radius=perturbed_radius,
|
||||
shifts_a=shifts_a,
|
||||
shifts_r=shifts_r)
|
||||
|
||||
pat = Pattern(f'L3p-a{lattice_constant:g}rp{perturbed_radius:g}')
|
||||
pat.subpatterns += [SubPattern(hole,
|
||||
offset=(lattice_constant * x,
|
||||
lattice_constant * y),
|
||||
scale=r)
|
||||
for x, y, r in xyr]
|
||||
|
||||
min_xy, max_xy = pat.get_bounds()
|
||||
trench_dx = max_xy[0] - min_xy[0]
|
||||
|
||||
pat.shapes += [
|
||||
Polygon.rect(ymin=max_xy[1], xmin=min_xy[0], lx=trench_dx, ly=trench_width,
|
||||
layer=trench_layer, dose=trench_dose),
|
||||
Polygon.rect(ymax=min_xy[1], xmin=min_xy[0], lx=trench_dx, ly=trench_width,
|
||||
layer=trench_layer, dose=trench_dose),
|
||||
]
|
||||
|
||||
extent = lattice_constant * xy_size[0]
|
||||
ports = {
|
||||
'input': Port((-extent, 0), rotation=0, ptype=1),
|
||||
'output': Port((extent, 0), rotation=pi, ptype=1),
|
||||
}
|
||||
|
||||
return Device(pat, ports)
|
||||
|
||||
|
||||
def waveguide(lattice_constant: float,
|
||||
hole: Pattern,
|
||||
length: int,
|
||||
mirror_periods: int,
|
||||
) -> Device:
|
||||
"""
|
||||
Generate a `Device` representing a photonic crystal line-defect waveguide.
|
||||
|
||||
Args:
|
||||
lattice_constant: Distance between nearest neighbor holes
|
||||
hole: `Pattern` object containing a single hole
|
||||
length: Distance (number of mirror periods) between the input and output ports.
|
||||
Ports are placed at lattice sites.
|
||||
mirror_periods: Number of hole rows on each side of the line defect
|
||||
|
||||
Returns:
|
||||
`Device` object representing the waveguide.
|
||||
"""
|
||||
xy = pcgen.waveguide(length=length, num_mirror=mirror_periods)
|
||||
|
||||
pat = Pattern(f'_wg-a{lattice_constant:g}l{length}')
|
||||
pat.subpatterns += [SubPattern(hole, offset=(lattice_constant * x,
|
||||
lattice_constant * y))
|
||||
for x, y in xy]
|
||||
|
||||
extent = lattice_constant * length / 2
|
||||
ports = {
|
||||
'left': Port((-extent, 0), rotation=0, ptype=1),
|
||||
'right': Port((extent, 0), rotation=pi, ptype=1),
|
||||
}
|
||||
return Device(pat, ports)
|
||||
|
||||
|
||||
def bend(lattice_constant: float,
|
||||
hole: Pattern,
|
||||
mirror_periods: int,
|
||||
) -> Device:
|
||||
"""
|
||||
Generate a `Device` representing a 60-degree counterclockwise bend in a photonic crystal
|
||||
line-defect waveguide.
|
||||
|
||||
Args:
|
||||
lattice_constant: Distance between nearest neighbor holes
|
||||
hole: `Pattern` object containing a single hole
|
||||
mirror_periods: Minimum number of mirror periods on each side of the line defect.
|
||||
|
||||
Returns:
|
||||
`Device` object representing the waveguide bend.
|
||||
Ports are named 'left' (input) and 'right' (output).
|
||||
"""
|
||||
xy = pcgen.wgbend(num_mirror=mirror_periods)
|
||||
|
||||
pat= Pattern(f'_wgbend-a{lattice_constant:g}l{mirror_periods}')
|
||||
pat.subpatterns += [SubPattern(hole, offset=(lattice_constant * x,
|
||||
lattice_constant * y))
|
||||
for x, y in xy]
|
||||
|
||||
extent = lattice_constant * mirror_periods
|
||||
ports = {
|
||||
'left': Port((-extent, 0), rotation=0, ptype=1),
|
||||
'right': Port((extent / 2,
|
||||
extent * numpy.sqrt(3) / 2), rotation=pi * 4 / 3, ptype=1),
|
||||
}
|
||||
return Device(pat, ports)
|
||||
|
||||
|
||||
def y_splitter(lattice_constant: float,
|
||||
hole: Pattern,
|
||||
mirror_periods: int,
|
||||
) -> Device:
|
||||
"""
|
||||
Generate a `Device` representing a photonic crystal line-defect waveguide y-splitter.
|
||||
|
||||
Args:
|
||||
lattice_constant: Distance between nearest neighbor holes
|
||||
hole: `Pattern` object containing a single hole
|
||||
mirror_periods: Minimum number of mirror periods on each side of the line defect.
|
||||
|
||||
Returns:
|
||||
`Device` object representing the y-splitter.
|
||||
Ports are named 'in', 'top', and 'bottom'.
|
||||
"""
|
||||
xy = pcgen.y_splitter(num_mirror=mirror_periods)
|
||||
|
||||
pat = Pattern(f'_wgsplit_half-a{lattice_constant:g}l{mirror_periods}')
|
||||
pat.subpatterns += [SubPattern(hole, offset=(lattice_constant * x,
|
||||
lattice_constant * y))
|
||||
for x, y in xy]
|
||||
|
||||
extent = lattice_constant * mirror_periods
|
||||
ports = {
|
||||
'in': Port((-extent, 0), rotation=0, ptype=1),
|
||||
'top': Port((extent / 2,
|
||||
extent * numpy.sqrt(3) / 2), rotation=pi * 4 / 3, ptype=1),
|
||||
'bot': Port((extent / 2,
|
||||
-extent * numpy.sqrt(3) / 2), rotation=pi * 2 / 3, ptype=1),
|
||||
}
|
||||
return Device(pat, ports)
|
||||
|
||||
|
||||
def label_ports(device: Device, layer: layer_t = (3, 0)) -> Device:
|
||||
"""
|
||||
Place a text label at each port location, specifying the port data.
|
||||
|
||||
This can be used to debug port locations or to automatically generate ports
|
||||
when reading in a GDS file.
|
||||
|
||||
Args:
|
||||
device: The device which is to have its ports labeled.
|
||||
layer: The layer on which the labels will be placed.
|
||||
|
||||
Returns:
|
||||
`device` is returned (and altered in-place)
|
||||
"""
|
||||
for name, port in device.ports.items():
|
||||
angle_deg = numpy.rad2deg(port.rotation)
|
||||
device.pattern.labels += [
|
||||
Label(string=f'{name} (angle {angle_deg:g})', layer=layer, offset=port.offset)
|
||||
]
|
||||
return device
|
||||
|
||||
|
||||
def main():
|
||||
a = 512
|
||||
radius = a / 2 * 0.75
|
||||
smile = basic.smile(radius)
|
||||
hole = basic.hole(radius)
|
||||
|
||||
wg10 = label_ports(waveguide(lattice_constant=a, hole=hole, length=10, mirror_periods=5))
|
||||
wg05 = label_ports(waveguide(lattice_constant=a, hole=hole, length=5, mirror_periods=5))
|
||||
wg28 = label_ports(waveguide(lattice_constant=a, hole=hole, length=28, mirror_periods=5))
|
||||
bend0 = label_ports(bend(lattice_constant=a, hole=hole, mirror_periods=5))
|
||||
l3cav = label_ports(perturbed_l3(lattice_constant=a, hole=smile, xy_size=(4, 10)))
|
||||
ysplit = label_ports(y_splitter(lattice_constant=a, hole=hole, mirror_periods=5))
|
||||
|
||||
dev = Device(name='my_bend', ports={})
|
||||
dev.place(wg10, offset=(0, 0), port_map={'left': 'in', 'right': 'signal'})
|
||||
dev.plug(wg10, {'signal': 'left'})
|
||||
dev.plug(ysplit, {'signal': 'in'}, {'top': 'signal1', 'bot': 'signal2'})
|
||||
|
||||
dev.plug(wg05, {'signal1': 'left'})
|
||||
dev.plug(wg05, {'signal2': 'left'})
|
||||
dev.plug(bend0, {'signal1': 'right'})
|
||||
dev.plug(bend0, {'signal2': 'left'})
|
||||
|
||||
dev.plug(wg10, {'signal1': 'left'})
|
||||
dev.plug(l3cav, {'signal1': 'input'})
|
||||
dev.plug(wg10, {'signal1': 'left'})
|
||||
|
||||
dev.plug(wg28, {'signal2': 'left'})
|
||||
|
||||
dev.plug(bend0, {'signal1': 'right'})
|
||||
dev.plug(bend0, {'signal2': 'left'})
|
||||
dev.plug(wg05, {'signal1': 'left'})
|
||||
dev.plug(wg05, {'signal2': 'left'})
|
||||
|
||||
dev.plug(ysplit, {'signal1': 'bot', 'signal2': 'top'}, {'in': 'signal_out'})
|
||||
dev.plug(wg10, {'signal_out': 'left'})
|
||||
|
||||
writefile(dev.pattern, 'phc.gds', 1e-9, 1e-3)
|
||||
dev.pattern.visualize()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Loading…
Reference in New Issue