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_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_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 test_basic(self):
dgraph = DisconnectivityGraph(self.tsgraph)
dgraph.calculate()
dgraph.plot()
layout = dgraph.get_tree_layout()
dgraph.draw_minima(self.db.minima()[:2])
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 _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 _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 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 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_basic(self):
dgraph = DisconnectivityGraph(self.tsgraph)
dgraph.calculate()
dgraph.plot()
layout = dgraph.get_tree_layout()
dgraph.draw_minima(self.db.minima()[:2])
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 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_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_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 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 = 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_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_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(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 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_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 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_graph(path_to_data_dir,database):
# make a graph from the database
graph = database2graph(database)
# turn the graph into a disconnectivity graph
dg = DisconnectivityGraph(graph)
dg.calculate()
print "number of minima:", dg.tree_graph.number_of_leaves()
dg.plot()
path_to_file = os.path.join(path_to_data_dir,"Disconnectivity_graph.png")
plt.savefig(path_to_file,dpi=1000)
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 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()
for ts in db.transition_states():
if ts.energy > Emax:
Emax = ts.energy
print 'max ts:', Emax
#check the structures with energy larger than check_e
#print paras['check_structure']
if check_structure:
for ts in db.transition_states():
if ts.energy > check_e:
print ts.coords
for rs in db.minima():
if ts.energy > check_e:
print rs.coords
graph = database2graph(db)
dg = DisconnectivityGraph(graph,
nlevels=nlevels,
Emax=Emax + 0.05,
node_offset=0)
dg.calculate()
dg.plot()
if min_state_n == 0:
dg.draw_minima([start_state], c='tab:gray')
if len(emphasize) > 0:
dg.draw_minima(emphasize, marker='o', c='tab:red')
if specified_min is not None:
dg.draw_minima([specified_min], marker='8', c='tab:green')
#find max number of atoms on surface
max_key = 0
for key in Au_seg:
if len(Au_seg[key]) > 0 and key > max_key:
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()
def test_show_minima(self):
dgraph = DisconnectivityGraph(self.tsgraph)
dgraph.calculate()
dgraph.plot(show_minima=True)
def test_show_minima(self):
dgraph = DisconnectivityGraph(self.tsgraph)
dgraph.calculate()
dgraph.plot(show_minima=True)
from __future__ import print_function
from pele.utils.disconnectivity_graph import DisconnectivityGraph
from pele.storage import Database
from pele.landscape import TSGraph
import pylab as pl
import numpy as np
kbT = 0.75
db = Database(db="tip4p_8.sqlite", createdb=False)
graph = TSGraph(db)
dg = DisconnectivityGraph(graph.graph, db.minima(), subgraph_size=20)
dg.calculate()
dg.plot()
for m in db.minima():
if m.pgorder != 2:
print(m.pgorder)
m.free_energy = m.energy + kbT * 0.5*m.fvib + kbT*np.log(m.pgorder)
for ts in db.transition_states():
# if ts.pgorder != 2:
print(ts.pgorder)
#assert ts.pgorder == 2
ts.free_energy = ts.energy + kbT * 0.5*ts.fvib + kbT*np.log(ts.pgorder) + kbT*np.log(kbT)
if ts.free_energy > ts.minimum1.free_energy or ts.free_energy > ts.minimum2.free_energy:
print("warning, free energy of transition state lower than minimum")
def test_color_value(self):
dgraph = DisconnectivityGraph(self.tsgraph)
dgraph.calculate()
def minimum_to_value(m):
if m.energy < 5.:
return m.energy
else:
return None
dgraph.color_by_value(minimum_to_value)
dgraph.plot(linewidth=2.)
dgraph.label_minima({
self.db.minima()[0]: "gmin",
self.db.minima()[1]: "2nd lowest"
})
if _show:
from matplotlib import pyplot as plt
plt.title("color by value")
dgraph.show()
def test_basic(self):
dgraph = DisconnectivityGraph(self.tsgraph)
dgraph.calculate()
dgraph.plot()
def make_disconnectivity_graph(database):
graph = database2graph(database)
dg = DisconnectivityGraph(graph, nlevels=3, center_gmin=True)
dg.calculate()
dg.plot()
plt.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()
for ts in db.transition_states():
if ts.energy > Emax:
Emax = ts.energy
print 'max ts:', Emax
#check the structures with energy larger than check_e
#print paras['check_structure']
if paras['check_structure']:
for ts in db.transition_states():
if ts.energy > paras['check_e']:
print ts.coords
for rs in db.minima():
if ts.energy > paras['check_e']:
print rs.coords
graph = database2graph(db)
dg = DisconnectivityGraph(graph,
nlevels=paras['nlevels'],
Emax=Emax + 0.05,
node_offset=0)
dg.calculate()
dg.plot()
if paras['min_state_n'] == 0:
dg.draw_minima([start_state], c='tab:gray')
if len(emphasize) > 0:
dg.draw_minima(emphasize, marker='o', c='tab:red')
if len(specified_min) > 0:
dg.draw_minima(specified_min, marker='8', c='tab:green')
#find max number of atoms on surface
max_key = 0
for key in Au_seg:
if len(Au_seg[key]) > 0 and key > max_key:
def test_color_value(self):
dgraph = DisconnectivityGraph(self.tsgraph)
dgraph.calculate()
def minimum_to_value(m):
if m.energy < 5.:
return m.energy
else:
return None
dgraph.color_by_value(minimum_to_value)
dgraph.plot(linewidth=2.)
dgraph.label_minima({self.db.minima()[0]: "gmin",
self.db.minima()[1]: "2nd lowest"})
if _show:
from matplotlib import pyplot as plt
plt.title("color by value")
dgraph.show()
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')
ax = fig.add_subplot(111, adjustable='box')
#ax = fig.add_subplot(111)
#ax.axvline(linewidth=4, color="g")
