def _generate_ports(self, ports): # Use _generate_ports method to define ports
#ports += i3.InFluidicPort(name = "in", position = (0., 10.), angle = 180.0)
ports += i3.OpticalPort(name = "in", position = (0., self.channel_trap_width*0.5), angle = 180.0)
#ports += i3.OutFluidicPort(name ="out", position = (30., 10.), angle = 0.0)
ports += i3.OpticalPort(name ="out", position = ((self.obstacle_trap_length+self.gap_btw_barriers)*2, self.channel_trap_width*0.5), angle = 0.0)
return ports
def _generate_ports(self, ports):
ports += i3.OpticalPort(name="in", position=(-self.taper_length, 0.0), angle=180.0, trace_template=self.trace_template)
ports += i3.OpticalPort(name="out1", position=(self.length + self.taper_length, -0.5 * self.waveguide_spacing), angle=0.0,
trace_template=self.trace_template)
ports += i3.OpticalPort(name="out2", position=(self.length + self.taper_length, +0.5 * self.waveguide_spacing), angle=0.0,
trace_template=self.trace_template)
return ports
def _generate_ports(self, ports):
# generate ports
# the ports are 'right', and 'left'
ports += i3.OpticalPort(name='right',
position=(0.0, 0.0),
angle=0.0)
ports += i3.OpticalPort(name='left',
position=(-self.length, 0.0),
angle=180.0)
return ports
def _generate_ports(self, ports):
for cnt, coords in enumerate(self._get_input_taper_coords(), 1):
ports += i3.OpticalPort(name="in{}".format(cnt), position=coords[1], angle=180.0,
trace_template=self.trace_template)
for cnt, coords in enumerate(self._get_output_taper_coords(), 1):
ports += i3.OpticalPort(name="out{}".format(cnt), position=coords[1], angle=0.0,
trace_template=self.trace_template)
return ports
def _generate_ports(self, ports):
# ports += i3.OpticalPort(name="in", position=(0.0, 0.0), angle=180.0,
# trace_template=StripWgTemplate().Layout(core_width=self.wg_width))
# ports += i3.OpticalPort(name="out", position=(self.length, 0.0), angle=0.0,
# trace_template=StripWgTemplate().Layout(core_width=self.wg_width))
ports += i3.OpticalPort(name="in",
position=(0.0, 0.0),
angle=180.0)
ports += i3.OpticalPort(name="out",
position=(self.length, 0.0),
angle=0.0)
return ports
def _generate_ports(
self, ports): # Use _generate_ports method to define ports
ports += i3.OpticalPort(name="in",
position=(0., self.obstacle_trap_radius +
self.gap_btw_barriers),
angle=180.0)
ports += i3.OpticalPort(
name="out",
position=((self.gap_btw_barriers * 1.5 +
self.obstacle_trap_radius * 3),
self.obstacle_trap_radius + self.gap_btw_barriers),
angle=0.0)
return ports
def _generate_ports(self, ports):
size = self.wg_width.shape
length = size[0] - 1
ports += i3.OpticalPort(name="in",
position=(self.wg_path[0, 0],
self.wg_path[0, 1]),
angle=self.start_angle + 180.0,
trace_template=StripWgTemplate().Layout(
core_width=self.wg_width[0]))
ports += i3.OpticalPort(name="out",
position=(self.wg_path[length, 0],
self.wg_path[length, 1]),
angle=self.end_angle,
trace_template=StripWgTemplate().Layout(
core_width=self.wg_width[length]))
return ports
def _generate_ports(self, ports):
# add ports 'left' and 'right'
# left port
ports += i3.OpticalPort(
name='left',
position=self.instances['tp0'].ports['left'].position,
angle=180.0)
# right port
ports += i3.OpticalPort(
name='right',
position=self.instances['tp' + str(self.n_pairs -
1)].ports['right'].position,
angle=0.0)
return ports
def _generate_ports(self, ports):
# add ports 'left' and 'right'
# left port
ports += i3.OpticalPort(
name='left',
position=self.instances[self.name +
'_taper1'].ports['left'].position,
angle=180.0)
# right port
ports += i3.OpticalPort(
name='right',
position=self.instances[self.name +
'_taper2'].ports['left'].position,
angle=0.0)
return ports
def _generate_ports(self, ports):
# add ports 'left' and 'right'
# left port
ports += i3.OpticalPort(
name='left',
position=self.instances[
self.name + '_EDGETAPER_WEST'].ports['in'].position,
angle=180.0)
# right port
ports += i3.OpticalPort(
name='right',
position=self.instances[
self.name + '_EDGETAPER_EAST'].ports['out'].position,
angle=0.0)
return ports
def _generate_ports(self, ports):
"""
THIS NEEDS TO BE UPDATED TO REFLECT INPUT OUTPUT TAPERS
"""
# ports += self.instances["SidewallGratWg0"].ports["in"]
# ports += self.instances["SidewallGratWg"+str(self.numrows-1)].ports["out"]
ports += i3.OpticalPort(name='in',
position=self.instances["SwgTaper_West0"].
ports["left"].position,
angle=180.0)
ports += i3.OpticalPort(
name='out',
position=self.instances["SwgTaper_East" +
str(self.numrows -
1)].ports["left"].position,
angle=0.0)
return ports
def _generate_ports(self, ports):
# add ports 'left' and 'right'
# left port
ports += i3.OpticalPort(
name='in',
position=self.instances[self.name +
'_BEND_A0'].ports['in'].position,
angle=0.0)
# right port
ports += i3.OpticalPort(
name='out',
position=self.instances[self.name + '_BEND_B' +
str(self.n_pairs -
1)].ports['out'].position,
angle=180.0)
return ports
def _generate_ports(self, ports):
ports += i3.OpticalPort(
name='in', position=(20.0, 0.0), angle=0.0
) # We have to manually set the ports as this info is not in the gdsii file yet
ports += i3.VerticalOpticalPort(
name="vertical_in",
position=(0.0, 0.0),
inclination=90.0,
angle=0.0) # For the fiber a vertical port is used.
return ports
def _generate_ports(self, ports):
from ..waveguides.wire import SWG450
ports += i3.OpticalPort(name="in",
position=(-5.0, 0.0),
angle=180.0,
trace_template=SWG450())
ports += i3.ElectricalPort(name="cathode",
position=(0.5 * self.length,
self.contact_offset + 1.25))
ports += i3.ElectricalPort(name="anode",
position=(0.5 * self.length,
-self.contact_offset - 1.25))
return ports
def _generate_ports(self, ports):
# Port 'out' = chip edge
# Port 'in' = connecting waveguide
# generate chip/out port
edge_coupler_size_inf = self.instances[
self.name + '_EDGE_COUPLER'].size_info()
edge_coupler_left_edge_pos = edge_coupler_size_inf.west
edge_coupler_mid_y = edge_coupler_size_inf.center[1]
ports += i3.OpticalPort(name='out',
position=(edge_coupler_left_edge_pos,
edge_coupler_mid_y),
angle=180.0)
# generate waveguide/in port
edge_coupler_right_edge_pos = edge_coupler_size_inf.east
ports += i3.OpticalPort(name='in',
position=(edge_coupler_right_edge_pos,
edge_coupler_mid_y),
angle=0.0)
return ports
def new_function(start_port,
end_port,
name=None,
shape=None,
connector_kwargs={}):
start_ports = [start_port] + [
i3.OpticalPort(trace_template=start_port.trace_template,
position=(0.0, 0.0)).transform(transformation=t)
for t in cleaned_transformations
]
end_ports = [
p.modified_copy(angle=p.angle + 180.0) for p in start_ports[1:]
] + [end_port]
traces = []
for cnt, (cf, sp, ep) in enumerate(
zip(connector_functions, start_ports, end_ports)):
seg_name = "{}_segment_{}".format(name, cnt)
traces.append(cf(start_port=sp, end_port=ep, name=seg_name))
return TraceChainWithCenterLine(name=name, traces=traces)
def _generate_instances(self, insts):
# Generates taper pairs w edge couplers
# load the aim gds just to get its positions and stuff
# main chip GDS
fname = '../PDK_Library_Layout_GDS/ap_suny_v20a_chipframe.gds'
main_chip_gds_cell = i3.GDSCell(filename=fname)
# grab layout size info
main_chip_gds_lay = main_chip_gds_cell.Layout()
main_chip_gds_lay_size_info = main_chip_gds_lay.size_info()
# grab relevant positions
chip_edge_east = main_chip_gds_lay_size_info.east
chip_edge_west = main_chip_gds_lay_size_info.west
# make edge coupler
edge_coupler_gds_lay = EdgeCoupler(name=self.name +
'edge_coupler_sffdfi').Layout()
# add and route input/west edgecoupler
# position edge coupler on west side of chip
chip_port_west = i3.OpticalPort(position=(chip_edge_west, 0.0),
angle_deg=0.0)
edge_coupler_west_port = edge_coupler_gds_lay.ports['out']
t = i3.vector_match_transform(edge_coupler_west_port,
chip_port_west)
edge_coupler_west_name = self.name + '_EDGE_COUPLER_WEST'
west_edge_coupler = i3.SRef(name=edge_coupler_west_name,
reference=edge_coupler_gds_lay,
transformation=t,
flatten=False)
# add a small linear taper to go from 0.4 to 0.5um wg
lin_taper_lay = LinearTaper().get_default_view(i3.LayoutView)
lin_taper_lay.set(wg_width_in=0.4, wg_width_out=0.5, length=10.0)
t = i3.vector_match_transform(lin_taper_lay.ports['in'],
west_edge_coupler.ports['in'])
lin_taper_lay_name = self.name + '_EDGETAPER_WEST'
insts += i3.SRef(name=lin_taper_lay_name,
reference=lin_taper_lay,
transformation=t,
flatten=True)
# route wg to wg with arc
bend_radius = 10.0
arc_center_1 = (
insts[lin_taper_lay_name].ports['out'].position[0],
insts[lin_taper_lay_name].ports['out'].position[1] +
bend_radius)
route_wg_shape_arc1 = i3.ShapeArc(radius=bend_radius,
angle_step=1.0,
center=arc_center_1,
start_angle=269.5,
end_angle=0.5,
closed=False,
clockwise=False)
wg_name_arc1 = self.name + '_ARC1'
wg_lay_arc1 = i3.Waveguide(trace_template=StripWgTemplate(),
name=wg_name_arc1).get_default_view(
i3.LayoutView)
wg_lay_arc1.set(shape=route_wg_shape_arc1)
insts += i3.SRef(name=wg_name_arc1,
reference=wg_lay_arc1,
flatten=True)
# add the bends
bend_clip_lay = BendClip(
name=self.name + '_BEND_CLIP').get_default_view(i3.LayoutView)
bend_clip_lay.set(n_pairs=self.n_pairs)
# add to insts
bend_clip_lay_name = self.name + '_BEND_CLIP'
t = i3.vector_match_transform(bend_clip_lay.ports['in'],
insts[wg_name_arc1].ports['out'])
insts += i3.SRef(name=bend_clip_lay_name,
reference=bend_clip_lay,
transformation=t,
flatten=True)
# add output bend
arc_center_2 = (
insts[bend_clip_lay_name].ports['out'].position[0] +
bend_radius,
insts[bend_clip_lay_name].ports['out'].position[1])
route_wg_shape_arc2 = i3.ShapeArc(radius=bend_radius,
angle_step=1.0,
center=arc_center_2,
start_angle=180.5,
end_angle=89.5,
closed=False,
clockwise=True)
wg_name_arc2 = self.name + '_ARC2'
wg_lay_arc2 = i3.Waveguide(trace_template=StripWgTemplate(),
name=wg_name_arc2).get_default_view(
i3.LayoutView)
wg_lay_arc2.set(shape=route_wg_shape_arc2)
insts += i3.SRef(name=wg_name_arc2,
reference=wg_lay_arc2,
flatten=True)
# add east coupler
chip_port_east = i3.OpticalPort(
position=(chip_edge_east,
insts[wg_name_arc2].ports['out'].position[1]),
angle_deg=180.0)
edge_coupler_east_port = edge_coupler_gds_lay.ports['out']
t = i3.vector_match_transform(edge_coupler_east_port,
chip_port_east,
mirrored=True)
edge_coupler_east_name = self.name + '_EDGE_COUPLER_EAST'
east_edge_coupler = i3.SRef(name=edge_coupler_east_name,
reference=edge_coupler_gds_lay,
transformation=t,
flatten=False)
# add a small linear taper to go from 0.4 to 0.5um wg
lin_taper_lay = LinearTaper().get_default_view(i3.LayoutView)
lin_taper_lay.set(wg_width_in=0.4, wg_width_out=0.5, length=10.0)
t = i3.vector_match_transform(lin_taper_lay.ports['in'],
east_edge_coupler.ports['in'],
mirrored=True)
lin_taper_lay_name = self.name + '_EDGETAPER_EAST'
insts += i3.SRef(name=lin_taper_lay_name,
reference=lin_taper_lay,
transformation=t,
flatten=True)
# route arc to arc with straight section
route_wg_shape_out = i3.Shape([
insts[wg_name_arc2].ports['out'].position,
insts[lin_taper_lay_name].ports['out'].position
])
wg_name_out = self.name + '_WG_CON_OUT'
wg_lay_out = i3.Waveguide(trace_template=StripWgTemplate(),
name=wg_name_out).get_default_view(
i3.LayoutView)
wg_lay_out.set(shape=route_wg_shape_out)
insts += i3.SRef(name=wg_name_out,
reference=wg_lay_out,
flatten=True)
return insts
def _generate_ports(self, ports):
from technology.WgTemplate import StripWgTemplate
ports += i3.OpticalPort(name="port_name0", position=(xloc0, yloc0), angle=angle0, trace_template=StripWgTemplate())
ports += i3.OpticalPort(name="port_name1", position=(xloc1, yloc1), angle=angle1, trace_template=StripWgTemplate())
return ports
width_wide = connector_kwargs["width_wide"]
else:
width_wide = 3.
if shape is None:
shape = RouteManhattan(input_port=start_port,
output_port=end_port,
bend_radius=bend_radius)
from ipkiss3.pcell.photonics.expanded_waveguide import ExpandedWaveguide
wav = ExpandedWaveguide(trace_template=trace_template, name=name)
wav.Layout(shape=shape,
narrow_width=trace_template.core_width,
expanded_width=width_wide,
taper_length=taper_length,
expanded_layer=trace_template.core_layer)
return wav
if __name__ == "__main__":
from ipkiss3 import all as i3
start_port = i3.OpticalPort(position=(0.0, 0.0), angle=0.0)
end_port = i3.OpticalPort(position=(200.0, 50.0), angle=180.0)
cell = wide_manhattan(start_port, end_port, name="TestWaveguide")
lv = cell.get_default_view(i3.LayoutView)
lv.visualize()
lv.write_gdsii("expanded.gds")
def _generate_instances(self, insts):
# Generates taper pairs
tp_name_list = []
# temporary? pick taper properties
taper_prop_dict = {
'length': 79.0,
'width1': 0.50,
'width2': 6.50,
'width_etch': 2.0
}
# generate a huge taper row
tp_rows_layout = TaperPairRow().Layout(
taper_prop_dict=taper_prop_dict,
connect_length=0.0,
pair_connect_length=10.0,
n_pairs=self.n_pairs)
# load the aim gds just to get its positions and stuff
# main chip GDS
fname = os.path.dirname(
os.path.realpath(__file__)) + '/gds/ap_suny_v20a_chipframe.gds'
main_chip_gds_cell = i3.GDSCell(filename=fname)
# grab layout size info
main_chip_gds_lay = main_chip_gds_cell.Layout()
main_chip_gds_lay_size_info = main_chip_gds_lay.size_info()
# grab relevant positions
chip_edge_east = main_chip_gds_lay_size_info.east
chip_edge_west = main_chip_gds_lay_size_info.west
# make edge coupler and add to layout
# edge coupler
edge_coupler_gds_lay = EdgeCoupler(name=self.name +
'edge_coupler_si').Layout()
# add and route input/west edgecoupler
# position edge coupler on west side of chip
chip_port_west = i3.OpticalPort(position=(chip_edge_west, 0.0),
angle_deg=0.0)
edge_coupler_west_port = edge_coupler_gds_lay.ports['out']
t = i3.vector_match_transform(edge_coupler_west_port,
chip_port_west)
edge_coupler_west_name = self.name + '_EDGE_COUPLER_WEST'
west_edge_coupler = i3.SRef(name=edge_coupler_west_name,
reference=edge_coupler_gds_lay,
transformation=t,
flatten=False)
# add a small linear taper to go from 0.4 to 0.5um wg
lin_taper_lay = LinearTaper().get_default_view(i3.LayoutView)
lin_taper_lay.set(wg_width_in=0.4, wg_width_out=0.5, length=10.0)
t = i3.vector_match_transform(lin_taper_lay.ports['in'],
west_edge_coupler.ports['in'])
lin_taper_lay_name = self.name + '_EDGETAPER_WEST'
insts += i3.SRef(name=lin_taper_lay_name,
reference=lin_taper_lay,
transformation=t,
flatten=True)
# add taper rows
taper_row_name = self.name + '_TAPERSSSSSSSS'
t = i3.vector_match_transform(
tp_rows_layout.ports['left'],
insts[lin_taper_lay_name].ports['out'])
insts += i3.SRef(name=taper_row_name,
reference=tp_rows_layout,
transformation=t,
flatten=True)
# add east coupler
chip_port_east = i3.OpticalPort(position=(chip_edge_east, 0.0),
angle_deg=180.0)
edge_coupler_east_port = edge_coupler_gds_lay.ports['out']
t = i3.vector_match_transform(edge_coupler_east_port,
chip_port_east,
mirrored=True)
edge_coupler_east_name = self.name + '_EDGE_COUPLER_EAST'
east_edge_coupler = i3.SRef(name=edge_coupler_east_name,
reference=edge_coupler_gds_lay,
transformation=t,
flatten=False)
# add a small linear taper to go from 0.4 to 0.5um wg
lin_taper_lay = LinearTaper().get_default_view(i3.LayoutView)
lin_taper_lay.set(wg_width_in=0.4, wg_width_out=0.5, length=10.0)
t = i3.vector_match_transform(lin_taper_lay.ports['in'],
east_edge_coupler.ports['in'],
mirrored=True)
lin_taper_lay_name = self.name + '_EDGETAPER_EAST'
insts += i3.SRef(name=lin_taper_lay_name,
reference=lin_taper_lay,
transformation=t,
flatten=True)
# route the east coupler to the east edge of the taper pairs
route_wg_row_taper = i3.Shape([
insts[taper_row_name].ports['right'].position,
insts[lin_taper_lay_name].ports['out'].position
])
wg_name = self.name + '_WG'
wg_lay = i3.Waveguide(trace_template=StripWgTemplate(),
name=wg_name).get_default_view(i3.LayoutView)
wg_lay.set(shape=route_wg_row_taper)
insts += i3.SRef(name=wg_name, reference=wg_lay, flatten=True)
return insts
def _generate_ports(self, ports):
ports += i3.OpticalPort(name="in", position=(4.0, 0.0), angle=0.0, trace_template=i3.TECH.PCELLS.WG.DEFAULT)
return ports
def _generate_instances(self, insts):
width = 200.0
p1 = (-self.radius, -self.radius) #near cylinders
p2 = (-self.radius, -2 * self.radius) #bottom
p3 = (2 * self.radius, -2 * self.radius) #right
p4 = (2 * self.radius, 0) #top
p5 = (2 * self.radius + 500, 0) #out
pax = (-width * 0.5 * math.cos(45), width * 0.5 * math.sin(45))
#generate a circle
sr1 = i3.ShapeCircle(center=(0.0, 0.0),
radius=self.radius) #, line_width = 200)
br1 = i3.Boundary(layer=self.layer, shape=sr1)
#s= i3.Structure(elements = br1)
#rectangle
sc1 = i3.ShapeRectangle(center=p1,
box_size=(self.radius * 4,
self.radius * 0.25))
bc1 = i3.Boundary(layer=self.layer,
shape=sc1,
transformation=i3.Rotation((0, 0),
-45.0)) # was -35
#Substruct boundaries and add to the element list
b_sub = br1 - bc1
s = i3.Structure(elements=b_sub)
insts += i3.SRef(s)
#Input channel - segment
channel1 = microfluidics.Channel(
trace_template=self.cell.channel_template)
#channel_template = microfluidics.ShortChannelTemplate().Layout(width=200.0)
channel1_lo = channel1.Layout(shape=[(self.inlet_channel_length +
self.offset_matching * 0.5,
0), (0, 0)])
insts += i3.SRef(
channel1_lo,
position=(-(self.inlet_channel_length + self.radius), 0),
transformation=i3.Rotation((0.0, 0.0), 0.0))
#############################routing
from ipkiss.plugins.photonics.routing.manhattan import RouteManhattan
channel_4 = microfluidics.RoundedChannel(
trace_template=self.cell.channel_template) # used for routing
channel_4_layout = channel_4.Layout()
import operator
p1Array = tuple(map(operator.add, p1, pax))
print 'p1: ', p1
print 'pax: ', pax
print 'p1Array: ', p1Array
#obstacles
insts += i3.SRef(reference=self.obstacles,
position=p1Array,
transformation=i3.Rotation((0, 0), -45.0))
in_port_1 = microfluidics.FluidicPort(
position=p1, trace_template=self.cell.channel_template)
out_port_1 = microfluidics.FluidicPort(
trace_template=self.cell.channel_template)
in_port_1.angle_deg = 225
out_port_1.angle_deg = 45
in_port_2 = microfluidics.FluidicPort(
position=p2, trace_template=self.cell.channel_template)
in_port_2.angle_deg = 225
channel_4_layout.set(bend_radius=150.0,
shape=RouteManhattan(input_port=in_port_2,
points=[p2, p3, p4, p5],
output_port=out_port_1,
bend_radius=300.0))
insts += i3.SRef(name="Route_1", reference=channel_4)
##############################routing
from ipkiss3.pcell.routing import RouteToAngle
# create the route object
channel_1 = microfluidics.RoundedChannel(
trace_template=self.cell.channel_template) # used for routing
channel_1_layout = channel_1.Layout()
channel_1_layout.set(bend_radius=50.0,
shape=RouteToAngle(input_port=in_port_1,
start_straight=300,
end_straight=300,
angle_out=45))
#insts += i3.SRef(name = "Route_2", reference = channel_1)
from ipkiss3.pcell.routing import RouteToEastAtMaxY, RouteToEastAtMinY, RouteToEastAtY
# create the route object
input_portx = i3.OpticalPort(name="in",
position=(-self.radius, -self.radius),
angle_deg=225.0)
channel_x = microfluidics.RoundedChannel(
trace_template=self.cell.channel_template) # used for routing
channel_x_layout = channel_x.Layout()
channel_x_layout.set(bend_radius=150.0,
shape=RouteToEastAtY(input_port=input_portx,
start_straight=200,
end_straight=200,
y_position=-2 *
self.radius))
insts += i3.SRef(name="Route_x", reference=channel_x)
return insts
def _generate_instances(self, insts):
# Generates a long ass row of gratings
# serp_grating_layout = SerpGratingArray().get_default_view(i3.LayoutView)
# serp_grating_layout.set( pitch = 0.5,
# grat_wg_width = 6.5,
# flyback_wg_width = 6.5,
# grating_amp = grating_amps[i_row][i_col],
# duty_cycle = duty_cycle,
# period = period,
# numrows = numrows_tx,
# grating_type = grating_types[i_row][i_col],
# length = 100.0 )
# load the aim gds just to get its positions and stuff
# main chip GDS
fname = '../PDK_Library_Layout_GDS/ap_suny_v20a_chipframe.gds'
main_chip_gds_cell = i3.GDSCell(filename=fname)
# grab layout size info
main_chip_gds_lay = main_chip_gds_cell.Layout()
main_chip_gds_lay_size_info = main_chip_gds_lay.size_info()
# grab relevant positions
chip_edge_east = main_chip_gds_lay_size_info.east
chip_edge_west = main_chip_gds_lay_size_info.west
# make edge coupler
edge_coupler_gds_lay = EdgeCoupler(
name=self.name + 'edge_coupler_mmmmffff').Layout()
# add and route input/west edgecoupler
# position edge coupler on west side of chip
chip_port_west = i3.OpticalPort(position=(chip_edge_west, 0.0),
angle_deg=0.0)
edge_coupler_west_port = edge_coupler_gds_lay.ports['out']
t = i3.vector_match_transform(edge_coupler_west_port,
chip_port_west)
edge_coupler_west_name = self.name + '_EDGE_COUPLER_WEST'
west_edge_coupler = i3.SRef(name=edge_coupler_west_name,
reference=edge_coupler_gds_lay,
transformation=t,
flatten=False)
# add a small linear taper to go from 0.4 to 0.5um wg
lin_taper_lay = LinearTaper().get_default_view(i3.LayoutView)
lin_taper_lay.set(wg_width_in=0.4, wg_width_out=0.5, length=10.0)
t = i3.vector_match_transform(lin_taper_lay.ports['in'],
west_edge_coupler.ports['in'])
lin_taper_lay_name = self.name + '_EDGETAPER_WEST'
insts += i3.SRef(name=lin_taper_lay_name,
reference=lin_taper_lay,
transformation=t,
flatten=True)
# Hard code the tapers into here: (I hate hardcoding stuff, but no choice here)
taper_length = 79.0 # 79 is the best according to deniz' sims
width_etch = 4.0
wg_width = 0.5
taper_swg_lay_1 = ParabolicTaper(
name=self.name + '_TAPER_1').get_default_view(i3.LayoutView)
taper_swg_lay_1.set(length=taper_length,
width1=wg_width,
width2=self.grat_wg_width,
width_etch=width_etch)
taper_swg_name_1 = self.name + '_TAPER_1'
t = i3.vector_match_transform(
taper_swg_lay_1.ports['left'],
insts[lin_taper_lay_name].ports['out'])
insts += i3.SRef(name=taper_swg_name_1,
reference=taper_swg_lay_1,
transformation=t,
flatten=True)
# add grating array
# make grating layout
swg_l_name = self.name + '_SWG'
if self.grating_type == 'one_sidewall':
# single sidewall grating
swg_l = SidewallGratingWg(name=swg_l_name).get_default_view(
i3.LayoutView)
swg_l.set(period=self.period,
duty_cycle=self.duty_cycle,
grating_amp=self.grating_amp,
wg_width=self.grat_wg_width,
length=self.length,
both_sides=False)
elif self.grating_type == 'two_sidewalls':
# double sidewall grating
swg_l = SidewallGratingWg(name=swg_l_name).get_default_view(
i3.LayoutView)
swg_l.set(period=self.period,
duty_cycle=self.duty_cycle,
grating_amp=self.grating_amp,
wg_width=self.grat_wg_width,
length=self.length,
both_sides=True)
elif self.grating_type == 'nitride_vertical_top':
# nitride vertical grating, top layer
swg_l = NitrideGratingWg(name=swg_l_name).get_default_view(
i3.LayoutView)
swg_l.set(period=self.period,
duty_cycle=self.duty_cycle,
grating_amp=self.grating_amp,
wg_width=self.grat_wg_width,
length=self.length,
grating_type='vertical',
nitride_layer='top')
elif self.grating_type == 'nitride_vertical_bottom':
# nitride vertical grating, top layer
swg_l = NitrideGratingWg(name=swg_l_name).get_default_view(
i3.LayoutView)
swg_l.set(period=self.period,
duty_cycle=self.duty_cycle,
grating_amp=self.grating_amp,
wg_width=self.grat_wg_width,
length=self.length,
grating_type='vertical',
nitride_layer='bottom')
elif self.grating_type == 'nitride_one_sidewall_top':
# nitride vertical grating, top layer
swg_l = NitrideGratingWg(name=swg_l_name).get_default_view(
i3.LayoutView)
swg_l.set(period=self.period,
duty_cycle=self.duty_cycle,
grating_amp=self.grating_amp,
wg_width=self.grat_wg_width,
length=self.length,
grating_type='one_sidewall',
nitride_layer='top')
elif self.grating_type == 'nitride_one_sidewall_bottom':
# nitride vertical grating, top layer
swg_l = NitrideGratingWg(name=swg_l_name).get_default_view(
i3.LayoutView)
swg_l.set(period=self.period,
duty_cycle=self.duty_cycle,
grating_amp=self.grating_amp,
wg_width=self.grat_wg_width,
length=self.length,
grating_type='one_sidewall',
nitride_layer='bottom')
# end getting grating layout
# add waveguide instance
t = i3.vector_match_transform(
swg_l.ports['in'], insts[taper_swg_name_1].ports['right'])
insts += i3.SRef(name=swg_l_name,
reference=swg_l,
transformation=t,
flatten=True)
# add east coupler
chip_port_east = i3.OpticalPort(position=(chip_edge_east, 0.0),
angle_deg=180.0)
edge_coupler_east_port = edge_coupler_gds_lay.ports['out']
t = i3.vector_match_transform(edge_coupler_east_port,
chip_port_east,
mirrored=True)
edge_coupler_east_name = self.name + '_EDGE_COUPLER_EAST'
east_edge_coupler = i3.SRef(name=edge_coupler_east_name,
reference=edge_coupler_gds_lay,
transformation=t,
flatten=False)
# add a small linear taper to go from 0.4 to 0.5um wg
lin_taper_lay = LinearTaper().get_default_view(i3.LayoutView)
lin_taper_lay.set(wg_width_in=0.4, wg_width_out=0.5, length=10.0)
t = i3.vector_match_transform(lin_taper_lay.ports['in'],
east_edge_coupler.ports['in'],
mirrored=True)
lin_taper_lay_name_east = self.name + '_EDGETAPER_EAST'
insts += i3.SRef(name=lin_taper_lay_name_east,
reference=lin_taper_lay,
transformation=t,
flatten=True)
# east taper
taper_swg_lay_2 = ParabolicTaper(
name=self.name + '_TAPER_2').get_default_view(i3.LayoutView)
taper_swg_lay_2.set(length=taper_length,
width1=wg_width,
width2=self.grat_wg_width,
width_etch=width_etch)
taper_swg_name_2 = self.name + '_TAPER_2'
t = i3.vector_match_transform(
taper_swg_lay_2.ports['left'],
insts[lin_taper_lay_name_east].ports['out'],
mirrored=True)
insts += i3.SRef(name=taper_swg_name_2,
reference=taper_swg_lay_2,
transformation=t,
flatten=True)
# connect with fat waveguide, which is just a sidewall grating with no amp
connect_len = insts[taper_swg_name_2].ports['right'].position[
0] - insts[swg_l_name].ports['out'].position[0]
fat_wg_l = SidewallGratingWg().get_default_view(i3.LayoutView)
fat_wg_l_name = self.name + '_FAT_WG_CON'
fat_wg_l.set(period=self.period,
duty_cycle=self.duty_cycle,
grating_amp=0.0,
wg_width=self.grat_wg_width,
length=connect_len,
both_sides=False)
t = i3.vector_match_transform(fat_wg_l.ports['in'],
insts[swg_l_name].ports['out'])
insts += i3.SRef(name=fat_wg_l_name,
reference=fat_wg_l,
transformation=t,
flatten=True)
return insts
def _generate_instances(self, insts):
# Generates taper clip
# taper clip defaults
n_rows = 3
n_taper_pairs_per_row = [1, 3, 5]
row_spacing = 15.0
grating_name = 'FGCCTE_FCWFC1DC_630_378'
connect_length = 5.0
pair_connect_length = 5.0
bot_gc_connect_length = 15.0
top_gc_connect_length = 15.0
bend_radius = 10.0
# taper properties
# taper_prop_dict = {
# 'length': 100.0,
# 'width1': 0.450,
# 'width2': 11.0,
# 'width_etch': 2.0
# }
# add first taper clip
tc1_name = self.name + '_tc1'
taper_clip_layout = TaperClip(tc1_name).get_default_view(
i3.LayoutView)
taper_clip_layout.set(
n_rows=n_rows,
n_taper_pairs_per_row=n_taper_pairs_per_row[0],
row_spacing=row_spacing,
grating_name=grating_name,
connect_length=connect_length,
pair_connect_length=pair_connect_length,
bot_gc_connect_length=bot_gc_connect_length,
top_gc_connect_length=top_gc_connect_length,
bend_radius=bend_radius,
taper_prop_dict=self.taper_prop_dict)
# plop it down
insts += i3.SRef(name=tc1_name, reference=taper_clip_layout)
# add second taper clip
tc2_name = self.name + '_tc2'
taper_clip_layout = TaperClip(tc2_name).get_default_view(
i3.LayoutView)
taper_clip_layout.set(
n_rows=n_rows,
n_taper_pairs_per_row=n_taper_pairs_per_row[1],
row_spacing=row_spacing,
grating_name=grating_name,
connect_length=connect_length,
pair_connect_length=pair_connect_length,
bot_gc_connect_length=bot_gc_connect_length,
top_gc_connect_length=top_gc_connect_length,
bend_radius=bend_radius,
taper_prop_dict=self.taper_prop_dict)
# plop it down
tc1_size_info = insts[tc1_name].size_info()
tc2_size_info = taper_clip_layout.size_info()
t = i3.vector_match_transform(
i3.OpticalPort(name='temp1',
position=(tc2_size_info.west, 0.0),
angle=180.0),
i3.OpticalPort(name='temp2',
position=(tc1_size_info.east, 0.0),
angle=0.0))
t += i3.Translation((-25.0, 0.0))
insts += i3.SRef(name=tc2_name,
reference=taper_clip_layout,
transformation=t)
# add third taper clip
tc3_name = self.name + '_tc3'
taper_clip_layout = TaperClip(tc3_name).get_default_view(
i3.LayoutView)
taper_clip_layout.set(
n_rows=n_rows,
n_taper_pairs_per_row=n_taper_pairs_per_row[2],
row_spacing=row_spacing,
grating_name=grating_name,
connect_length=connect_length,
pair_connect_length=pair_connect_length,
bot_gc_connect_length=bot_gc_connect_length,
top_gc_connect_length=top_gc_connect_length,
bend_radius=bend_radius,
taper_prop_dict=taper_prop_dict)
# plop it down
tc2_size_info = insts[tc2_name].size_info()
tc3_size_info = taper_clip_layout.size_info()
pos = (0.0, 60.0)
insts += i3.SRef(name=tc3_name,
reference=taper_clip_layout,
position=pos)
# t = i3.vector_match_transform(
# i3.OpticalPort(name='temp1', position=(tc3_size_info.west, 0.0), angle=180.0),
# i3.OpticalPort(name='temp2', position=(tc2_size_info.east, 0.0), angle=0.0) )
# t += i3.Translation( (-25.0, 0.0) )
# insts += i3.SRef( name = tc3_name,
# reference = taper_clip_layout,
# transformation = t )
return insts
