def first_step_simulation(form_f):
strand_seq = form_f['sequence']
print ("Running first step mode simulations for %s (with Boltzmann sampling)..." % (strand_seq))
def getOptions(trials):
o = standardOptions(tempIn=float(form_f['temperature']), timeOut=A_TIME_OUT)
o.num_simulations = TRIALS
hybridization(o, strand_seq, trials)
o.sodium = form_f['sodium']
o.magnesium = form_f['magnesium']
o.concentration = 1.0E-9
if "RNA" == form_f['substrate']:
o.substrate_type = Literals.substrateRNA
return o
MergeSimSettings.max_trials = MAX_TRIALS
myMultistrand = MergeSim()
myMultistrand.setOptionsFactory1(getOptions, TRIALS)
myMultistrand.setTerminationCriteria(int(form_f["trajectories"]))
myMultistrand.settings.timeOut = max(WALL_TIME_TIMEOUT, form_f["trajectories"])
myMultistrand.run()
return myMultistrand
def estimateSuccessProbability(popularStructure, settings):
# Do a quick first step simulation and see how many end up succeeding.
# Use a new multistrand object so we don't lose the old results
newMultistrand = MergeSim()
newMultistrand.setNumOfThreads(myMultistrand.numOfThreads)
oldTrials = settings.trials
settings.trials = int(settings.trials / 50.0)
settings.initialStructure = popularStructure
first_step_simulation(newMultistrand, settings)
settings.trials = oldTrials
output = np.float(newMultistrand.nForward.value) / np.float(
newMultistrand.trialsPerThread * newMultistrand.numOfThreads)
return output
def first_passage_association(strand_seq, trials, concentration, T=20.0):
thisMS = MergeSim()
thisMS.setNumOfThreads(8)
print "Running first passage time simulations for association of %s at %s..." % (
strand_seq, concentration_string(concentration))
def getOptions(trials):
o = standardOptions(Literals.first_passage_time, TEMPERATURE, trials,
ATIME_OUT)
hybridization(o, strand_seq, trials, True)
setSaltGao2006(o)
o.join_concentration = concentration
o.DNA23Metropolis()
return o
thisMS.setOptionsFactory1(getOptions, trials)
thisMS.setPassageMode()
thisMS.run()
return thisMS
# Visit www.multistrand.org
# FD: This script is now set to use 4 threads and just 50,000 trajectories.
# FD: This is different from the results in case1.pdf
# FD: The results of this study heavily depend on the parameterization of the Metropolis model: JS or DNA23 (see below).
from multistrand.objects import StopCondition, Domain, Complex, Strand
from multistrand.options import Options, Literals
from multistrand.concurrent import MergeSim
from multistrand._options.interface import FirstStepResult
import numpy as np
ATIME_OUT = 10.0
myMultistrand = MergeSim()
myMultistrand.setNumOfThreads(8)
myMultistrand.setLeakMode()
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])
from constantsgao import goa2006_P0, goa2006_P3, goa2006_P4, setSaltGao2006, colors, position, pathProperties, analysisFactory, analysisResult, STR_ALL
from matplotlib.collections import LineCollection
import matplotlib
matplotlib.use('Agg') # multiprocessing errors?
import matplotlib.pylab as plt
import numpy as np
import operator, sys
# from copy import deepcopy
SCRIPT_DIR = "case3_gao_study"
TEMPERATURE = 20.0
ATIME_OUT = 10.0
myMultistrand = MergeSim()
class hybridizationSimSettings(object):
def __init__(self, mySeq, cutOff, trials):
self.mySeq = mySeq
self.cutOff = cutOff
self.trials = trials
def __str__(self):
output = "mySeq=" + self.mySeq
output += output + str(self.cutOff)
return output
import sys, os, os.path
import cPickle
import math
from multistrand.objects import Strand, Complex, Domain
from multistrand.options import Options
from multistrand.concurrent import MergeSim
import math
from nupack import *
# FD: This test attempts to compare the long-run partition function obtained from Multistrand and Nupack
myMultistrand = MergeSim()
numOfPaths = 400.0
kBoltzmann = .00198717 # units of kcal/(mol*K)
RT = kBoltzmann * (273.15 + 37.0)
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=".")
def computeHittingTimes(settings, reverse=False):
myMultistrand = MergeSim()
myMultistrand.setNumOfThreads(NUM_PROCESS)
if settings.type == enum_yurke2:
myMultistrand.setOptionsFactory1(simulationYurke2, settings.nTrials)
if settings.type == enum_bonnet:
myMultistrand.setOptionsFactory2(simulationHairpin, settings.nTrials,
reverse)
if settings.type == enum_flamm:
myMultistrand.setOptionsFactory1(simulationFlamm2000, settings.nTrials)
if settings.type == enum_yurke:
myMultistrand.setOptionsFactory1(simulationYurke, settings.nTrials)
if settings.type == enum_rickettsia:
myMultistrand.setOptionsFactory1(simulationRickettsia,
12 * settings.nTrials)
myMultistrand.setTerminationCriteria(terminationCount=settings.nTrials)
if settings.type == enum_bonnet or settings.type == enum_yurke2:
myMultistrand.setPassageMode() # using the pre-set success / fail
if settings.type == enum_flamm or settings.type == enum_yurke or settings.type == enum_rickettsia:
# non-first stepping mode, no need to store trajectory information
myMultistrand.setPassageMode()
myMultistrand.run()
return myMultistrand.results
def first_step_simulation(strand_seq, trials, T=20.0):
myMS = MergeSim()
myMS.setNumOfThreads(8)
print(
"Running first step mode simulations for %s (with Boltzmann sampling)..."
% (strand_seq))
def getOptions(trials):
o = standardOptions(Literals.first_step, TEMPERATURE, trials,
ATIME_OUT)
hybridization(o, strand_seq, trials)
setSaltGao2006(o)
o.DNA23Metropolis()
return o
myMS.setOptionsFactory1(getOptions, trials)
myMS.setFirstStepMode() # ensure the right results object is set.
# myMultistrand.setLeakMode()
myMS.setTerminationCriteria(terminationCount=trials)
myMS.run()
return myMS
def computeRate(selector):
myMultistrand = MergeSim()
myMultistrand.setOptionsFactory2(genOptions, NUMOFPATHS, selector)
myMultistrand.setNumOfThreads(NUMOFTHREADS)
myMultistrand.setTerminationCriteria(TERMINATIONCRIT)
myMultistrand.setLeakMode() # the new leak object -- faster bootstrapping.
myMultistrand.printTrajectory()
return 0.0, 0.0, 0.0
myMultistrand.run()
myFSR = myMultistrand.results
low, high = myFSR.doBootstrap()
return myFSR.k1(), low, high
