diff --git a/examples/tutorial/README.md b/examples/tutorial/README.md new file mode 100644 index 0000000..e69de29 diff --git a/examples/tutorial/basic.py b/examples/tutorial/basic.py new file mode 100644 index 0000000..041784a --- /dev/null +++ b/examples/tutorial/basic.py @@ -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() diff --git a/examples/tutorial/pcgen.py b/examples/tutorial/pcgen.py new file mode 100644 index 0000000..850f143 --- /dev/null +++ b/examples/tutorial/pcgen.py @@ -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 diff --git a/examples/tutorial/phc.py b/examples/tutorial/phc.py new file mode 100644 index 0000000..d69882e --- /dev/null +++ b/examples/tutorial/phc.py @@ -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()