def create_modules(self): """ create module """ self.replica_bitcell = self.mod_replica_bitcell() self.add_mod(self.replica_bitcell) # This is the replica bitline load column that is the same height as our array self.bitline_load = bitcell_array(name="bitline_load", cols=1, rows=self.rows) self.add_mod(self.bitline_load) # FIXME: This just creates 3 1x inverters self.delay_chain = self.mod_delay_chain("delay_chain", [1, 1, 1]) self.add_mod(self.delay_chain) self.inv = pinv(name="RBL_inv", nmos_width=drc["minwidth_tx"]) self.add_mod(self.inv) # These aren't for instantiating, but we use them to get the dimensions self.poly_contact = contact(layer_stack=("poly", "contact", "metal1")) self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) self.m2m3_via = contact(layer_stack=("metal2", "via2", "metal3")) self.nor = nor_2(name="replica_bitline_nor2", nmos_width=drc["minwidth_tx"]) self.add_mod(self.nor) self.access_tx = ptx(width=drc["minwidth_tx"], mults=1, tx_type="pmos") self.add_mod(self.access_tx)
def main(): src = img_read() print("name: {}\n".format(src.name)) # img_show('-FACE- continue = (Press eny key)', cv.resize(src.img, (540, 720))) # 中心判定 detection(src) # 調節 adjustment(src) # コンタクト貼り付け contact(src) key = img_show( '-RESULT- save = (Press < s >), end = (Press other key)', cv.resize(src.result, (540, 720))) if key == ord('s') or key == ord('S'): cv.imwrite("result_" + src.name + ".jpg", src.result) print("\n保存しました") cv.destroyAllWindows()
def runTest(self): globals.init_openram("config_20_{0}".format(OPTS.tech_name)) OPTS.check_lvsdrc = False import contact for layer_stack in [("poly", "contact", "metal1"), ("metal1", "via1", "metal2")]: stack_name = ":".join(map(str, layer_stack)) # Check single 1 x 1 contact" debug.info(2, "1 x 1 {} test".format(stack_name)) c = contact.contact(layer_stack, (1, 1)) self.local_check(c) # check vertical array with one in the middle and two ends debug.info(2, "1 x 3 {} test".format(stack_name)) c = contact.contact(layer_stack, (1, 3)) self.local_check(c) # check horizontal array with one in the middle and two ends debug.info(2, "3 x 1 {} test".format(stack_name)) c = contact.contact(layer_stack, (3, 1)) self.local_check(c) # check 3x3 array for all possible neighbors debug.info(2, "3 x 3 {} test".format(stack_name)) c = contact.contact(layer_stack, (3, 3)) self.local_check(c) OPTS.check_lvsdrc = True globals.end_openram()
def setup_layout_constants(self): """ Pre-compute some handy layout parameters. """ poly_contact = contact.contact(("poly", "contact", "metal1")) m1m2_via = contact.contact(("metal1", "via1", "metal2")) m2m3_via = contact.contact(("metal2", "via2", "metal3")) # metal spacing to allow contacts on any layer self.input_spacing = max( self.poly_space + poly_contact.first_layer_width, self.m1_space + m1m2_via.first_layer_width, self.m2_space + m2m3_via.first_layer_width, self.m3_space + m2m3_via.second_layer_width) # Compute the other pmos2 location, but determining offset to overlap the # source and drain pins self.overlap_offset = self.pmos.get_pin("D").ll() - self.pmos.get_pin( "S").ll() # Two PMOS devices and a well contact. Separation between each. # Enclosure space on the sides. self.well_width = 2*self.pmos.active_width + self.pmos.active_contact.width \ + 2*drc["active_to_body_active"] + 2*drc["well_enclosure_active"] self.width = self.well_width # Height is an input parameter, so it is not recomputed. # This is the extra space needed to ensure DRC rules to the active contacts extra_contact_space = max(-self.nmos.get_pin("D").by(), 0) # This is a poly-to-poly of a flipped cell self.top_bottom_space = max( 0.5 * self.m1_width + self.m1_space + extra_contact_space, drc["poly_extend_active"], self.poly_space)
def create_layout(self): """Calls all functions related to the generation of the layout(gds)""" # These aren't for instantiating, but we use them to get the dimensions self.poly_contact = contact.contact(("poly", "contact", "metal1")) self.m1m2_via = contact.contact(("metal1", "via1", "metal2")) self.determine_tx_mults() self.create_ptx() self.setup_layout_constants() self.add_rails() self.add_ptx() # These aren't for instantiating, but we use them to get the dimensions self.nwell_contact = contact.contact( layer_stack=("active", "contact", "metal1"), dimensions=(1, self.pmos.num_of_tacts)) self.pwell_contact = contact.contact( layer_stack=("active", "contact", "metal1"), dimensions=(1, self.nmos.num_of_tacts)) self.extend_wells() self.extend_active() self.add_well_contacts() self.connect_well_contacts() self.connect_rails() self.connect_tx() self.route_pins() self.setup_layout_offsets()
def main(): mask = make_mask() src = Src(camera(mask)) cv.imshow('-FACE- continue-(Press eny key)', cv.resize(src.img, (540, 720))) cv.waitKey(0) cv.destroyAllWindows() # 中心判定 detection(src) # 調節 adjustment(src) print("left<y: {}, x: {}>, right<y: {}, x: {}>".format( src.left.y, src.left.x, src.right.y, src.right.x)) print("l_length: {}, r_length: {}".format(src.left.length, src.right.length)) contact(src) # 拡大 # img = cv.resize(src.result, (540, 720)) # cv.imshow('-RESULT- continue-(Press eny key)', img) # 通常 cv.imshow('-RESULT- continue-(Press eny key)', src.result) cv.waitKey(0) cv.imwrite("result.jpg", src.result)
def runTest(self): globals.init_AMC("config_20_{0}".format(OPTS.tech_name)) global calibre import calibre OPTS.check_lvsdrc = False import contact for layer_stack in [("poly", "contact", "metal1"), ("metal1", "via1", "metal2")]: # Check single 1 x 1 contact" debug.info(2, "1 x 1 {} test".format(layer_stack)) c1 = contact.contact(layer_stack, (1, 1)) self.local_drc_check(c1) # check vertical array with one in the middle and two ends debug.info(2, "1 x 3 {} test".format(layer_stack)) c2 = contact.contact(layer_stack, (1, 3)) self.local_drc_check(c2) # check horizontal array with one in the middle and two ends debug.info(2, "3 x 1 {} test".format(layer_stack)) c3 = contact.contact(layer_stack, (3, 1)) self.local_drc_check(c3) # check 3x3 array for all possible neighbors debug.info(2, "3 x 3 {} test".format(layer_stack)) c4 = contact.contact(layer_stack, (3, 3)) self.local_drc_check(c4) # return it back to it's normal state OPTS.check_lvsdrc = True globals.end_AMC()
def create_contacts(self): """Initializes all required contacts/vias for this module""" # These aren't for instantiating, but we use them to get the dimensions self.nwell_contact = contact(layer_stack=("active", "contact", "metal1")) self.poly_contact = contact(layer_stack=("poly", "contact", "metal1")) self.upper_dimensions = self.upper_pmos.active_contact.dimensions self.lower_dimensions = self.lower_pmos.active_contact.dimensions self.upper_contact = contact(layer_stack=("metal1", "via1", "metal2"), dimensions=self.upper_dimensions) self.lower_contact = contact(layer_stack=("metal1", "via1", "metal2"), dimensions=self.lower_dimensions)
def create_layout(self): # This is not instantiated and used for calculations only. self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) self.pwell_contact = contact(layer_stack=("active", "contact", "metal1")) self.create_ptx() self.add_ptx() self.connect_poly() self.connect_to_bitlines() self.add_gnd_rail() self.add_well_contacts() self.setup_layout_constants()
def create_layout(self): # This is not instantiated and used for calculations only. self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) self.well_contact = contact(layer_stack=("active", "contact", "metal1")) self.create_ptx() self.width = self.bitcell.width # The height is bigger than necessary. self.height = 2 * self.nmos.height self.connect_poly() self.connect_to_bitlines() self.add_gnd_rail() self.add_well_contacts()
def setup_layout_offsets(self): """ Setup layout offsets, determine the size of the busses etc """ # This isn't for instantiating, but we use it to get the dimensions m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) # Vertical metal rail gap definition self.metal2_extend_contact = (m1m2_via.second_layer_height - m1m2_via.contact_width) / 2 self.gap_between_rails = self.metal2_extend_contact + drc["metal2_to_metal2"] self.gap_between_rail_offset = self.gap_between_rails + drc["minwidth_metal2"] self.via_shift = (m1m2_via.second_layer_width - m1m2_via.first_layer_width) / 2 # used to shift contact when connecting to NAND3 C pin down self.contact_shift = (m1m2_via.first_layer_width - m1m2_via.contact_width) / 2 # Common parameters for rails self.rail_width = drc["minwidth_metal2"] self.rail_gap = 2 * drc["metal2_to_metal2"] self.rail_offset_gap = self.rail_width + self.rail_gap # First RAIL Parameters self.num_rails_1 = 6 self.overall_rail_1_gap = (self.num_rails_1 + 1) * self.rail_offset_gap self.rail_1_x_offsets = [] # Second RAIL Parameters self.num_rails_2 = 4 self.overall_rail_2_gap = (self.num_rails_2 + 1) * self.rail_offset_gap self.rail_2_x_offsets = [] # GAP between main control and REPLICA BITLINE self.replica_bitline_gap = self.rail_offset_gap * 2 self.output_port_gap = 3 * drc["minwidth_metal3"] self.logic_height = max(self.replica_bitline.width, 4 * self.inv.height)
def set_layers(self, layers): """Allows us to change the layers that we are routing on. First layer is always horizontal, middle is via, and last is always vertical. """ self.layers = layers (horiz_layer, via_layer, vert_layer) = self.layers self.vert_layer_name = vert_layer self.vert_layer_width = tech.drc["minwidth_{0}".format(vert_layer)] self.vert_layer_spacing = tech.drc[str(self.vert_layer_name) + "_to_" + str(self.vert_layer_name)] self.vert_layer_number = tech.layer[vert_layer] self.horiz_layer_name = horiz_layer self.horiz_layer_width = tech.drc["minwidth_{0}".format(horiz_layer)] self.horiz_layer_spacing = tech.drc[str(self.horiz_layer_name) + "_to_" + str(self.horiz_layer_name)] self.horiz_layer_number = tech.layer[horiz_layer] # Contacted track spacing. via_connect = contact(self.layers, (1, 1)) self.max_via_size = max(via_connect.width, via_connect.height) self.horiz_track_width = self.max_via_size + self.horiz_layer_spacing self.vert_track_width = self.max_via_size + self.vert_layer_spacing # We'll keep horizontal and vertical tracks the same for simplicity. self.track_width = max(self.horiz_track_width, self.vert_track_width) debug.info(1, "Track width: " + str(self.track_width)) self.track_widths = [self.track_width] * 2 self.track_factor = [1 / self.track_width] * 2 debug.info(1, "Track factor: {0}".format(self.track_factor))
def __init__(self, layers, rail_track_width): """ Allows us to change the layers that we are routing on. First layer is always horizontal, middle is via, and last is always vertical. """ self.layers = layers self.rail_track_width = rail_track_width if len(self.layers) == 1: self.horiz_layer_name = self.vert_layer_name = self.layers[0] self.horiz_layer_number = self.vert_layer_number = layer[ self.layers[0]] (self.vert_layer_minwidth, self.vert_layer_spacing) = self.get_supply_layer_width_space(1) (self.horiz_layer_minwidth, self.horiz_layer_spacing) = self.get_supply_layer_width_space(0) self.horiz_track_width = self.horiz_layer_minwidth + self.horiz_layer_spacing self.vert_track_width = self.vert_layer_minwidth + self.vert_layer_spacing else: (self.horiz_layer_name, self.via_layer_name, self.vert_layer_name) = self.layers via_connect = contact(self.layers, (1, 1)) max_via_size = max(via_connect.width, via_connect.height) self.horiz_layer_number = layer[self.horiz_layer_name] self.vert_layer_number = layer[self.vert_layer_name] (self.vert_layer_minwidth, self.vert_layer_spacing) = self.get_supply_layer_width_space(1) (self.horiz_layer_minwidth, self.horiz_layer_spacing) = self.get_supply_layer_width_space(0) # For supplies, we will make the wire wider than the vias self.vert_layer_minwidth = max(self.vert_layer_minwidth, max_via_size) self.horiz_layer_minwidth = max(self.horiz_layer_minwidth, max_via_size) self.horiz_track_width = self.horiz_layer_minwidth + self.horiz_layer_spacing self.vert_track_width = self.vert_layer_minwidth + self.vert_layer_spacing # We'll keep horizontal and vertical tracks the same for simplicity. self.track_width = max(self.horiz_track_width, self.vert_track_width) debug.info(1, "Track width: {:.3f}".format(self.track_width)) self.track_space = max(self.horiz_layer_spacing, self.vert_layer_spacing) debug.info(1, "Track space: {:.3f}".format(self.track_space)) self.track_wire = self.track_width - self.track_space debug.info(1, "Track wire width: {:.3f}".format(self.track_wire)) self.track_widths = vector([self.track_width] * 2) self.track_factor = vector([1 / self.track_width] * 2) debug.info(2, "Track factor: {}".format(self.track_factor)) # When we actually create the routes, make them the width of the track (minus 1/2 spacing on each side) self.layer_widths = [self.track_wire, 1, self.track_wire]
def add_modules(self): self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) # Vertical metal rail gap definition self.metal2_extend_contact = (self.m1m2_via.second_layer_height - self.m1m2_via.contact_width) / 2 self.gap_between_rails = self.metal2_extend_contact + drc[ "metal2_to_metal2"] self.gap_between_rail_offset = self.gap_between_rails + drc[ "minwidth_metal2"] self.via_shift = (self.m1m2_via.second_layer_width - self.m1m2_via.first_layer_width) / 2 # used to shift contact when connecting to NAND3 C pin down self.contact_shift = (self.m1m2_via.first_layer_width - self.m1m2_via.contact_width) / 2 self.inv = pinv(name="pinverter", nmos_width=drc["minwidth_tx"], beta=2, height=self.bitcell_height) self.add_mod(self.inv) self.nand2 = nand_2(name="pnand2", nmos_width=self.nand2_nmos_width, height=self.bitcell_height) self.add_mod(self.nand2) self.nand3 = nand_3(name="pnand3", nmos_width=self.nand3_nmos_width, height=self.bitcell_height) self.add_mod(self.nand3) # CREATION OF PRE-DECODER self.pre2_4 = pre2x4(self.nand2_nmos_width, "pre2x4") self.add_mod(self.pre2_4) self.pre3_8 = pre3x8(self.nand3_nmos_width, "pre3x8") self.add_mod(self.pre3_8)
def create_vias(self): """ Add a via and corner square at every corner of the path.""" self.c = contact(self.layer_stack, (1, 1)) c_width = self.c.width c_height = self.c.height from itertools import tee, islice nwise = lambda g, n=2: zip(*(islice(g, i, None) for i, g in enumerate(tee(g, n)))) threewise = nwise(self.position_list, 3) for (a, offset, c) in list(threewise): # add a exceptions to prevent a via when we don't change directions if a[0] == c[0]: continue if a[1] == c[1]: continue via_offset = [ offset[0] + 0.5 * c_height, offset[1] - 0.5 * c_width ] self.obj.add_via(layers=self.layer_stack, offset=via_offset, rotate=90) corner_offset = [ offset[0] - 0.5 * (c_height + self.vert_layer_width), offset[1] + 0.5 * (c_width - self.horiz_layer_width) ]
def setup_layout_constants(self): self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) # Vertical metal rail gap definition self.metal2_extend_contact = (self.m1m2_via.second_layer_height - self.m1m2_via.contact_width) / 2 self.metal2_spacing = self.metal2_extend_contact + drc[ "metal2_to_metal2"] self.metal2_pitch = self.metal2_spacing + drc["minwidth_metal2"] self.via_shift = (self.m1m2_via.second_layer_width - self.m1m2_via.first_layer_width) / 2 self.predec_groups = [] # This array is a 2D array. # Distributing vertical rails to different groups. One group belongs to one pre-decoder. # For example, for two 2:4 pre-decoder and one 3:8 pre-decoder, we will # have total 16 output lines out of these 3 pre-decoders and they will # be distributed as [ [0,1,2,3] ,[4,5,6,7], [8,9,10,11,12,13,14,15] ] # in self.predec_groups index = 0 for i in range(self.no_of_pre2x4): lines = [] for j in range(4): lines.append(index) index = index + 1 self.predec_groups.append(lines) for i in range(self.no_of_pre3x8): lines = [] for j in range(8): lines.append(index) index = index + 1 self.predec_groups.append(lines) self.calculate_dimensions()
def add_via_center(self, layers, offset, size=[1,1], mirror="R0", rotate=0, implant_type=None, well_type=None): """ Add a three layer via structure by the center coordinate accounting for mirroring and rotation. """ import contact via = contact.contact(layer_stack=layers, dimensions=size, implant_type=implant_type, well_type=well_type) height = via.height width = via.width debug.check(mirror=="R0","Use rotate to rotate vias instead of mirror.") if rotate==0: corrected_offset = offset + vector(-0.5*width,-0.5*height) elif rotate==90: corrected_offset = offset + vector(0.5*height,-0.5*width) elif rotate==180: corrected_offset = offset + vector(0.5*width,0.5*height) elif rotate==270: corrected_offset = offset + vector(-0.5*height,0.5*width) else: debug.error("Invalid rotation argument.",-1) #print(rotate,offset,"->",corrected_offset) self.add_mod(via) inst=self.add_inst(name=via.name, mod=via, offset=corrected_offset, mirror=mirror, rotate=rotate) # We don't model the logical connectivity of wires/paths self.connect_inst([]) return inst
def setup_layout_offsets(self): """ Setup layout offsets, determine the size of the busses etc """ # These aren't for instantiating, but we use them to get the dimensions self.poly_contact = contact(layer_stack=("poly", "contact", "metal1")) self.poly_contact_offset = vector(0.5 * self.poly_contact.width, 0.5 * self.poly_contact.height) self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) self.m2m3_via = contact(layer_stack=("metal2", "via2", "metal3")) # For different layer width vias self.m1m2_offset_fix = vector( 0, 0.5 * (drc["minwidth_metal2"] - drc["minwidth_metal1"])) # M1/M2 routing pitch is based on contacted pitch self.m1_pitch = max(self.m1m2_via.width, self.m1m2_via.height) + max( drc["metal1_to_metal1"], drc["metal2_to_metal2"]) self.m2_pitch = max(self.m2m3_via.width, self.m2m3_via.height) + max( drc["metal2_to_metal2"], drc["metal3_to_metal3"]) # Have the cell gap leave enough room to route an M2 wire. # Some cells may have pwell/nwell spacing problems too when the wells are different heights. self.cell_gap = max(self.m2_pitch, drc["pwell_to_nwell"]) # Amount to shift a 90 degree rotated via from center-line path routing to it's offset self.m1m2_via_offset = vector(self.m1m2_via.first_layer_height, -0.5 * drc["minwidth_metal2"]) self.m2m3_via_offset = vector(self.m2m3_via.first_layer_height, -0.5 * drc["minwidth_metal3"]) # First RAIL Parameters: gnd, oe, oebar, cs, we, clk_buf, clk_bar self.rail_1_start_x = 0 self.num_rails_1 = 8 self.rail_1_names = [ "clk_buf", "gnd", "oe_bar", "cs", "we", "vdd", "oe", "clk_bar" ] self.overall_rail_1_gap = (self.num_rails_1 + 2) * self.m2_pitch self.rail_1_x_offsets = {} # Second RAIL Parameters: vdd self.rail_2_start_x = 0 self.num_rails_2 = 0 self.rail_2_names = ["vdd"] self.overall_rail_2_gap = (self.num_rails_2 + 2) * self.m2_pitch self.rail_2_x_offsets = {} # GAP between main control and replica bitline self.replica_bitline_gap = 2 * self.m2_pitch
def add_modules(self): self.mux = single_level_column_mux(name="single_level_column_mux", tx_size=8) self.single_mux = self.mux self.add_mod(self.mux) # This is not instantiated and used for calculations only. self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2"))
def contact(request): if request.method == 'POST': email = request.POST.get('email') password = request.POST.get('password') address = request.address.POST.get('address') contact = contact(email=email, password=password, address=address) contact.save() return render(request, 'contact.html')
def create_layout(self): """ create layout """ self.create_ptx() self.setup_layout_constants() self.add_rails() self.add_ptx() self.add_well_contacts() # These aren't for instantiating, but we use them to get the dimensions self.poly_contact = contact.contact(("poly", "contact", "metal1")) self.m1m2_via = contact.contact(("metal1", "via1", "metal2")) self.connect_tx() self.connect_well_contacts() self.extend_wells() self.extend_active() self.connect_rails() self.route_pins()
def main(): last = "Trentwood OR 94701" delivery = "1402 SW Alder st." second = "APT 11" testAddress = address(last, delivery, second) testRecipient = "John Doe" last2 = "Oakland CA 94501" delivery2 = "1244 Broadway st." second2 = "APT 11" testAddress2 = address(last2, delivery2, second2) testRecipient2 = "Lucas Rondenet" testContact = contact(testRecipient) testContact2 = contact(testRecipient2) testEmail = "*****@*****.**" testEmail2 = "*****@*****.**" testPhoneNumber = "542-345-6745" testEmail3 = "*****@*****.**" testEmail4 = "*****@*****.**" testPhoneNumber2 = "545-565-7889" testContact.addAddress(testAddress) testContact.addEmail(testEmail) testContact.addEmail(testEmail2) testContact.addPhoneNumber(testPhoneNumber) testContact2.addAddress(testAddress2) testContact2.addEmail(testEmail3) testContact2.addEmail(testEmail4) testContact2.addPhoneNumber(testPhoneNumber2) print(testContact) #testContact.removeAddress(testAddress) print(testContact) print print(testContact2) testContact.addField("age", "32") testContact3 = contact("John Newhall") print(testContact.age) print(vars(testContact)) print(vars(testContact2)) print(vars(testContact3))
def create_modules(self): layer_stack = ("metal1", "via1", "metal2") self.m1m2_via = contact(layer_stack=layer_stack) self.inv = pinv(nmos_width=drc["minwidth_tx"], beta=2, height=self.bitcell_height) self.add_mod(self.inv) # create_nand redefine in sub class based on number of inputs self.create_nand() self.add_mod(self.nand)
class taxudromio(object): "desrciption of the object" import contact import dema import epistoli demalist = [] epistolist = [] pelatis1 = contact.contact('Bla', 'Black', 'Petmeza 14', 12244, '123456789') pelatis2 = contact.contact('Blu', 'Blue', 'Skopeftirio 45', 16644, '987654321') demataki = dema.dema(2.70, pelatis1, pelatis2, 'small', 'foam', 1.0) tyepistoli = epistoli(1.00, pelatis2, pelatis1, 'low') epistolist.append(tyepistoli) epistolist.pop(0)
def calculate_module_offsets(self): """ Calculate all the module offsets """ # These aren't for instantiating, but we use them to get the dimensions self.active_contact = contact(layer_stack=("active", "contact", "poly")) self.poly_contact = contact(layer_stack=("poly", "contact", "metal1")) self.poly_contact_offset = vector(0.5 * self.poly_contact.width, 0.5 * self.poly_contact.height) self.m1m2_via = contact(layer_stack=("metal1", "via1", "metal2")) self.m2m3_via = contact(layer_stack=("metal2", "via2", "metal3")) # M1/M2 routing pitch is based on contacted pitch self.m1_pitch = max(self.m1m2_via.width, self.m1m2_via.height) + max( drc["metal1_to_metal1"], drc["metal2_to_metal2"]) self.m2_pitch = max(self.m2m3_via.width, self.m2m3_via.height) + max( drc["metal2_to_metal2"], drc["metal3_to_metal3"]) # This corrects the offset pitch difference between M2 and M1 self.offset_fix = vector( 0.5 * (drc["minwidth_metal2"] - drc["minwidth_metal1"]), 0) # delay chain will be rotated 90, so move it over a width # we move it up a inv height just for some routing room self.rbl_inv_offset = vector(self.delay_chain.height, self.inv.width) # access TX goes right on top of inverter, leave space for an inverter which is # about the same as a TX. We'll need to add rails though. self.access_tx_offset = vector(1.5 * self.inv.height, self.rbl_inv_offset.y) + vector( 0, 2.25 * self.inv.width) self.delay_chain_offset = self.rbl_inv_offset + vector( 0, 4 * self.inv.width) # Replica bitline and such are not rotated, but they must be placed far enough # away from the delay chain/inverter with space for three M2 tracks self.bitcell_offset = self.rbl_inv_offset + vector( 2 * self.m2_pitch, 0) + vector( 0, self.bitcell.height + self.inv.width) self.rbl_offset = self.bitcell_offset self.height = self.rbl_offset.y + self.rbl.height + self.m2_pitch self.width = self.rbl_offset.x + self.bitcell.width
def run_iters(num_iterations): all_hospitals = create_hospitals() all_people = create_people() all_hospital_full = False for i in range(num_iterations): for j in range(NUM_PERSONS): all_people[j].move() all_people[j].are_symptoms_visible(i) if all_people[j].shows_symptom: # Checking if there is any space left in hospital all_hospital_full = True for a_hospital in all_hospitals: if not a_hospital.is_full: all_hospital_full = False break # If all hospitals are not full then if not all_hospital_full: for a_hospital in all_hospitals: if not a_hospital.is_full: hospital_location = a_hospital.location a_hospital.occupy_bed() break all_people[j].hospitalize(hospital_location) # otherwise quarantine the person else: all_people[j].no_hospital_quarantine() for j in range(NUM_PERSONS): for k in range(NUM_PERSONS): if j != k: contact(all_people[j], all_people[k], i) for j in range(NUM_PERSONS): if all_people[j].status == NO_HOSPITAL_QUARANTINED or all_people[ j].is_hospitalized: all_people[j].dead_immune_delay(i) get_people_stats(all_people, i)
def __main__(): parser = argparse.ArgumentParser( description='OpenContact') parser.add_argument( '-a', '--protA', default=None, help='Path to proteinA.pdb') parser.add_argument( '-b', '--protB', default=None, help='Path to proteinB.pdb') parser.add_argument( '-A', '--protA_chain', default=None, help='proteinA chain') parser.add_argument( '-B', '--protB_chain', default=None, help='proteinB chain') parser.add_argument( '-t', '--tabular', default=False, action='store_true', help='Create tab separated map files') args = parser.parse_args() if not all([args.protA, args.protB, args.protA_chain, args.protB_chain]): parser.print_usage() sys.exit(1) # resource files need to be in working directory resource_path = os.path.abspath(os.path.dirname(sys.argv[0])) resource_files = ['ctresc03.pdb', 'ctresc03n.pdb', 'residc03n.pdb', 'residc03.pdb', 'ntresc03n.pdb', 'ntresc03.pdb', 'ljresidn', 'ljresid'] for f in resource_files: shutil.copyfile(resource_path+os.sep+f, "."+os.sep+f) start_time = time.time() # opencontact has hard coded input filenames shutil.copyfile(args.protA, "."+os.sep+"prota.pdb") shutil.copyfile(args.protB, "."+os.sep+"protb.pdb") inpututil(args.protA_chain, args.protB_chain) contact() end_time = time.time() print('Done %s' % (end_time - start_time)) if args.tabular: convert_to_tsv('coarsedata.txt', 'coarsedata.tsv') convert_to_tsv('finedata.txt', 'finedata.tsv')
def setup_layers(self): (horiz_layer, via_layer, vert_layer) = self.layer_stack self.via_layer_name = via_layer self.vert_layer_name = vert_layer self.vert_layer_width = drc["minwidth_{0}".format(vert_layer)] self.horiz_layer_name = horiz_layer self.horiz_layer_width = drc["minwidth_{0}".format(horiz_layer)] # offset this by 1/2 the via size self.c = contact(self.layer_stack, (1, 1))
def create_layout(self): # These aren't for instantiating, but we use them to get the dimensions self.poly_contact = contact.contact(("poly", "contact", "metal1")) self.m1m2_via = contact.contact(("metal1", "via1", "metal2")) self.determine_sizes() self.create_modules() # These aren't for instantiating, but we use them to get the dimensions self.nwell_contact = contact.contact(layer_stack=("active", "contact", "metal1"), dimensions=(1, self.pmos.num_contacts)) self.pwell_contact = contact.contact(layer_stack=("active", "contact", "metal1"), dimensions=(1, self.nmos.num_contacts)) self.setup_layout_constants() self.add_rails() self.add_ptx() self.add_well_contacts() self.extend_wells() self.extend_active() self.route()
def add_route(self, cell): """ Add the current wire route to the given design instance. """ # First, simplify the path for #debug.info(1,str(self.path)) contracted_path = self.contract_path(self.path) debug.info(1, str(contracted_path)) # Make sure there's a pin enclosure on the source and dest src_shape = self.convert_track_to_shape(contracted_path[0]) cell.add_rect(layer=self.layers[2 * contracted_path[0].z], offset=src_shape[0], width=src_shape[1].x - src_shape[0].x, height=src_shape[1].y - src_shape[0].y) dest_shape = self.convert_track_to_shape(contracted_path[-1]) cell.add_rect(layer=self.layers[2 * contracted_path[-1].z], offset=dest_shape[0], width=dest_shape[1].x - dest_shape[0].x, height=dest_shape[1].y - dest_shape[0].y) # convert the path back to absolute units from tracks abs_path = map(self.convert_point_to_units, contracted_path) debug.info(1, str(abs_path)) cell.add_route(self.layers, abs_path) # Check if a via is needed at the start point if (contracted_path[0].z != self.source_pin_zindex): # offset this by 1/2 the via size c = contact(self.layers, (1, 1)) via_offset = vector(-0.5 * c.width, -0.5 * c.height) cell.add_via(self.layers, abs_path[0] + via_offset) # Check if a via is needed at the end point if (contracted_path[-1].z != self.target_pin_zindex): # offset this by 1/2 the via size c = contact(self.layers, (1, 1)) via_offset = vector(-0.5 * c.width, -0.5 * c.height) cell.add_via(self.layers, abs_path[-1] + via_offset)
def add_via(self, layers, offset, size=[1, 1], mirror="R0", rotate=0): """ Add a three layer via structure. """ import contact via = contact.contact(layer_stack=layers, dimensions=size) self.add_mod(via) self.add_inst(name=via.name, mod=via, offset=offset, mirror=mirror, rotate=rotate) # We don't model the logical connectivity of wires/paths self.connect_inst([]) return via
def addressBookImport(self, fileName, app): if os.path.exists(fileName): f = open(fileName, 'r') data = utils.importParse(f) for element in data: newContact = contact(element['Recipient']) newAddress = address(element['Last'], element['Delivery'], element['Second']) newContact.addAddress(newAddress) if 'Phone' in element: newContact.addPhoneNumber(element['Phone']) if 'Email' in element: newContact.addEmail(element['Email']) self.addContact(newContact) app.cmdUpdateListbox(self.contacts)
def findContactByName(self, recipient): """ Finds all contacts by recipient which includes both the first name and last name. If more than one contact with the same recipient is found then both are added to the contactList to be returned. If no contacts are found then alert window pops up and displays contact not found """ tmp = contact(recipient) indices = [i for i, val in enumerate(self.contacts) if val == tmp] contactList = [] if (len(indices) > 1): for i in indices: contactList.append(self.contacts[i]) return contactList elif (len(indices) == 1): contactList.append(self.contacts[indices[0]]) return contactList else: tkMessageBox.showinfo("Alert", "Contact Not Found!", icon='warning')
def cmdAdd(self): """create a new contact based on the contact's name""" self.tempContact = contact.contact(self.entryName.get()) """build a temp address""" self.tempAddress = address.address(self.entryAddressLast.get(),self.entryAddressDelivery.get(),self.entryAddressSecond.get()) """add the address to the contact object""" self.tempContact.addAddress(self.tempAddress) """add the email address to the contact object""" self.tempContact.addEmail(self.entryEmail.get()) """get and add the phone number to the contact object""" self.tempContact.addPhoneNumber(self.entryPhone.get()) """add the contact to the address book""" self.logic.addContact(self.tempContact) """update the listbox""" self.cmdUpdateListbox(self.logic.contacts) """set the addressbook state to unsaved""" self.unSavedChanges = 1
def main(): testAddressBook = addressbook() testContact1 = contact("John Doe") testLast1 = "San Diego CA 94501" testDelivery1 = "1401 SW Main St." testSecond1 = "" testAddr1 = address(testLast1, testDelivery1, testSecond1) testEmail1 = "*****@*****.**" testEmail2 = "*****@*****.**" testPhoneNumber1 = "542-345-6745" testContact1.addAddress(testAddr1) testContact1.addEmail(testEmail1) testContact1.addEmail(testEmail2) testContact1.addPhoneNumber(testPhoneNumber1) print(testContact1) print(testContact1.mailingFormat()) #print(testContact1.city) #print(testContact1.state) #print(testContact1.zip) '''testContact2 = contact("Mary Sue")