IGEM:Harvard/2006/Container Design 4: Difference between revisions
No edit summary |
No edit summary |
||
Line 1: | Line 1: | ||
*[[/Schematics|Schematics]] | |||
**[[/Schematics#ASCII|ASCII]] | |||
**[[/Schematics#2D|2D]] | |||
**[[/Schematics#3D|3D]] | |||
*[[/Scaffold Sequences]] | |||
*[[/Python Code]] | |||
*[[/Latch Sequences]] | |||
===Design details=== | ===Design details=== | ||
based on ''n'' = 0.324 nm, ''d'' = 3.0 nm | based on ''n'' = 0.324 nm, ''d'' = 3.0 nm |
Revision as of 12:30, 10 July 2006
Design details
based on n = 0.324 nm, d = 3.0 nm
Shape | Lid ply | Cylinder design | Lid design | Total scaffold length |
honeycomb hexagon | single | 30 tubes (29.0 nm dia) x (84+12)bp long (30.8 nm) = 2880bp | 14 tubes (34.2 nm) x (84+12)bp long (30.8 nm) = 1344bp each | 2880+(2*1344) + (3*200)bp linkers = 6168 bp |
Sequence Chunks (KV, 6.27.06)
Script for adding aptamers:
####### # Add aptamers to the ends of the appropriate oligos. ####### # Constants apt_seq = 'GGTTGGTGTGGTTGG' T_linker = 'TTT' print oligo_ra num_aptamers = int(raw_input('How many aptamers do you want to add? ')) i = 0 while i < num_aptamers: oligo_num = int(raw_input('Which oligo needs an aptamer? ')) if oligo_num < len(oligo_ra): # Add the aptamer to that oligo oligo_ra[oligo_num] = oligo_ra[oligo_num] + T_linker + apt_seq i = i + 1 else: print 'oligo ' + str(oligo_num) + ' out of range.' print oligo_ra
Add aptamers using File Input rather than User Input
##### # Add apts this time using file input instead of user input ##### # Constants apt_seq = 'GGTTGGTGTGGTTGG' T_linker = 'TTT' fin_barrel = None try: fin_barrel = open("barrel_apts_to_add.txt", "r") except IOError, e: print "Error in file IO: ", e # Ask the user if they are running a lid or a barrel shape = int(raw_input("Enter 1 if you are running a barrel, 2 if lid: ")) if (shape == 1): apts_to_add = pickle.load(fin_barrel) for apt_specs in apts_to_add: oligo_num = apt_specs[0] type = apt_specs[1] if (type == 1): # apt is pointing in so add 'I' as a flag at the end oligo_ra[oligo_num] = oligo_ra[oligo_num] + T_linker + apt_seq + 'I' elif(type == 2): # apt is pointing out so add 'O' as a flag oligo_ra[oligo_num] = oligo_ra[oligo_num] + T_linker + apt_seq + 'O' else: # incorrect type print 'Bad input - aptamer needs to be pointing in or out'
Script for splitting up as many oligos as you want (USING USER INPUT). The first part goes in main. The second part goes in honeycomb_pointers_v1.py
##### # Oligo splitting: # get new list of oligos given user input specifying which oligo to cut ##### num_to_split = int(raw_input('How many oligos do you want to split?')) i = 0 new_OTP_ra = OTP_ra[:] while i < num_to_split: oligo_num = int(raw_input('Enter the number oligo you wish to split:')) print '\n' print 'How many tokens should the first new oligo be?' num_toks = int(raw_input('Number of toks starting from 5 prime: ')) new_OTP_ra = split_oligo(new_OTP_ra, oligo_num, num_toks) print new_OTP_ra print len(OTP_ra) print len(new_OTP_ra) i = i + 1 #### # given an oligo to split, split it and return the new list of oligos #### def split_oligo(new_OTP_ra, oligo_num, num_toks): print new_OTP_ra[oligo_num] original_oligo = new_OTP_ra[oligo_num] oligo_1 = original_oligo[:num_toks] oligo_2 = original_oligo[num_toks:] print oligo_1 print'\n' print oligo_2 new_OTP_ra[oligo_num] = oligo_1 new_OTP_ra.insert(oligo_num + 1, oligo_2) return new_OTP_ra
Script for splitting up oligos automatically (FILE INPUT). (make sure to import pickle at the top). This part goes in main. Further down is the file to read from essentially (uses pickle)
##### # Oligo splitting - this time reading from a file and not asking for user # input ##### fin_barrel = None fin_lid = None try: fin_barrel = open("barrel_oligos_to_split.txt", "r") fin_lid = open("lid_oligos_to_split.txt", "r") except IOError, e: print "Error in file IO: ", e # Ask the user if they are running a lid or a barrel shape = int(raw_input("Enter 1 if you are running a barrel, 2 if lid: ")) if (shape == 1): oligos_to_split = pickle.load(fin_barrel) elif (shape == 2): oligos_to_split = pickle.load(fin_lid) else: print 'Please modify code or run with lid or 30hb barrel' new_OTP_ra = OTP_ra[:] for pair in oligos_to_split: oligo_num = pair[0] print oligo_num num_toks = pair[1] print num_toks new_OTP_ra = split_oligo(new_OTP_ra, oligo_num, num_toks) print new_OTP_ra print len(OTP_ra) print len(new_OTP_ra) # if it's the barrel design and so that all the numbers aren't messed # up, the 7bp token on the start of strand 10 needs to be removed # because it's going to be left unpaired if (shape == 1): new_OTP_ra = new_OTP_ra[:61] + new_OTP_ra[62:] if fin_barrel: fin_barrel.close() if fin_lid: fin_lid.close()
### split = [[oligo_num, num_tokens for oligo_1 - from 5prime], ... ] import pickle fout_barrel = None fout_lid = None try: fout_barrel = open("barrel_oligos_to_split.txt", "w") fout_lid = open("lid_oligos_to_split.txt", "w") except IOError, e: print "Error in file IO: ", e barrel_split = [[56, 2], [57, 3], [41, 3], [26, 3], [21, 4]] lid_split = [[27, 4], [2, 4]] pickle.dump(barrel_split, fout_barrel) pickle.dump(lid_split, fout_lid) # clean up if they're open if fout_barrel: fout_barrel.close() if fout_lid: fout_lid.close()
Script for generating sequence chunks
#!/usr/bin/python import string import sys import fileinput def nowhite(s): return ''.join([c for c in s if c in string.letters]) seq = '' # read in sequence for line in fileinput.input("-"): seq = seq + nowhite(line) lid_1 = 96 * 13 linker_1 = 30 box = 29 * 96 linker_2 = 30 lid_2 = 96 * 14 linker_3 = 200 box_2 = 96 #store first segment up to end of lid 1 lid_1_seq = seq[:lid_1] #reset sequence to start at end of lid 1 seq = seq[lid_1:] linker_1_seq = seq[:linker_1] seq = seq[linker_1:] box_1_seq = seq[:box] seq = seq[box:] linker_2_seq = seq[:linker_2] seq = seq[linker_2:] lid_2_seq = seq[:lid_2] seq = seq[lid_2:] linker_3_seq = seq[:linker_3] seq = seq[linker_3:] box_2_seq = seq[:box_2] seq = seq[box_2:] extra_scaffold = seq barrel = box_1_seq + box_2_seq #print out the length of each segment and its sequence barrel_file = file('barrel_scaffold.txt', 'w') lid_1_file = file('lid_1_scaffold.txt', 'w') lid_2_file = file('lid_2_scaffold.txt', 'w') print len(lid_1_seq) print lid_1_seq lid_1_file.write(lid_1_seq) print len(linker_1_seq) print linker_1_seq print len(barrel) print barrel barrel_file.write(barrel) print len(linker_2_seq) print linker_2_seq print len(lid_2_seq) print lid_2_seq lid_2_file.write(lid_2_seq) print len(linker_3_seq) print linker_3_seq
Oligo sorting - find an print out those with aptamers
##### # oligo sorting ##### # sort based on whether or not there's an aptamer attached to the end of # an oligo apt = re.compile('TTTGGTTGGTGTGGTTGG') oligo_num = 0 for oligo in oligo_ra: m = apt.search(oligo) if m: print 'Match found: ', oligo + ' : ' + str(oligo_num) else: print 'No match' + str(oligo_num) oligo_num = oligo_num + 1
Modifications to William's program to print each oligo number next to what tokens it represents
oligo_num = 0 for oligo in OTP_ra: for token in oligo: print str(oligo_num) + ": ", token oligo_num = oligo_num + 1
Modifications to William's program to print a grid of oligo numbers completely filled in
- add this part to main (AAA or BBB)
#### # generate and print the oligo grid #### # Initialize the grid with all periods num_strands = len(TPP_ra) num_subzones = len(TPP_ra[0]) sub_token_visit_ra = ['.' for subzone_num in range(num_subzones)] grid_ra = [sub_token_visit_ra[:] for strand_num in range(num_strands)] oligo_num = 0 for oligo in OTP_ra: grid_ra = generate_oligo_path(oligo, oligo_num, grid_ra) oligo_num = oligo_num + 1 print grid_ra print_all_oligos(grid_ra, num_strands, num_subzones)
- add this part to honeycomb_pointers_v1.py
# The idea here is to have a function that adds the numbers of one oligo path # to the appropriate places in the big grid array. Eventually this will be printed # in main. Also it needs to be initialized in main. Oligo_path is the path of # one oligo, while grid_ra is the grid that is constantly being updated until # it is printed in main. oligo_num is number that will be inputed to the grid_ra. def generate_oligo_path(oligo_path, oligo_num, grid_ra): num_path_tokens = len(oligo_path) # Assign visits for path_token_num in range(num_path_tokens): token = oligo_path[path_token_num] strand = token[0] subzone = token[1] grid_ra[strand][subzone] = oligo_num return grid_ra def print_all_oligos(grid_ra, num_strands, num_subzones): spacer = ' ' for strand_num in range(num_strands): for subzone_num in range(num_subzones): visitor_string = str(grid_ra[strand_num][subzone_num]) sys.stdout.write(visitor_string) sys.stdout.write(spacer[:4 - len(visitor_string)]) sys.stdout.write('\n')
Sequence Chunks (TChan, 7.5.06)
Sequence Chunks (TChan, 6.27.06)
- Media:Chunk1p7308_TC_62706.txt
- Chunk of p7308 sequence for container4's lid1.
- Media:Chunk2p7308_TC_62706.txt
- Chunk of p8256 sequence for container4's barrel (skips 6bp after lid1's chunk, 6bp right before lid2, the 96bp*13helices that is lid2, 6bp after lid2, and appends the final helix).
- Media:Chunk3p7308_TC_62706.txt
- Chunk of p7308 sequence for container4's lid2.
Oligos (TChan, 6.27.06)
- Media:lid1_7308_TC_62706.txt
- Oligos for lid 1 (correct wordcount: 30lines, 30words, 1122chars (includes 30 carriage returns) for (96bp-12ssbp)*13helices)
- Media:barrel_7308_TC_62706.txt
- Oligos for barrel (correct wordcount: 74lines, 74words, 2594chars (includes 74 carriage returns) for (96bp-12ssbp)*30helices)
- Media:lid2_7308_TC_62706.txt
- Oligos for lid 2 (correct wordcount: 30lines, 30words, 1122chars (includes 30 carriage returns) for (96bp-12ssbp)*13helices)
Latches
Two-Oligo Latch Sequences
- Latch strands: Ts---any necessary additional bps---15bp overlap---12bp random toehold
- Displacement strands: 5'---12 bp pairing w/ toehold---15 bp pairing w/ rest of oligo, except the T spacers---3'
*latch1B1: barrel strand 10, oligo 60 TTTTTTT GTAACGAAGTTGCAC CACACAACGCTA *disp1B1: displaces latchB1 TAGCGTTGTGTG GTGCAACTTCGTTAC *latch1L1: lid1 strand 6, oligo 2 TTTTTTT GTGCAACTTCGTTAC ACGAGTAATGCG *disp1L1: displaces latchL1 CGCATTACTCGT GTAACGAAGTTGCAC --- *latch1B2: barrel strand 24, oligo 43 TTTTTTTTTTTTTT GTACGCATGGCAAAT TACCACTCTAGC *disp1B2: displaces latchB2 GCTAGAGTGGTA ATTTGCCATGCGTAC *latch1L2: lid1 strand 7, oligo 29 TTTTTTTTTTTTTT ATTTGCCATGCGTAC CGGTTAGATAGC *disp1L2: displaces latchL2 GCTATCTAACCG GTACGCATGGCAAAT --- *latch1B3: barrel strand 10, oligo 21 TTTTTTTTTT TCGAGTTGACAAAGC TACCGGTTCAAG *disp1B3: displaes latchB3 CTTGAACCGGTA GCTTTGTCAACTCGA *latch1L3: lid2 strand 6, oligo 2 TTTTTTTTTTT GCTTTGTCAACTCGA ACTGGCCCTTAA *disp1L3: displaces latchL3 TTAAGGGCCAGT TCGAGTTGACAAAGC --- *latch1B4: barrel strand 24, oligo 27 TTTTTTTTTTTTTT CAGGATACCATCATC TACTAACCGGTG *disp1B4: displaces latchB4 CACCGGTTAGTA GATGATGGTATCCTG *latch1L4: lid2 strand 7, oligo 29 TTTTTTTTTTTTTT GATGATGGTATCCTG GTGGAGTAGTTG *disp1L4: displaces latchL4 CAACTACTCCAC CAGGATACCATCATC
Four-Oligo Latch Sequences
- FIRST ATTACHED-to-BARREL OLIGO:
- 5'---3Ts---Ts for spacers---7 rand bp (called '1A')---8 rand bp (called '1B')---3'
- FIRST ZIPPER OLIGO:
- 5'---8bp complementing 2A---7 bp reverse complementing 1A--12 rand bp toehold---3'
- SECOND ZIPPER OLIGO:
- 5'---8bp reverse complementing 1B---7 bp complementing 2B--12 rand bp toehold---3'
- SECOND ATTACHED-to-BARREL OLIGO:
- 3'---8 rand bp (called '2A')---8 rand bp (called '2B')---Ts for spacers---3Ts---5'
- STRAND DISPLACERS FOR ZIPPER OLIGOS:
- 5'---12 bp pairing w/ toehold---15 bp pairing w/ the rest of the zipper oligo---3'
*latch2B1: barrel strand 10, oligo 60 TTTTTTT CCGGTGC AGAAGTTT *latch2B1z: zipper oligo attached to latch2B1 GTATGGTC GCACCGG TGAGTACCGCTA *latch2L1: lid1 strand 6, oligo 2 TTTTTTT TAGAGAC GACCATAC *latch2L1z: zipper oligo attached to latch2L1 AAACTTCT GTCTCTA TCTCTTCAGTCG *disp2B1z: displaces latch2B1z TAGCGGTACTCA CCGGTGC GACCATAC *disp2L1z: displaces latch2L1z CGACTGAAGAGA TAGAGAC AGAAGTTT --- *latch2B2: barrel strand 24, oligo 43 TTTTTTTTTTTTTT GGATCGG TACATTGT *latch2B2z: zipper oligo attached to latch2B2 GTATTCGA CCGATCC GGACTTTCTAGG *latch2L2: lid1 strand 7, oligo 29 TTTTTTTTTTTTTT AGGCAAC TCGAATAC *latch2L2z: zipper oligo attached to latch2L2 ACAATGTA GTTGCCT GGTTAAGGGTAC *disp2B2z: displaces latch2B2z CCTAGAAAGTCC GGATCGG TCGAATAC *disp2L2z: displaces latch2L2z GTACCCTTAACC AGGCAAC TACATTGT --- *latch2B3: barrel strand 10, oligo 21 TTTTTTTTTT GGCACTC CTACAATT *latch2B3z: zipper oligo attached to latch2B3 GTTGGTCT GAGTGCC GCACGGCAATAA *latch2L3: lid2 strand 6, oligo 2 TTTTTTTTTTT GTAGTAG AGACCAAC *latch2L3z: zipper oligo attached to latch2L3 AATTGTAG CTACTAC CGAAGGCTATTC *disp2B3z: displaces latch2B3z TTATTGCCGTGC GGCACTC AGACCAAC *disp2L3z: displaces latch2L3z GAATAGCCTTCG GTAGTAG CTACAATT --- *latch2B4: barrel strand 24, oligo 27 TTTTTTTTTTTTTT GACGATA GGGAAACA *latch2B4z: zipper oligo attached to latch2B4 TGATCTTC TATCGTC GTTGTGAGCGAT *latch2L4: lid2 strand 7, oligo 29 TTTTTTTTTTTTTT CCTACGA GAAGATCA *latch2L4z: zipper oligo attached to latch2L4 TGTTTCCC TCGTAGG TCAGTGCTTGTG *disp2B4z: displaces latch2B4z ATCGCTCACAAC GACGATA GAAGATCA *disp2L4z: displaces latch2L4z CACAAGCACTGA CCTACGA GGGAAACA
Latch-Including Schematics
-
Barrel schematic showing where oligos need to be cut and latches added
(ai file) -
Lid schematic showing where oligos need to be cut and latches added
(ai file) -
Updated barrel schematic showing latch position and oligo cutting
(ai file) -
Updated lid schematic showing latch position and oligo cutting
(ai file) -
Final barrel schematic with latch and aptamer positions
-
Final lid 1 or 2 schematic with latch positions