IGEM:Harvard/2006/Container Design 4/Python Code: Difference between revisions

From OpenWetWare
Jump to navigationJump to search
No edit summary
 
(23 intermediate revisions by 3 users not shown)
Line 1: Line 1:
==Add aptamers==
<div class="tabs-blue">
<pre>
<ul>
#######
<li>[[IGEM:Harvard/2006/DNA nanostructures|Project Overview]]</li>
# Add aptamers to the ends of the appropriate oligos.
<li id = "current">[[IGEM:Harvard/2006/DNA_nanostructures/Designs|Designs]]</li>
#######
<li>[[IGEM:Harvard/2006/DNA_nanostructures/Notebook|Notebook]]</li>
<li>[[IGEM:Harvard/2006/DNA_nanostructures/Protocols|Protocols]]</li>
<li>[[IGEM:Harvard/2006/DNA_nanostructures/Presentations|Presentations]]</li>
<li>[[IGEM:Harvard/2006/DNA_nanostructures/Literature|Literature]]</li>
</ul>
</div>
<br style="clear:both">


# Constants
<div class = "tabs-blue">
apt_seq = 'GGTTGGTGTGGTTGG'
<ul>
T_linker = 'TTT'
<li>[[IGEM:Harvard/2006/Container Design 1|Design 1]]</li>
       
<li>[[IGEM:Harvard/2006/Container Design 2|Design 2]]</li>
print oligo_ra
<li>[[IGEM:Harvard/2006/Container Design 3|Design 3]]</li>
num_aptamers = int(raw_input('How many aptamers do you want to add? '))
<li id = "current">[[IGEM:Harvard/2006/Container Design 4|Design 4]]</li>
i = 0 
<li>[[IGEM:Harvard/2006/Container Design 5|Design 5]]</li>
while i < num_aptamers:
<li>[[IGEM:Harvard/2006/Container Design 6|Design 6]]</li>
        oligo_num = int(raw_input('Which oligo needs an aptamer? '))
</ul>
        if oligo_num < len(oligo_ra):
</div>
                # Add the aptamer to that oligo
<br style = "clear:both">
                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
<div class="tabs-blue">
</pre>
<ul>
<li>[[IGEM:Harvard/2006/Container_Design_4|Design 4 Overview]]</li>
<li>[[IGEM:Harvard/2006/Container_Design_4/Schematics|Schematics]]</li>
<li>[[IGEM:Harvard/2006/Container_Design_4/Scaffold Sequences|Scaffold]]</li>
<li id = "current">[[IGEM:Harvard/2006/Container_Design_4/Python Code|Code]]</li>
<li>[[IGEM:Harvard/2006/Container_Design_4/Latch Sequences|Latches]]</li>
<li>[[IGEM:Harvard/2006/Container_Design_4/Oligos|Final Oligo List]]</li>
</ul>
</div>
<br style="clear:both">


==Add aptamers using File Input rather than User Input==
<pre>
#####
# 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
==Modifications and Additions to Dr. Shih's Code==
shape = int(raw_input("Enter 1 if you are running a barrel, 2 if lid: "))
The code is fairly general with the exception of the Pickle Scripts which generate lists specific to Design 4 and some hardcoded lists under Oligo Sorting
if (shape == 1): 
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Full_Code_Final|Full Code - Finalized 7/11]]<br>
        apts_to_add = pickle.load(fin_barrel)
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Split_Oligos|Oligo Splitting]]<br>
        for apt_specs in apts_to_add:
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Add_Aptamers|Adding Aptamers]]<br>
                oligo_num = apt_specs[0]
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Add_Latches|Adding Latches]]<br>
                type = apt_specs[1]
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Oligo_Sorting|Oligo Sorting]]<br>
                if (type == 1):
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Pickle_Scripts|Pickle Scripts]]<br>
                        # apt is pointing in so add 'I' as a flag at the end
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Print_Oligo_Grid|Print Oligo Grid]]<br>
                        oligo_ra[oligo_num] = oligo_ra[oligo_num] + T_linker + apt_seq + 'I'
== Other Useful Scripts==
                elif(type == 2):
*[[IGEM:Harvard/2006/Container_Design_4/Python_Code/Split_Scaffold|Split Scaffold]]<br>
                        # 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'
 
</pre>
 
==Split Oligos From User Input==
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
<pre>
 
#####
# 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   
 
 
</pre>
 
 
==Split Oligos From File Input==
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)
 
<pre>
#####
# 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()
       
</pre>
 
==Pickle Split Parameters==
<pre>
### 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()
</pre>
 
==Split Scaffold Sequence into Chunks==
--[[User:Vlau|Vlau]] 16:12, 10 July 2006 (EDT)
<pre>
#!/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 * 14
linker_1 = 200
box = 29 * 96
linker_2 = 200
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
</pre>
 
==Print Aptamer Oligos==
Oligo sorting - find an print out those with aptamers
 
<pre>
 
##### 
# 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
 
 
</pre>
 
==Modiifications to honeycomb_v1 scripts==
*Modifications to William's program to print each oligo number next to what tokens it represents
<pre>
oligo_num = 0
for oligo in OTP_ra:
        for token in oligo:
                print str(oligo_num) + ": ", token
        oligo_num = oligo_num + 1
</pre>
 
*Modifications to William's program to print a grid of oligo numbers completely filled in
* add this part to main (AAA or BBB)
<pre>
####
# 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)
 
</pre>
 
* add this part to honeycomb_pointers_v1.py
<pre>
# 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') 
</pre>

Latest revision as of 07:38, 27 July 2006





Modifications and Additions to Dr. Shih's Code

The code is fairly general with the exception of the Pickle Scripts which generate lists specific to Design 4 and some hardcoded lists under Oligo Sorting

Other Useful Scripts

Retrieved from "https://openwetware.org/mediawiki/index.php?title=IGEM:Harvard/2006/Container_Design_4/Python_Code&oldid=54308"