def compare(self, A, B, nnodes=10, nedges=20, weights=None, x=1):
print ""
maker = _MakeRandomGraph(nnodes=nnodes, nedges=nedges, node_set=A+B+[x])
graph = maker.run()
graph_backup = graph.copy()
reducer = GraphReduction(maker.rates, A, B, weights=weights)
kmc = KineticMonteCarlo(graph_backup, debug=False)
# test compute_committor_probability()
PxB = reducer.compute_committor_probability(x)
PxB_kmc = kmc.committor_probability(x, A, B, niter=1000)
print "committor probability ", x, "->", B, "=", PxB
print "committor probability kmc", x, "->", B, "=", PxB_kmc
self.assertAlmostEqual(PxB, PxB_kmc, delta=.1)
reducer.compute_rates()
rAB = reducer.get_rate_AB()
rBA = reducer.get_rate_BA()
rAB_SS = reducer.get_rate_AB_SS()
# compute rate via linalg
lin = TwoStateRates(maker.rates, A, B, weights=weights)
lin.compute_rates()
rAB_LA = lin.get_rate_AB()
lin.compute_committors()
rAB_SS_LA = lin.get_rate_AB_SS()
self.assertAlmostEqual(rAB_SS, rAB_SS_LA, 5)
PxB_LA = lin.get_committor(x)
if x not in A and x not in B:
self.assertAlmostEqual(PxB, PxB_LA, 5)
rAB_KMC = kmc.mean_rate(A, B, niter=1000, weights=weights)
print "NGT rate A->B", rAB
print "KMC rate A->B", rAB_KMC
print "normalized difference", (rAB - rAB_KMC)/rAB
print "normalized difference to linalg", (rAB - rAB_LA)/rAB
self.assertLess(abs(rAB - rAB_KMC)/rAB, .1)
self.assertLess(abs(rAB - rAB_LA)/rAB, .00001)
rBA_KMC = kmc.mean_rate(B, A, niter=1000, weights=weights)
print "NGT rate B->A", rBA
print "KMC rate B->A", rBA_KMC
print "normalized difference", (rBA - rBA_KMC)/rBA
self.assertLess(abs(rBA - rBA_KMC)/rBA, .1)
paB = kmc.committor_probability(A[0], [A[0]], B, niter=1000)
print "the committor probability a->B", paB
print "graph reduction committor prob", reducer.get_committor_probabilityAB(A[0])
self.assertAlmostEqual(paB, reducer.get_committor_probabilityAB(A[0]), delta=.1)
def main():
nnodes = 3
# make matrix of transition rates with three states
transition_matrix = [ [0., 1., 1.],
[1., 0., 1.],
[1., 1., 0.] ]
print "Computing rates and committor probabilities for transition matrix"
print transition_matrix
# an easy way to set up the graph is to make
# a dictionary of rates
rates = dict()
for i in range(nnodes):
for j in range(nnodes):
if i != j:
rates[(i,j)] = transition_matrix[i][j]
# we want to compute rates from node 0 to node 1
A = [0]
B = [1]
x = 0
# set up the class which will compute rates for us
reducer = GraphReduction(rates, A, B)
# now to check the values do a kinetic monte carlo run
# use the utility function to build the rate graph with the correct formatting
kmc_graph = kmcgraph_from_rates(rates)
kmc = KineticMonteCarlo(kmc_graph)
niterlist = [10, 100, 1000, 10000]
print ""
print "computing the probability for a trajectory to start at", x, "and reach", B, "before reaching", A
PxB = reducer.compute_committor_probability(x)
print "the committor probability computed by graph transformation is", PxB
for niter in niterlist:
PxB_KMC = kmc.committor_probability(x, A, B, niter=niter)
print "the KMC committor probability averaged over %8d trajectories is %s. abs(PxB-PxB_KMC) = %s" % (niter, PxB_KMC, abs(PxB-PxB_KMC))
print ""
print "computing the transition rate from nodes", A, "to nodes", B
print "the exact rate for this network is 1.0"
reducer.compute_rates()
rAB = reducer.get_rate_AB()
print "the transition rate computed by graph transformation is", rAB
for niter in niterlist:
rAB_KMC = kmc.mean_rate(A, B, niter=niter)
print "the KMC rate averaged over %8d trajectories is %s. abs(rAB-rAB_KMC) = %s" % (niter, rAB_KMC, abs(rAB-rAB_KMC))
def main():
nnodes = 6
# the graph need not be made from a transition matrix, but it's an
# easy way to make a random graph ensuring that everything is connected
transition_matrix = np.random.uniform(0,1,[nnodes, nnodes])
print "Computing rates and committor probabilities for transition matrix"
print transition_matrix
# an easy way to set up the graph is to make
# a dictionary of rates
rates = dict()
for i in range(nnodes):
for j in range(nnodes):
if i != j:
rates[(i,j)] = transition_matrix[i][j]
# we want to compute rates from node 0 to node 1
A = [0,1]
B = [4,5]
x = 2
# set up the class which will compute rates for us
reducer = GraphReduction(rates, A, B)
# now to check the values do a kinetic monte carlo run
# use the utility function to build the rate graph with the correct formatting
kmc_graph = kmcgraph_from_rates(rates)
kmc = KineticMonteCarlo(kmc_graph)
niterlist = [10, 100, 1000, 10000]
print ""
print "computing the probability for a trajectory to start at", x, "and reach", B, "before reaching", A
PxB = reducer.compute_committor_probability(x)
print "the committor probability computed by graph transformation is", PxB
for niter in niterlist:
PxB_KMC = kmc.committor_probability(x, A, B, niter=niter)
print "the KMC committor probability averaged over %8d trajectories is %s. abs(PxB-PxB_KMC) = %s" % (niter, PxB_KMC, abs(PxB-PxB_KMC))
print ""
print "computing the transition rate from nodes", A, "to nodes", B
reducer.compute_rates()
rAB = reducer.get_rate_AB()
print "the transition rate computed by graph transformation is", rAB
for niter in niterlist:
rAB_KMC = kmc.mean_rate(A, B, niter=niter)
print "the KMC rate averaged over %8d trajectories is %s. abs(rAB-rAB_KMC) = %s" % (niter, rAB_KMC, abs(rAB-rAB_KMC))
class TestKMC(unittest.TestCase):
def setUp(self):
graph = _three_state_graph()
self.kmc = KineticMonteCarlo(graph)
def test_mfp(self):
time = self.kmc.mean_first_passage_time(0, [1], niter=1000)
self.assertAlmostEqual(time, 1.0, delta=.1)
def test_committor_probabilities(self, nnodes=10, nedges=20):
A = [0,1,2,3]
B = [8,9]
xx = 5
maker = _MakeRandomGraph(nnodes=nnodes, nedges=nedges, node_set=A+B)
graph = maker.run()
graph_backup = graph.copy()
kmc = KineticMonteCarlo(graph_backup, debug=False)
reducer = GraphReduction(maker.rates, A, B)
nodes = set(A + B + [xx])
PxB = reducer.compute_committor_probabilities(nodes)
for x in nodes:
self.assertIn(x, PxB)
for x in nodes:
PxB_kmc = kmc.committor_probability(x, A, B, niter=1000)
self.assertAlmostEqual(PxB[x], PxB_kmc, delta=.1)
def setUp(self):
graph = _three_state_graph()
self.kmc = KineticMonteCarlo(graph)
