예제 #1
0
    def init_primitives(self):
        origin = DPoint(0, 0)
        pars = self.params
        up_pad_center = origin + DVector(0, pars.pads_distance / 2)
        down_pad_center = origin + DVector(0, -pars.pads_distance / 2)
        self.pad_down = Circle(down_pad_center,
                               pars.pad_r,
                               n_pts=pars.n,
                               offset_angle=pi / 2)
        self.primitives["pad_down"] = self.pad_down

        self.p_ext_down = Kolbaska(down_pad_center,
                                   origin + DPoint(0, -pars.sq_len / 2),
                                   pars.p_ext_width, pars.p_ext_r)
        self.primitives["p_ext_down"] = self.p_ext_down

        self.pad_up = Circle(up_pad_center,
                             pars.pad_r,
                             n_pts=pars.n,
                             offset_angle=-pi / 2)
        self.primitives["pad_up"] = self.pad_up

        self.p_ext_up = Kolbaska(up_pad_center,
                                 origin + DVector(0, pars.sq_len / 2),
                                 pars.p_ext_width, pars.p_ext_r)
        self.primitives["p_ext_up"] = self.p_ext_up

        origin = DPoint(0, 0)
        if self.side == 0:
            self.init_half(origin, side=1)  # right
            self.init_half(origin, side=-1)  # left
        else:
            self.init_half(origin, side=self.side)
예제 #2
0
    def draw(self):
        origin = DPoint(0, 0)
        circ = Circle(origin, 200e3, n_pts=400, inverse=False)
        circ.place(self.region_ph)

        self.region_ph = split_polygons(self.region_ph.dup(),
                                        max_pts=100,
                                        print_tree=True)
        print("it's ok")
예제 #3
0
    def draw_el_dc_contacts(self):
        for squid in self.squids:
            r_pad = squid.params.pad_r
            center_up = squid.pad_up.center + DPoint(0, r_pad)
            center_down = squid.pad_down.center + DPoint(0, -r_pad)
            self.el_dc_contacts.append(
                [Circle(center_up, 2 * r_pad),
                 Circle(center_down, 2 * r_pad)])

            for contact in self.el_dc_contacts[-1]:
                contact.place(self.region_el2)
예제 #4
0
    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]
예제 #5
0
	def draw_el_dc_contacts(self, squids: AsymSquid = None):
		# if argument is omitted, use all squids stored in `self.squids`
		if squids is None:
			squids = self.squids + self.test_squids

		for squid in squids:
			r_pad = squid.params.pad_r
			center_up = squid.pad_up.center + DPoint(0, r_pad)
			center_down = squid.pad_down.center + DPoint(0, -r_pad)
			big_circle_r = 1.5 * r_pad
			self.el_dc_contacts.append(
				[Circle(center_up, big_circle_r), Circle(center_down, big_circle_r)]
			)
			for contact in self.el_dc_contacts[-1]:
				contact.place(self.region_el2)

			# DC contacts has to have intersection with empty layer in photo litography
			# 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.
			squid_pad_r = squid.params.pad_r
			squid_pads_d = squid.params.pads_distance - 2 * squid_pad_r
			rec_width = 1.6 * squid_pad_r - 2 * FABRICATION.OVERETCHING
			rec_height = 1.6 * squid_pad_r - FABRICATION.OVERETCHING
			# Rectangle for top DC contact pad
			p1 = squid.origin + DVector(-rec_width / 2, squid_pads_d / 2) + \
				 DVector(0, -FABRICATION.OVERETCHING)
			rec_top = Rectangle(p1, rec_width, rec_height, inverse=True)
			rec_top.place(self.region_ph)

			# Rectangle for bottom DC contact pad
			p2 = squid.origin + DVector(-rec_width / 2, -squid_pads_d / 2) + \
				 DVector(0, FABRICATION.OVERETCHING)
			rec_bot = Rectangle(p2, rec_width, -rec_height, inverse=True)
			rec_bot.place(self.region_ph)
