def init_primitives(self): origin = DPoint(0, 0) transition_end = origin + DPoint(self.transition_length, 0) alpha = self.z0_cpw.angle_connections[1] self.transition_cpw2cpw = CPW2CPW( self.z0_cpw, self.z1_params, origin, transition_end, trans_in=DCplxTrans(1, degrees(alpha), False, 0, 0) ) self.primitives["transition_cpw2cpw"] = self.transition_cpw2cpw z1_cpw_end = self.transition_cpw2cpw.end + DPoint(self.z1_length, 0) self.z1_cpw = CPW(cpw_params=self.z1_params, start=self.transition_cpw2cpw.end, end=z1_cpw_end, trans_in=DCplxTrans(1, degrees(alpha), False, 0, 0)) self.primitives["z1_cpw"] = self.z1_cpw # open-ended self.z1_cpw_open_end = CPW( 0, gap=self.z1_params.b / 2, start=self.z1_cpw.end, end=self.z1_cpw.end + DPoint(self.z1_params.b / 2, 0), trans_in=DCplxTrans(1, degrees(alpha), False, 0, 0) ) self.primitives["z1_cpw_open_end"] = self.z1_cpw_open_end self.connections = [self.transition_cpw2cpw.start, self.z1_cpw.end]
def init_primitives(self):
center = DPoint(0, 0)
self.empty_circle = Circle(center, self.ring1_outer_r + self.ring1_thickness, inverse=True)
self.primitives["empty_circle"] = self.empty_circle
# outer ring
self.ring1 = Ring(center, self.ring1_outer_r, self.ring1_thickness)
self.primitives["ring1"] = self.ring1
# inner ring
self.ring2 = Ring(center, self.ring2_outer_r, self.ring2_thickness)
self.primitives["ring2"] = self.ring2
## four aim lines ##
center_shift = self.aim_lines_width/3
line_length = self.ring1_outer_r - self.ring1_thickness/2 - center_shift
# left horizontal line
p1 = center + DPoint(-center_shift, 0)
p2 = p1 + DPoint(-line_length, 0)
self.left_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["left_aim_line"] = self.left_aim_line
# bottom vertical line
p1 = center + DPoint(0, -center_shift)
p2 = p1 + DPoint(0, -line_length)
self.bottom_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["bottom_aim_line"] = self.bottom_aim_line
# right horizontal line
p1 = center + DPoint(center_shift, 0)
p2 = p1 + DPoint(line_length, 0)
self.right_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["right_aim_line"] = self.right_aim_line
# top vertical line
p1 = center + DPoint(0, center_shift)
p2 = p1 + DPoint(0, line_length)
self.top_aim_line = CPW(self.aim_lines_width, 0, p1, p2)
self.primitives["top_aim_line"] = self.top_aim_line
# center romb for better aiming
self.center_romb = Rectangle(
center,
self.aim_lines_width, self.aim_lines_width,
trans_in=DCplxTrans(1, 45, False, -self.aim_lines_width/2, -self.aim_lines_width/2),
inverse=True
)
self.primitives["center_romb"] = self.center_romb
self.connections = [center]
def init_primitives(self):
origin = DPoint(0, 0)
self.c_wave = CWave(origin, self.r_out, self.dr, self.n_semiwaves, self.s, self.alpha, self.r_curve,
n_pts=self.n_pts_cwave)
self.primitives["c_wave"] = self.c_wave
Z1_start = origin + DPoint(0, self.r_in + self.gap1 + self.width1 / 2)
Z1_end = Z1_start + DPoint(0, -self.gap1 - self.width1 / 2 + self.dr)
self.cpw1 = CPW(self.Z1.width, self.Z1.gap, Z1_start, Z1_end)
self.primitives["cpw1"] = self.cpw1
Z2_start = origin - DPoint(0, self.r_in + self.gap2 + self.width2 / 2)
Z2_end = Z2_start - DPoint(0, -self.gap2 - self.width2 / 2 + self.dr)
self.cpw2 = CPW(self.Z2.width, self.Z2.gap, Z2_start, Z2_end)
self.primitives["cpw2"] = self.cpw2
if isinstance(self.params, dict):
self.c_wave_2_cpw_adapter = CWave2CPW(self.c_wave, self.params, n_pts=self.n_pts_arcs)
else:
# not recommended
self.c_wave_2_cpw_adapter = CWave2CPW(self.c_wave, self.params[7:15], n_pts=self.n_pts_arcs)
self.primitives["c_wave_2_cpw_adapter"] = self.c_wave_2_cpw_adapter
p_squid = None
squid_trans_in = None
if not self.squid_pos:
if (self.c_wave.n_segments % 2 == 1):
squid_trans_in = DCplxTrans(1, -self.c_wave.alpha * 180 / pi, False, 0, 0)
p_squid = origin
else:
squid_trans_in = None
second_parity = self.c_wave.n_segments / 2
y_shift = self.c_wave.L0 * sin(self.c_wave.alpha) - self.c_wave.r_curve * (
1 / cos(self.c_wave.alpha) - 1)
if (second_parity % 2 == 0):
p_squid = origin + DPoint(0, y_shift)
else:
p_squid = origin + DPoint(0, -y_shift)
else:
squid_trans_in = None
p_squid = origin - DPoint(self.squid_pos * (self.r_out - 1.8 * self.dr), 0)
self.squid = AsymSquid( p_squid, self.squid_params, trans_in=squid_trans_in )
self.primitives["qubit"] = self.squid
self.connections = [Z1_end, Z2_end]
self.angle_connections = [pi / 2, 3 / 2 * pi]
def draw_inductor_for_fl_line(design, fl_line_idx):
cpwrl_fl = self.cpw_fl_lines[fl_line_idx]
cpwrl_fl_inductor_start = cpwrl_fl.end + \
DVector(0, -design.current_line_width / 2)
cpwrl_fl_inductor = CPW(
cpw_params=CPWParameters(width=design.current_line_width, gap=0),
start=cpwrl_fl_inductor_start,
end=cpwrl_fl_inductor_start +
DVector(2 * abs(design.flux_lines_x_shifts[fl_line_idx]), 0))
cpwrl_fl_inductor.place(design.region_ph)
cpwrl_fl_inductor_empty_box = Rectangle(
origin=cpwrl_fl.end +
DVector(0, -design.current_line_width - 2 * design.z_md_fl.gap),
width=cpwrl_fl_inductor.dr.abs(),
height=2 * design.z_md_fl.gap,
inverse=True)
cpwrl_fl_inductor_empty_box.place(design.region_ph)
def init_primitives(self):
L = abs(abs(self.dr.y) - abs(self.dr.x))
r = min(abs(self.dr.y), abs(self.dr.x))
if (abs(self.dr.y) > abs(self.dr.x)):
self.arc1 = CPW_arc(self.Z0, DPoint(0, 0), copysign(
r, self.dr.y), copysign(pi / 2, self.dr.x * self.dr.y))
self.cop1 = CPW(self.Z0.width, self.Z0.gap, self.arc1.end,
self.arc1.end + DPoint(0, copysign(L, self.dr.y)))
self.connections = [self.arc1.start, self.cop1.end]
self.angle_connections = [self.arc1.alpha_start, self.cop1.alpha_end]
else:
self.cop1 = CPW(self.Z0.width, self.Z0.gap, DPoint(
0, 0), DPoint(0, 0) + DPoint(copysign(L, self.dr.x), 0))
self.arc1 = CPW_arc(self.Z0, self.cop1.end, copysign(
r, self.dr.y), copysign(pi / 2, self.dr.y * self.dr.x))
self.connections = [self.cop1.start, self.arc1.end]
self.angle_connections = [self.cop1.alpha_start, self.arc1.alpha_end]
self.primitives = {"arc1": self.arc1, "cop1": self.cop1}
def init_primitives(self):
self.arc1 = CPW_arc(self.Z0, DPoint(0, 0), -self.r, pi / 2)
self.primitives["arc1"] = self.arc1
p1 = self.arc1.end
p2 = self.arc1.end + DPoint(0, -self.L0)
self.cop_end_open = CPW(start=p1, end=p2, cpw_params=self.Z0)
# open end tail face is separated from ground by `b = width + 2*gap`
self.cop_end_open_gap = CPW(
0, self.Z0.b / 2, self.cop_end_open.end,
self.cop_end_open.end - DPoint(0, self.Z0.b))
self.primitives["cpw_hor_end_open"] = self.cop_end_open
self.primitives["cop_end_open_gap"] = self.cop_end_open_gap
# making coil
name = "coil0"
setattr(
self, name,
Coil_type_1(self.Z0, DPoint(0, 0), self.L_coupling, self.r,
self.L1))
self.primitives[name] = getattr(self, name)
# coils filling
for i in range(self.N):
name = "coil" + str(i + 1)
setattr(
self, name,
Coil_type_1(
self.Z0,
DPoint(-self.L1 + self.L_coupling,
-(i + 1) * (4 * self.r)), self.L1, self.r, self.L1))
self.primitives[name] = getattr(self, name)
# draw the shorted "tail"
self.arc_end_shorted = CPW_arc(
self.Z0, self.primitives["coil" + str(self.N)].end, -self.L1 / 2,
-pi / 2)
self.cop_end_shoted = CPW(
self.Z0.width, self.Z0.gap, self.arc_end_shorted.end,
self.arc_end_shorted.end - DPoint(0, self.L2))
self.primitives["arc_end_shorted"] = self.arc_end_shorted
self.primitives["cop_end_shoted"] = self.cop_end_shoted
self.connections = [DPoint(0, 0), self.cop_end_open.end]
self.angle_connections = [0, self.cop_end_open.alpha_end]
def draw_fork_along_x(self):
forkZ = CPW(self.fork_metal_width, self.fork_gnd_gap)
p1 = self.cop_tail.end + DPoint(-self.fork_x_span / 2, -forkZ.b / 2)
p2 = p1 + DPoint(self.fork_x_span, 0)
self.fork_x_cpw = CPW(forkZ.width, forkZ.gap, p1, p2)
self.primitives["fork_x_cpw"] = self.fork_x_cpw
# return waveguide that was erased during ground drawing
p3 = self.cop_tail.end + DPoint(0, -forkZ.gap)
erased_cpw = CPW(self.Z0.width, self.Z0.gap, self.cop_tail.end, p3)
self.primitives["erased_cpw"] = erased_cpw
# erase additional spaces at the ends of fork_x_cpw
p1 = self.fork_x_cpw.start + DPoint(-forkZ.gap, 0)
self.primitives["erased_fork_left"] = CPW(0, forkZ.b / 2,
self.fork_x_cpw.start, p1)
p1 = self.fork_x_cpw.end + DPoint(forkZ.gap, 0)
self.primitives["erased_fork_right"] = CPW(0, forkZ.b / 2,
self.fork_x_cpw.end, p1)
def init_primitives(self): self.arc1 = CPW_arc(self.Z0, DPoint(0, 0), -self.r, pi / 2) self.primitives["arc1"] = self.arc1 p1 = self.arc1.end p2 = self.arc1.end + DPoint(0, -self.L0) self.cop_vertical = CPW(start=p1, end=p2, cpw_params=self.Z0) # open end tail face is separated from ground by `b = width + 2*gap` self.primitives["cop_vertical"] = self.cop_vertical # draw the open-circuited "tail" self.cpw_end_open_RLPath = CPW_RL_Path( self.cop_vertical.end, self.tail_shape, cpw_parameters=self.Z0, turn_radiuses=self.tail_turn_radiuses, segment_lengths=self.tail_segment_lengths, turn_angles=self.tail_turn_angles, trans_in=self.tail_trans_in ) self.primitives["cpw_end_open_RLPath"] = self.cpw_end_open_RLPath self.cpw_end_open_gap = CPW( 0, self.Z0.b / 2, self.cpw_end_open_RLPath.end, self.cpw_end_open_RLPath.end - DPoint(0, self.Z0.b) ) self.primitives["cpw_end_open_gap"] = self.cpw_end_open_gap # making coil name = "coil0" setattr(self, name, Coil_type_1(self.Z0, DPoint(0, 0), self.L_coupling, self.r, self.L1)) self.primitives[name] = getattr(self, name) # coils filling for i in range(self.N): name = "coil" + str(i + 1) setattr(self, name, Coil_type_1(self.Z0, DPoint(-self.L1 + self.L_coupling, -(i + 1) * (4 * self.r)), self.L1, self.r, self.L1)) self.primitives[name] = getattr(self, name) self.connections = [DPoint(0, 0), self.cpw_end_open_RLPath.end] self.angle_connections = [0, self.cpw_end_open_RLPath.alpha_end]
def draw_fork_along_x(self): forkZ = CPW(self.fork_metal_width, self.fork_gnd_gap) p1 = self.cpw_end_open_gap.start + DPoint(-self.fork_x_span / 2, -forkZ.b / 2) p2 = p1 + DPoint(self.fork_x_span, 0) self.fork_x_cpw = CPW(forkZ.width, forkZ.gap, p1, p2) self.primitives["fork_x_cpw"] = self.fork_x_cpw # draw waveguide that was erased during `fork_x_cpw` ground erasing p1 = self.cpw_end_open_gap.start p2 = self.cpw_end_open_gap.start + DPoint(0, -forkZ.gap) erased_cpw = CPW(self.Z0.width, self.Z0.gap, p1, p2) self.primitives["erased_cpw"] = erased_cpw # erase additional spaces at the ends of fork_x_cpw p1 = self.fork_x_cpw.start p2 = self.fork_x_cpw.start + DPoint(-forkZ.gap, 0) self.primitives["erased_fork_left"] = CPW(0, forkZ.b / 2, p1, p2) p1 = self.fork_x_cpw.end p2 = self.fork_x_cpw.end + DPoint(forkZ.gap, 0) self.primitives["erased_fork_right"] = CPW(0, forkZ.b / 2, p1, p2)
class CHIP:
dx = 10.0e6
dy = 5.0e6
L1 = 2.416721e6
gap = 150e3
width = 260e3
Z = CPW(width, gap, DPoint(0, 0), DPoint(1, 1))
b = 2 * gap + width
origin = DPoint(0, 0)
box = pya.DBox(origin, origin + DPoint(dx, dy))
# only 4 connections programmed by now
connections = [box.p1 + DPoint(L1 + b / 2, 0), box.p1 + DPoint(dx - (L1 + b / 2), 0),
box.p2 - DPoint(L1 + b / 2, 0), box.p1 + DPoint(L1 + b / 2, dy)]
def draw_fork_along_y(self): forkZ = CPW(self.fork_metal_width, self.fork_gnd_gap) # draw left part p1 = self.fork_x_cpw.start + DPoint(forkZ.width / 2, -forkZ.width / 2) p2 = p1 + DPoint(0, -self.fork_y_span) self.fork_y_cpw1 = CPW(forkZ.width, forkZ.gap, p1, p2) self.primitives["fork_y_cpw1"] = self.fork_y_cpw1 # draw right part p1 = self.fork_x_cpw.end + DPoint(-forkZ.width / 2, -forkZ.width / 2) p2 = p1 + DPoint(0, -self.fork_y_span) self.fork_y_cpw2 = CPW(forkZ.width, forkZ.gap, p1, p2) self.primitives["fork_y_cpw2"] = self.fork_y_cpw2 # erase gap at the ends of `y` fork parts p1 = self.fork_y_cpw1.end p2 = self.fork_y_cpw1.end + DPoint(0, -forkZ.gap) self.primitives["erased_fork_left_cpw_end"] = CPW(0, forkZ.b / 2, p1, p2) p1 = self.fork_y_cpw2.end p2 = self.fork_y_cpw2.end + DPoint(0, -forkZ.gap) self.primitives["erased_fork_right_cpw_end"] = CPW(0, forkZ.b / 2, p1, p2)
def init_primitives(self):
origin = DPoint(0, 0)
# place metal between pad and PCB-chip edge
self.cpw_back_metal = CPW(self.pcb_cpw_params.b,
0,
start=origin,
end=origin +
DPoint(self.back_metal_length, 0))
self.primitives["cpw_back_metal"] = self.cpw_back_metal
# erase metal between previous metal structure and pad-pcb face
self.cpw_back_gap = CPW(0,
self.pcb_cpw_params.b / 2,
start=self.cpw_back_metal.end,
end=self.cpw_back_metal.end +
DPoint(self.back_metal_gap, 0))
self.primitives["cpw_back_gap"] = self.cpw_back_gap
# place PCB-matching pad
self.cpw_pcb_match = CPW(start=self.cpw_back_gap.end,
end=self.cpw_back_gap.end +
DPoint(self.pad_length, 0),
cpw_params=self.pcb_cpw_params)
self.primitives["cpw_pcb_match"] = self.cpw_pcb_match
# PCB-match to on-chip waveguide trapeziod adapter
self.cpw2cpw = CPW2CPW(self.pcb_cpw_params,
self.chip_cpw_params,
start=self.cpw_pcb_match.end,
end=self.cpw_pcb_match.end +
DPoint(self.transition_length, 0))
self.primitives["cpw2cpw"] = self.cpw2cpw
self.connections = [origin, self.cpw2cpw.end]
self.angle_connections = [0, self.cpw2cpw.alpha_end]
def init_primitives(self):
origin = DPoint(0, 0)
# draw central square
from classLib.shapes import Rectangle
lb_corner = DPoint(-self.sideX_width / 2, -self.sideY_width / 2)
center_square = Rectangle(lb_corner, self.sideX_width, self.sideY_width)
self.primitives["center_square"] = center_square
""" left part of Xmon cross """
p1 = origin + DPoint(-self.sideY_width / 2, 0)
p2 = p1 + DPoint(-self.sideX_length, 0)
self.cpw_l = CPW(self.sideX_width, self.sideX_gnd_gap, p1, p2)
self.primitives["cpw_l"] = self.cpw_l
p3 = p2 + DPoint(-self.sideX_face_gnd_gap, 0)
self.cpw_lempt = CPW(0, self.cpw_l.b / 2, p2, p3)
self.primitives["cpw_lempt"] = self.cpw_lempt
""" right part of Xmon cross """
p1 = origin + DPoint(self.sideY_width / 2, 0)
p2 = p1 + DPoint(self.sideX_length, 0)
self.cpw_r = CPW(self.sideX_width, self.sideX_gnd_gap, p1, p2)
self.primitives["cpw_r"] = self.cpw_r
p3 = p2 + DPoint(self.sideX_face_gnd_gap, 0)
self.cpw_rempt = CPW(0, self.cpw_r.b / 2, p2, p3)
self.primitives["cpw_rempt"] = self.cpw_rempt
""" top part of Xmon cross """
p1 = origin + DPoint(0, self.sideX_width / 2)
p2 = p1 + DPoint(0, self.sideY_length)
self.cpw_t = CPW(self.sideY_width, self.sideY_gnd_gap, p1, p2)
self.primitives["cpw_t"] = self.cpw_t
p3 = p2 + DPoint(0, self.sideY_face_gnd_gap)
self.cpw_tempt = CPW(0, self.cpw_t.b / 2, p2, p3)
self.primitives["cpw_tempt"] = self.cpw_tempt
""" bottom part of Xmon cross """
p1 = origin + DPoint(0, -self.sideX_width / 2)
p2 = p1 + DPoint(0, -self.sideY_length)
self.cpw_b = CPW(self.sideY_width, self.sideY_gnd_gap, p1, p2)
self.primitives["cpw_b"] = self.cpw_b
p3 = p2 + DPoint(0, -self.sideY_face_gnd_gap)
self.cpw_bempt = CPW(0, self.cpw_b.b / 2, p2, p3)
self.primitives["cpw_bempt"] = self.cpw_bempt
self.connections = [origin]
def init_primitives(self):
self.arc1 = CPW_arc(self.Z0, DPoint(0, 0), -self.r, pi / 2)
self.primitives["arc1"] = self.arc1
# making coil
name = "coil0"
setattr(
self, name,
Coil_type_1(self.Z0, DPoint(0, 0), self.L_coupling, self.r,
self.L1))
self.primitives[name] = getattr(self, name)
# coils filling
for i in range(self.N):
name = "coil" + str(i + 1)
prev_coil_end = getattr(self, "coil" + str(i)).connections[-1]
setattr(
self, name,
Coil_type_1(self.Z0, prev_coil_end, self.L1, self.r, self.L1))
self.primitives[name] = getattr(self, name)
# draw the "tail"
self.arc_tail = CPW_arc(self.Z0,
self.primitives["coil" + str(self.N)].end,
-self.L1 / 2, -pi / 2)
self.cop_tail = CPW(self.Z0.width, self.Z0.gap, self.arc_tail.end,
self.arc_tail.end - DPoint(0, self.L2))
# tail face is separated from ground by `b = width + 2*gap`
self.cop_open_end = CPW(0, self.Z0.b / 2, self.cop_tail.end,
self.cop_tail.end - DPoint(0, self.Z0.b))
self.primitives["arc_tail"] = self.arc_tail
self.primitives["cop_tail"] = self.cop_tail
self.primitives["cop_open_end"] = self.cop_open_end
self.connections = [DPoint(0, 0), self.cop_tail.end]
self.angle_connections = [0, self.cop_tail.alpha_end]
def draw_el_dc_contacts(self):
test_samples_el2: List[Region] = []
test_samples_ph_cut: List[Region] = []
for squid, xmon, fl_line in zip(self.squids, self.xmons,
self.cpw_fl_lines):
# dc contact pad has to be completely
# inside union of both e-beam and photo deposed
# metal regions.
# `self.dc_cont_clearance` represents minimum distance
# from dc contact pad`s perimeter to the perimeter of the
# e-beam and photo-deposed metal perimeter.
top_rect1 = CPW(start=squid.pad_top.center,
end=squid.ph_el_conn_pad.end +
DPoint(0, self.dc_cont_clearance),
width=squid.ph_el_conn_pad.width -
2 * self.dc_cont_clearance,
gap=0)
if xmon == self.xmons[0]:
end = DPoint(squid.origin.x,
xmon.center.y - xmon.cpw_l.width / 2)
elif xmon == self.xmons[-1]:
end = DPoint(squid.origin.x,
xmon.center.y - xmon.cpw_r.width / 2)
else:
end = xmon.cpw_b.end
end += DPoint(0, self.dc_cont_clearance)
top_rect2 = CPW(start=squid.ph_el_conn_pad.start +
DPoint(0, squid.pad_top.r + self.dc_cont_ph_ext),
end=end,
width=2 * (squid.pad_top.r + self.dc_cont_ph_ext),
gap=0)
left_bottom = list(
squid.bot_dc_flux_line_left.primitives.values())[0]
bot_left_shape1 = CPW(
start=fl_line.end + DPoint(0, -self.dc_cont_clearance),
end=left_bottom.start,
width=left_bottom.width - 2 * self.dc_cont_clearance,
gap=0)
bot_left_shape2 = CPW(
start=fl_line.end + DPoint(0, -self.dc_cont_clearance),
end=left_bottom.start + DPoint(0, -self.dc_cont_ph_ext),
width=left_bottom.width + 2 * self.dc_cont_ph_ext,
gap=0)
right_bottom = list(
squid.bot_dc_flux_line_right.primitives.values())[0]
bot_right_shape1 = CPW(
start=DPoint(right_bottom.start.x, fl_line.end.y) +
DPoint(0, self.dc_cont_clearance),
end=right_bottom.start + DPoint(0, -self.dc_cont_ph_ext),
width=right_bottom.width - 2 * self.dc_cont_clearance,
gap=0)
bot_right_shape2 = CPW(
start=DPoint(right_bottom.start.x, fl_line.end.y) +
DPoint(0, -self.dc_cont_clearance),
end=right_bottom.start + DPoint(0, -self.dc_cont_ph_ext),
width=right_bottom.width + 2 * self.dc_cont_ph_ext,
gap=0)
self.el_dc_contacts.append([
top_rect1, top_rect2, bot_left_shape1, bot_left_shape2,
bot_right_shape1, bot_right_shape2
])
test_sample_reg_el2 = Region()
for contact in self.el_dc_contacts[-1]:
contact.place(self.region_el2)
contact.place(test_sample_reg_el2)
test_samples_el2.append(test_sample_reg_el2)
# DC contacts has to have intersection with empty
# layer in photo litography. This is needed in order
# to ensure that first e-beam layer does not
# broke at the step between substrate and
# photolytography polygons.
# Following rectangle pads are cutted from photo region
# to ensure DC contacts are covering aforementioned level step.
test_ph_cut = Region()
# Rectangle to cut for top DC contact pad
rec_top = CPW(start=squid.ph_el_conn_pad.start +
DPoint(0, -self.dc_cont_cut_clearance),
end=squid.ph_el_conn_pad.end,
width=0,
gap=self.dc_cont_cut_width / 2)
rec_top.place(self.region_ph)
test_ph_cut |= rec_top.empty_region
# Rectangle for bottom left DC contact pad
left_bot = CPW(
start=fl_line.end + DPoint(0, self.cross_gnd_gap_x / 6),
end=left_bottom.start + DPoint(0, self.dc_cont_cut_clearance),
width=0,
gap=self.dc_cont_cut_width / 2)
left_bot.place(self.region_ph)
test_ph_cut |= left_bot.empty_region
# Rectangle for bottom right DC contact pad
right_bot = CPW(start=DPoint(right_bottom.start.x, fl_line.end.y) +
DPoint(0, self.cross_gnd_gap_x),
end=right_bottom.start +
DPoint(0, self.dc_cont_cut_clearance),
width=0,
gap=self.dc_cont_cut_width / 2)
right_bot.place(self.region_ph)
test_ph_cut |= right_bot.empty_region
test_samples_ph_cut.append(test_ph_cut)
self.region_el2.merge()
for squid in self.test_squids:
trans = DCplxTrans(1, 0, False,
-self.squids[0].origin + squid.origin)
test_reg_el2 = test_samples_el2[0].dup().transformed(trans)
self.region_el2 |= test_reg_el2
cut_reg_ph = test_samples_ph_cut[0].dup().transformed(trans)
self.region_ph -= cut_reg_ph
# setting layout view
lv.select_cell(cell.cell_index(), 0)
lv.add_missing_layers()
## DRAWING SECTION START ##
origin = DPoint(0, 0)
# main drive line coplanar
width = 24.1e3
gap = 12.95e3
x = None
y = 0.9 * CHIP.dy
p1 = DPoint(0, y)
p2 = DPoint(CHIP.dx, y)
Z0 = CPW(width, gap, p1, p2)
# resonator
L_coupling = 200e3
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L0 = 1700e3
L1_list = [1e3 * x for x in [79.3927, 75.5225, 71.7273, 68.0048, 64.353]]
estimated_res_freqs = [5.0209, 5.0715, 5.1209, 5.1756, 5.2140] # GHz
freqs_span = 0.004 # GHz
r = 50e3
L2_list = [100e3 + 0.5 * (L1_list[0] - L1) for L1 in L1_list]
N = 7
width_res = 10e3
gap_res = 10e3
to_line = 45e3
Z_res = CPW(width_res, gap_res, origin, origin)
# setting layout view
lv.select_cell(cell.cell_index(), 0)
lv.add_missing_layers()
## DRAWING SECTION START ##
origin = DPoint(0, 0)
# main drive line coplanar
width = 24.1e3
gap = 12.95e3
x = None
y = 0.9 * CHIP.dy
p1 = DPoint(0, y)
p2 = DPoint(CHIP.dx, y)
Z0 = CPW(width, gap, p1, p2)
# resonator
# corresponding to resonanse freq is somewhere near 5 GHz
# resonator
L_coupling = 200e3
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L0 = 1700e3
L1_list = [1e3 * x for x in [79.3927, 75.5225, 71.7273, 68.0048, 64.353]]
estimated_res_freqs = [5.0209, 5.0715, 5.1209, 5.1756, 5.2140] # GHz
disp = -0.040 # GHz
estimated_res_freqs = [freq - disp for freq in estimated_res_freqs]
freqs_span = 0.080 # GHz
r = 50e3
L2_list = [100e3 + 0.5 * (L1_list[0] - L1) for L1 in L1_list]
N = 7
## DRAWING SECTION START ##
origin = DPoint(0, 0)
# resonator
L_coupling = 300e3
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L1 = 100e3
r = 100e3
L2 = 270e3
gnd_width = 35e3
N = 4
width_res = 9.6e3
gap_res = 5.2e3
to_line = 35e3
Z_res = CPW(width_res, gap_res)
# xmon cross parameters
cross_widths = 60e3
cross_lens = 60e3
cross_gnd_gaps = 20e3
cross_lens_x = 180e3
cross_widths_x = 60e3
cross_gnd_gaps_x = 20e3
cross_lens_y = 60e3
cross_widths_y = 60e3
cross_gnd_gaps_y = 20e3
xmon_resEnd_distances = [1e3 * x for x in range(1, 2)]
# resonator
# corresponding to resonanse freq is somewhere near 5 GHz
# resonator
L_coupling = 200e3
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L0 = 1700e3
L1_list = [1e3 * x for x in [79.3927, 75.5225, 71.7273, 68.0048, 64.353]]
estimated_res_freqs = [5.0209, 5.0715, 5.1209, 5.1756, 5.2140] # GHz
freqs_span = 0.004 # GHz
r = 50e3
L2_list = [100e3 + 0.5 * (L1_list[0] - L1) for L1 in L1_list]
N = 7
width_res = 20e3
gap_res = 10e3
to_line = 45e3
Z_res = CPW(width_res, gap_res, origin, origin)
# xmon cross parameters
cross_width = 60e3
cross_len = 125e3
cross_gnd_gap = 20e3
# fork at the end of resonator parameters
fork_metal_width = 20e3
fork_gnd_gap = 20e3
xmon_fork_gnd_gap = 20e3
fork_x_span = cross_width + 2 * (xmon_fork_gnd_gap + fork_metal_width)
fork_y_span = None
# Xmon-fork parameters
# -20e3 for Xmons in upper sweet-spot
# -10e3 for Xmons in lower sweet-spot
L2_2 = 0.222e6
L3_2 = 0
L4_2 = 0.3e6
L5_2 = 1e6
r1_2 = 0.709e6
r2_2 = 0.2e6
r3_2 = 0.2e6
r4_2 = 0.3e6
gamma1_2 = 0.8042477
gamma2_2 = 2.318495378
origin = DPoint(0, 0)
chip = pya.DBox(origin, DPoint(CHIP.dx, CHIP.dy))
cell.shapes(layer_i).insert(pya.Box().from_dbox(chip))
Z0 = CPW(width1, gap1, origin, origin)
Z1 = CPW(width2, gap2, origin, origin)
# bl2_params = import_bl2_params( "C:/Users/botan_000/Documents/BozonSampling/Calculator/layout2_opt_res.txt" )
# bl2_params_2 = bl2_params
# save_dir = "C:/Users/botan_000/Documents/BozonSampling/Lambda_div_4_coupler_curv/v3.0_28_03_2017/v.3.0.6/"
bl2_params = [L1, L2, L3, L4, L5, r1, r2, r3, r4, gamma1, gamma2]
bl2_params_2 = [L1_2, L2_2, L3_2, L4_2, L5_2, r1_2, r2_2, r3_2, r4_2, gamma1_2, gamma2_2]
bl_hor = BranchLine_finger2(Z1, origin, bl2_params_2)
bl_vert = BranchLine_finger2(Z0, origin, bl2_params)
tj = TJunction_112(Z0, Z1, origin)
coupler = Coupler_BranchLine(origin, bl_hor, bl_vert, tj)
coupler.make_trans(DCplxTrans(1, 0, False, (CHIP.dx - coupler.connections[2].x) / 2,
(CHIP.dy - (coupler.connections[2].y + coupler.tj_TR.Z1.b / 2)) / 2))
coupler.place(cell, layer_i)
lv.add_missing_layers()
## DRAWING SECTION START ##
chip_box = pya.Box(Point(0, 0), Point(CHIP.dx, CHIP.dy))
origin = DPoint(0, 0)
contact_L = 1e6
# main drive line coplanar
width = 24.1e3
gap = 12.95e3
x = 0.25 * CHIP.dx
y = 0.9 * CHIP.dy
p1 = DPoint(0, y)
p2 = DPoint(CHIP.dx, y)
Z0 = CPW(width, gap, p1, p2)
# resonator
L_coupling = 300e3
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L1_list = [
261653., 239550., 219456., 201109., 184291., 168819., 154536., 141312.,
129032., 117600.
]
r = 50e3
L2 = 270e3
gnd_width = 35e3
N = 4
width_res = 9.6e3
gap_res = 5.2e3
to_line = 35e3
# setting layout view
lv.select_cell(cell.cell_index(), 0)
lv.add_missing_layers()
## DRAWING SECTION START ##
origin = DPoint(0, 0)
# main drive line coplanar
width = 24.1e3
gap = 12.95e3
x = None
y = 0.9 * CHIP.dy
p1 = DPoint(0, y)
p2 = DPoint(CHIP.dx, y)
Z0 = CPW(width, gap, p1, p2)
# resonator
# corresponding to resonanse freq is somewhere near 5 GHz
# resonator
L_coupling = 200e3
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L0 = 1700e3
L1_list = [1e3 * x for x in [79.3927, 75.5225, 71.7273, 68.0048, 64.353]]
estimated_res_freqs = [5.0209, 5.0715, 5.1209, 5.1756, 5.2140] # GHz
disp = -0.040 # GHz
estimated_res_freqs = [freq - disp for freq in estimated_res_freqs]
freqs_span = 0.080 # GHz
r = 50e3
L2_list = [100e3 + 0.5 * (L1_list[0] - L1) for L1 in L1_list]
N = 7
layer_el = layout.layer( layer_info_el ) # setting layout view lv.select_cell(cell.cell_index(), 0) lv.add_missing_layers() ## DRAWING SECTION START ## origin = DPoint(0, 0) # main drive line coplanar x = None y = 0.9 * CHIP_10x10_12pads.dy p1 = DPoint(0, y) p2 = DPoint(CHIP_10x10_12pads.dx, y) Z0 = CPW(CHIP_10x10_12pads.chip_cpw_width, CHIP_10x10_12pads.cpw_gap, p1, p2) # resonator # corresponding to resonanse freq is somewhere near 5 GHz L_coupling_list = [250e3]*5 # corresponding to resonanse freq is linspaced in interval [6,9) GHz L0 = 1600e3 L1_list = [1e3 * x for x in [86.3011, 79.9939, 73.8822, 67.9571, 62.2103]] estimated_res_freqs_init = [4.932, 5.0, 5.08, 5.16, 5.24] # GHz freqs_span_corase = 1.0 # GHz freqs_span_fine = 0.005 r = 50e3 N = 7 L2_list = [0.0e3] * len(L1_list) L3 = 0 width_res = 20e3
L_coupling_list = [1e3 * x for x in [310, 320, 320, 310, 300]]
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L0 = 1150e3
L1_list = [1e3 * x for x in [50.7218, 96.3339, 138.001, 142.77, 84.9156]]
estimated_res_freqs_init = [6.5, 6.59, 6.68, 6.77, 6.86] # GHz
freqs_span_corase = 1.0 # GHz
corase_only = False
freqs_span_fine = 0.005
r = 60e3
N = 3
L2_list = [r] * len(L1_list)
L3_list = [0e3] * len(L1_list)
L4_list = [r] * len(L1_list)
width_res = 20e3
gap_res = 10e3
Z_res = CPW(width_res, gap_res, origin, origin)
# xmon cross parameters
cross_len_x = 180e3
cross_width_x = 60e3
cross_gnd_gap_x = 20e3
cross_len_y = 155e3
cross_width_y = 60e3
cross_gnd_gap_y = 20e3
xmon_x_distance = 545e3
# fork at the end of resonator parameters
fork_metal_width = 20e3
fork_gnd_gap = 10e3
xmon_fork_gnd_gap = 25e3
fork_x_span = cross_width_x + 2 * (xmon_fork_gnd_gap + fork_metal_width)
### DRAWING SECTION START ###
# drawing chip
cell.shapes(layer_photo2_bridges).insert(CHIP.box)
cell.shapes(layer_photo).insert(CHIP.box)
origin = DPoint(CHIP.dx / 2, CHIP.dy / 2)
bridge = Bridge1(origin)
bridge.place(cell, layer_photo1_bridges, "bridges_1")
bridge.place(cell, layer_photo2_bridges, "bridges_2")
p1 = DPoint(1 / 4 * CHIP.dx, CHIP.dy / 5)
p2 = DPoint(3 / 4 * CHIP.dx, CHIP.dy / 4)
width = 20e3
gap = 10e3
cpw = CPW(width, gap, p1, p2)
cpw.place(cell, layer_photo)
bridges_step = 50e3
Bridge1.bridgify_CPW(cpw,
bridges_step,
cell=cell,
bridge_layer1=layer_photo1_bridges,
bridge_layer2=layer_photo2_bridges)
z2 = CPWParameters(width, gap)
cpw2 = CPW_RL_Path(DPoint(400e3, 400e3), "LRLRL", z2, 60e3, 100e3,
[pi / 4, pi / 3])
cpw2.place(cell, layer_photo)
Bridge1.bridgify_CPW(cpw2,
bridges_step,
cell=cell,
bridge_layer1=layer_photo1_bridges,
def init_primitives(self):
# introducing shorthands for long-named variables
origin = DPoint(0, 0)
pars = self.squid_params
# (TC) Top contact polygon
tc_p1 = DPoint(
0, pars.squid_dy / 2 + pars.SQT_dy + pars.TCW_dy + pars.TC_dy)
tc_p2 = tc_p1 + DVector(0, -pars.TC_dy)
self.TC = CPW(start=tc_p1, end=tc_p2, width=pars.TC_dx, gap=0)
self.primitives["TC"] = self.TC
# (TCW) Top contact wire
tcw_p1 = self.TC.end
tcw_p2 = tcw_p1 + DVector(0, -pars.TCW_dy)
self.TCW = CPW(start=tcw_p1, end=tcw_p2, width=pars.TCW_dx, gap=0)
self.primitives["TCW"] = self.TCW
# (SQT) squid loop top
sqt_p1 = origin + DVector(-pars.SQT_dx / 2,
pars.squid_dy / 2 + pars.SQT_dy / 2)
sqt_p2 = sqt_p1 + DVector(pars.SQT_dx, 0)
self.SQT = CPW(start=sqt_p1, end=sqt_p2, width=pars.SQT_dy, gap=0)
self.primitives["SQT"] = self.SQT
# (SQLTT) squid loop left top thick
sqltt_p1 = self.SQT.start + DVector(pars.SQLTT_dx / 2,
-pars.SQT_dy / 2)
sqltt_p2 = sqltt_p1 + DVector(0, -pars.SQLTT_dy)
self.SQLTT = CPW(start=sqltt_p1,
end=sqltt_p2,
width=pars.SQLTT_dx,
gap=0)
self.primitives["SQLTT"] = self.SQLTT
# (SQLTJJ) squid loop left top JJ
sqltjj_p1 = self.SQLTT.end
sqltjj_p2 = sqltjj_p1 + DVector(0, -pars.SQLTJJ_dy)
self.SQLTJJ = CPW(start=sqltjj_p1,
end=sqltjj_p2,
width=pars.SQLTJJ_dx,
gap=0)
self.primitives["SQLTJJ"] = self.SQLTJJ
# (SQB) squid bottom
sqb_p1 = origin + DVector(-pars.squid_dx / 2 - pars.SQLBT_dx,
-pars.squid_dy / 2 - pars.SQB_dy / 2)
sqb_p2 = sqb_p1 + DVector(
pars.squid_dx + pars.SQLBT_dx + pars.SQRBT_dx, 0)
self.SQB = CPW(start=sqb_p1, end=sqb_p2, width=pars.SQB_dy, gap=0)
self.primitives["SQB"] = self.SQB
# (SQLBT) squid left bottom thick
sqlbt_p1 = self.SQB.start + \
DVector(pars.SQLBT_dx / 2, pars.SQB_dy / 2) + \
DVector(0, pars.SQLBT_dy)
sqlbt_p2 = sqlbt_p1 + DVector(0, -pars.SQLBT_dy)
self.SQLBT = CPW(start=sqlbt_p1,
end=sqlbt_p2,
width=pars.SQLBT_dx,
gap=0)
self.primitives["SQLBT"] = self.SQLBT
# (SQLBJJ) squid left botton JJ
if ((pars.SQLBT_dx / 2 + pars.SQLBJJ_dx + pars.SQLTJJ_dx) < pars.JJC):
raise Warning("please, increase SQLBJJ_dy is too low")
sqlbjj_p1 = self.SQLBT.start + DVector(pars.SQLBT_dx / 2,
-pars.SQLBJJ_dy / 2)
sqlbjj_p2 = sqlbjj_p1 + DVector(pars.SQLBJJ_dx, 0)
self.SQLBJJ = CPW(start=sqlbjj_p1,
end=sqlbjj_p2,
width=pars.SQLBJJ_dy,
gap=0)
self.primitives["SQLBJJ"] = self.SQLBJJ
# (SQRTT) squid loop right top thick
sqrtt_p1 = self.SQT.end + DVector(-pars.SQRTT_dx / 2, -pars.SQT_dy / 2)
sqrtt_p2 = sqrtt_p1 + DVector(0, -pars.SQRTT_dy)
self.SQRTT = CPW(start=sqrtt_p1,
end=sqrtt_p2,
width=pars.SQRTT_dx,
gap=0)
self.primitives["SQRTT"] = self.SQRTT
# (SQRTJJ) squid loop right top JJ
sqrtjj_p1 = self.SQRTT.end
sqrtjj_p2 = sqrtjj_p1 + DVector(0, -pars.SQRTJJ_dy)
self.SQRTJJ = CPW(start=sqrtjj_p1,
end=sqrtjj_p2,
width=pars.SQRTJJ_dx,
gap=0)
self.primitives["SQRTJJ"] = self.SQRTJJ
# (SQRBT) squid right bottom thick
sqrbt_p1 = self.SQB.end + \
DVector(-pars.SQRBT_dx / 2, pars.SQB_dy / 2) + \
DVector(0, pars.SQRBT_dy)
sqrbt_p2 = sqrbt_p1 + DVector(0, -pars.SQRBT_dy)
self.SQRBT = CPW(start=sqrbt_p1,
end=sqrbt_p2,
width=pars.SQRBT_dx,
gap=0)
self.primitives["SQRBT"] = self.SQRBT
# (SQRBJJ) squid right botton JJ
if ((pars.SQRBT_dx / 2 + pars.SQRBJJ_dx + pars.SQRTJJ_dx) < pars.JJC):
raise Warning("please, increase SQLBJJ_dy is too low")
sqrbjj_p1 = self.SQRBT.start + DVector(-pars.SQRBT_dx / 2,
-pars.SQRBJJ_dy / 2)
sqrbjj_p2 = sqrbjj_p1 + DVector(-pars.SQRBJJ_dx, 0)
self.SQRBJJ = CPW(start=sqrbjj_p1,
end=sqrbjj_p2,
width=pars.SQRBJJ_dy,
gap=0)
self.primitives["SQRBJJ"] = self.SQRBJJ
''' following code can enclude multiple bottom connections '''
if isinstance(pars.bot_wire_x, list):
pass
else:
pars.bot_wire_x = [pars.bot_wire_x]
for i, x in enumerate(pars.bot_wire_x):
# (BC) bottom contact polygon
bc_p1 = DPoint(x, -pars.squid_dy / 2 - pars.BCW_dy)
bc_p2 = bc_p1 + DVector(0, -pars.BC_dy)
name = "BC" + str(i)
setattr(self, name,
CPW(start=bc_p1, end=bc_p2, width=pars.BC_dx, gap=0))
self.primitives[name] = getattr(self, name)
# (BCW) Bottom contact wire
bcw_p1 = getattr(self, "BC"+str(i)).start + \
DVector(0, pars.BCW_dy)
bcw_p2 = bcw_p1 + DVector(0, -pars.BCW_dy)
name = "BCW" + str(i)
setattr(self, name,
CPW(start=bcw_p1, end=bcw_p2, width=pars.BCW_dx, gap=0))
self.primitives[name] = getattr(self, name)
# (BCE) bottom contact extension
if x < (-pars.SQB_dx / 2 + pars.BCW_dx / 2):
bce_p1 = getattr(self, "BCW"+str(i)).start + \
DVector(-pars.BCW_dx/2, pars.SQB_dy/2)
bce_p2 = self.SQB.start
elif x > (pars.SQB_dx / 2 - pars.BCW_dx / 2):
bce_p1 = getattr(self, "BCW" + str(i)).start + \
DVector(pars.BCW_dx / 2, pars.SQB_dy / 2)
bce_p2 = self.SQB.end
else:
continue
name = "BCE" + str(i)
setattr(self, name,
CPW(start=bce_p1, end=bce_p2, width=pars.SQB_dy, gap=0))
self.primitives[name] = getattr(self, name)
