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 make_only_dg(system, database, color=None): from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph import matplotlib.pyplot as plt # m1 = database.minima()[6] # tss = database.getTransitionStatesMinimum(m1) # for ts in tss: # print orderbyenergy(database, ts.minimum1.energy), orderbyenergy(database, ts.minimum2.energy), ts.minimum1._id, ts.minimum2._id, ts.energy # exit() for mi, m in enumerate(database.minima()): print mi, m.energy graph = database2graph(database) # dg = DisconnectivityGraph(graph, center_gmin=True, Emax=4.0) # dg = DisconnectivityGraph(graph, nlevels=2, center_gmin=True, subgraph_size=3) dg = DisconnectivityGraph(graph, nlevels=30, subgraph_size=5, minima=[database.minima()[i] for i in [1, 2]]) dg.calculate() # dg.color_by_value(lambda x : np.random.random(), colormap=lambda x : np.random.random(3)) if color != None: dg.color_by_value( lambda m: color[0, orderbyenergy(database, m.energy)], colormap=cmap) dg.plot() plt.show()
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 long_summary(db): nts = db.number_of_transition_states() if nts == 0: print "long summary not applicable: no transition states" return graph = database2graph(db) cclist = nx.connected_components(graph) # print "number of connected components", len(cclist) counts = dict() minimum_energy = dict() for cc in cclist: nc = len(cc) Emin = min((m.energy for m in cc)) try: counts[nc] += 1 if Emin < minimum_energy[nc]: minimum_energy[nc] = Emin except KeyError: counts[nc] = 1 minimum_energy[nc] = Emin counts = counts.items() counts.sort(key=lambda x:-x[0]) print "Connectivity of the database:" for n, count in counts: if n == 1: print "%7d unconnected minima : minimum energy = %s" % (count, minimum_energy[n]) else: print "%7d connected clusters of size %7d: minimum energy = %s" % (count, n, minimum_energy[n])
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 long_summary(db): nts = db.number_of_transition_states() if nts == 0: print "long summary not applicable: no transition states" return graph = database2graph(db) cclist = nx.connected_components(graph) # print "number of connected components", len(cclist) counts = dict() minimum_energy = dict() for cc in cclist: nc = len(cc) Emin = min((m.energy for m in cc)) try: counts[nc] += 1 if Emin < minimum_energy[nc]: minimum_energy[nc] = Emin except KeyError: counts[nc] = 1 minimum_energy[nc] = Emin counts = counts.items() counts.sort(key=lambda x: -x[0]) print "Connectivity of the database:" for n, count in counts: if n == 1: print "%7d unconnected minima : minimum energy = %s" % (count, minimum_energy[n]) else: print "%7d connected clusters of size %7d: minimum energy = %s" % (count, n, minimum_energy[n])
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_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 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 make_disconnectivity_graph(system, database, **kwargs): from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph graph = database2graph(database) dg = DisconnectivityGraph(graph, **kwargs) dg.calculate() # color DG points by test-set error # minimum_to_testerror = lambda m: system.model.testset_error(m.coords) # dg.color_by_value(minimum_to_testerror) dg.plot(linewidth=1.5) #dg.plot(linewidth=1.5) # plt.colorbar() plt.show()
def plot(self): from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph import matplotlib.pyplot as plt graph = database2graph(self.db) # dg = DisconnectivityGraph(graph, nlevels=30, subgraph_size=5, minima=[self.db.minima()[i] for i in [1,2]]) dg = DisconnectivityGraph(graph, nlevels=30, subgraph_size=5) dg.calculate() dg.color_by_value( lambda m: self.hem.HEM[0, orderbyenergy(self.db, m.energy)], colormap=self.colormap) dg.plot() plt.show()
def make_graph(database): # make a graph from the database graph = dg.database2graph(db) # turn the graph into a disconnectivity graph mydg = dg.DisconnectivityGraph(graph, nlevels=5, center_gmin=False, order_by_energy=True, ) mydg.calculate() print "number of minima:", mydg.tree_graph.number_of_leaves() mydg.plot() plt.show()
def make_graph(self, database=None, minima=None): """build an nx graph from the database""" if database is None: database = self.database if minima is None: minima = self.minima print "making graph", database, minima # get the graph object, eliminate nodes without edges graph = database2graph(database) if minima is not None: to_remove = set(graph.nodes()).difference(set(minima)) graph.remove_nodes_from(to_remove) self.full_graph = graph print graph.number_of_nodes() degree = graph.degree() nodes = [n for n, nedges in degree.items() if nedges > 0] self.graph = graph.subgraph(nodes) print self.graph.number_of_nodes(), self.graph.number_of_edges()
def make_graph(self, database=None, minima=None): """build an nx graph from the database""" if database is None: database = self.database if minima is None: minima = self.minima print("making graph", database, minima) # get the graph object, eliminate nodes without edges graph = database2graph(database) if minima is not None: to_remove = set(graph.nodes()).difference(set(minima)) graph.remove_nodes_from(to_remove) self.full_graph = graph print(graph.number_of_nodes()) degree = graph.degree() nodes = [n for n, nedges in degree.items() if nedges > 0] self.graph = graph.subgraph(nodes) print(self.graph.number_of_nodes(), self.graph.number_of_edges())
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()
def main(): if len(sys.argv) < 2: usage() exit(1) # The default is to use the largest connected component of the graph, # rather than the component which includes the global minimum. kwargs = {"include_gmin":False, "center_gmin":False} outfile, colourfile, groupcolourfile, idfile = None, None, None, None aspect = 6.0/7.0 width = 6 OPTIM = False opts, args = getopt.gnu_getopt(sys.argv[1:], "ho:", ["help", "nlevels=", "subgraph_size=", "OPTIM", "order_by_basin_size", "order_by_energy", "include_gmin", "center_gmin", "Emax=", "colourfile=", "groupcolourfile=", "idfile=", "shape=", "width=" ]) for o, a in opts: if o == "-h" or o == "--help": usage() exit(1) if o == "-o": outfile = a elif o == "--nlevels": kwargs["nlevels"] = int(a) elif o == "--Emax": kwargs["Emax"] = float(a) elif o == "--subgraph_size": kwargs["subgraph_size"] = int(a) elif o == "--order_by_basin_size": kwargs["order_by_basin_size"] = True elif o == "--order_by_energy": kwargs["order_by_energy"] = True elif o == "--include_gmin": kwargs["include_gmin"] = True elif o == "--center_gmin": kwargs["center_gmin"] = True elif o == "--OPTIM": OPTIM = True elif o == "--colourfile": colourfile = a print "Setting colourfile to ", colourfile elif o == "--groupcolourfile": if colourfile: raise AttributeError("Can't specify both colourfile and groupcolourfile") groupcolourfile = a elif o == '--idfile': idfile = a elif o == '--shape': aspect = float(a) elif o == '--width': width = float(a) else: print "don't understand", o, a print "" usage() exit(1) groups = None if OPTIM: #make database from min.data ts.data db = Database() converter = OptimDBConverter(db) converter.convert_no_coords() groups = read_AB(db) else: if len(args) == 0: print "you must specify database file" print "" usage() exit() dbfile = args[0] if not os.path.exists(dbfile): print "database file doesn't exist", dbfile exit() db = Database(dbfile) if outfile is None and use_gui: app = QApplication(sys.argv) kwargs["show_minima"] = False md = DGraphDialog(db, params=kwargs) md.rebuild_disconnectivity_graph() if groups is not None: md.dgraph_widget.dg.color_by_group(groups) md.dgraph_widget.redraw_disconnectivity_graph() md.show() sys.exit(app.exec_()) # make graph from database t0 = time.time() if "Emax" in kwargs and use_gui: graph = reduced_db2graph(db, kwargs['Emax']) else: graph = dg.database2graph(db) t1 = time.time() print "loading the data into a transition state graph took", t1-t0, "seconds" # do the disconnectivity graph analysis mydg = dg.DisconnectivityGraph(graph, **kwargs) print "doing disconnectivity graph analysis" sys.stdout.flush() t1 = time.time() mydg.calculate() t2 = time.time() print "d-graph analysis finished in", t2-t1, "seconds" print "number of minima:", mydg.tree_graph.number_of_leaves() print "plotting disconnectivity graph" sys.stdout.flush() if colourfile: print "Colouring tree according to file ", colourfile colourfetcher = get_colours_from_file(db, colourfile) colouredtree = dg.ColorDGraphByValue(mydg.tree_graph,colourfetcher,normalize_values=True) print "tree set up" colouredtree.run() print "Finished colouring" elif groupcolourfile: print "Colouring tree according to file ", colourfile grouplists = get_group_lists(groupcolourfile) colouredtree = dg.ColorDGraphByGroups(mydg.tree_graph,grouplists) colouredtree.run() print "Finished colouring" if idfile: labelminima = [] labels = {} fin = open(idfile,'r') for line in fin: minID = line.split()[0] labelminima.append(db.getMinimum(minID)) # labels[labelminima[-1]]=str(labelminim fin.close() print "Labelling ", len(labelminima), "minima" print "Creating axes with dimensions ", width, width/aspect fig = plt.figure(figsize=(width, width/aspect)) fig.set_facecolor('white') ax = fig.add_subplot(111, adjustable='box') # make the figure and save it mydg.plot(axes=ax) if idfile: print "Going into draw_minima" mydg.draw_minima(labelminima,labels=True) if outfile is None: plt.show() else: plt.savefig(outfile) t3 = time.time() print "plotting finished in", t3-t2, "seconds"
def make_disconnectivity_graph(database): graph = database2graph(database) dg = DisconnectivityGraph(graph, nlevels=3, center_gmin=True) dg.calculate() dg.plot() plt.show()
print "\nprint found a connection with", nts, "transition states" # connect all minima to the lowest minimum print "now connecting all the minima to the lowest energy minimum" from pele.landscape import ConnectManager manager = ConnectManager(db, strategy="gmin") for i in xrange(db.number_of_minima()-1): print "connecting minima with id's", m1._id, m2._id m1, m2 = manager.get_connect_job() connect = system.get_double_ended_connect(m1, m2, db) connect.connect() # print some data about the database print "database summary:" print " ", len(db.minima()), "minima" print " ", len(db.transition_states()), "transition states" # finally, create a disconnectivity graph from the database print "computing and showing disconnectivity graph" import pylab as pl graph = database2graph(db) dg = DisconnectivityGraph(graph, nlevels=6) dg.calculate() dg.plot() pl.show()
bh.run(20) print "starting with a database of", len(db.minima()), "minima" # turn of status printing for the connect run # first use the logging module to turn off the status messages logger = logging.getLogger("pele.connect") logger.setLevel("WARNING") # connect all minima to the lowest minimum print "now connecting all the minima to the lowest energy minimum" m1 = db.minima()[0] for m2 in db.minima()[1:]: print " connecting minima with id's", m1._id, m2._id connect = system.get_double_ended_connect(m1, m2, db) connect.connect() # print some data about the database print "database summary:" print " ", len(db.minima()), "minima" print " ", len(db.transition_states()), "transition states" # finally, create a disconnectivity graph from the database print "computing and showing disconnectivity graph" import pylab as pl graph = database2graph(db) dg = DisconnectivityGraph(graph, nlevels=6) dg.calculate() dg.plot() pl.show()
def main(): if len(sys.argv) < 2: usage() exit(1) kwargs = {} outfile = None OPTIM = False opts, args = getopt.gnu_getopt(sys.argv[1:], "ho:", ["help", "nlevels=", "subgraph_size=", "OPTIM", "order_by_basin_size", "order_by_energy", "include_gmin", "center_gmin", "Emax=", ]) for o, a in opts: if o == "-h" or o == "--help": usage() exit(1) if o == "-o": outfile = a elif o == "--nlevels": kwargs["nlevels"] = int(a) elif o == "--Emax": kwargs["Emax"] = float(a) elif o == "--subgraph_size": kwargs["subgraph_size"] = int(a) elif o == "--order_by_basin_size": kwargs["order_by_basin_size"] = True elif o == "--order_by_energy": kwargs["order_by_energy"] = True elif o == "--includer_gmin": kwargs["includer_gmin"] = True elif o == "--center_gmin": kwargs["center_gmin"] = True elif o == "--OPTIM": OPTIM = True else: print "don't understand", o, a print "" usage() exit(1) groups = None if OPTIM: #make database from min.data ts.data db = Database() converter = OptimDBConverter(db) converter.convert_no_coords() groups = read_AB(db) else: if len(args) == 0: print "you must specify database file" print "" usage() exit() dbfile = args[0] if not os.path.exists(dbfile): print "database file doesn't exist", dbfile exit() db = Database(dbfile) if outfile is None and use_gui: app = QApplication(sys.argv) kwargs["show_minima"] = False md = DGraphDialog(db, params=kwargs) md.rebuild_disconnectivity_graph() if groups is not None: md.dgraph_widget.dg.color_by_group(groups) md.dgraph_widget.redraw_disconnectivity_graph() md.show() sys.exit(app.exec_()) # make graph from database t0 = time.time() if "Emax" in kwargs and use_gui: graph = reduced_db2graph(db, kwargs['Emax']) else: graph = dg.database2graph(db) t1 = time.time() print "loading the data into a transition state graph took", t1-t0, "seconds" # do the disconnectivity graph analysis mydg = dg.DisconnectivityGraph(graph, **kwargs) print "doing disconnectivity graph analysis" sys.stdout.flush() t1 = time.time() mydg.calculate() t2 = time.time() print "d-graph analysis finished in", t2-t1, "seconds" print "number of minima:", mydg.tree_graph.number_of_leaves() print "plotting disconnectivigy graph" sys.stdout.flush() # make the figure and save it mydg.plot() if outfile is None: plt.show() else: plt.savefig(outfile) t3 = time.time() print "plotting finished in", t3-t2, "seconds"
def setUp(self): np.random.seed(0) self.db = create_random_database(20, 60) self.tsgraph = database2graph(self.db)
def setUp(self): # np.random.seed(1) self.db = create_random_database(20, 60) self.tsgraph = database2graph(self.db)
from pele.storage import Database from pele.utils.disconnectivity_graph import DisconnectivityGraph, database2graph import pylab as plt import sys class orderByValue(object): def __call__(self, min1): print 'ID', min1.coords[0] return min1.coords[0] args = sys.argv db_amp = Database(db=args[1], accuracy=1e-10) db_lj = Database(db=args[2], accuracy=1e-10) dg_amp = DisconnectivityGraph(database2graph(db_amp), nlevels=100, Emax=-56.7716 + 0.05, order_by_basin_size=False, center_gmin=False, order_by_value=orderByValue()) dg_lj = DisconnectivityGraph(database2graph(db_lj), nlevels=100, Emax=-56.7716 + 0.05, order_by_basin_size=True, center_gmin=True, order_by_value=orderByValue()) dg_lj.calculate() fig = plt.figure(figsize=(9, 7)) fig.set_facecolor('white')