def test():
from pele.systems import LJCluster
from pele.landscape import ConnectManager
system = LJCluster(13)
db = system.create_database()
bh = system.get_basinhopping(db, outstream=None)
bh.run(200)
manager = ConnectManager(db)
for i in range(3):
min1, min2 = manager.get_connect_job()
connect = system.get_double_ended_connect(min1, min2, db)
connect.connect()
# get_thermodynamic_information(system, db)
print "getting thermodynamic info", db.number_of_minima()
get_thermodynamic_information(system, db, nproc=4)
for m in db.minima():
print m.id(), m.pgorder, m.fvib
print "\nnow transition states"
for ts in db.transition_states():
print ts.id(), ts.pgorder, ts.fvib
def create_random_database(system, db, nmin=20, nts=10):
if db.number_of_minima() < nmin:
bh = system.get_basinhopping(db, outstream=None)
bh.run(50)
if db.number_of_transition_states() < nts:
manager = ConnectManager(db, strategy="gmin")
for i in range(nts):
try:
min1, min2 = manager.get_connect_job("gmin")
except Exception as e:
if not "couldn't find any random minima pair to connect" in str(
e):
raise
connect = system.get_double_ended_connect(min1,
min2,
db,
verbosity=0)
connect.connect()
connect = system.get_double_ended_connect(db.minima()[0],
db.minima()[-1],
db,
verbosity=0)
connect.connect()
get_thermodynamic_information(system, db, nproc=2)
return db
def main2():
"""a copy of main to clean it up a bit"""
np.random.seed(0)
#params=[0.1,1.0,0.0,0.0,0.0]
#params=[0.1,1.0,0.0]
params = [0.1, 1.0, 0.0, 0.0, 0.5 * np.pi]
model = WaveModel(params0=params, sigma=0.1)
system = RegressionSystem(model)
database = system.create_database(db="/home/ab2111/mydb.sqlite")
pot = system.get_potential()
# do basinhopping
x0 = np.random.uniform(0., 3, [model.nparams])
print pot.getEnergy(x0)
pot.test_potential(x0)
step = RandomCluster(volume=1.0)
bh = system.get_basinhopping(database=database,
takestep=step,
coords=x0,
temperature=10.0)
bh.run(100)
mindist = system.get_mindist()
#for j,m in enumerate(database.minima()):
# for i,mi in enumerate(database.minima()):
# distbest,c,minew = mindist(m.coords,mi.coords)
# if distbest-np.linalg.norm(mi.coords-m.coords) != 0.:
# print j,i,distbest,np.linalg.norm(mi.coords-m.coords),"\n",mi.coords,"\n",minew
#print m.energy,m.coords
for m in database.minima():
print m.energy, m.coords
m0 = database.minima()[0]
m1 = database.minima()[1]
mindist(m0.coords, m1.coords)
# connect the minima
manager = ConnectManager(database, strategy="gmin")
for i in xrange(3):
try:
m1, m2 = manager.get_connect_job()
except manager.NoMoreConnectionsError:
break
connect = system.get_double_ended_connect(m1, m2, database)
connect.connect()
for m in database.minima():
print m.energy, m.coords
database.session.commit()
exit()
make_disconnectivity_graph(database)
m1 = database.minima()[0]
m2 = database.minima()[1]
def __init__(self, system, database, server_name=None, host=None, port=0):
self.system = system
self.db = database
self.server_name = server_name
self.host = host
self.port = port
self.connect_manager = ConnectManager(self.db)
def run_double_ended_connect(system, database):
# connect the all minima to the lowest minimum
from pele.landscape import ConnectManager
manager = ConnectManager(database, strategy="gmin")
for i in xrange(database.number_of_minima() - 1):
min1, min2 = manager.get_connect_job()
connect = system.get_double_ended_connect(min1, min2, database)
connect.connect()
def test_gmin(self):
manager = ConnectManager(self.db, strategy="gmin")
m0 = self.db.minima()[0]
for i in range(5):
m1, m2 = manager.get_connect_job()
self.assertEqual(m1, m0)
self.connect_min(m1, m2)
def test_untrap(self):
# first connect them all randomly
manager = ConnectManager(self.db, strategy="random")
while True:
try:
m1, m2 = manager.get_connect_job()
except manager.NoMoreConnectionsError:
break
self.connect_min(m1, m2)
for i in range(5):
try:
m1, m2 = manager.get_connect_job(strategy="untrap")
except manager.NoMoreConnectionsError:
break
self.connect_min(m1, m2)
def test_combine(self):
minima = self.db.minima()
i = 5
for m1, m2 in zip(minima[:i - 1], minima[1:i]):
self.connect_min(m1, m2)
for m1, m2 in zip(minima[i:], minima[i + 1:]):
self.connect_min(m1, m2)
# at this point the minima should be in two disconnected groups
g = database2graph(self.db)
self.assertEqual(len(list(nx.connected_components(g))), 2)
manager = ConnectManager(self.db, strategy="combine")
m1, m2 = manager.get_connect_job()
self.connect_min(m1, m2)
# they should all be connected now
g = database2graph(self.db)
self.assertEqual(len(list(nx.connected_components(g))), 1)
def __init__(self, system, database, parent=None, app=None):
ConnectViewer.__init__(self, system, database, app=app, parent=parent)
self.setWindowTitle("Connect all")
self.wgt_dgraph = DGraphWidget(database=self.database, parent=self)
self.connect_manager = ConnectManager(database)
self.view_dgraph = self.new_view("Disconnectivity Graph",
self.wgt_dgraph,
QtCore.Qt.TopDockWidgetArea)
self.view_dgraph.hide()
self.ui.actionD_Graph.setVisible(True)
self.ui.actionD_Graph.setChecked(False)
self.textEdit_summary = QtGui.QTextEdit(parent=self)
self.textEdit_summary.setReadOnly(True)
self.view_summary = self.new_view("Summary",
self.textEdit_summary,
pos=QtCore.Qt.TopDockWidgetArea)
self.connect_summary = _ConnectAllSummary()
self.ui.actionSummary.setVisible(True)
self.view_summary.hide()
self.ui.actionSummary.setChecked(False)
self.ui.action3D.setChecked(False)
self.view_3D.hide()
self.ui.actionEnergy.setChecked(False)
self.view_energies.hide()
self.ui.actionPause.setVisible(True)
self.is_running = False
self.failed_pairs = set()
# add combo box to toolbar
self.combobox = Qt.QComboBox()
self.ui.toolBar.addWidget(self.combobox)
self.combobox.addItems(
["connect strategy:", "random", "global min", "untrap", "combine"])
self.combobox.setToolTip(
"the strategy used to select which minima to connect")
def create_random_database(nmin=20, nts=20):
db = Database()
for i in range(nmin):
energy = np.random.uniform(-1., 10.)
x = [energy]
db.addMinimum(energy, x)
manager = ConnectManager(db, verbosity=0)
for i in range(old_div(nts, 2)):
m1, m2 = manager.get_connect_job("gmin")
energy = max([m1.energy, m2.energy]) + np.random.uniform(1, 10)
x = [energy]
db.addTransitionState(energy, x, m1, m2)
for i in range(old_div(nts, 2)):
m1, m2 = manager.get_connect_job("random")
energy = max([m1.energy, m2.energy]) + np.random.uniform(1, 5)
x = [energy]
db.addTransitionState(energy, x, m1, m2)
return db
def test_script():
natoms = 24
boxl = 3
boxvec = np.ones(3) * boxl
# system = MorseCluster(natoms, rho=1.6047, r0=2.8970, A=0.7102, rcut=9.5)
radii = np.ones(natoms) * .6
system = SoftSphereSystem(radii, boxvec, power=2.5)
db = system.create_database()
bh = system.get_basinhopping(db)
bh.run(100)
from pele.landscape import ConnectManager
manager = ConnectManager(db, strategy="random")
for i in range(10):
try:
m1, m2 = manager.get_connect_job()
except manager.NoMoreConnectionsError:
break
connect = system.get_double_ended_connect(m1, m2, db)
connect.connect()
def test_random(self):
manager = ConnectManager(self.db, strategy="random")
for i in range(5):
m1, m2 = manager.get_connect_job()
self.connect_min(m1, m2)
#
# first use the logging module to turn off the status messages
logger = logging.getLogger("pele.connect")
logger.setLevel("WARNING")
# now create the double ended connect object
connect = system.get_double_ended_connect(m1, m2, db)
connect.connect()
mints, S, energies = connect.returnPath()
nts = (len(mints) - 1) / 2
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
