def simulationFlamm2000(trialsIn):
seq = "GGCCCCTTTGGGGGCCAGACCCCTAAAGGGGTC"
structStart = "................................."
struct0 = "((((((((((((((.....))))))))))))))"
struct1 = "((((((....)))))).((((((....))))))"
stdOptions = standardOptions(simMode=Literals.trajectory,
trials=trialsIn,
tempIn=37.0)
stdOptions.substrate_type = Literals.substrateRNA
stdOptions.gt_enable = 1
stdOptions.simulation_time = A_TIME_OUT
stdOptions.DNA23Metropolis()
stemdomain1 = Domain(name="stemdomain1", sequence=seq)
strand = Strand(name="top", domains=[stemdomain1])
startComplex = Complex(strands=[strand], structure=structStart)
successComplex0 = Complex(strands=[strand], structure=struct0)
successComplex1 = Complex(strands=[strand], structure=struct1)
# Stop when the exact full duplex is achieved.
stopSuccess0 = StopCondition(
Literals.success, [(successComplex0, Literals.exact_macrostate, 0)])
stopSuccess1 = StopCondition(
Literals.alt_success,
[(successComplex1, Literals.exact_macrostate, 0)])
stdOptions.start_state = [startComplex]
stdOptions.stop_conditions = [stopSuccess0, stopSuccess1]
return stdOptions
def calculateGateGateLeak(gateA, gateB, trials=INCREMENT_TRIALS, material="DNA"):
# define stop conditions
gateA_complex = gateA.gate_output_complex
gateB_complex = gateB.gate_output_complex
leak_complex = gateB.output_complex
alt_leak_complex = gateA.output_complex
success_stop_condition = StopCondition(
Options.STR_SUCCESS, [(leak_complex,
Options.dissocMacrostate, 0)])
alt_success_stop_condition = StopCondition(
Options.STR_ALT_SUCCESS, [(alt_leak_complex, Options.dissocMacrostate, 0)])
failed_stop_condition = StopCondition(
Options.STR_FAILURE, [(gateA_complex,
Options.dissocMacrostate, 0)])
myMultistrand.setOptionsFactory6(getOptions, trials, material,
gateA_complex, gateB_complex,
[success_stop_condition,
alt_success_stop_condition],
[failed_stop_condition])
return getRates()
def leakInvasion(options, mySeq, myTrials=0, doFirstPassage=False):
onedomain = Domain(name="d1", sequence=mySeq)
top = Strand(name="top", domains=[onedomain])
bot = top.C
initial_complex = Complex(strands=[top, bot], structure="(+)")
invader_top = Complex(strands=[top], structure=".")
# Turns Boltzmann sampling on for this complex and also does sampling more efficiently by sampling 'trials' states.
if (myTrials > 0):
setBoltzmann(initial_complex, myTrials)
setBoltzmann(invader_top, myTrials)
# Stop when the exact full duplex is achieved.
stopSuccess = StopCondition(
Literals.success, [(success_complex, Literals.exact_macrostate, 0)])
# Declare the simulation unproductive if the strands become single-stranded again.
failed_complex = Complex(strands=[top], structure=".")
stopFailed = StopCondition(
Literals.failure, [(failed_complex, Literals.dissoc_macrostate, 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]
def simulationYurke(trialsIn):
stdOptions = standardOptions(simMode=Literals.first_passage_time,
trials=trialsIn)
stdOptions.simulation_time = A_TIME_OUT
stdOptions.DNA23Metropolis()
stdOptions.temperature = 25.0
domS = Domain(sequence="ACTAATCCTCAGATCCAGCTAGTGTC", name="d_S")
domD = Domain(sequence="A", name="d_A")
domT = Domain(sequence="CGTACT", name="d_T")
strandQ = Strand(domains=[domS, domD])
strandT = Strand(domains=[domT, domS])
strandS = strandT.C
complexStart = Complex(strands=[strandQ, strandS, strandT],
structure="(.+)(+).")
complexEndS = Complex(strands=[strandQ], structure="..")
complexEndF = Complex(strands=[strandT],
structure="..") # # ALT_SUCCESS is dissociation
stopSuccess = StopCondition(Literals.success,
[(complexEndS, Literals.dissoc_macrostate, 3)])
stopFailed = StopCondition(Literals.alt_success,
[(complexEndF, Literals.dissoc_macrostate, 3)])
stdOptions.start_state = [complexStart]
stdOptions.stop_conditions = [stopSuccess, stopFailed]
return stdOptions
def two_input(options,
input_complex_A,
input_complex_B,
output_complex,
trials=0,
supersample=25,
doFirstPassage=False):
if (trials > 0):
for x in [input_complex_A, input_complex_B]:
setBoltzmann(x, trials, supersample)
successful_stop_condition = StopCondition(
Literals.success, [(output_complex, Literals.dissoc_macrostate, 0)])
failure_stop_condition = StopCondition(
Literals.failure, [(input_complex_B, Literals.dissoc_macrostate, 0)])
options.start_state = [input_complex_A, input_complex_B]
# Point the options to the right objects
if not doFirstPassage:
options.stop_conditions = [
successful_stop_condition, failure_stop_condition
]
else:
options.stop_conditions = [successful_stop_condition]
def threewayDisplacement(options,
toeholdSeq,
domainSeq,
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(
Options.STR_SUCCESS, [(successComplex, Options.dissocMacrostate, 0)])
# Declare the simulation unproductive if the invader becomes single-stranded again.
stopFailed = StopCondition(Options.STR_FAILURE,
[(invaderComplex, Options.dissocMacrostate, 0)])
#set the starting and stopping conditions
options.start_state = [startComplex, invaderComplex]
options.stop_conditions = [stopFailed, stopSuccess]
def two_input_two_success(trials,
options,
input_complex_A,
input_complex_B,
output_complex_A,
output_complex_B,
supersample=25,
doFirstPassage=False):
if (trials > 0):
for x in [input_complex_A, input_complex_B]:
setBoltzmann(x, trials, supersample)
successful_stop_condition = StopCondition(
Options.STR_SUCCESS, [(output_complex_A, Options.dissocMacrostate, 0)])
alt_successful_stop_condition = StopCondition(
Options.STR_ALT_SUCCESS,
[(output_complex_B, Options.dissocMacrostate, 0)])
failure_stop_condition = StopCondition(
Options.STR_FAILURE, [(input_complex_B, Options.dissocMacrostate, 0)])
options.start_state = [input_complex_A, input_complex_B]
# Point the options to the right objects
if not doFirstPassage:
options.stop_conditions = [
successful_stop_condition, alt_successful_stop_condition,
failure_stop_condition
]
else:
options.stop_conditions = [
successful_stop_condition, alt_successful_stop_condition
]
def first_step_simulation(strand_seq, trials, T=25, material="DNA"):
print(
"Running first step mode simulations for %s (with Boltzmann sampling)..."
% (strand_seq))
# Using domain representation makes it easier to write secondary structures.
onedomain = Domain(name="onedomain", sequence=strand_seq)
gdomain = Domain(name="gdomain", sequence="TTTT")
top = Strand(name="top", domains=[onedomain])
bot = top.C
dangle = Strand(name="Dangle", domains=[onedomain, gdomain])
duplex_complex = Complex(strands=[top, bot], structure="(+)")
invader_complex = Complex(strands=[dangle], structure="..")
duplex_invaded = Complex(strands=[dangle, bot], structure="(.+)")
# Declare the simulation complete if the strands become a perfect duplex.
success_stop_condition = StopCondition(
Options.STR_SUCCESS, [(duplex_invaded, Options.exactMacrostate, 0)])
failed_stop_condition = StopCondition(
Options.STR_FAILURE, [(duplex_complex, Options.dissocMacrostate, 0)])
for x in [duplex_complex, invader_complex]:
x.boltzmann_count = trials
x.boltzmann_sample = True
# the first argument has to be trials.
def getOptions(trials, material, duplex_complex, dangle,
success_stop_condition, failed_stop_condition):
o = Options(simulation_mode="First Step",
substrate_type=material,
rate_method="Metropolis",
num_simulations=trials,
simulation_time=ATIME_OUT,
temperature=T)
o.start_state = [duplex_complex, dangle]
o.stop_conditions = [success_stop_condition, failed_stop_condition]
# FD: The result of this script depend significantly on JS or DNA23 parameterization.
# o.JSMetropolis25()
# o.DNA23Metropolis()
setArrheniusConstantsDNA23(o)
return o
myMultistrand.setOptionsFactory6(getOptions, trials, material,
duplex_complex, invader_complex,
success_stop_condition,
failed_stop_condition)
myMultistrand.run()
myFSR = myMultistrand.results
# Now determine the reaction model parameters from the simulation results.
# myFSR = FirstStepRate(dataset, 5e-9)
print myFSR
def ravan(options, trialsIn, selector):
# we only allow first step mode at this point.
if PENG_YIN == True:
RAVAN_H1 = "GCTTGAGATGTTAGGGAGTAGTGCTCCAATCACAACGCACTACTCCCTAACATC"
RAVAN_H2 = "AGGGAGTAGTGCGTTGTGATTGGAAACATCTCAAGCTCCAATCACAACGCACTA"
RAVAN_H3 = "GTTGTGATTGGAGCTTGAGATGTTGCACTACTCCCTAACATCTCAAGCTCCAAT"
RAVAN_I = "GCACTACTCCCTAACATCTCAAGC"
strand_H1 = Strand(name="H1", sequence=RAVAN_H1)
strand_H2 = Strand(name="H2", sequence=RAVAN_H2)
strand_H3 = Strand(name="H3", sequence=RAVAN_H3)
strand_I = Strand(name="I", sequence=RAVAN_I)
dotparen_H1 = "." * len(RAVAN_H1)
dotparen_H2 = "." * len(RAVAN_H2)
dotparen_H3 = "." * len(RAVAN_H3)
dotparen_I = "." * len(RAVAN_I)
""" No special secondary structure, just a hack to make a connected
complex composed of the correct set of strands """
dotparen_I_H1 = '(' + ("." * (len(RAVAN_I) - 1)) + "+" + ')' + ("." * (len(RAVAN_H1) - 1))
dotparen_I_H1_H2 = '(' + ("." * (len(RAVAN_I) - 1)) + "+" + ')' + ("." * (len(RAVAN_H1) - 2)) + "(" + "+" + ")" + ("." * (len(RAVAN_H2) - 1))
dotparen_H1_H2_H3 = '(' + ("." * (len(RAVAN_H1) - 1)) + "+" + ')' + ("." * (len(RAVAN_H2) - 2)) + '(' + "+" + ')' + ("." * (len(RAVAN_H3) - 1))
if selector == 0:
target_complex = Complex(strands=[strand_H1], structure=dotparen_H1)
complex_trigger = Complex(strands=[strand_I], structure=dotparen_I)
success_complex = Complex(strands=[strand_I, strand_H1], structure=dotparen_I_H1)
if selector == 1:
target_complex = Complex(strands=[strand_I, strand_H1], structure=dotparen_I_H1)
complex_trigger = Complex(strands=[strand_H2], structure=dotparen_H2)
success_complex = Complex(strands=[strand_I, strand_H1, strand_H2], structure=dotparen_I_H1_H2)
if selector == 2:
target_complex = Complex(strands=[strand_I, strand_H1, strand_H2], structure=dotparen_I_H1_H2)
complex_trigger = Complex(strands=[strand_H3], structure=dotparen_H3)
success_complex = Complex(strands=[strand_H1, strand_H2, strand_H3], structure=dotparen_H1_H2_H3)
setBoltzmann(complex_trigger, trialsIn)
setBoltzmann(target_complex, trialsIn)
stopSuccess = StopCondition(Literals.success, [(success_complex, Literals.dissoc_macrostate, 0)])
stopFailed = StopCondition(Literals.failure, [(complex_trigger, Literals.dissoc_macrostate, 0)])
# actually set the intial and stopping states
options.start_state = [complex_trigger, target_complex]
options.stop_conditions = [stopSuccess, stopFailed]
def simulationRickettsia(trialsIn):
stdOptions = standardOptions(simMode=Literals.first_passage_time,
trials=trialsIn)
stdOptions.simulation_time = A_TIME_OUT
stdOptions.DNA23Metropolis()
stdOptions.temperature = 25.0
stdOptions.magnesium = 0.0125
stdOptions.sodium = 0.1
dom_a = Domain(sequence="ATTCAA", name="a") # length 6
dom_b = Domain(sequence="GCGACACCGTGGACGTGC", name="b") # length 18
dom_c = Domain(sequence="ACCCAC", name="c") # length 6
dom_x = Domain(sequence="GGT", name="x") # length 3
dom_y = Domain(sequence="AAC", name="y") # length 3
strand_H1 = Strand(domains=[dom_a, dom_b, dom_c, dom_b.C, dom_x.C])
strand_H2 = Strand(domains=[dom_y.C, dom_b.C, dom_a.C, dom_b, dom_c.C])
strand_A = Strand(domains=[dom_b.C, dom_a.C])
strand_B = Strand(domains=[dom_x, dom_b, dom_y])
strand_R = Strand(domains=[dom_x, dom_b, dom_y])
H1 = Complex(strands=[strand_H1], structure=".(.).", name="H1")
H2 = Complex(strands=[strand_H2], structure=".(.).", name="H2")
# state1 = Complex(strands=[strand_H1, strand_R, strand_A], structure="((.)*+*(.+))") # domain x does not have to be bound
state2 = Complex(strands=[strand_H1, strand_R, strand_A],
structure="((.((+)).+))",
name="state2")
state3 = Complex(strands=[strand_H1, strand_R, strand_H2, strand_A],
structure="(((((+))(+)(.))+))")
# state4 = Complex(strands=[strand_H1, strand_R, strand_H2, strand_A], structure="(((((+)((+)).))+))", name = "state4")
state5 = Complex(strands=[strand_H1, strand_R, strand_H2, strand_A],
structure="((((.+.((+)).))+))",
name="state5")
# state6 = Complex(strands=[strand_H1, strand_H1, strand_R, strand_H2, strand_A], structure="((((.+((.)*+*((+)))))+))") # domain x does not have to be bound
# state6 = Complex(strands=[strand_H1, strand_H1, strand_R, strand_H2, strand_A], structure="((((.+((.).+.((+)))))+))", name = "state6")
# state7 = Complex(strands=[strand_H1, strand_H1, strand_R, strand_H2, strand_A], structure="((((.+((.((+))*+*))))+))", name = "state7")
stopFailure = StopCondition(Literals.failure,
[(state2, Literals.dissoc_macrostate, 0)])
stopSuccess = StopCondition(Literals.success,
[(state5, Literals.loose_macrostate, 6)])
stdOptions.start_state = [state3]
stdOptions.stop_conditions = [stopSuccess, stopFailure]
stdOptions.join_concentration = 0.001
return stdOptions
def doExperiment(trials):
# complexes
seqOutput = "CTACTTTCACCCTACGTCTCCAACTAACTTACGG"
seqSignal = "CCACATACATCATATTCCCTCATTCAATACCCTACG"
seqBackbone = "TGGAGACGTAGGGTATTGAATGAGGGCCGTAAGTT"
# output + signal + backbone
complex_dotparen = "." * 10 + "(" * (len(seqOutput) - 10)
complex_dotparen += "+" + "." * 16 + "(" * (len(seqSignal) - 16)
complex_dotparen += "+" + "." * 6 + ")" * (len(seqBackbone) - 6)
myGate = makeComplex([seqOutput, seqSignal, seqBackbone], complex_dotparen)
seqFuel = "CCTACGTCTCCAACTAACTTACGGCCCTCATTCAATACCCTACG"
myFuel = makeComplex([seqFuel], "." * len(seqFuel))
myLeakedSignal = makeComplex([seqSignal], "." * len(seqSignal))
for x in [myGate, myFuel]:
setBoltzmann(x, trials, supersample=10)
# stopping states
# the failed state is when the fuel releases again
# the success state is when the leaked signal is observed.
# we use dissocMacrostate - this only checks the presence of strands in the complex, and
# does not depend on dotparens structure.
successStopping = StopCondition(
Options.STR_SUCCESS, [(myLeakedSignal, Options.dissocMacrostate, 0)])
failedStopping = StopCondition(Options.STR_FAILURE,
[(myFuel, Options.dissocMacrostate, 0)])
# options
stdOptions = standardOptions(trials=trials)
stdOptions.start_state = [myGate, myFuel]
stdOptions.stop_conditions = [successStopping, failedStopping]
# buffer and temperature
stdOptions.sodium = 0.05
stdOptions.magnesium = 0.0125 ## believed to be 11.5 mM effectively -- using 12.5 mM anyway
stdOptions.temperature = 25 # can run at higher temperature to increase leak rate.
# rate model
stdOptions.DNA23Metropolis()
#setArrheniusConstantsDNA23(stdOptions)
stdOptions.simulation_time = 10.0
return stdOptions
def simulationYurke2(trialsIn):
stdOptions = standardOptions(simMode=Literals.first_passage_time,
trials=trialsIn)
stdOptions.simulation_time = A_TIME_OUT
stdOptions.DNA23Metropolis()
domS = Domain(sequence="ACTAATCCTCAGATCCAGCTAGTGTC", name="d_S")
domD = Domain(sequence="A", name="d_A")
domT = Domain(sequence="CGTACT", name="d_T")
strandQ = Strand(domains=[domS, domD])
strandT = Strand(domains=[domT, domS])
strandS = strandT.C
# complexEndS = Complex(strands=[strandQ], structure="..")
complexEndF = Complex(strands=[strandT], structure="..")
complexEndFC = Complex(strands=[strandQ, strandS], structure="(.+).")
complexAttached = Complex(strands=[strandQ, strandS, strandT],
structure="**+*(+)*")
stopSuccess = StopCondition(
Literals.success, [(complexAttached, Literals.loose_macrostate, 1)])
stdOptions.start_state = [complexEndF, complexEndFC]
stdOptions.stop_conditions = [stopSuccess]
stdOptions.join_concentration = 0.0001 # 100 microMolar
return stdOptions
def setup_options_hairpin(trials, stem_seq, hairpin_seq):
# Define the domains
stem = Domain(name="stem", sequence=stem_seq, length=len(stem_seq))
hairpin = Domain(name="hairpin",
sequence=hairpin_seq,
length=len(hairpin_seq))
s = stem + hairpin + stem.C
# We give domain-level structures for the open and closed hairpin configurations
start_complex = Complex(strands=[s], structure="...")
stop_complex = Complex(strands=[s], structure="(.)")
full_sc = StopCondition("CLOSED",
[(stop_complex, Literals.exact_macrostate, 0)])
# Note: unlike in Transition Mode, in First Passage Time Mode, no "stop:" prefix is needed in the macrostate name
# in order for the StopCondition to trigger the end of the simulation.
o = Options(simulation_mode="First Passage Time",
parameter_type="Nupack",
substrate_type="DNA",
temperature=310.15,
num_simulations=trials,
simulation_time=0.1,
rate_scaling='Calibrated',
verbosity=0,
start_state=[start_complex],
stop_conditions=[full_sc])
return o
def create_test0C():
domain_seq = "AGT"
domain_seq2 = "GTA"
left = Domain(name="branch_migration", sequence=domain_seq, seq_length=3)
right = Domain(name="branch_migration2",
sequence=domain_seq2,
seq_length=3)
incoming = left + right
substrate = incoming.C
start_complex1 = Complex(strands=[incoming], structure="..")
start_complex2 = Complex(strands=[substrate], structure="..")
stop_complex = Complex(strands=[incoming, substrate], structure="((+))")
full_sc = StopCondition("CLOSED",
[(stop_complex, Literals.dissoc_macrostate, 2)])
o1 = Options(simulation_mode=Literals.first_passage_time,
temperature=273.15 + 25.0,
num_simulations=10,
simulation_time=0.00001,
rate_scaling='Calibrated',
verbosity=0,
join_concentration=1e-9,
rate_method="Metropolis",
start_state=[start_complex1, start_complex2],
stop_conditions=[full_sc])
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, Literals.dissoc_macrostate, 2)])
return createOptions(start_complex, stop_complex, "First Passage Time")
def first_step_simulation(strand_seq, trials, T=25, material="DNA"):
print ("Running %i first step mode simulations for %s (with Boltzmann sampling)..." % (trials, strand_seq))
# Using domain representation makes it easier to write secondary structures.
onedomain = Domain(name="onedomain", sequence=strand_seq)
gdomain = Domain(name="gdomain", sequence="TTTT")
top = Strand(name="top", domains=[onedomain])
bot = top.C
dangle = Strand(name="Dangle", domains=[onedomain, gdomain])
duplex_complex = Complex(strands=[top, bot], structure="(+)")
invader_complex = Complex(strands=[dangle], structure="..")
duplex_invaded = Complex(strands=[dangle, bot], structure="(.+)")
# Declare the simulation complete if the strands become a perfect duplex.
success_stop_condition = StopCondition(Options.STR_SUCCESS, [(duplex_invaded, Options.exactMacrostate, 0)])
failed_stop_condition = StopCondition(Options.STR_FAILURE, [(duplex_complex, Options.dissocMacrostate, 0)])
for x in [duplex_complex, invader_complex]:
x.boltzmann_count = trials
x.boltzmann_sample = True
# the first argument has to be trials.
def getOptions(trials, material, duplex_complex, dangle, success_stop_condition, failed_stop_condition):
o = Options(simulation_mode="First Step", substrate_type=material, rate_method="Metropolis",
num_simulations=trials, simulation_time=ATIME_OUT, temperature=T)
o.start_state = [duplex_complex, dangle]
o.stop_conditions = [success_stop_condition, failed_stop_condition]
# FD: The result of this script depend significantly on JS or DNA23 parameterization.
o.unimolecular_scaling = 5.0e6;
o.bimolecular_scaling = 1.4e6;
return o
myOptions = getOptions(trials,material, duplex_complex, invader_complex, success_stop_condition, failed_stop_condition)
s = SimSystem(myOptions)
s.start()
print "debug_mac2 finished running."
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 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 calculateGateInputRate(gate_complex, input_complex, output_complex, trials=INCREMENT_TRIALS, alt_output_complex=None):
success_stop_condition = StopCondition(
Options.STR_SUCCESS, [(output_complex, Options.dissocMacrostate, 0)])
failed_stop_condition = StopCondition(
Options.STR_FAILURE, [(input_complex, Options.dissocMacrostate, 0)])
try:
if alt_output_complex is None:
raise TypeError
alt_success_stop_condition = StopCondition(
Options.STR_ALT_SUCCESS, [(output_complex, Options.dissocMacrostate, 0)])
myMultistrand.setOptionsFactory6(getOptions, trials, DNA,
gate_complex, input_complex,
[success_stop_condition,
alt_success_stop_condition],
[failed_stop_condition])
except TypeError:
myMultistrand.setOptionsFactory6(getOptions, trials, DNA, gate_complex, input_complex, [
success_stop_condition], [failed_stop_condition])
return getRates()
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]
def getOptions(arguments):
o = standardOptions()
o.simulation_mode = Literals.trajectory
o.num_simulations = 80
o.temperature = 30.0
o.simulation_time = 0.0000001
endComplex = arguments[0]
stopSuccess = StopCondition(Literals.success,
[(endComplex, Literals.exact_macrostate, 0)])
o.stop_conditions = [stopSuccess]
return o
def createOptions(start_complex, stop_complex, simMode):
full_sc = StopCondition("CLOSED", [(stop_complex, Options.dissocMacrostate, 2)])
o1 = Options(simulation_mode=simMode, # "First Passage Time",
parameter_type="Nupack", substrate_type="DNA", temperature=273.15 + 25.0,
num_simulations=10,
simulation_time=0.00001,
rate_scaling='Calibrated',
verbosity=0,
join_concentration=1e-9,
rate_method="Metropolis",
start_state=[start_complex],
stop_conditions=[full_sc])
return o1
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 getOptions(arguments):
o = standardOptions()
o.simulation_mode = Literals.trajectory
o.num_simulations = B_MULT * form_f["trajectories"]
o.sodium = form_f['sodium']
o.magnesium = form_f['magnesium']
o.temperature = float(form_f['temperature'])
o.simulation_time = BUILDER_TIMEOUT
if "RNA" == form_f['substrate']:
o.substrate_type = Literals.substrateRNA
endComplex = arguments[0]
stopSuccess = StopCondition(Literals.success, [(endComplex, Literals.exact_macrostate, 0)])
o.stop_conditions = [stopSuccess]
return o
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 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 associationNoInit(arguments):
stdOptions = standardOptions()
stdOptions.simulation_mode = Literals.trajectory
stdOptions.verbosity = True
stdOptions.num_simulations = arguments[0]
stdOptions.temperature = arguments[1]
stdOptions.join_concentration = arguments[2]
endComplex = arguments[3]
stdOptions.simulation_time = A_TIME_OUT
stopSuccess = StopCondition(Literals.success,
[(endComplex, Literals.exact_macrostate, 0)])
stdOptions.stop_conditions = [stopSuccess]
# stdOptions.DNA23Arrhenius()
return stdOptions
def doReaction(arguments):
# the first argument is always the number of paths
options = Options(trials=arguments[0])
#options.output_interval = 1 # do not uncomment ---> might get memory issues
options.num_simulations = arguments[0]
options.simulation_time = arguments[1]
options.sodium = arguments[5]
options.magnesium = arguments[6]
options.temperature = arguments[9] + arguments[10]
options.join_concentration = arguments[12] * arguments[11]
if arguments[13] == Literals.metropolis:
set_Metropolis_params(options, arguments[7])
elif arguments[13] == Literals.arrhenius:
set_Arrhenius_params(options, arguments[7])
options.simulation_mode = Literals.trajectory
if arguments[14] == True:
endComplex1 = arguments[15][-1][0]
stopSuccess = StopCondition(
Literals.success, [(endComplex1, Literals.exact_macrostate, 0)])
options.stop_conditions = [stopSuccess]
if use_Gillespie_MFPT == True:
options.start_state = arguments[15][0]
return options
def changeComplex(options, expirement_type=NORMAL, trials=500):
# Easiest to use full dot paren here
# See SI Document for these sequences and lengths!
toehold_length = 7
h_length = 15
helper = Strand(name="Helper_AAq",
sequence="TTTCCTAATCCCAATCAACACCTTTCCTA")
produce_bot = Strand(
name="Produce_BOT_CApAq",
sequence="GTAAAGACCAGTGGTGTGAAGATAGGAAAGGTGTTGATTGGGATTAGGAAACC")
ap = Strand(name="ap",
sequence="CATCACTATCAATCATACATGGTTTCCTATCTTCACACCACTGG")
aq = Strand(name="aq",
sequence="CATCACTATCAATCATACATGGTTTCCTAATCCCAATCAACACC")
# Offset of two to account for clamp domains
produce_struct = "." * toehold_length + "(" * (
len(produce_bot.sequence) -
toehold_length) + "+" + '.' * (toehold_length + h_length - 2) + ')' * (
len(ap.sequence) - toehold_length - h_length + 2) + "+" + '.' * (
toehold_length + h_length) + ')' * (len(ap.sequence) -
toehold_length - h_length)
if expirement_type == WITHOUT_GG:
ap = Strand(name="ap",
sequence="CATCACTATCAATCATACATTTTCCTATCTTCACACCACTGG")
# bot, aq, ap
# Offsets due to a) clamp domains b) two b.p. removal
produce_struct = "." * toehold_length + "(" * (
len(produce_bot.sequence) - toehold_length) + "+" + '.' * (
toehold_length + h_length - 2) + ')' * (
len(ap.sequence) - toehold_length - h_length +
4) + "+" + '.' * (toehold_length + h_length - 2) + ')' * (
len(ap.sequence) - toehold_length - h_length + 2)
elif expirement_type == WITHOUT_G:
ap = Strand(name="ap",
sequence="CATCACTATCAATCATACATGTTTCCTATCTTCACACCACTGG")
# bot, aq, ap
# Offsets due to a) clamp domains b) one b.p. removal
produce_struct = "." * toehold_length + "(" * (
len(produce_bot.sequence) - toehold_length) + "+" + '.' * (
toehold_length + h_length - 2) + ')' * (
len(ap.sequence) - toehold_length - h_length +
3) + "+" + '.' * (toehold_length + h_length - 1) + ')' * (
len(ap.sequence) - toehold_length - h_length + 1)
elif expirement_type == HELPER_WITHOUT_CC:
# only modify helper sequence here - remove the two 3' most 'C'.
helper = Strand(name="Helper_AAq",
sequence="TTTCCTAATCCCAATCAACACCTTTTA")
# No change required elsewhere - we check for the release of strands rather than the complicated
# leak complex formed for simplicity. We should really check for ANY free strands here i.e. Ap OR Aq
# but it is hard to imagine a mechanism which results in the release of Ap in this simulation
produce_complex = Complex(name="produce",
strands=[produce_bot, aq, ap],
structure=produce_struct)
helper_complex = Complex(name="helper",
strands=[helper],
structure='.' * len(helper.sequence))
leak_complex = Complex(name="leak",
strands=[aq],
structure='.' * len(aq.sequence))
if trials > 0:
setBoltzmann(produce_complex, trials, 75)
setBoltzmann(helper_complex, trials, 75)
success_stop_cond = StopCondition(
Literals.success, [(leak_complex, Options.dissoc_macrostate, 0)])
# the leak has failed if we end up with our initial complexes again.
# check if we end up with a free helper complex
failure_stop_cond = StopCondition(
Literals.failure, [(helper_complex, Options.dissoc_macrostate, 0)])
options.start_state = [produce_complex, helper_complex]
options.stop_conditions = [success_stop_cond, failure_stop_cond]
def machinek2014(options, selector, trialsIn):
# we only allow first step mode at this point.
# these are the sequences we need to build the dot-parens
incumbent = ""
target = ""
invader = ""
toeholdSelect = selector / 12
mismatchSelect = selector % 12
positionSelector = [0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14]
mismatchSelect = positionSelector[mismatchSelect]
# decide on toehold sequence
toeholdSeq = "ATGTGG" # 6 nt toehold option
if toeholdSelect == 1:
toeholdSeq = "ATGTGGA" # 7 nt toehold option
if toeholdSelect == 2:
toeholdSeq = "ATGTGGAGGG" # 10 nt toehold option
# determine the incumbent, target and invader sequences
# FD: copy-pasting supplementary Table 6 directly
if mismatchSelect == 0 or mismatchSelect == 2 or mismatchSelect == 12 or mismatchSelect == 14:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTTGAGGTTGA"
target = "CCCTCCACATTCAACCTCAAACTCACC"
if mismatchSelect == 0: # perfect
invader = "GGTGAGTTTGAGGTTGA"
if mismatchSelect == 2:
invader = "GGTGAGTTTGAGGTTCA"
if mismatchSelect == 12:
invader = "GGTGACTTTGAGGTTGA"
if mismatchSelect == 14:
invader = "GGTCAGTTTGAGGTTGA"
if mismatchSelect == 3:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTTGAGGTGAT"
target = "CCCTCCACATATCACCTCAAACTCACC"
invader = "GGTGAGTTTGAGGTCAT"
if mismatchSelect == 4:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTTGAGTGAGT"
target = "CCCTCCACATACTCACTCAAACTCACC"
invader = "GGTGAGTTTGAGTCAGT"
if mismatchSelect == 5:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTTGATGAGGT"
target = "CCCTCCACATACCTCATCAAACTCACC"
invader = "GGTGAGTTTGATCAGGT"
if mismatchSelect == 6:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTTGTGAAGGT"
target = "CCCTCCACATACCTTCACAAACTCACC"
invader = "GGTGAGTTTGTCAAGGT"
if mismatchSelect == 7:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTTTGAGAGGT"
target = "CCCTCCACATACCTCTCAAAACTCACC"
invader = "GGTGAGTTTTCAGAGGT"
if mismatchSelect == 8:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTTGATGAGGT"
target = "CCCTCCACATACCTCATCAAACTCACC"
invader = "GGTGAGTTTCATGAGGT"
if mismatchSelect == 9:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTTGATTGAGGT"
target = "CCCTCCACATACCTCAATCAACTCACC"
invader = "GGTGAGTTCATTGAGGT"
if mismatchSelect == 10:
incumbent = "TGGTGTTTGTGGGTGTGGTGAGTGATTTGAGGT"
target = "CCCTCCACATACCTCAAATCACTCACC"
invader = "GGTGAGTCATTTGAGGT"
invader = invader + toeholdSeq
# set up the actual complexes
strandIncumbent = Strand(name="incumbent", sequence=incumbent)
strandTarget = Strand(name="target", sequence=target)
strandInvader = Strand(name="invader", sequence=invader)
intialDotParen = '.' * 16 + '(' * 17 + "+" + '.' * 10 + ')' * 17
intialInvaderDotParen = '.' * len(invader)
successDotParen = '.' * 33
initialComplex = Complex(strands=[strandIncumbent, strandTarget],
structure=intialDotParen)
initialInvader = Complex(strands=[strandInvader],
structure=intialInvaderDotParen)
successComplex = Complex(strands=[strandIncumbent],
structure=successDotParen)
# Turns Boltzmann sampling on for this complex and also does sampling more efficiently by sampling 'trials' states.
if (trialsIn > 0):
setBoltzmann(initialComplex, trialsIn)
setBoltzmann(initialInvader, trialsIn)
initialComplex.boltzmann_supersample = 25
initialInvader.boltzmann_supersample = 25
stopSuccess = StopCondition(
Options.STR_SUCCESS, [(successComplex, Options.dissocMacrostate, 0)])
stopFailed = StopCondition(Options.STR_FAILURE,
[(initialComplex, Options.dissocMacrostate, 0)])
# actually set the intial and stopping states
options.start_state = [initialComplex, initialInvader]
options.stop_conditions = [stopSuccess, stopFailed]
