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)