def create_test6():
toehold_seq = "CTGC"
toehold_seq2 = "CAT"
domain_seq = "CATGCTAAC"
# build complexes with domain-level information
toehold = Domain(name="toehold", sequence=toehold_seq, length=4)
toehold2 = Domain(name="toehold", sequence=toehold_seq2, length=3)
branch_migration = Domain(name="branch_migration", sequence=domain_seq, seq_length=9)
incoming = toehold2.C + branch_migration.C + toehold.C
substrate = toehold + branch_migration + toehold2
start_complex = Complex(strands=[incoming, substrate], structure="(.(+).)")
stop_complex = Complex(strands=[incoming, substrate], structure="...+...")
return createOptions(start_complex, stop_complex, "First Passage Time")
def hairpinopening(options, stemSeq, loopSeq, myTrials=0):
# Using domain representation makes it easier to write secondary structures.
stemdomain1 = Domain(name="stemdomain1", sequence=stemSeq)
loopdomain = Domain(name="loopdomain", sequence=loopSeq)
stemdomain2 = stemdomain1.C
strand = Strand(name="top", domains=[stemdomain1, loopdomain, stemdomain2])
start_complex = Complex(strands=[strand], structure="(.)")
success_complex = Complex(strands=[strand], structure="...")
# N.B.: myTrials input signature is considered "default",
# but in no circumstance will we enable Boltzmann sampling
# Stop when the exact full duplex is achieved.
stopSuccess = StopCondition(
Literals.success, [(success_complex, Literals.exact_macrostate, 0)])
options.start_state = [start_complex]
options.stop_conditions = [stopSuccess]
def create_setup(trials, toehold_seq, toehold_seq2, domain_seq):
# build complexes with domain-level information
toehold = Domain(name="toehold",
sequence=toehold_seq,
length=len(toehold_seq2))
toehold_2 = Domain(name="toehold",
sequence=toehold_seq2,
length=len(toehold_seq2))
branch_migration = Domain(name="branch_migration",
sequence=domain_seq,
seq_length=len(domain_seq))
incoming = branch_migration.C + toehold.C
substrate = toehold + branch_migration + toehold_2
incumbent = Strand(name="incumbent",
domains=[toehold_2.C, branch_migration.C])
# Note that "+" is used to indicate strand breaks.
# So the initial structures represent the incoming strand bound by its toehold,
# and we'll see that either it completes strand displacement, or it dissociates.
start_complex = Complex(strands=[incoming, substrate, incumbent],
structure=".(+)((+))")
stop_complex = Complex(strands=[incoming, substrate, incumbent],
structure="((+))(+).")
full_sc = StopCondition("CLOSED",
[(stop_complex, Literals.exact_macrostate, 0)])
o1 = Options(simulation_mode="First Passage Time",
parameter_type="Nupack",
substrate_type="DNA",
temperature=273.15 + 25.0,
num_simulations=trials,
simulation_time=0.0001,
rate_scaling='Calibrated',
verbosity=0,
start_state=[start_complex],
stop_conditions=[full_sc])
return o1
def create_test0B():
toehold_seq = "CC"
domain_seq = "CAAC"
# build complexes with domain-level information
toehold = Domain(name="toehold", sequence=toehold_seq, length=2)
branch_migration = Domain(name="branch_migration",
sequence=domain_seq,
seq_length=4)
incoming = branch_migration.C + toehold.C
substrate = toehold + branch_migration
# start_complex = Complex(strands=[incoming, substrate], structure="..+..")
# stop_complex = Complex(strands=[incoming, substrate], structure="((+))")
start_complex = Complex(strands=[incoming, substrate], structure="((+))")
stop_complex = Complex(strands=[incoming, substrate], structure="..+..")
return createOptions(start_complex, stop_complex, "First Passage Time")
def create_test2():
top0 = "T"
top1 = "G"
top2 = "G"
bottom0 = "C"
bottom1 = "C"
bottom2 = "A"
# build complexes with domain-level information
strand0 = Domain(name="toehold0", sequence=top0, length=1)
strand1 = Domain(name="toehold1", sequence=top1, length=1)
strand2 = Domain(name="toehold2", sequence=top2, length=1)
strand3 = Domain(name="toehold3", sequence=bottom0, length=1)
strand4 = Domain(name="toehold4", sequence=bottom1, length=1)
strand5 = Domain(name="toehold5", sequence=bottom2, length=1)
substrate = strand3 + strand4 + strand5
invading = strand0 + strand1 + strand2
# start_complex = Complex(strands=[substrate, invading], structure="(..+..)")
# start_complex = Complex(strands=[substrate, invading], structure=".(.+.).")
start_complex = Complex(strands=[substrate, invading], structure="..(+)..")
stop_complex = Complex(strands=[substrate, invading], structure="...+...")
return createOptions(start_complex, stop_complex, "First Passage Time")
def create_test2B():
top0 = "T"
top1 = "T"
top2 = "T"
bottom0 = "A"
bottom1 = "A"
bottom2 = "A"
# build complexes with domain-level information
strand0 = Domain(name="toehold0", sequence=top0, length=1)
strand1 = Domain(name="toehold1", sequence=top1, length=1)
strand2 = Domain(name="toehold2", sequence=top2, length=1)
strand3 = Domain(name="toehold3", sequence=bottom0, length=1)
strand4 = Domain(name="toehold4", sequence=bottom1, length=1)
strand5 = Domain(name="toehold5", sequence=bottom2, length=1)
substrate = strand3 + strand4 + strand5
invading = strand0 + strand1 + strand2
start_complex = Complex(strands=[substrate, invading], structure=".(.+.).")
stop_complex = Complex(strands=[substrate, invading], structure="...+...")
o1 = createOptions(start_complex, stop_complex, "First Passage Time")
# o1.join_concentration = 8
# o1.bimolecular_scaling = 777.0
# o1.DNA23Metropolis()
return o1
def create_test4():
toehold_t = "CTGC"
toehold_dd = "CATATC"
domain_R = "CATTAAC"
# build complexes with domain-level information
toehold = Domain(name="toehold", sequence=toehold_t, length=6)
toehold_2 = Domain(name="toehold", sequence=toehold_dd, length=6)
branch_migration = Domain(name="branch_migration", sequence=domain_R, seq_length=7)
incoming = branch_migration.C + toehold.C
substrate = toehold + branch_migration
# Note that "+" is used to indicate strand breaks.
# So the initial structures represent the incoming strand bound by its toehold,
# and we'll see that either it completes strand displacement, or it dissociates.
start_complex = Complex(strands=[incoming, substrate], structure=".(+).")
stop_complex = Complex(strands=[incoming, substrate], structure="..+..")
full_sc = StopCondition("CLOSED", [(stop_complex, msUtil.Dissoc_Macrostate, 2)])
return createOptions(start_complex, stop_complex, "First Passage Time")
def makeComplex(seq, dotparen):
strandList = []
for seq in seq:
onedomain = Domain(name="domain" + str(makeComplex.counter),
sequence=seq)
makeComplex.counter += 1
onestrand = Strand(domains=[onedomain])
strandList.append(onestrand)
return Complex(strands=strandList, structure=dotparen)
def threewayDisplacement(options,
toeholdSeq,
domainSeq,
doFirstPassage=False,
myTrials=0,
mySuperSample=1):
toeholdDomain = Domain(name="toehold", sequence=toeholdSeq)
disDomain = Domain(name="displacement", sequence=domainSeq)
topS = Strand(name="top", domains=[disDomain])
invaderS = Strand(name="invader", domains=[disDomain, toeholdDomain])
botS = invaderS.C
startComplex = Complex(strands=[topS, botS], structure="(+.)")
invaderComplex = Complex(strands=[invaderS], structure="..")
successComplex = Complex(strands=[botS, invaderS], structure="((+))")
if (myTrials > 0):
setBoltzmann(startComplex, myTrials, mySuperSample)
setBoltzmann(invaderComplex, myTrials, mySuperSample)
# stop when the invasion is complete, or when the invader dissociates
stopSuccess = StopCondition(
Literals.success, [(successComplex, Literals.dissoc_macrostate, 0)])
# Declare the simulation unproductive if the invader becomes single-stranded again.
stopFailed = StopCondition(
Literals.failure, [(invaderComplex, Literals.dissoc_macrostate, 0)])
# set the starting and stopping conditions
options.start_state = [startComplex, invaderComplex]
if doFirstPassage:
options.stop_conditions = [stopSuccess]
else:
options.stop_conditions = [stopFailed, stopSuccess]
def create_setup(seed):
# build complexes with domain-level information
toehold_seq = "GTGGGT"
bm_design_B = "ACCGCACGTCACTCACCTCG"
toehold_extra = "TTT"
toehold = Domain(name="toehold", sequence=toehold_seq, length=6)
branch_migration_B = Domain(name="bm_B",
sequence=bm_design_B,
seq_length=20)
substrate_B = toehold + branch_migration_B
incumbent_B = Strand(name="incumbent", domains=[branch_migration_B.C])
incoming_B = substrate_B.C
start_complex_B1 = Complex(
strands=[incoming_B, substrate_B, incumbent_B],
structure=
"..(.((.....)).).....((((((+))))))((((((((((((((((((((+))))))))))))))))))))"
)
o2 = Options()
o2.simulation_mode = 0x0080 # trajectory mode
o2.current_seed = 20
o2.initial_seed = seed
o2.num_simulations = 1
o2.simulation_time = 0.0001
o2.temperature = 37.0
o2.dangles = 1
o2.start_state = [start_complex_B1]
o2.output_interval = 1
o2.JSDefault()
return o2
def create_test9():
seq0 = "GTGT"
seq1 = "T"
# build complexes with domain-level information
branch = Domain(name="toehold0", sequence=seq0, length=3)
toehold = Domain(name="toehold1", sequence=seq1, length=1)
ghost = Domain(name="toeholdG", sequence="T", length=1)
substrate = toehold + branch
left = toehold.C + ghost
right = branch.C + ghost
# Note that "+" is used to indicate strand breaks.
# So the initial structures represent the incoming strand bound by its toehold,
# and we'll see that either it completes strand displacement, or it dissociates.
start_complex = Complex(strands=[right, left, substrate],
structure="(.+(.+))")
stop_complex = Complex(strands=[left, right, substrate],
structure="..+..+..")
return createOptions(start_complex, stop_complex, "First Passage Time")
def create_options():
print "creating options..."
d1 = Domain(name="d1", sequence="GTTGGTTTGTGTTTGGTGGG")
s1 = Strand(name="s1", domains=[d1])
c1 = Complex(name="c1", strands=[s1], structure=".")
c2 = Complex(name="c2", strands=[s1.C], structure=".")
c3 = Complex(name="c3", strands=[s1, s1.C], structure="(+)")
sc_rev = StopCondition("REVERSE", [(c1, 2, 0), (c2, 2, 0)])
sc_for = StopCondition("END", [(c3, 4, 6)])
o = Options(simulation_mode = 'First Step', num_simulations = 100,
simulation_time = 0.5, start_state = [RestingState("1", [c1]), RestingState("2", [c2])],
stop_conditions = [sc_rev, sc_for])
#o.initial_seed = random.SystemRandom().randrange(-2147483648, 2147483647)
print "finished options. creating simsystem..."
#print o.interface
return o
def __init__(self, input_sequence, base_sequence, output_sequence,
fuel_sequence, toehold_sequence):
count_str = str(NormalSeesawGate.Gate_Count)
self.input_domain = Domain(name="input_domain_" + count_str,
sequence=input_sequence)
self.base_domain = Domain(name="base_domain_" + count_str,
sequence=base_sequence)
self.output_domain = Domain(name="output_domain_" + count_str,
sequence=output_sequence)
self.fuel_domain = Domain(name="fuel_domain_" + count_str,
sequence=fuel_sequence)
self.toehold_domain = Domain(name="toehold_domain_" + count_str,
sequence=toehold_sequence)
# Use the convention of always adding 5' to 3'
# Setup stuff for this type of gate
self.input_strand = self.base_domain + self.toehold_domain + self.input_domain
self.fuel_strand = self.fuel_domain + self.toehold_domain + self.base_domain
self.base_strand = self.toehold_domain.C + \
self.base_domain.C + self.toehold_domain.C
self.output_strand = self.output_domain + \
self.toehold_domain + self.base_domain
self.input_partial = Domain(
name="partial", sequence=self.input_domain.sequence[:SEESAW_DELTA])
self.threshold_base = self.input_partial.C + self.toehold_domain.C + \
self.base_domain.C
self.base_dom_strand = Strand(name="base strand",
domains=[self.base_domain])
self.threshold_free_waste_complex = Complex(
strands=[self.base_dom_strand],
structure='.' * len(self.base_dom_strand.sequence))
self.gate_output_complex = Complex(
strands=[self.base_strand, self.output_strand],
structure=".((+.))")
self.gate_fuel_complex = Complex(
strands=[self.base_strand, self.fuel_strand], structure=".((+.))")
self.gate_input_complex = Complex(
strands=[self.base_strand, self.input_strand], structure="((.+)).")
self.threshold_complex = Complex(
strands=[self.threshold_base, self.base_dom_strand],
structure="..(+)")
self.input_complex = Complex(strands=[self.input_strand],
structure='.' *
len(self.input_strand.sequence))
self.fuel_complex = Complex(strands=[self.fuel_strand],
structure='.' *
len(self.fuel_strand.sequence))
self.output_complex = Complex(strands=[self.output_strand],
structure='.' *
len(self.output_strand.sequence))
NormalSeesawGate.Gate_Count += 1
def makeComplex(sequences, dotparen, ids=None):
strandList = []
for i in range(len(sequences)):
onedomain = Domain(name="domain" + str(makeComplex.counter),
sequence=sequences[i])
makeComplex.counter += 1
onestrand = Strand(domains=[onedomain])
strandList.append(onestrand)
if not ids == None:
onestrand.id = ids[i]
onestrand.name = "a_" + str(ids[i])
return Complex(strands=strandList, structure=dotparen)
def create_test3():
strand_seq = "CTGA"
num_traj = 10
# Essentially, creates the options object and prepares to simulate the hybridization of the strand and its complement.
onedomain = Domain(name="itall", sequence=strand_seq)
top = Strand(name="top", domains=[onedomain])
bot = top.C
# Note that the structure is specified to be single stranded, but this will be over-ridden when Boltzmann sampling is turned on.
start_complex_top = Complex(strands=[top], structure=".")
start_complex_bot = Complex(strands=[bot], structure=".")
start_complex_top.boltzmann_count = num_traj
start_complex_bot.boltzmann_count = num_traj
start_complex_top.boltzmann_sample = True
start_complex_bot.boltzmann_sample = True
# Turns Boltzmann sampling on for this complex and also does sampling more efficiently by sampling 'num_traj' states.
# Stop when the exact full duplex is achieved. (No breathing!)
success_complex = Complex(strands=[top, bot], structure="(+)")
success_stop_condition = StopCondition(
"SUCCESS", [(success_complex, Literals.exact_macrostate, 0)])
# Declare the simulation unproductive if the strands become single-stranded again.
failed_complex = Complex(strands=[top], structure=".")
failed_stop_condition = StopCondition(
"FAILURE", [(failed_complex, Literals.dissoc_macrostate, 0)])
o = Options(simulation_mode="First Step",
parameter_type="Nupack",
substrate_type="DNA",
rate_method="Metropolis",
num_simulations=num_traj,
simulation_time=1.0,
dangles="Some",
temperature=273.15 + 25.0,
rate_scaling="Calibrated",
useArrRates=True,
verbosity=0)
o.start_state = [start_complex_top, start_complex_bot]
o.stop_conditions = [success_stop_condition, failed_stop_condition]
return o
def dissociation(options, mySeq, myTrials=0):
# Using domain representation makes it easier to write secondary structures.
onedomain = Domain(name="itall", sequence=mySeq)
top = Strand(name="top", domains=[onedomain])
bot = top.C
# Note that the structure is specified to be single stranded, but this will be over-ridden when Boltzmann sampling is turned on.
duplex = Complex(strands=[top, bot], structure="(+)")
# Turns Boltzmann sampling on for this complex and also does sampling more efficiently by sampling 'trials' states.
if (myTrials > 0):
setBoltzmann(duplex, myTrials)
# Stop when the strands fall apart.
successComplex = Complex(strands=[top], structure=".")
stopSuccess = StopCondition(
Options.STR_SUCCESS, [(successComplex, Options.dissocMacrostate, 0)])
options.start_state = [duplex]
options.stop_conditions = [stopSuccess]
def doSims(strandSeq, numTraj=2):
curr = time.time()
o1 = standardOptions(tempIn=36.95)
o1.num_simulations = numTraj
o1.output_time = 0.0004 # 0.2 ms output
o1.simulation_time = 0.52 # 10 ms
o1.gt_enable = 1
o1.substrate_type = Literals.substrateRNA
o1.simulation_mode = Literals.trajectory
o1.cotranscriptional = True
# enables the strand growing on the 3' end.
# onedomain = Domain(name="itall", sequence="GGAACCGUCUCCCUCUGCCAAAAGGUAGAGGGAGAUGGAGCAUCUCUCUCUACGAAGCAGAGAGAGACGAAGG")
# onedomain = Domain(name="itall", sequence="GGAACCGTCTCCCTCTGCCAAAAGGTAGAGGGAGATGGAGCATCTCTCTCTACGAAGCAGAGAGAGACGAAGG")
# onedomain = Domain(name="itall", sequence="GGAACCGTCTCCCTCTGCCAAAAGGTAGAGGGAGATGGAGCATCTCTCTCTACGAAGCAGAGAGAGACGAAGGGGAACCGTCTCCCTCTGCCAAAAGGTAGAGGGAGATGGAGCATCTCTCTCTACGAAGCAGAGAGAGACGAAGG")
# onedomain = Domain(name="itall", sequence="ATTCCGGTTGATCCTGCCGGAGGTCATTGCTATTGGGGTCCGATTTAGCCATGCTAGTTGCACGAGTTCATACTCGTGGCGAAAAGCTCAGTAACACGTGGCCAAACTACCCTACAGAGAACGATAACCTCGGGAAACTGAGGCTAATAGTTCATACGGGAGTCATGCTGGAATGCCGACTCCCCGAAACGCTCAGGCGCTGTAGGATGTGGCTGCGGCCGATTAGGTAGACGGTGGGGTAACGGCCCACCGTGCCGATAATCGGTACGGGTTGTGAGAGCAAGAGCCCGGAGACGGAATCTGAGACAAGATTCCGGGCCCTACGGGGCGCAGCAGGCGCGAAACCTTTACACTGCACGCAAGTGCGATAAGGGGACCCCAAGTGCGAGGGCATATAGTCCTCGCTTTTCTCGACCGTAAGGCGGTCGAGGAATAAGAGCTGGGCAAGACCGGTGCCAGCCGCCGCGGTAATACCGGCAGCTCAAGTGATGACCGATATTATTGGGCCTAAAGCGTCCGTAGCCGGCCACGAAGGTTCATCGGGAAATCCGCCAGCTCAACTGGCGGGCGTCCGGTGAAAACCACGTGGCTTGGGACCGGAAGGCTCGAGGGGTACGTCCGGGGTAGGAGTGAAATCCCGTAATCCTGGACGGACCACCGATGGCGAAAGCACCTCGAGAAGACGGATCCGACGGTGAGGGACGAAAGCTAGGGTCTCGAACCGGATTAGATACCCGGGTAGTCCTAGCTGTAAACGATGCTCGCTAGGTGTGACACAGGCTACGAGCCTGTGTTGTGCCGTAGGGAAGCCGAGAAGCGAGCCGCCTGGGAAGTACGTCCGCAAGGATGAAACTTAAAGGAATTGGCGGGGGAGCACTACAACCGGAGGAGCCTGCGGTTTAATTGGACTCAACGCCGGACATCTCACCAGCTCCGACTACAGTGATGACGATCAGGTTGATGACCTTATCACGACGCTGTAGAGAGGAGGTGCATGGCCGCCGTCAGCTCGTACCGTGAGGCGTCCTGTTAAGTCAGGCAACGAGCGAGACCCGCACTTCTAATTGCCAGCAGCAGTTTCGACTGGCTGGGTACATTAGAAGGACTGCCGCTGCTAAAGCGGAGGAAGGAACGGGCAACGGTAGGTCAGTATGCCCCGAATGAGCTGGGCTACACGCGGGCTACAATGGTCGAGACAATGGGTTGCTATCTCGAAAGAGAACGCTAATCTCCTAAACTCGATCGTAGTTCGGATTGAGGGCTGAAACTCGCCCTCATGAAGCTGGATTCGGTAGTAATCGCATTTCAATAGAGTGCGGTGAATACGTCCCTGCTCCTTGCACACACCGCCCGTCAAAGCACCCGAGTGAGGTCCGGATGAGGCCACCACACGGTGGTCGAATCTGGGCTTCGCAAGGGGGCTTAAGTCGTAACAAGGTAGCCGTAGGGGAATCTGCGGCTGGATCACCTCCTG")
# onedomain = Domain(name="itall", sequence="ATTCCGGTTGATCCTGCCGGAGGTCATTGCTATTGGGGTCCGATTTAGCCATGCTAGTTGCACGAGTTCATACTCGTGGCGAAAAGCTCAGTAACACGTGGCCAAACTACCCTACAGAGAACGATAACCTCGGGAAACTGAGGCTAATAGTTCATACGGGAGTCATGCTGGAATGCCGACTCCCCGAAACGCTCAGGCGCTGTAGGATGTGGCTGCGGCCGATTAGGTAGACGGTGGGGTAACGGCCCACCGTGCCGATAATCGGTACGGGTTGTGAGAGCAAGAGCCCGGAGACGGAATCTGAGACAAGATTCCGGGCCCTA") #CGGGGCGCAGCAGGCGCGAAACCTTTACACTGCACGCAAGTGCGATAAGGGGACCCCAAGTGCGAGGGCATATAGTCCTCGCTTTTCTCGACCGTAAGGCGGTCGAGGAATAAGAGCTGGGCAAGACCGGTGCCAGCCGCCGCGGTAATACCGGCAGCTCAAGTGATGACCGATATTATTGGGCCTAAAGCGTCCGTAGCCGGCCACGAAGGTTCATCGGGAAATCCGCCAGCTCAACTGGCGGGCGTCCGGTGAAAACCACGTGGCTTGGGACCGGAAGGCTCGAGGGGTACGTCCGGGGTAGGAGTGAAATCCCGTAATCCTGGACGGACCACCGATGGCGAAAGCACCTCGAGAAGACGGATCCGACGGTGAGGGACGAAAGCTAGGGTCTCGAACCGGATTAGATACCCGGGTAGTCCTAGCTGTAAACGATGCTCGCTAGGTGTGACACAGGCTACGAGCCTGTGTTGTGCCGTAGGGAAGCCGAGAAGCGAGCCGCCTGGGAAGTACGTCCGCAAGGATGAAACTTAAAGGAATTGGCGGGGGAGCACTACAACCGGAGGAGCCTGCGGTTTAATTGGACTCAACGCCGGACATCTCACCAGCTCCGACTACAGTGATGACGATCAGGTTGATGACCTTATCACGACGCTGTAGAGAGGAGGTGCATGGCCGCCGTCAGCTCGTACCGTGAGGCGTCCTGTTAAGTCAGGCAACGAGCGAGACCCGCACTTCTAATTGCCAGCAGCAGTTTCGACTGGCTGGGTACATTAGAAGGACTGCCGCTGCTAAAGCGGAGGAAGGAACGGGCAACGGTAGGTCAGTATGCCCCGAATGAGCTGGGCTACACGCGGGCTACAATGGTCGAGACAATGGGTTGCTATCTCGAAAGAGAACGCTAATCTCCTAAACTCGATCGTAGTTCGGATTGAGGGCTGAAACTCGCCCTCATGAAGCTGGATTCGGTAGTAATCGCATTTCAATAGAGTGCGGTGAATACGTCCCTGCTCCTTGCACACACCGCCCGTCAAAGCACCCGAGTGAGGTCCGGATGAGGCCACCACACGGTGGTCGAATCTGGGCTTCGCAAGGGGGCTTAAGTCGTAACAAGGTAGCCGTAGGGGAATCTGCGGCTGGATCACCTCCTG")
onedomain = Domain(
name="itall",
sequence=
"ATTCCGGTTGATCCTGCCGGAGGTCATTGCTATTGGGGTCCGATTTAGCCATGCTAGTTGCACGAGTTCATACTCGTGGCGAAAAGCTCAGTAACACGTGGCCAAACTACCCTACAGAGAACGATAACCTCGGGAAACTGAGGCTAATAGTTCATACGGGAGTCATGCTGGAATGCCGACTCCCCGAAACGCTCAGGCGCTGTAGGATGTGGCTGCGGCCGATTAGGTAGACGGTGGGGTAACGGCCCACCGTGCCGATAATCGGTACGGGTTGTGAGAGCAAGAGCCCGGAGACGGAATCTGAGACAAGATTCCGGGCCCTACGGGGCGCAGCAGGCGCGAAACCTTTACACTGCACGCAAGTGCGATAAGGGGACCCCAAGTGCGAGGGCATATAGTCCTCGCTTTTCTCGACCGTAAGGCGGTCGAGGAATAAGAGCTGGGCAAGACCGGTGCCAGCCGCCGCGGTAATACCGGCAGCTCAAGTGATGA"
) #CCGATATTATTGGGCCTAAAGCGTCCGTAGCCGGCCACGAAGGTTCATCGGGAAATCCGCCAGCTCAACTGGCGGGCGTCCGGTGAAAACCACGTGGCTTGGGACCGGAAGGCTCGAGGGGTACGTCCGGGGTAGGAGTGAAATCCCGTAATCCTGGACGGACCACCGATGGCGAAAGCACCTCGAGAAGACGGATCCGACGGTGAGGGACGAAAGCTAGGGTCTCGAACCGGATTAGATACCCGGGTAGTCCTAGCTGTAAACGATGCTCGCTAGGTGTGACACAGGCTACGAGCCTGTGTTGTGCCGTAGGGAAGCCGAGAAGCGAGCCGCCTGGGAAGTACGTCCGCAAGGATGAAACTTAAAGGAATTGGCGGGGGAGCACTACAACCGGAGGAGCCTGCGGTTTAATTGGACTCAACGCCGGACATCTCACCAGCTCCGACTACAGTGATGACGATCAGGTTGATGACCTTATCACGACGCTGTAGAGAGGAGGTGCATGGCCGCCGTCAGCTCGTACCGTGAGGCGTCCTGTTAAGTCAGGCAACGAGCGAGACCCGCACTTCTAATTGCCAGCAGCAGTTTCGACTGGCTGGGTACATTAGAAGGACTGCCGCTGCTAAAGCGGAGGAAGGAACGGGCAACGGTAGGTCAGTATGCCCCGAATGAGCTGGGCTACACGCGGGCTACAATGGTCGAGACAATGGGTTGCTATCTCGAAAGAGAACGCTAATCTCCTAAACTCGATCGTAGTTCGGATTGAGGGCTGAAACTCGCCCTCATGAAGCTGGATTCGGTAGTAATCGCATTTCAATAGAGTGCGGTGAATACGTCCCTGCTCCTTGCACACACCGCCCGTCAAAGCACCCGAGTGAGGTCCGGATGAGGCCACCACACGGTGGTCGAATCTGGGCTTCGCAAGGGGGCTTAAGTCGTAACAAGGTAGCCGTAGGGGAATCTGCGGCTGGATCACCTCCTG")
top = Strand(name="top", domains=[onedomain])
startTop = Complex(strands=[top], structure=".")
o1.start_state = [startTop]
setArrParams(o1, 92)
# o1.initial_seed = 1777+6
s = SimSystem(o1)
s.start()
printTrajectory(o1)
print "Exe time is " + str(time.time() - curr)
def setup_options(trials, seq, concentration):
"""
setup_options( seq )
creates an Options object using the sequence passed as a single
domain with initially unpaired structure.
"""
d = Domain(name="initial", sequence=seq, length=len(seq))
s = Strand(domains=[d])
c = Complex(strands=[s], structure=".")
o = Options(simulation_mode="Normal",
parameter_type="Nupack",
substrate_type="DNA",
num_sims=trials,
sim_time=0.008,
start_state=[c])
o.DNA23Metropolis()
o.temperature = 310.15
o.join_concentration = concentration
return o
def hybridization(options, mySeq, myTrials=0, doFirstPassage=False):
# Using domain representation makes it easier to write secondary structures.
onedomain = Domain(name="itall", sequence=mySeq)
top = Strand(name="top", domains=[onedomain])
bot = top.C
# Note that the structure is specified to be single stranded, but this will be over-ridden when Boltzmann sampling is turned on.
startTop = Complex(strands=[top], structure=".")
startBot = Complex(strands=[bot], structure=".")
# Turns Boltzmann sampling on for this complex and also does sampling more efficiently by sampling 'trials' states.
if (myTrials > 0):
setBoltzmann(startTop, myTrials)
setBoltzmann(startBot, myTrials)
# Stop when the exact full duplex is achieved.
success_complex = Complex(strands=[top, bot], structure="(+)")
stopSuccess = StopCondition(
Options.STR_SUCCESS, [(success_complex, Options.exactMacrostate, 0)])
# Declare the simulation unproductive if the strands become single-stranded again.
failed_complex = Complex(strands=[top], structure=".")
stopFailed = StopCondition(Options.STR_FAILURE,
[(failed_complex, Options.dissocMacrostate, 0)])
options.start_state = [startTop, startBot]
# Point the options to the right objects
if not doFirstPassage:
options.stop_conditions = [stopSuccess, stopFailed]
else:
options.stop_conditions = [stopSuccess]
myMultistrand.setNumOfThreads(8)
LONG_SEQ2 = "CCAAACAAAACCTAT"
LONG_SEQ5 = "AACCACCAAACTTAT"
LONG_SEQ6 = "CCTAACACAATCACT"
# some ive made up, but these shouldn't make much difference
LONG_SEQ7 = "CCACAAAACAAAACT"
LONG_SEQ1 = "CATCCATTCAACTAT"
LONG_SEQT = "CTCT"
# The actual main method
if __name__ == '__main__':
toehold_dom = Domain(name="T", sequence=LONG_SEQT)
base_dom = Domain(name="S2", sequence=LONG_SEQ2+LONG_SEQ2)
input_dom = Domain(name="S5", sequence=LONG_SEQ5+LONG_SEQ5)
output_dom = Domain(name="S6", sequence=LONG_SEQ6+LONG_SEQ6)
input_strand = base_dom + toehold_dom + input_dom
output_strand = output_dom + toehold_dom + base_dom
base_strand = toehold_dom.C + base_dom.C + toehold_dom.C
gate_complex = Complex(strands=[base_strand, output_strand], structure = ".((+.))")
input_complex = Complex(strands=[input_strand], structure="...")
intermediate_complex = Complex(strands=[base_strand, output_strand, input_strand], structure = "(((+.).+.))")
output_complex = Complex(strands=[output_strand], structure="...")
success_stop_condition = StopCondition(
Options.STR_SUCCESS, [(intermediate_complex, Options.looseMacrostate, 6)])
def __init__(self,
input_sequence,
base_sequence,
output_sequence,
fuel_sequence,
toehold_sequence,
clamp_sequence="CG"):
count_str = str(ClampedSeesawGate.Gate_Count) + '_Cl '
self.input_domain = Domain(name="input_domain_" + count_str,
sequence=input_sequence)
self.base_domain = Domain(name="base_domain_" + count_str,
sequence=base_sequence)
self.output_domain = Domain(name="output_domain_" + count_str,
sequence=output_sequence)
self.fuel_domain = Domain(name="fuel_domain_" + count_str,
sequence=fuel_sequence)
self.toehold_domain = Domain(name="toehold_domain_" + count_str,
sequence=toehold_sequence)
self.clamp_domain = Domain(name="clamp_domain_" + count_str,
sequence=clamp_sequence)
# Use the convention of always adding 5' to 3'
# Setup stuff for this type of gate
# Clamp domain setup - add clamp domains either side of each recognition domain
self.input_strand = self.clamp_domain + self.base_domain + self.clamp_domain + \
self.toehold_domain + self.clamp_domain + self.input_domain + self.clamp_domain
self.fuel_strand = self.clamp_domain + self.fuel_domain + self.clamp_domain + \
self.toehold_domain + self.clamp_domain + self.base_domain + self.clamp_domain
self.base_strand = self.clamp_domain.C + self.toehold_domain.C + self.clamp_domain.C + \
self.base_domain.C + self.clamp_domain.C + \
self.toehold_domain.C + self.clamp_domain.C
self.output_strand = self.clamp_domain + self.output_domain + self.clamp_domain + \
self.toehold_domain + self.clamp_domain + self.base_domain + self.clamp_domain
self.input_partial = Domain(
name="partial", sequence=self.input_domain.sequence[:SEESAW_DELTA])
self.threshold_base = self.input_partial.C + self.clamp_domain.C + \
self.toehold_domain.C + self.clamp_domain + \
self.base_domain.C + self.clamp_domain
self.base_dom_strand = self.clamp_domain + self.base_domain + self.clamp_domain
self.gate_output_complex = Complex(
strands=[self.base_strand, self.output_strand],
structure="..(((((+..)))))")
self.gate_fuel_complex = Complex(
strands=[self.base_strand, self.fuel_strand],
structure="..(((((+..)))))")
self.gate_input_complex = Complex(
strands=[self.base_strand, self.input_strand],
structure="(((((..+)))))..")
self.threshold_complex = Complex(
strands=[self.threshold_base, self.base_dom_strand],
structure="...(((+)))")
self.input_complex = Complex(strands=[self.input_strand],
structure='.' *
len(self.input_strand.sequence))
self.fuel_complex = Complex(strands=[self.fuel_strand],
structure='.' *
len(self.fuel_strand.sequence))
self.output_complex = Complex(strands=[self.output_strand],
structure='.' *
len(self.output_strand.sequence))
ClampedSeesawGate.Gate_Count += 1
