Python disconnectivity_graph.DisconnectivityGraph类代码示例

def test_connect():  # pragma: no cover

    nmol = 5
    boxvec = np.array([5,5,5])
    rcut = 2.5
    system = OTPBulk(nmol,boxvec,rcut)   

    db = test_bh()
#     X1 = db.minima()[0].coords
#     X2 = db.minima()[1].coords
    
#     import pele.angleaxis.aaperiodicttransforms as md
#     a = md.MeasurePeriodicRigid(system.aatopology, transform=TransformPeriodicRigid())
#     b = MinPermDistBulk(boxvec, a, transform=TransformPeriodicRigid())     
#     dist, x1, x2 = b(X1,X2)
    
    min1, min2 = db.minima()[0], db.minima()[1]
#     from pele.landscape import ConnectManager
#     manager = ConnectManager(db, strategy="gmin")
#     for i in xrange(db.number_of_minima()-1):
#         min1, min2 = manager.get_connect_job()
    connect = system.get_double_ended_connect(min1, min2, db)
    connect.connect()
    from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph
    import matplotlib.pyplot as plt
#     convert the database to a networkx graph
    graph = database2graph(db)
    dg = DisconnectivityGraph(graph, nlevels=3, center_gmin=True)
    dg.calculate()
    dg.plot()
    plt.show()          

 def test_2_minima(self):
     db = create_random_database(nmin=3, nts=1)
     
     tsgraph = database2graph(self.db)
     dgraph = DisconnectivityGraph(tsgraph, include_gmin=True)
     dgraph.calculate()
     dgraph.plot()

 def test_gmin_not_connected(self):
     m0 = self.db.get_lowest_energy_minimum()
     self.db.addMinimum(m0.energy - 10., m0.coords)
     
     tsgraph = database2graph(self.db)
     dgraph = DisconnectivityGraph(tsgraph, include_gmin=True)
     dgraph.calculate()
     dgraph.plot()

def make_disconnectivity_graph(system, database, fname='dg.pdf', **kwargs):
    import matplotlib.pyplot as plt
    from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph
    graph = database2graph(database)
    dg = DisconnectivityGraph(graph, **kwargs)
    dg.calculate()
    dg.plot(linewidth=1.5)
    plt.savefig(fname)

 def test_Emax(self):
     emax = self.db._highest_energy_minimum().energy
     m1 = self.db.addMinimum(emax-5.1, [0.])
     m2 = self.db.addMinimum(emax-5.2, [0.])
     self.db.addTransitionState(emax-5, [0.], m1, m2)
     self.db.addMinimum(emax-5.3, [0.]) # so this will need to be removed
     dgraph = DisconnectivityGraph(self.tsgraph, Emax=emax-2, subgraph_size=1, order_by_energy=True)
     dgraph.calculate()
     dgraph.plot()

 def test_disconn_graph(self,database):
     from pele.utils.disconnectivity_graph import DisconnectivityGraph
     from pele.landscape import TSGraph
     import matplotlib.pyplot as plt
     graph = TSGraph(database).graph
     dg = DisconnectivityGraph(graph, nlevels=3, center_gmin=True)
     dg.calculate()
     dg.plot()
     plt.show()

def make_disconnectivity_graph(database):
    from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph
    import matplotlib.pyplot as plt
    
    graph = database2graph(database)
    dg = DisconnectivityGraph(graph, nlevels=3, center_gmin=True)
    dg.calculate()
    dg.plot()
    plt.show()

 def _compute_barriers(self, graph, min1):
     """for each minimum graph compute the (approximate) energy barrier to min1"""
     # this is a local import to avoid cyclical imports
     from pele.utils.disconnectivity_graph import DisconnectivityGraph
     dgraph = DisconnectivityGraph(graph, nlevels=self.nlevels)
     dgraph.calculate()
     tree = dgraph.tree_graph
     
     energy_barriers = dict()
     self._recursive_label(tree, min1, energy_barriers)
     return energy_barriers

 def _build_disconnectivity_graph(self, **params):
     if self.database is not None:
         db = self.database
         apply_Emax = "Emax" in params and "T" not in params
         if apply_Emax:
             self.graph = database2graph(db, Emax=params['Emax'])
         else:
             self.graph = database2graph(db)
     dg = DisconnectivityGraph(self.graph, **params)
     dg.calculate()
     self.dg = dg

 def test_basic(self):
     dgraph = DisconnectivityGraph(self.tsgraph)
     dgraph.calculate()
     dgraph.plot()
     layout = dgraph.get_tree_layout()
     
     dgraph.draw_minima(self.db.minima()[:2])

