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