In [1]:
import numpy as np
import matplotlib
from matplotlib import pyplot as plt
import ensemble as we
import ssad
import util
from imp import reload
In [2]:
reload(we)
reload(ssad)
reload(util)
Out[2]:
In [2]:
paving = we.UniformPaving([-10, -3], [15, 9], [5, 4])
In [13]:
paving.get_bin_num([1, 1]) # 9
Out[13]:
In [14]:
paving.get_bin_num([1, 4]) # 10
Out[14]:
In [15]:
paving.get_bin_num([1, 3]) # 10
Out[15]:
In [16]:
paving.get_bin_num([0, 0]) # 9
Out[16]:
In [17]:
paving.get_bin_num([4, -4]) # 8
Out[17]:
In [18]:
paving.get_bin_num([4, -4000]) # 8
Out[18]:
In [19]:
paving.get_bin_num([5, -4]) # 12
Out[19]:
In [20]:
paving.get_bin_num([-10, -4]) # 0
Out[20]:
In [21]:
paving.get_bin_num([-10000, -4]) # 0
Out[21]:
In [22]:
paving.get_bin_num([15, 9]) # 19
Out[22]:
In [23]:
paving.get_bin_num([15, 6]) # 19
Out[23]:
In [24]:
paving.get_bin_num([14, 6]) # 19
Out[24]:
In [25]:
paving.get_bin_num([0, 9]) # 11
Out[25]:
In [3]:
coord_set = np.array([[1, 1],
[1, 4],
[1, 3],
[0, 0],
[4, -4],
[4, -4000],
[5, -4],
[-10, -4],
[-10000, -4],
[15, 9],
[15, 6],
[14, 6],
[0, 9]])
In [4]:
paving.get_bin_num(coord_set)
Out[4]:
In [45]:
paving = we.UniformPaving([0], [60], (60))
In [46]:
paving.get_bin_num(33)
Out[46]:
In [47]:
# This is a nice, quick, visual way to find any irregularities in the binning
xs = np.array(range(61))
xs = xs[:,np.newaxis]
plt.plot(xs, paving.get_bin_num(xs))
plt.show()
In [13]:
nbins = 30
binrange = (0, 60)
bin_xs, bin_width = np.linspace(*binrange, num=nbins, endpoint=False, retstep=True)
paving = we.UniformPaving(*binrange, bin_counts=nbins)
xs = np.array(range(61))
plt.plot(xs, paving.get_bin_num(xs[:,np.newaxis]))
plt.show()
In [28]:
ssad._combinations(5, 6)
Out[28]:
In [29]:
ssad._combinations(5, 5)
Out[29]:
In [30]:
ssad._combinations(1000, 1000)
Out[30]:
In [31]:
ssad._combinations(1000, 6)
Out[31]:
In [32]:
ssad._combinations(1000, 994)
Out[32]:
In [33]:
ssad._combinations(30, 0)
Out[33]:
In [37]:
ssad._combinations(30, -2)
Out[37]:
In [38]:
ssad._combinations(0, 0)
Out[38]:
In [15]:
species = ['X']
rxns = [ssad.Reaction([1], [-1], 1), # Production
ssad.Reaction([0], [+1], 25)] # Degradation
trj1 = we.WeightedTrajectory([0], rxns, 1.0)
In [16]:
trj1.run_dynamics(20)
states = np.asarray(trj1.hist_states)
times = np.asarray(trj1.hist_times)
In [17]:
plt.plot(times, states[:,0])
plt.show()
In [18]:
trj_clones = trj1.clone(3)
In [19]:
trj_clones
Out[19]:
In [20]:
print([clone.weight for clone in trj_clones])
In [21]:
trj1.weight
Out[21]:
In [22]:
type(trj_clones[0])
Out[22]:
In [24]:
states1 = np.asarray(trj_clones[1].hist_states)
times1 = np.asarray(trj_clones[1].hist_times)
plt.plot(times1, states1[:,0])
plt.show()
Make sure the trajectories aren't aliased to each other.
In [25]:
trj1.run_dynamics(20)
In [30]:
states0 = np.asarray(trj1.hist_states)
times0 = np.asarray(trj1.hist_times)
plt.plot(times0, states0[:,0])
plt.show()
In [29]:
states1 = np.asarray(trj_clones[2].hist_states)
times1 = np.asarray(trj_clones[2].hist_times)
plt.plot(times1, states1[:,0])
plt.show()
Set up a system with delayed reactions.
In [141]:
species = ['X']
rxns = [ssad.Reaction([0], [+1], 100),
ssad.Reaction([1], [-1], 3),
ssad.Reaction([1], [-1], 5, delay=20.0)]
trj = ssad.Trajectory([0], rxns)
In [142]:
trj.run_dynamics(60)
In [143]:
states = np.asarray(trj.hist_states)
times = np.asarray(trj.hist_times)
plt.plot(times, states[:,0])
plt.show()
In [144]:
trj.time
Out[144]:
In [145]:
trj.prune_history()
In [146]:
states = np.asarray(trj.hist_states)
times = np.asarray(trj.hist_times)
plt.plot(times, states[:,0])
plt.show()
In [147]:
trj.last_rxn_time
Out[147]:
In [148]:
min(trj.hist_times)
Out[148]:
In [150]:
trj.last_rxn_time - 20
Out[150]:
In [171]:
species = ['X']
rxns = [ssad.Reaction([1], [-1], 1), # Production
ssad.Reaction([0], [+1], 25)] # Degradation
trj1 = we.WeightedTrajectory([0], rxns, 1.0)
paving = we.UniformPaving([0], [50], 2)
ens = we.Ensemble(10, paving, (3, 5), [trj1])
In [172]:
print(ens.bins[0][0])
In [173]:
ens.run_step()
In [174]:
ens.bins
Out[174]:
In [175]:
for traj in ens:
print(traj)
In [176]:
ens._resample()
In [177]:
for traj in ens:
print(traj)
In [178]:
sum(traj.weight for traj in ens)
Out[178]:
In [179]:
species = ['X']
rxns = [ssad.Reaction([1], [-1], 1), # Production
ssad.Reaction([0], [+1], 25)] # Degradation
init_trjs = []
for idx in range(14):
init_trjs.append(we.WeightedTrajectory([0], rxns, 1/14))
paving = we.UniformPaving([0], [50], 2)
ens = we.Ensemble(10, paving, (3, 5), init_trjs)
In [180]:
ens.bins[0]
Out[180]:
In [181]:
ens._run_dynamics_all()
In [182]:
ens._recompute_bins()
In [183]:
for bin_no, trjs in ens.bins.items():
for traj in trjs:
print(' '.join(("Bin", str(bin_no) + ".", str(traj))))
In [184]:
ens._resample()
In [185]:
for bin_no, trjs in ens.bins.items():
for traj in trjs:
print(' '.join(("Bin", str(bin_no) + ".", str(traj))))
In [186]:
sum(trj.weight for trj in ens)
Out[186]:
In [60]:
A = 100.0
B = 3.0
C = 1.0
tau = 20.0
rxns = [ssad.Reaction([0], [+1], A),
ssad.Reaction([1], [-1], B),
ssad.Reaction([1], [-1], C, delay=tau)]
In [61]:
init_trjs = []
ntrajs = 100
nbins = 30
binrange = (0, 60)
bin_xs, bin_width = np.linspace(*binrange, num=nbins, endpoint=False, retstep=True)
paving = we.UniformPaving(*binrange, bin_counts=nbins)
for idx in range(ntrajs):
init_state = np.random.randint(*binrange)
init_time = np.random.random_sample() * rxns[2].delay
init_trjs.append(we.WeightedTrajectory([init_state], rxns, 1.0 / ntrajs, init_time=init_time))
In [62]:
ens = we.Ensemble(0.1, paving, (10, 10), init_trjs)
In [63]:
print(ens.get_bin_counts())
ens.run_step()
print(ens.get_bin_counts())
ens._resample()
print(ens.get_bin_counts())
In [64]:
plt.bar(bin_xs, ens.get_pdist())
plt.show()
In [65]:
ens.time
Out[65]:
In [66]:
ens.run_time(20.0)
Out[66]:
In [67]:
plt.bar(bin_xs, ens.get_pdist())
plt.show()
In [70]:
ens.get_bin_counts()
Out[70]:
In [69]:
ens._resample()
In [3]:
rxns = [ssad.Reaction([0], [+1], 100),
ssad.Reaction([1], [-1], 3),
ssad.Reaction([1], [-1], 5, delay=20.0)]
trj = ssad.Trajectory([0], rxns)
In [4]:
trj.run_dynamics(1)
In [12]:
states = np.asarray(trj.hist_states)
times = np.asarray(trj.hist_times)
plt.step(times, states[:,0], where='post')
plt.show()
In [6]:
trj.hist_states[1]
Out[6]:
In [7]:
trj.hist_times[1]
Out[7]:
In [8]:
trj.hist_times[2]
Out[8]:
In [10]:
print(trj.get_hist_index(0.001))
print(trj.sample_state(0.001))
In [13]:
print(trj.get_hist_index(0.003))
print(trj.sample_state(0.003))
In [14]:
print(trj.get_hist_index(0.0044))
print(trj.sample_state(0.0044))
Construct an artificial trajectory with a history whose joint distribution is known
In [3]:
paving = we.UniformPaving([0], [7], 7)
rxns = [ssad.Reaction([], [+1], 1.0)]
trj = ssad.Trajectory([1], rxns)
trj._execute_rxn(rxns[0], 4)
trj._execute_rxn(rxns[0], 6)
trj._execute_rxn(rxns[0], 8)
trj._execute_rxn(rxns[0], 10)
trj._execute_rxn(rxns[0], 12)
trj.time = 13.0
In [4]:
plt.step(trj.hist_times, trj.hist_states, where='post')
plt.show()
In [5]:
j_pdist = util.delay_joint_pdist(trj, 5.0, paving, paving)
print(j_pdist)
In [6]:
j_pdist[6, 3]
Out[6]:
In [7]:
np.sum(j_pdist)
Out[7]:
Restarting capability:
In [88]:
species = ['X']
tau = 20.0
rxns = [ssad.Reaction([0], [+1], 100),
ssad.Reaction([1], [-1], 3),
ssad.Reaction([1], [-1], 5, delay=tau)]
trj = ssad.Trajectory([0], rxns)
In [89]:
trj.run_dynamics(60)
In [90]:
paving = we.UniformPaving([0], [60], 60)
joint_pdist = util.delay_joint_pdist(trj, tau, paving, paving)
In [91]:
np.sum(joint_pdist)
Out[91]:
In [92]:
last_upd_time = trj.time
In [93]:
trj.run_dynamics(40)
In [94]:
joint_pdist_all = util.delay_joint_pdist(trj, tau, paving, paving)
joint_pdist_new = util.delay_joint_pdist(trj, tau, paving, paving, from_time=last_upd_time, existing=joint_pdist)
np.any(joint_pdist_all - joint_pdist_new > 1.0E-10)
Out[94]:
In [97]:
np.sum(joint_pdist)
Out[97]:
In [98]:
last_upd_time = trj.time
trj.prune_history()
trj.run_dynamics(40)
joint_pdist_final = util.delay_joint_pdist(trj, tau, paving, paving, from_time=last_upd_time, existing=joint_pdist)
In [99]:
np.sum(joint_pdist)
Out[99]:
In [100]:
plt.pcolormesh(joint_pdist, cmap='hot')
plt.show()
Everything works as expected.
Note: Replaced by time integral, see above
In [31]:
import bisect
In [32]:
species = ['X']
tau = 20.0
rxns = [ssad.Reaction([0], [+1], 100),
ssad.Reaction([1], [-1], 3),
ssad.Reaction([1], [-1], 5, delay=tau)]
trj = ssad.Trajectory([0], rxns)
In [33]:
trj.run_dynamics(60)
In [34]:
states = np.asarray(trj.hist_states)
times = np.asarray(trj.hist_times)
plt.plot(times, states[:,0])
plt.show()
In [35]:
start_idx = bisect.bisect_right(trj.hist_times, tau)
In [36]:
start_idx
Out[36]:
In [37]:
len(trj.hist_times)
Out[37]:
In [38]:
paving = we.UniformPaving([0], [60], 60)
joint_pdist = util.delay_joint_pdist(trj, tau, paving, paving)
In [40]:
plt.matshow(joint_pdist)
plt.show()
Excellent, the basics seem to work! Now on to checkpoint-style sampling.
In [64]:
trj = ssad.Trajectory([0], rxns)
In [65]:
trj.run_dynamics(100)
In [66]:
len(trj.hist_times)
Out[66]:
In [67]:
start_idx = bisect.bisect_right(trj.hist_times, tau)
In [68]:
pdist = util.delay_joint_pdist(trj, tau, paving, paving)
In [81]:
last_upd_time = trj.time
In [55]:
trj.prune_history()
In [82]:
trj.run_dynamics(100)
In [83]:
util.delay_joint_pdist(trj, tau, paving, paving, existing=pdist, from_time=last_upd_time)
Out[83]:
In [84]:
np.sum(pdist)
Out[84]:
In [85]:
len(trj.hist_times[start_idx:])
Out[85]:
In [87]:
plt.pcolormesh(pdist, cmap='hot')
plt.show()
Good, works just as expected.
In [ ]: