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 _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 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_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 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(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(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 make_disconnectivity_graph(database):
graph = database2graph(database)
dg = DisconnectivityGraph(graph, nlevels=3, center_gmin=True)
dg.calculate()
dg.plot()
plt.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')
