def make(self):
"""Build the component"""
face = draw.shapely.geometry.Point(0, 0).buffer(1)
eye = draw.shapely.geometry.Point(0, 0).buffer(0.2)
eye_l = draw.translate(eye, -0.4, 0.4)
eye_r = draw.translate(eye, 0.4, 0.4)
smile = draw.shapely.geometry.Point(0, 0).buffer(0.8)
cut_sq = draw.shapely.geometry.box(-1, -0.3, 1, 1)
smile = draw.subtract(smile, cut_sq)
frown = draw.rotate(smile, 180)
frown = draw.translate(frown, 0, 0.3)
frown = draw.subtract(frown,
draw.shapely.geometry.Point(0, -0.8).buffer(0.7))
face = draw.subtract(face, eye_l)
if self.p.happy:
face = draw.subtract(face, smile)
else:
face = draw.subtract(face, frown)
if self.p.wink:
face = draw.subtract(
face,
draw.shapely.geometry.LineString([(0.2, 0.4),
(0.6, 0.4)]).buffer(0.02))
else:
face = draw.subtract(face, eye_r)
face = draw.rotate(face, self.p.orientation, origin=(0, 0))
self.add_qgeometry('poly', {'Smiley': face})
def make_readout_resonator(self):
"""This function draws the readout resonator.
Adds pins. And adds the drawn geometry to qgeomtery table.
"""
p = self.p
coords_readout = self.make_readout_coordinates()
circle = self.make_circle()
pockets = self.make_pockets()
coords = self.make_coordinates_trap()
# Make the readout resonator with the pocket
contact_rdout = draw.Polygon(coords_readout)
contact_rdout = draw.subtract(circle, contact_rdout)
contact_rdout = self.make_rotation(contact_rdout, 1)
# Define contacts
pocket0 = draw.rectangle(pockets[0], pockets[1])
pocket0 = draw.translate(pocket0, xoff=0, yoff=(coords[3][1]))
pocket0 = self.make_rotation(pocket0, 1)
# Join the coupler and contact
contact_rdout = draw.union(contact_rdout[0], pocket0[0])
pins = self.make_pin_coordinates()
pins_rdout = self.make_rotation(pins, 2)
objects = [contact_rdout, pins_rdout]
objects = draw.rotate(objects, p.orientation, origin=(0, 0))
objects = draw.translate(objects, p.pos_x, p.pos_y)
[contact_rdout, pins_rdout] = objects
##################################################################
# Add geometry and Qpin connections
self.add_qgeometry('poly', {'contact_rdout': contact_rdout},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip)
self.add_pin('pin_rdout',
pins_rdout[0].coords,
width=p.cpw_width,
input_as_norm=True)
def make(self):
"""The make function implements the logic that creates the geoemtry
(poly, path, etc.) from the qcomponent.options dictionary of
parameters, and the adds them to the design, using
qcomponent.add_qgeometry(...), adding in extra needed information, such
as layer, subtract, etc."""
p = self.p # p for parsed parameters. Access to the parsed options.
# create the geometry
rect = draw.rectangle(p.width, p.height, p.pos_x, p.pos_y)
rec1 = draw.rectangle(p.inner.width, p.inner.height,
p.pos_x + p.inner.offset_x,
p.pos_y + p.inner.offset_y)
rec1 = draw.rotate(rec1, p.inner.orientation)
rect = draw.subtract(rect, rec1)
rect = draw.rotate(rect, p.orientation)
# add qgeometry
self.add_qgeometry('poly', {'rect': rect},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip)
def make(self):
"""Build the component."""
p = self.p
N = int(p.finger_count)
#Finger Capacitor
cap_box = draw.rectangle(N * p.cap_width + (N - 1) * p.cap_gap,
p.cap_gap + 2 * p.cap_width + p.finger_length,
0, 0)
make_cut_list = []
make_cut_list.append([0, (p.finger_length) / 2])
make_cut_list.append([(p.cap_width) + (p.cap_gap / 2),
(p.finger_length) / 2])
flip = -1
for i in range(1, N):
make_cut_list.append([
i * (p.cap_width) + (2 * i - 1) * (p.cap_gap / 2),
flip * (p.finger_length) / 2
])
make_cut_list.append([
(i + 1) * (p.cap_width) + (2 * i + 1) * (p.cap_gap / 2),
flip * (p.finger_length) / 2
])
flip = flip * -1
cap_cut = draw.LineString(make_cut_list).buffer(p.cap_gap / 2,
cap_style=2,
join_style=2)
cap_cut = draw.translate(cap_cut,
-(N * p.cap_width + (N - 1) * p.cap_gap) / 2,
0)
cap_body = draw.subtract(cap_box, cap_cut)
cap_body = draw.translate(
cap_body, 0, -p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length) / 2)
cap_etch = draw.rectangle(
N * p.cap_width + (N - 1) * p.cap_gap + 2 * p.cap_gap_ground,
p.cap_gap + 2 * p.cap_width + p.finger_length +
2 * p.cap_gap_ground, 0, -p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length) / 2)
#CPW
north_cpw = draw.LineString([[0, 0], [0, -p.cap_distance]])
south_cpw = draw.LineString(
[[
0, -p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length)
],
[
0, -2 * p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length)
]])
#Rotate and Translate
c_items = [north_cpw, south_cpw, cap_body, cap_etch]
c_items = draw.rotate(c_items, p.orientation, origin=(0, 0))
c_items = draw.translate(c_items, p.pos_x, p.pos_y)
[north_cpw, south_cpw, cap_body, cap_etch] = c_items
#Add to qgeometry tables
self.add_qgeometry('path', {'north_cpw': north_cpw},
width=p.north_width,
layer=p.layer)
self.add_qgeometry('path', {'north_cpw_sub': north_cpw},
width=p.north_width + 2 * p.north_gap,
layer=p.layer,
subtract=True)
self.add_qgeometry('path', {'south_cpw': south_cpw},
width=p.south_width,
layer=p.layer)
self.add_qgeometry('path', {'south_cpw_sub': south_cpw},
width=p.south_width + 2 * p.south_gap,
layer=p.layer,
subtract=True)
self.add_qgeometry('poly', {'cap_body': cap_body}, layer=p.layer)
self.add_qgeometry('poly', {'cap_etch': cap_etch},
layer=p.layer,
subtract=True)
#Add pins
north_pin_list = north_cpw.coords
south_pin_list = south_cpw.coords
self.add_pin('north_end',
points=np.array(north_pin_list[::-1]),
width=p.north_width,
input_as_norm=True)
self.add_pin('south_end',
points=np.array(south_pin_list),
width=p.south_width,
input_as_norm=True)
def make(self):
"""Build the component."""
p = self.p
N = int(p.finger_count)
prime_cpw_length = p.cap_width * 2 * N
#Primary CPW
prime_cpw = draw.LineString([[-prime_cpw_length / 2, 0],
[prime_cpw_length / 2, 0]])
#Finger Capacitor
cap_box = draw.rectangle(N * p.cap_width + (N - 1) * p.cap_gap,
p.cap_gap + 2 * p.cap_width + p.finger_length,
0, 0)
make_cut_list = []
make_cut_list.append([0, (p.finger_length) / 2])
make_cut_list.append([(p.cap_width) + (p.cap_gap / 2),
(p.finger_length) / 2])
flip = -1
for i in range(1, N):
make_cut_list.append([
i * (p.cap_width) + (2 * i - 1) * (p.cap_gap / 2),
flip * (p.finger_length) / 2
])
make_cut_list.append([
(i + 1) * (p.cap_width) + (2 * i + 1) * (p.cap_gap / 2),
flip * (p.finger_length) / 2
])
flip = flip * -1
cap_cut = draw.LineString(make_cut_list).buffer(p.cap_gap / 2,
cap_style=2,
join_style=2)
cap_cut = draw.translate(cap_cut,
-(N * p.cap_width + (N - 1) * p.cap_gap) / 2,
0)
cap_body = draw.subtract(cap_box, cap_cut)
cap_body = draw.translate(
cap_body, 0, -p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length) / 2)
cap_etch = draw.rectangle(
N * p.cap_width + (N - 1) * p.cap_gap + 2 * p.second_gap,
p.cap_gap + 2 * p.cap_width + p.finger_length + 2 * p.second_gap,
0, -p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length) / 2)
#Secondary CPW
second_cpw_top = draw.LineString([[0, -p.prime_width / 2],
[0, -p.cap_distance]])
second_cpw_bottom = draw.LineString(
[[
0, -p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length)
],
[
0, -2 * p.cap_distance -
(p.cap_gap + 2 * p.cap_width + p.finger_length)
]])
#Rotate and Translate
c_items = [
prime_cpw, second_cpw_top, second_cpw_bottom, cap_body, cap_etch
]
c_items = draw.rotate(c_items, p.orientation, origin=(0, 0))
c_items = draw.translate(c_items, p.pos_x, p.pos_y)
[prime_cpw, second_cpw_top, second_cpw_bottom, cap_body,
cap_etch] = c_items
#Add to qgeometry tables
self.add_qgeometry('path', {'prime_cpw': prime_cpw},
width=p.prime_width,
layer=p.layer)
self.add_qgeometry('path', {'prime_cpw_sub': prime_cpw},
width=p.prime_width + 2 * p.prime_gap,
subtract=True,
layer=p.layer)
self.add_qgeometry('path', {
'second_cpw_top': second_cpw_top,
'second_cpw_bottom': second_cpw_bottom
},
width=p.second_width,
layer=p.layer)
self.add_qgeometry('path', {
'second_cpw_top_sub': second_cpw_top,
'second_cpw_bottom_sub': second_cpw_bottom
},
width=p.second_width + 2 * p.second_gap,
subtract=True,
layer=p.layer)
self.add_qgeometry('poly', {'cap_body': cap_body}, layer=p.layer)
self.add_qgeometry('poly', {'cap_etch': cap_etch},
layer=p.layer,
subtract=True)
#Add pins
prime_pin_list = prime_cpw.coords
second_pin_list = second_cpw_bottom.coords
self.add_pin('prime_start',
points=np.array(prime_pin_list[::-1]),
width=p.prime_width,
input_as_norm=True)
self.add_pin('prime_end',
points=np.array(prime_pin_list),
width=p.prime_width,
input_as_norm=True)
self.add_pin('second_end',
points=np.array(second_pin_list),
width=p.second_width,
input_as_norm=True)
def make_coupling_resonators(self, num):
"""This function draws the coulping resonators.
Adds pins. And adds the drawn geometry to qgeomtery table.
"""
p = self.p
# rotate these trapezoids to form the contacts
coords = self.make_coordinates_trap()
coords1 = self.make_resonator_coordinates()
trap_z = draw.Polygon(coords1)
traps_connection = self.make_rotation(trap_z, 4)
# Define contacts
pockets = self.make_pockets()
pocket0 = draw.rectangle(pockets[0], pockets[1])
pocket0 = draw.translate(pocket0, xoff=0, yoff=(coords[3][1]))
pockets = self.make_rotation(pocket0, 4)
# Define the connectors
circle = self.make_circle()
contacts = [0] * num
for i in range(num):
contacts[i] = draw.subtract(circle, traps_connection[i])
contacts[i] = draw.union(contacts[i], pockets[i])
pins = self.make_pin_coordinates()
pins_cpl = self.make_rotation(pins, 3)
objects = [contacts, pins_cpl]
objects = draw.rotate(objects, p.orientation, origin=(0, 0))
objects = draw.translate(objects, p.pos_x, p.pos_y)
[contacts, pins_cpl] = objects
##################################################################
# Add geometry and Qpin connections
if (p.number_of_connectors) >= 1:
self.add_qgeometry('poly', {'contact_cpl1': contacts[0]},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip)
# Add pin connections
self.add_pin('pin_cpl1',
pins_cpl[0].coords,
width=p.cpw_width,
input_as_norm=True)
if (p.number_of_connectors) >= 2:
self.add_qgeometry('poly', {'contact_cpl2': contacts[1]},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip)
# Add pin connections
self.add_pin('pin_cpl2',
pins_cpl[1].coords,
width=p.cpw_width,
input_as_norm=True)
if (p.number_of_connectors) >= 3:
self.add_qgeometry('poly', {'contact_cpl3': contacts[2]},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip)
# Add pin connections
self.add_pin('pin_cpl3',
pins_cpl[2].coords,
width=p.cpw_width,
input_as_norm=True)
if (p.number_of_connectors) >= 4:
self.add_qgeometry('poly', {'contact_cpl4': contacts[3]},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip)
# Add pin connections
self.add_pin('pin_cpl4',
pins_cpl[3].coords,
width=p.cpw_width,
input_as_norm=True)
def make_inner_star(self):
"""This function creates the coordinates for the pins
"""
p = self.p
# Extracting coordinated from the user input values
coords = self.make_coordinates_trap()
coords1 = self.make_resonator_coordinates()
trap_0 = draw.Polygon(coords)
traps = self.make_rotation(trap_0, 5)
# Define the final structure based on use input
if (p.number_of_connectors) == 0:
traps = traps[2]
elif (p.number_of_connectors) == 1:
traps = draw.union(traps[0], traps[2])
elif (p.number_of_connectors) == 2:
traps = draw.union(traps[0], traps[1], traps[2])
elif (p.number_of_connectors) == 3:
traps = draw.union(traps[0], traps[1], traps[2], traps[3])
elif (p.number_of_connectors) == 4:
traps = draw.union(traps[0], traps[1], traps[2], traps[3],
traps[4])
# Subtract from circle
circle = self.make_circle()
total1 = draw.subtract(circle, traps)
# create rectangular connectors to junction
pockets = self.make_pockets()
rect1 = draw.rectangle(pockets[2], pockets[3])
rect1 = draw.translate(rect1, xoff=coords1[0][0] * 1.1, yoff=p.radius)
rect1 = draw.rotate(rect1, p.rotation_cpl1, origin=(0, 0))
rect2 = draw.rectangle(pockets[2], pockets[3])
rect2 = draw.translate(rect2, xoff=coords1[1][0] * 1.1, yoff=p.radius)
rect2 = draw.rotate(rect2, p.rotation_cpl1, origin=(0, 0))
#junction
jjunction = draw.LineString([[0, 0], [0, coords[1][0]]])
jjunction = draw.translate(jjunction, yoff=(1.15 * (p.radius)))
jjunction = draw.rotate(jjunction, p.rotation_cpl1, origin=(0, 0))
# Add connection to the junction
total = draw.union(total1, rect1, rect2)
objects = [total, jjunction]
objects = draw.rotate(objects, p.orientation, origin=(0, 0))
objects = draw.translate(objects, p.pos_x, p.pos_y)
[total, jjunction] = objects
self.add_qgeometry('poly', {'circle_inner': total},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip)
self.add_qgeometry('junction', {'poly': jjunction},
subtract=p.subtract,
helper=p.helper,
layer=p.layer,
chip=p.chip,
width=p.junc_h)
def make(self):
"""Convert self.options into QGeometry."""
p = self.parse_options() # Parse the string options into numbers
# draw the concentric pad regions
outer_pad = draw.Point(0, 0).buffer(p.rad_o)
space = draw.Point(0, 0).buffer((p.gap + p.rad_i))
outer_pad = draw.subtract(outer_pad, space)
inner_pad = draw.Point(0, 0).buffer(p.rad_i)
#gap = draw.subtract(space, inner_pad)
#pads = draw.union(outer_pad, inner_pad)
# draw the top Josephson Junction
jj_t = draw.LineString([(0.0, p.rad_i), (0.0, p.rad_i + p.gap)])
# draw the bottom Josephson Junction
jj_b = draw.LineString([(0.0, -1.0 * p.rad_i),
(0.0, -1.0 * p.rad_i - 1.0 * p.gap)])
# draw the readout resonator
qp1a = (-0.5 * p.pocket_w, p.rad_o + p.res_s
) # the first (x,y) coordinate is qpin #1
qp1b = (p.res_ext, p.rad_o + p.res_s
) # the second (x,y) coordinate is qpin #1
rr = draw.LineString([qp1a, qp1b])
# draw the flux bias line
a = (0.5 * p.pocket_w, -0.5 * p.fbl_gap)
b = (0.5 * p.pocket_w - p.fbl_ext, -0.5 * p.fbl_gap)
c = (p.rad_o + p.fbl_sp + p.fbl_rad, -1.0 * p.fbl_rad)
d = (p.rad_o + p.fbl_sp + 0.2929 * p.fbl_rad, 0.0 - 0.7071 * p.fbl_rad)
e = (p.rad_o + p.fbl_sp, 0.0)
f = (p.rad_o + p.fbl_sp + 0.2929 * p.fbl_rad, 0.0 + 0.7071 * p.fbl_rad)
g = (p.rad_o + p.fbl_sp + p.fbl_rad, p.fbl_rad)
h = (0.5 * p.pocket_w - p.fbl_ext, 0.5 * p.fbl_gap)
i = (0.5 * p.pocket_w, 0.5 * p.fbl_gap)
fbl = draw.LineString([a, b, c, d, e, f, g, h, i])
# draw the transmon pocket bounding box
pocket = draw.rectangle(p.pocket_w, p.pocket_h)
# Translate and rotate all shapes
objects = [outer_pad, inner_pad, jj_t, jj_b, pocket, rr, fbl]
objects = draw.rotate(objects, p.orientation, origin=(0, 0))
objects = draw.translate(objects, xoff=p.pos_x, yoff=p.pos_y)
[outer_pad, inner_pad, jj_t, jj_b, pocket, rr, fbl] = objects
# define a function that both rotates and translates the qpin coordinates
def qpin_rotate_translate(x):
y = list(x)
z = [0.0, 0.0]
z[0] = y[0] * cos(p.orientation * 3.14159 / 180) - y[1] * sin(
p.orientation * 3.14159 / 180)
z[1] = y[0] * sin(p.orientation * 3.14159 / 180) + y[1] * cos(
p.orientation * 3.14159 / 180)
z[0] = z[0] + p.pos_x
z[1] = z[1] + p.pos_y
x = (z[0], z[1])
return x
# rotate and translate the qpin coordinates
qp1a = qpin_rotate_translate(qp1a)
qp1b = qpin_rotate_translate(qp1b)
a = qpin_rotate_translate(a)
b = qpin_rotate_translate(b)
h = qpin_rotate_translate(h)
i = qpin_rotate_translate(i)
##############################################################
# Use the geometry to create Metal QGeometry
geom_rr = {'path1': rr}
geom_fbl = {'path2': fbl}
geom_outer = {'poly1': outer_pad}
geom_inner = {'poly2': inner_pad}
geom_jjt = {'poly4': jj_t}
geom_jjb = {'poly5': jj_b}
geom_pocket = {'poly6': pocket}
self.add_qgeometry('path',
geom_rr,
layer=1,
subtract=False,
width=p.cpw_width)
self.add_qgeometry('path',
geom_fbl,
layer=1,
subtract=False,
width=p.cpw_width)
self.add_qgeometry('poly', geom_outer, layer=1, subtract=False)
self.add_qgeometry('poly', geom_inner, layer=1, subtract=False)
self.add_qgeometry('junction',
geom_jjt,
layer=1,
subtract=False,
width=p.inductor_width)
self.add_qgeometry('junction',
geom_jjb,
layer=1,
subtract=False,
width=p.inductor_width)
self.add_qgeometry('poly', geom_pocket, layer=1, subtract=True)
###########################################################################
# Add Qpin connections
self.add_pin('pin1',
points=np.array([qp1b, qp1a]),
width=0.01,
input_as_norm=True)
self.add_pin('pin2',
points=np.array([b, a]),
width=0.01,
input_as_norm=True)
self.add_pin('pin3',
points=np.array([h, i]),
width=0.01,
input_as_norm=True)
