def init_primitives(self):
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 "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))
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 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 init_half(self, origin, side=-1):
# side = -1 is left, 1 is right
up_st_gap = self.sq_area / (2 * self.sq_len)
low_st_gap = up_st_gap + self.low_lead_w * 2.5
up_st_start_p = self.primitives["p_ext_up"].connections[1]
low_st_start_p = self.primitives["p_ext_down"].connections[1]
up_st_start = up_st_start_p + DVector(side * up_st_gap / 2, 0)
up_st_stop = origin + DVector(side * up_st_gap / 2, self.bridge / 2)
low_st_start = low_st_start_p + DVector(side * low_st_gap / 2, 0)
low_st_stop = origin + DVector(side * (low_st_gap / 2 - self.b_ext),
-self.bridge / 2)
Z_low = CPWParameters(self.j_length, 0)
Z_low2 = CPWParameters(self.low_lead_w, 0)
len_ly = (low_st_stop - low_st_start).y - Z_low2.width / 2
len_lb = side * (low_st_start - low_st_stop).x - Z_low2.width / 2
suff = "_left" if side < 0 else "_right"
self.primitives["upp_st" + suff] = Kolbaska(up_st_start, up_st_stop,
self.j_width,
self.j_width / 4)
self.primitives["upp_st_thick" + suff] = Kolbaska(
up_st_start, up_st_stop + DPoint(0, 400), self.low_lead_w,
self.low_lead_w / 2)
self.primitives["low_st" + suff] = CPW_RL_Path(low_st_start, 'LR', Z_low2, Z_low2.width/2,\
[len_ly],[side * pi/2],trans_in = DTrans.R90)
self.primitives["low_st_jj" + suff] = CPW(Z_low.width, Z_low.gap, low_st_stop + DPoint(side * (self.b_ext - Z_low2.width/2),\
-self.j_length/2), low_st_stop + DPoint(0, -self.j_length/2))
def init_primitives(self):
origin = DPoint(0, 0)
total_neck_length = pi * self.R / 2 + self.neck if not self.no_neck else 0
meander_length = (self.len - self.cpl_L - 2 *
(1 + self.N) * pi * self.R - 3 * self.R -
total_neck_length -
self.extra_neck_length) / (2 * self.N + 3 / 2)
shape = "LRL" + self.N * "RLRL" + "RL" + ("RL"
if not self.no_neck else "")
segment_lengths = [
self.cpl_L, meander_length
] + 2 * self.N * [meander_length] + [
meander_length + 3 * self.R + self.extra_neck_length
] + ([self.neck] if not self.no_neck else [])
turn_angles = [pi] + self.N * [-pi, pi] + [-pi] + (
[-pi / 2] if not self.no_neck else [])
self.line = CPW_RL_Path(origin, shape, self.Z, self.R, segment_lengths,
turn_angles)
self.primitives['line'] = self.line
if self.open_end == None:
self.open_end = CPW(
0, self.Z.b / 2, self.line.end,
self.line.end + (DPoint(0, -self.Z.b) if not self.no_neck else
DPoint(-self.Z.b, 0)))
self.primitives['open_end'] = self.open_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_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 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_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 + DPoint(0, -forkZ.gap)
self.primitives["erased_fork_left_cpw_end"] = CPW(0, forkZ.b / 2, self.fork_y_cpw1.end, p1)
p1 = self.fork_y_cpw2.end + DPoint(0, -forkZ.gap)
self.primitives["erased_fork_right_cpw_end"] = CPW(0, forkZ.b / 2, self.fork_y_cpw2.end, p1)
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)
def init_primitives(self):
origin = DPoint(0, 0)
# draw central square
from ClassLib.Shapes import Rectangle
lb_corner = DPoint(-self.cross_width / 2, -self.cross_width / 2)
center_square = Rectangle(lb_corner, self.cross_width, self.cross_width)
self.primitives["center_square"] = center_square
""" left part of Xmon cross """
p1 = origin + DPoint(-self.cross_width / 2, 0)
p2 = p1 + DPoint(-self.side_length, 0)
self.cpw_l = CPW(self.cross_width, self.gnd_gap, p1, p2)
self.primitives["cpw_l"] = self.cpw_l
p3 = p2 + DPoint(-self.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.cross_width / 2, 0)
p2 = p1 + DPoint(self.side_length, 0)
self.cpw_r = CPW(self.cross_width, self.gnd_gap, p1, p2)
self.primitives["cpw_r"] = self.cpw_r
p3 = p2 + DPoint(self.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.cross_width / 2)
p2 = p1 + DPoint(0, self.side_length)
self.cpw_t = CPW(self.cross_width, self.gnd_gap, p1, p2)
self.primitives["cpw_t"] = self.cpw_t
p3 = p2 + DPoint(0, self.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.cross_width / 2)
p2 = p1 + DPoint(0, -self.side_length)
self.cpw_b = CPW(self.cross_width, self.gnd_gap, p1, p2)
self.primitives["cpw_b"] = self.cpw_b
p3 = p2 + DPoint(0, -self.gnd_gap)
self.cpw_bempt = CPW(0, self.cpw_l.b / 2, p2, p3)
self.primitives["cpw_bempt"] = self.cpw_bempt
self.connections = [origin]
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]
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.dy
p1 = DPoint(0, y)
p2 = DPoint(CHIP.dx, y)
Z0 = CPW(CHIP.cpw_width, CHIP.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
# resonator
# corresponding to resonanse freq is somewhere near 5 GHz
# resonator
L_coupling = 350e3
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L0 = 1700e3
L1_list = [1e3 * x for x in [106.795, 102.268, 97.8285, 93.4743, 89.2028]]
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 = 6
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
# setting layout view
lv.select_cell(cell.cell_index(), 0)
lv.add_missing_layers()
### 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)
print(cpw.dr)
bridges_step = 50e3
Bridge1.bridgify_CPW(cpw,
bridges_step,
cell=cell,
bridge_layer1=layer_photo1_bridges,
bridge_layer2=layer_photo2_bridges)
lv.zoom_fit()
### DRAWING SECTION END ###
# 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)
trans_in=Trans.R270)
cpwrl_ro.place(tmp_reg)
# resonators parameters
L_coupling_list = [1e3 * x for x in [255, 250, 250, 240, 230]]
# corresponding to resonanse freq is linspaced in interval [6,9) GHz
L0 = 1600e3
L1_list = [1e3 * x for x in [37.7039, 67.6553, 90.925, 81.5881, 39.9021]]
r = 60e3
N = 5
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_width = 60e3
cross_len = 125e3
cross_gnd_gap = 20e3
xmon_x_distance = 393e3 # from simulation of g_12
# 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
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
Z_res = CPW(width_res, gap_res)
# fork at the end of resonator parameters
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 = 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
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]
# 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]
gnd_width = 35e3
N = 7
width_res = 10e3
gap_res = 10e3
to_line = 45e3
# 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