def main():
import numpy
import cmepy.solver
import cmepy.recorder
import cmepy.domain
dna_count = 5
m = create_model(dna_count = dna_count)
domain_states = cmepy.domain.from_iter(gen_states(dna_count = dna_count))
solver = cmepy.solver.create(
m,
sink = True,
domain_states = domain_states
)
recorder = cmepy.recorder.create(
(m.species,
m.species_counts)
)
time_steps = numpy.linspace(0.0, 10.0, 101)
for t in time_steps:
solver.step(t)
p, p_sink = solver.y
print 't = %g; p_sink = %g' % (t, p_sink)
recorder.write(t, p)
cmepy.recorder.display_plots(recorder, title = m.name)
def main():
"""
solves transcription regulation model and plot results
"""
import cmepy.solver
import cmepy.recorder
m = create_model()
solver = cmepy.solver.create(m,
sink=True,
time_dependencies=create_time_dependencies())
recorder = cmepy.recorder.create((m.species, m.species_counts))
t_final = 60.0
time_steps = numpy.linspace(0.0, t_final, 61)
for t in time_steps:
solver.step(t)
p, p_sink = solver.y
print 't = %g; p_sink = %g' % (t, p_sink)
recorder.write(t, p)
cmepy.recorder.display_plots(recorder)
def main():
import numpy
from cmepy import domain
import cmepy.solver
import cmepy.recorder
max_s1_copies = 40
max_s2_copies = 100
m = create_model_gene_toggle(max_s1_copies, max_s2_copies)
# define domain states as union of two rectangular regions along the axes
a_shape = (max_s1_copies, 6)
b_shape = (10, max_s2_copies)
domain_states_a = set(domain.to_iter(domain.from_rect(a_shape)))
domain_states_b = set(domain.to_iter(domain.from_rect(b_shape)))
states = domain.from_iter(domain_states_a | domain_states_b)
solver = cmepy.solver.create(m, sink=True, domain_states=states)
recorder = cmepy.recorder.create((m.species, m.species_counts))
time_steps = numpy.linspace(0.0, 100.0, 101)
for t in time_steps:
solver.step(t)
p, p_sink = solver.y
print('t = {:.4}; p_sink = {:.4E}'.format(t, p_sink))
recorder.write(t, p)
cmepy.recorder.display_plots(recorder, title=m.name)
def main():
"""
solves transcription regulation model and plot results
"""
import cmepy.solver
import cmepy.recorder
m = create_model()
solver = cmepy.solver.create(
m,
sink = True,
time_dependencies = create_time_dependencies()
)
recorder = cmepy.recorder.create(
(m.species,
m.species_counts)
)
t_final = 60.0
time_steps = numpy.linspace(0.0, t_final, 61)
for t in time_steps:
solver.step(t)
p, p_sink = solver.y
print 't = %g; p_sink = %g' % (t, p_sink)
recorder.write(t, p)
cmepy.recorder.display_plots(
recorder
)
def f(p):
recorder = cmepy.recorder.create(
(m.species,
m.species_counts)
)
recorder.write(t_max, p)
d = recorder['B'].distributions[-1]
return d.to_dense((exact_size+1, ))
def main():
"""
solve burr08 model using FSP with better expansion approach
"""
# create model and initial states for domain
model = burr08.create_model()
initial_states = cmepy.domain.from_iter((model.initial_state, ))
# Create expander for FSP expansion strategy.
# The SolutionExpander only expands states around the
# support of the current solution, instead of
# expanding the entire domain
expander = cmepy.fsp.support_expander.SupportExpander(model.transitions,
depth=1,
epsilon=1.0e-7)
# create fsp solver for model, initial states, expander
# - time dependencies for the burr08 model are also supplied
fsp_solver = cmepy.fsp.solver.create(
model,
initial_states,
expander,
time_dependencies=burr08.create_time_dependencies())
# define time steps:
# this problem is initially stiff so
# we begin with some finer time steps
# before changing to coarser steps
time_steps = numpy.concatenate(
(numpy.linspace(0.0, 1.0, 10), numpy.linspace(2.0, 16.0, 15)))
# we want the error of the solution at the
# final time to be bounded by epsilon
epsilon = 1.0e-2
num_steps = numpy.size(time_steps)
# define how much error is tolerated per step
max_error_per_step = epsilon / num_steps
# create recorder to record species counts
recorder = cmepy.recorder.create((model.species, model.species_counts))
domains = []
for i, t in enumerate(time_steps):
print 'STEP t = %g' % t
fsp_solver.step(t, max_error_per_step)
if i % 3 == 0:
print 'recording solution and domain'
# record the solution
p, _ = fsp_solver.y
recorder.write(t, p)
# store a copy of the domain so we can plot it later
domains.append(numpy.array(fsp_solver.domain_states))
print 'OK'
print 'plotting solution and domain'
fsp_example_util.plot_solution_and_domain(recorder[('A', 'B')], domains)
def main():
"""
Solves the CME for a simple catalytic reaction and plot results
"""
initial_counts = {
'A' : 50,
'D' : 80
}
# define the model
model = create_model(**initial_counts)
# create cme solver
solver = cmepy.solver.create(
model,
sink = True,
domain_states = cmepy.domain.from_iter(gen_states(**initial_counts))
)
# create cme recorder, specifying that we wish to measure the
# species random variables, via the species_counts functions,
# and also the reactions random variables, via the default
# coordinate projections
recorder = cmepy.recorder.create(
(model.species, model.species_counts),
(model.reactions, )
)
step_size = 0.005
times = (0.0, 0.05, 0.2, 0.5)
limits = consecutive_pairs(times)
intervals = (numpy.linspace(a, b, (b-a)/step_size + 1) for a,b in limits)
for interval in intervals:
for t in interval:
solver.step(t)
p, p_sink = solver.y
print 'time : %.3f, truncation error: %.1e' % (t, p_sink)
print 'recording results'
recorder.write(interval[-1], p)
print 'plotting results'
marginal_shape = (initial_counts['D']+1, )
measurement = recorder['E']
pylab.figure()
for time, marginal in zip(measurement.times, measurement.distributions):
pylab.plot(
marginal.to_dense(marginal_shape),
label = 't = %.2f' % time
)
pylab.legend()
pylab.title('probability distribution of E')
pylab.ylabel('P(E)')
pylab.xlabel('E (copy count)')
pylab.show()
def main():
import cmepy.solver
import cmepy.recorder
m = create_model_quad_autocat(fixed_s=False)
solver = cmepy.solver.create(m, sink=True)
recorder = cmepy.recorder.create((m.species, m.species_counts))
time_steps = numpy.linspace(0.0, 1000.0, 101)
for t in time_steps:
solver.step(t)
p, p_sink = solver.y
recorder.write(t, p)
print('t = {:.4}; p_sink = {:.4E}'.format(t, p_sink))
cmepy.recorder.display_plots(recorder, title=m.name)
def main():
import numpy
from cmepy import domain
import cmepy.solver
import cmepy.recorder
max_s1_copies = 40
max_s2_copies = 100
m = create_model_gene_toggle(max_s1_copies, max_s2_copies)
# define domain states as union of two rectangular regions along the axes
a_shape = (max_s1_copies, 6)
b_shape = (10, max_s2_copies)
domain_states_a = set(domain.to_iter(domain.from_rect(a_shape)))
domain_states_b = set(domain.to_iter(domain.from_rect(b_shape)))
states = domain.from_iter(domain_states_a | domain_states_b)
solver = cmepy.solver.create(
m,
sink = True,
domain_states = states
)
recorder = cmepy.recorder.create(
(m.species,
m.species_counts)
)
time_steps = numpy.linspace(0.0, 100.0, 101)
for t in time_steps:
solver.step(t)
p, p_sink = solver.y
print 't = %g; p_sink = %g' % (t, p_sink)
recorder.write(t, p)
cmepy.recorder.display_plots(recorder,
title = m.name)
def main():
import cmepy.solver
import cmepy.recorder
m = create_model_quad_autocat(fixed_s = False)
solver = cmepy.solver.create(
m,
sink = True
)
recorder = cmepy.recorder.create(
(m.species,
m.species_counts)
)
time_steps = numpy.linspace(0.0, 1000.0, 101)
for t in time_steps:
solver.step(t)
p, p_sink = solver.y
recorder.write(t, p)
print 't = %g; p_sink = %g' % (t, p_sink)
cmepy.recorder.display_plots(recorder, title = m.name)
def main():
"""
Solve dual enzymatic reaction system
"""
import numpy
import cmepy.solver
import cmepy.recorder
import cmepy.domain
model = create_model()
solver = cmepy.solver.create(
model = model,
sink = True,
domain_states = cmepy.domain.from_iter(gen_states()),
)
recorder = cmepy.recorder.create(
(model.species, model.species_counts)
)
t_final = 10.0
steps_per_time = 25
time_steps = numpy.linspace(0.0, t_final, int(steps_per_time*t_final) + 1)
print 'solving dual enzymatic system to t_final = %.2f' % t_final
for step, t in enumerate(time_steps):
print 't = %.2f' % t
solver.step(t)
# record results every second, not every step
if step % steps_per_time == 0:
print 'recording solution'
p, p_sink = solver.y
recorder.write(t, p)
cmepy.recorder.display_plots(recorder)
def main():
"""
Solve dual enzymatic reaction system
"""
import numpy
import cmepy.solver
import cmepy.recorder
import cmepy.domain
model = create_model()
solver = cmepy.solver.create(
model=model,
sink=True,
domain_states=cmepy.domain.from_iter(gen_states()),
)
recorder = cmepy.recorder.create((model.species, model.species_counts))
t_final = 10.0
steps_per_time = 25
time_steps = numpy.linspace(0.0, t_final,
int(steps_per_time * t_final) + 1)
print 'solving dual enzymatic system to t_final = %.2f' % t_final
for step, t in enumerate(time_steps):
print 't = %.2f' % t
solver.step(t)
# record results every second, not every step
if step % steps_per_time == 0:
print 'recording solution'
p, p_sink = solver.y
recorder.write(t, p)
cmepy.recorder.display_plots(recorder)
def f(p):
recorder = cmepy.recorder.create((m.species, m.species_counts))
recorder.write(t_max, p)
d = recorder['B'].distributions[-1]
return d.to_dense((exact_size + 1, ))
def main():
"""
solve burr08 model using FSP with simple expansion approach
"""
# create model and initial states for domain
model = burr08.create_model()
initial_states = cmepy.domain.from_iter((model.initial_state, ))
# create simple expander for FSP expansion strategy
# - this expands the ENTIRE domain by 3, along the
# state transitions
expander = cmepy.fsp.simple_expander.SimpleExpander(
model.transitions,
depth = 3,
)
# create fsp solver for model, initial states, expander
# - time dependencies for the burr08 model are also supplied
fsp_solver = cmepy.fsp.solver.create(
model,
initial_states,
expander,
time_dependencies = burr08.create_time_dependencies()
)
# define time steps:
# this problem is initially stiff so
# we begin with some finer time steps
# before changing to coarser steps
time_steps = numpy.concatenate((
numpy.linspace(0.0, 1.0, 10),
numpy.linspace(2.0, 16.0, 15)
))
# we want the error of the solution at the
# final time to be bounded by epsilon
epsilon = 1.0e-2
num_steps = numpy.size(time_steps)
# define how much error is tolerated per step
max_error_per_step = epsilon / num_steps
# create recorder to record species counts
recorder = cmepy.recorder.create(
(model.species, model.species_counts)
)
domains = []
for i, t in enumerate(time_steps):
print 'STEP t = %g' % t
fsp_solver.step(t, max_error_per_step)
if i % 3 == 0:
print 'recording solution and domain'
# record the solution
p, _ = fsp_solver.y
recorder.write(t, p)
# store a copy of the domain so we can plot it later
domains.append(numpy.array(fsp_solver.domain_states))
print 'OK'
print 'plotting solution and domain'
fsp_example_util.plot_solution_and_domain(
recorder[('A', 'B')],
domains
)
