コード例 #1
0
    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)
コード例 #2
0
ファイル: test_cpp_ngt.py プロジェクト: spraharsh/pele
    def compare_linalg(self, A, B, nnodes=20, nedges=20):
        from pele.rates._rates_linalg import TwoStateRates
        maker = _MakeRandomGraph(nnodes=20, nedges=20, node_set=A + B)
        maker.run()

        reducer = NGT(maker.rates, A, B)
        reducer.compute_rates_and_committors()
        committors = reducer.get_committors()

        la = TwoStateRates(maker.rates, A, B)
        #        la.compute_rates()
        la.compute_committors()
        qla = la.committor_dict
        for n, qla in la.committor_dict.items():
            self.assertAlmostEqual(qla, committors[n], 7)
コード例 #3
0
ファイル: test_cpp_ngt.py プロジェクト: Mahdisadjadi/pele
    def compare_linalg(self, A, B, nnodes=20, nedges=20):
        from pele.rates._rates_linalg import TwoStateRates
        maker = _MakeRandomGraph(nnodes=20, nedges=20, node_set=A+B)
        maker.run()
        
        reducer = NGT(maker.rates, A, B)
        reducer.compute_rates_and_committors()
        committors = reducer.get_committors()
        
        la = TwoStateRates(maker.rates, A, B)
#        la.compute_rates()
        la.compute_committors()
        qla = la.committor_dict
        for n, qla in la.committor_dict.iteritems():
            self.assertAlmostEqual(qla, committors[n], 7)
コード例 #4
0
ファイル: _rates.py プロジェクト: jaotta/pele
 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,
     )
コード例 #5
0
    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)
コード例 #6
0
    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)
コード例 #7
0
ファイル: test_kmc.py プロジェクト: pele-python/pele
    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)
コード例 #8
0
ファイル: test_linalg.py プロジェクト: pele-python/pele
 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)
コード例 #9
0
    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)
コード例 #10
0
ファイル: test_linalg.py プロジェクト: pele-python/pele
    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)
コード例 #11
0
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
コード例 #12
0
ファイル: test_linalg.py プロジェクト: pele-python/pele
 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)
コード例 #13
0
ファイル: _rates.py プロジェクト: jaotta/pele
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
コード例 #14
0
 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)