start work on tutorial

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()

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

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()