def make_disconnectivity_graph(system, database, vinputs, vtargets):
    from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph
    import matplotlib.pyplot as plt
    
    graph = database2graph(database)
    dg = DisconnectivityGraph(graph, nlevels=5, center_gmin=True, Emax=50.0, subgraph_size=3)
    dg.calculate()

    pot = system.get_potential()
    validation_energy = lambda m: pot.getValidationEnergy(m.coords, vinputs, vtargets)
    vmin = min(graph.nodes(), key=lambda m: validation_energy(m))
    labels = {vmin : "vmin"}    
    print vmin.energy, min(database.minima(), key = lambda m : validation_energy(m)).energy
#     for m in graph.nodes():
#         print m.energy
    for t in database.transition_states():
        print t.minimum1.energy, t.minimum2.energy, t.energy
        if abs(t.minimum1.energy-12.1884413947)<0.1 or abs(t.minimum2.energy-12.1884413947)<0.1:
            print t.minimum1.energy, t.minimum2.energy, t.energy
#     for u,v,data in graph.edges(data=True):
#         ts = data["ts"]
#         if abs(u.energy-12.1884413947)<0.1 or abs(v.energy-12.1884413947)<0.1:
#             print u.energy, v.energy, ts.energy  
    dg.plot()
    dg.label_minima(labels)

    plt.show()   

 def test_color_groups_many(self):
     dgraph = DisconnectivityGraph(self.tsgraph)
     dgraph.calculate()
     groups = []
     for m in self.db.minima():
         groups.append([m])
         if len(groups) > 13:
             break
     dgraph.color_by_group(groups)
     dgraph.plot(linewidth=2.)
     if _show:
         from matplotlib import pyplot as plt
         plt.title("color by group")

 def test_color_groups(self):
     dgraph = DisconnectivityGraph(self.tsgraph)
     dgraph.calculate()
     groups = [ self.db.minima()[:5],
               self.db.minima()[5:10],
               self.db.minima()[10:15],
               self.db.minima()[15:18],
               ]
     dgraph.color_by_group(groups)
     dgraph.plot(linewidth=2.)
     if _show:
         from matplotlib import pyplot as plt
         plt.title("color by group")

def make_graph(database):
    # make a graph from the database
    graph = database2graph(database)

    # turn the graph into a disconnectivity graph
    dg = DisconnectivityGraph(graph,
                              nlevels=5,
                              center_gmin=False,
                              order_by_energy=True)
    dg.calculate()

    print "number of minima:", dg.tree_graph.number_of_leaves()
    dg.plot()
    dg.show()

def make_validation_disconnectivity_graph(system, database):
    from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph
    import matplotlib.pyplot as plt
 
    inputs, targets = get_validation_data()
   
    """ make validation_energy a minimum object"""    
    pot = system.get_potential()
    validation_energy = lambda m: pot.getValidationEnergy(m.coords, inputs, targets)
    graph = database2graph(database)
    for m in graph.nodes():
        m.validation_energy = validation_energy(m)
    for u,v,data in graph.edges(data=True):
        ts = data["ts"]
        ve = max([validation_energy(ts), u.validation_energy, v.validation_energy])
        ts.validation_energy = ve

    gmin = min(graph.nodes(), key=lambda m:m.energy)
#     smin = graph.nodes().sort(key=lambda m:m.energy)
    smin = sorted(graph.nodes(), key=lambda m:m.energy)
#     gmax = max(graph.nodes(), key=lambda m:m.energy)
    
    labels = dict()
    for i,s in enumerate(smin):
        if i % 10 == 0: labels[s] = str(i)
#     labels = {gmin : "gmin"}
    dg = DisconnectivityGraph(graph, nlevels=10, center_gmin=True, energy_attribute="validation_energy", subgraph_size=3)
    dg.calculate()
    
#     minimum_to_validation_energy = lambda m: pot.getValidationEnergy(m.coords, inputs, targets)
    
#     dg.color_by_value(validation_energy)
    
    dg.plot()
    dg.label_minima(labels)
    print labels
    plt.show()