예제 #6
0
 def init_primitives(self):
     origin = DPoint(0, 0)
     self.primitives["empty_ring1"] = Ring(origin, self.ring1_outer_r, self.ring1_thickness, inverse=True)
     self.primitives["empty_ring2"] = Ring(origin, self.ring2_outer_r, self.ring2_thickness, inverse=True)
     self.primitives["inner_circle"] = Circle(origin, self.inner_circle_radius, inverse=True)
     self.primitives["trap_top"] = IsoTrapezoid(
         origin + DPoint(-self.trap_b / 2, self.trap_dist),
         self.trap_h, self.trap_b, self.trap_t
     )
     self.primitives["trap_left"] = IsoTrapezoid(
         origin + DPoint(-self.trap_dist, -self.trap_b / 2),
         self.trap_h, self.trap_b, self.trap_t, trans_in=Trans.R90
     )
     self.primitives["trap_bottom"] = IsoTrapezoid(
         origin + DPoint(self.trap_b / 2, -self.trap_dist),
         self.trap_h, self.trap_b, self.trap_t, trans_in=Trans.R180
     )
     self.primitives["trap_right"] = IsoTrapezoid(
         origin + DPoint(self.trap_dist, self.trap_b / 2),
         self.trap_h, self.trap_b, self.trap_t, trans_in=Trans.R270
     )
     self.primitives["cross"] = Cross2(origin, self.cross_thickness, self.cross_size)
예제 #7
0
 def draw(self):
     origin = DPoint(0, 0)
     circ = Circle(origin, 200e3, n_pts=2000, inverse=False)
     circ.place(self.region_ph)
예제 #8
0
    def init_ph_el_conn_pads(self, leg_side=0):
        ''' draw top contact pad '''
        origin = DPoint(0, 0)
        pars = self.params
        top_pad_center = origin + DVector(0, pars.pads_distance / 2)
        self.pad_top = Circle(top_pad_center,
                              pars.pad_r,
                              n_pts=pars.n,
                              offset_angle=np.pi / 2)
        self.primitives["pad_top"] = self.pad_top

        self.top_ph_el_conn_pad = DPathCL(
            pts=[top_pad_center, origin + DPoint(0, pars.sq_dy / 2)],
            width=pars.contact_pad_width)
        self.primitives["top_ph_el_conn_pad"] = self.top_ph_el_conn_pad
        ''' draw bottom DC flux line '''
        if leg_side == 1 or leg_side == 0:
            # print(self.bot_inter_lead_dx)
            self.bot_dc_flux_line_right = CPWRLPath(
                origin=origin + DPoint(
                    pars.flux_line_dx / 2,
                    -(pars.sq_dy / 4 + pars.flux_line_dy) -
                    pars.flux_line_outer_width / 2),
                shape="LRL",
                cpw_parameters=[
                    CPWParameters(width=pars.flux_line_contact_width, gap=0),
                    CPWParameters(smoothing=True),
                    CPWParameters(width=pars.flux_line_outer_width, gap=0)
                ],
                turn_radiuses=max(pars.flux_line_outer_width,
                                  pars.flux_line_contact_width),
                segment_lengths=[
                    pars.flux_line_dy + pars.flux_line_outer_width,
                    pars.flux_line_dx / 2 - self.bot_inter_lead_dx
                ],
                turn_angles=[np.pi / 2],
                trans_in=Trans.R90)
            self.primitives["bot_dc_flux_line_right"] = \
                self.bot_dc_flux_line_right
        if leg_side == 0 or leg_side == -1:
            self.bot_dc_flux_line_left = CPWRLPath(
                origin=origin + DPoint(
                    -pars.flux_line_dx / 2,
                    -(pars.sq_dy / 4 + pars.flux_line_dy) -
                    pars.flux_line_outer_width / 2),
                shape="LRL",
                cpw_parameters=[
                    CPWParameters(width=pars.flux_line_contact_width, gap=0),
                    CPWParameters(smoothing=True),
                    CPWParameters(width=pars.flux_line_outer_width, gap=0)
                ],
                turn_radiuses=max(pars.flux_line_outer_width,
                                  pars.flux_line_contact_width),
                segment_lengths=[
                    pars.flux_line_dy + pars.flux_line_outer_width,
                    pars.flux_line_dx / 2 - self.bot_inter_lead_dx
                ],
                turn_angles=[-np.pi / 2],
                trans_in=Trans.R90)
            self.primitives["bot_dc_flux_line_left"] = \
                self.bot_dc_flux_line_left