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", old_div((rAB - rAB_KMC), rAB)) print("normalized difference to linalg", old_div((rAB - rAB_LA), rAB)) self.assertLess(old_div(abs(rAB - rAB_KMC), rAB), .1) self.assertLess(old_div(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", old_div((rBA - rBA_KMC), rBA)) self.assertLess(old_div(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 _test_rate(self, i, j): reducer = TwoStateRates(self.rates, [i], [j]) reducer.compute_rates() rAB = reducer.get_rate_AB() self.assertAlmostEqual(rAB, self.final_rate, 7) reducer.compute_committors() rAB_ss = reducer.get_rate_AB_SS() print "kSS", rAB_ss self.assertAlmostEqual(rAB_ss, 1.5, 7)
def _test_rate(self, i, j): reducer = TwoStateRates(self.rates, [i], [j]) reducer.compute_rates() rAB = reducer.get_rate_AB() self.assertAlmostEqual(rAB, self.final_rate, 7) reducer.compute_committors() rAB_ss = reducer.get_rate_AB_SS() print("kSS", rAB_ss) self.assertAlmostEqual(rAB_ss, 1.5, 7)
def _test_rate(self, A, B): reducer = TwoStateRates(self.rates, A, B) reducer.compute_rates() reducer.compute_committors() kAB = reducer.get_rate_AB() self.assertAlmostEqual(kAB, self.true_kAB, 7) # kBA = reducer.get_rate_BA() # self.assertAlmostEqual(kBA, self.true_kBA, 7) rAB_SS = reducer.get_rate_AB_SS() self.assertAlmostEqual(rAB_SS, self.true_kAB_SS, 7)
def _test_rate(self, A, B): reducer = TwoStateRates(self.rates, A, B) reducer.compute_rates() reducer.compute_committors() kAB = reducer.get_rate_AB() self.assertAlmostEqual(kAB, self.true_kAB, 7) # kBA = reducer.get_rate_BA() # self.assertAlmostEqual(kBA, self.true_kBA, 7) rAB_SS = reducer.get_rate_AB_SS() self.assertAlmostEqual(rAB_SS, self.true_kAB_SS, 7)
class RatesLinalg(object): """this class duplicates the behavior in RateCalculation, but with the linalg solver""" _initialized = False _times_computed = False def __init__(self, transition_states, A, B, T=1., use_fvib=True): self.minima2rates = _Minima2Rates(transition_states, A, B, T=T, use_fvib=use_fvib) def initialize(self): self.minima2rates.run() self.two_state_rates = TwoStateRates(self.minima2rates.rate_constants, self.minima2rates.A, self.minima2rates.B, weights=self.minima2rates.weights) def compute_rates(self): if not self._initialized: self.initialize() if not self._times_computed: self.two_state_rates.compute_rates() self._times_computed = True return old_div(self.two_state_rates.get_rate_AB(), self.minima2rates.rate_norm) def get_mfptimes(self): if not self._initialized: self.initialize() if not self._times_computed: self.two_state_rates.compute_rates() times = self.two_state_rates.mfpt_computer.mfpt_dict self.mfpt_dict = dict( ((m, t * self.minima2rates.rate_norm) for m, t in times.items())) for m in self.minima2rates.B: self.mfpt_dict[m] = 0. return self.mfpt_dict def compute_committors(self): if not self._initialized: self.initialize() self.two_state_rates.compute_committors() self.committors = self.two_state_rates.committor_dict for m in self.minima2rates.A: self.committors[m] = 0. for m in self.minima2rates.B: self.committors[m] = 1. return self.committors def get_committors(self): return self.committors
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 do_check(self, A, B, nnodes=20, nedges=20): maker = _MakeRandomGraph(nnodes=20, nedges=20, node_set=A+B) rates = maker.make_rates() reducer = TwoStateRates(rates, A, B) reducer.compute_rates() reducer.compute_committors() from pele.rates._ngt_cpp import NGT ngt = NGT(rates, A, B) ngt.compute_rates() self.assertAlmostEqual(reducer.get_rate_AB(), ngt.get_rate_AB(), 7) self.assertAlmostEqual(reducer.get_rate_AB_SS(), ngt.get_rate_AB_SS(), 7)
class RatesLinalg(object): """this class duplicates the behavior in RateCalculation, but with the linalg solver""" _initialized = False _times_computed = False def __init__(self, transition_states, A, B, T=1.0, use_fvib=True): self.minima2rates = _Minima2Rates(transition_states, A, B, T=T, use_fvib=use_fvib) def initialize(self): self.minima2rates.run() self.two_state_rates = TwoStateRates( self.minima2rates.rate_constants, self.minima2rates.A, self.minima2rates.B, weights=self.minima2rates.weights, ) def compute_rates(self): if not self._initialized: self.initialize() if not self._times_computed: self.two_state_rates.compute_rates() self._times_computed = True return self.two_state_rates.get_rate_AB() / self.minima2rates.rate_norm def get_mfptimes(self): if not self._initialized: self.initialize() if not self._times_computed: self.two_state_rates.compute_rates() times = self.two_state_rates.mfpt_computer.mfpt_dict self.mfpt_dict = dict(((m, t * self.minima2rates.rate_norm) for m, t in times.iteritems())) for m in self.minima2rates.B: self.mfpt_dict[m] = 0.0 return self.mfpt_dict def compute_committors(self): if not self._initialized: self.initialize() self.two_state_rates.compute_committors() self.committors = self.two_state_rates.committor_dict for m in self.minima2rates.A: self.committors[m] = 0.0 for m in self.minima2rates.B: self.committors[m] = 1.0 return self.committors def get_committors(self): return self.committors
def do_check(self, A, B, nnodes=20, nedges=20): maker = _MakeRandomGraph(nnodes=20, nedges=20, node_set=A + B) rates = maker.make_rates() reducer = TwoStateRates(rates, A, B) reducer.compute_rates() reducer.compute_committors() from pele.rates._ngt_cpp import NGT ngt = NGT(rates, A, B) ngt.compute_rates() self.assertAlmostEqual(reducer.get_rate_AB(), ngt.get_rate_AB(), 7) self.assertAlmostEqual(reducer.get_rate_AB_SS(), ngt.get_rate_AB_SS(), 7)