def main():
# add some program options
parser = OptionParser(usage = "usage: %prog [options] storage")
parser.add_option("--write-disconnect",
dest="writeDPS", action="store_true",
help="generate min.dat and ts.dat to use with disconnectDPS")
parser.add_option("-m",
dest="writeMinima", action="store_true",
help="dump minima to screen")
parser.add_option("-t",
dest="writeTS", action="store_true",
help="dump transition states to screen")
parser.add_option("--cif",
dest="writeCIF", action="store_true",
help="export cif files")
parser.add_option("--cif-dir",
dest="cifDir", default=".", action="store",type="string",
help="directory to write cifs to")
(options, args) = parser.parse_args()
# print help if no input file is given
if(len(args) != 1):
parser.print_help()
exit(-1)
db = Database(db=args[0])
if(options.writeMinima):
print "List of minima:"
print "---------------"
for m in db.minima():
print "%f\t\tid %d"%(m.energy, m._id)
print "END\n"
if(options.writeTS):
print "List of transition states:"
print "--------------------------"
for ts in db.transition_states():
print "%d\t<->\t%d\tid %d\tenergies %f %f %f"%\
(ts.minimum1._id, ts.minimum2._id, ts._id, ts.minimum1.energy, ts.energy, ts.minimum2.energy)
print "END\n"
if(options.writeDPS):
writeDPS(db)
if(options.writeCIF):
GMIN.initialize()
i=0
for m in db.minima():
i+=1
filename = options.cifDir+"/lowest%03d.cif"%(i)
print "minimum",i, "energy",m.energy,"to",filename
GMIN.writeCIF(filename, m.coords, "E"+str(m.energy))
def main():
# add some program options
parser = OptionParser(usage = "usage: %prog [options] storage")
from pygmin.storage.database import Database
parser.add_option("--write-disconnect",
dest="writeDPS", action="store_true",
help="generate min.dat and ts.dat to use with disconnectDPS")
parser.add_option("-m",
dest="writeMinima", action="store_true",
help="dump minima to screen")
parser.add_option("-t",
dest="writeTS", action="store_true",
help="dump transition states to screen")
parser.add_option("-d",
dest="write_distances", action="store_true",
help="dump distances to screen")
(options, args) = parser.parse_args()
# print help if no input file is given
if(len(args) != 1):
parser.print_help()
exit(-1)
db = Database(db=args[0])
if(options.writeMinima):
print "List of minima:"
print "---------------"
for m in db.minima():
print "%f\t\tid %d"%(m.energy, m._id)
print "END\n"
if(options.writeTS):
print "List of transition states:"
print "--------------------------"
for ts in db.transition_states():
print "%d\t<->\t%d\tid %d\tenergies %f %f %f"%\
(ts.minimum1._id, ts.minimum2._id, ts._id, ts.minimum1.energy, ts.energy, ts.minimum2.energy)
print "END\n"
if(options.write_distances):
print "List of distances:"
print "--------------------------"
for d in db.distances():
print "%d\t<->\t%d\tid %d\tdistance %f"%\
(d._minimum1_id, d._minimum2_id, d._id, d.dist)
print "END\n"
if(options.writeDPS):
writeDPS(db)
def getSetOfMinLJ(natoms = 32): #for testing purposes
from pygmin.potentials.lj import LJ
pot = LJ()
coords = np.random.uniform(-1,1,natoms*3)
from pygmin.basinhopping import BasinHopping
from pygmin.takestep.displace import RandomDisplacement
from pygmin.takestep.adaptive import AdaptiveStepsize
from pygmin.storage.database import Database
import os
#dbfile = "test.db"
#os.remove(dbfile)
#saveit = Database(db=dbfile)
saveit = Database()
takestep1 = RandomDisplacement()
takestep = AdaptiveStepsize(takestep1, frequency=15)
bh = BasinHopping(coords, pot, takestep, storage=saveit.minimum_adder(), outstream=None)
bh.run(100)
return pot, saveit
def execute(self):
print "The program was started with the following command line argument"
print " ".join(sys.argv)
self.add_options()
(self.options, self.args) = self.parser.parse_args()
print "Starting the run with the following options"
print "-------------------------------------------"
for key, value in self.options.__dict__.iteritems():
print str(key) + " = " + str(value)
print "-------------------------------------------"
self.database = Database(db=self.options.database,
accuracy=self.accuracy,
compareMinima=self.compareStructures)
self.run()
def main():
# add some program options
parser = OptionParser(usage="usage: %prog [options] storage")
parser.add_option(
"--write-disconnect",
dest="writeDPS",
action="store_true",
help="generate min.dat and ts.dat to use with disconnectDPS")
parser.add_option("-m",
dest="writeMinima",
action="store_true",
help="dump minima to screen")
parser.add_option("-t",
dest="writeTS",
action="store_true",
help="dump transition states to screen")
parser.add_option("--coords",
dest="writeCoords",
action="store_true",
help="export coordinates files")
parser.add_option("--xyz",
dest="writeXYZ",
action="store_true",
help="export xyz files")
(options, args) = parser.parse_args()
# print help if no input file is given
if (len(args) != 1):
parser.print_help()
exit(-1)
db = Database(db=args[0])
if (options.writeMinima):
print "List of minima:"
print "---------------"
for m in db.minima():
print "%f\t\tid %d" % (m.energy, m._id)
print "END\n"
if (options.writeTS):
print "List of transition states:"
print "--------------------------"
for ts in db.transition_states():
print "%d\t<->\t%d\tid %d\tenergies %f %f %f"%\
(ts.minimum1._id, ts.minimum2._id, ts._id, ts.minimum1.energy, ts.energy, ts.minimum2.energy)
print "END\n"
if (options.writeDPS):
writeDPS(db)
if (options.writeCoords):
GMIN.initialize()
i = 0
for m in db.minima():
i += 1
filename = "lowest/lowest%03d.cif" % (i)
print "minimum", i, "energy", m.energy, "to", filename
GMIN.userpot_dump(filename, m.coords)
if (not TO_PDB is None):
os.system(TO_PDB % filename)
np.savetxt("lowest/coords_%03d.txt" % (i), m.coords)
if (options.writeXYZ):
traj = open("lowest/traj.xyz", "w")
i = 0
for m in db.minima():
i += 1
filename = "lowest/lowest%03d.xyz" % (i)
print "minimum", i, "energy", m.energy, "to", filename
export_xyz(open(filename, "w"), m.coords)
export_xyz(traj, m.coords)
traj.close()
Input:
coords.prmtop ( for number of atoms )
min.data, ts.data, extractedmin, extractedts
Output:
storage.sqlite
"""
# determine number of atoms from prmtop
prmtop = AmberPrmtopFile( 'coords.prmtop' ) # TOSET
natoms = prmtop.topology._numAtoms
# open database
db = Database(db="storage.sqlite") # TOSET
def read_coords(filee):
coords = np.zeros(3*natoms)
for i in xrange(natoms):
x = filee.readline().split()
coords[i*3:i*3+3] = [float(y) for y in x]
return coords
# counter to keep track of added minima
mini=1
minima={}
# for timing
tt = t0 = time.time()
def read_coords(file):
coords = np.zeros(3*natoms)
for i in xrange(natoms):
x = file.readline().split()
coords[i*3:i*3+3] = [float(y) for y in x]
return coords
# ---- main
natoms = input('Enter number of atoms: ')
# open database
print 'database file name = storage.sqlite'
if os.path.exists('storage.sqlite'):
db = Database(db="storage.sqlite")
print 'database file exists'
if hasattr(db,'minima'):
print ' number of minima = ', len(db.minima())
if hasattr(db,'ts'):
print ' number of ts = ', len(db.ts() )
print '\n Note that minima and ts will be appended to existing set without testing for duplicates \n'
else:
db = Database(db="storage.sqlite")
# --- Minima
# counter to keep track of added minima
ct=1
minima={}
coords=potential.getCoords()
coords=np.random.random(coords.shape)
# create takestep routine
# we combine a normal step taking
group = takestep.BlockMoves()
step1 = takestep.AdaptiveStepsize(OXDNATakestep(displace=parameters.displace, rotate=0.), frequency=50)
step2 = takestep.AdaptiveStepsize(OXDNATakestep(displace=0., rotate=parameters.rotate), frequency=50)
group.addBlock(100, step1)
group.addBlock(100, step2)
# with a generate random configuration
genrandom = OXDNAReseed()
# in a reseeding takestep procedure
reseed = takestep.Reseeding(group, genrandom, maxnoimprove=parameters.reseed)
# store all minima in a database
db = Database(db="storage.sqlite", accuracy=1e-2)
# create Basinhopping object
opt = BasinHopping(coords, potential, reseed, db.minimum_adder(), temperature=parameters.temperature)
# run for 100 steps
opt.run(parameters.nsteps)
# now dump all the minima
i=0
for m in db.minima():
i+=1
GMIN.userpot_dump("lowest_%03d.dat"%(i), m.coords)
def main():
# add some program options
parser = OptionParser(usage="usage: %prog [options] storage")
parser.add_option(
"--write-disconnect",
dest="writeDPS",
action="store_true",
help="generate min.dat and ts.dat to use with disconnectDPS")
parser.add_option("-m",
dest="writeMinima",
action="store_true",
help="dump minima to screen")
parser.add_option("-t",
dest="writeTS",
action="store_true",
help="dump transition states to screen")
parser.add_option("--cif",
dest="writeCIF",
action="store_true",
help="export cif files")
parser.add_option("--cif-dir",
dest="cifDir",
default=".",
action="store",
type="string",
help="directory to write cifs to")
(options, args) = parser.parse_args()
# print help if no input file is given
if (len(args) != 1):
parser.print_help()
exit(-1)
db = Database(db=args[0])
if (options.writeMinima):
print "List of minima:"
print "---------------"
for m in db.minima():
print "%f\t\tid %d" % (m.energy, m._id)
print "END\n"
if (options.writeTS):
print "List of transition states:"
print "--------------------------"
for ts in db.transition_states():
print "%d\t<->\t%d\tid %d\tenergies %f %f %f"%\
(ts.minimum1._id, ts.minimum2._id, ts._id, ts.minimum1.energy, ts.energy, ts.minimum2.energy)
print "END\n"
if (options.writeDPS):
writeDPS(db)
if (options.writeCIF):
GMIN.initialize()
i = 0
for m in db.minima():
i += 1
filename = options.cifDir + "/lowest%03d.cif" % (i)
print "minimum", i, "energy", m.energy, "to", filename
GMIN.writeCIF(filename, m.coords, "E" + str(m.energy))
import random
import pickle
from pygmin.storage.database import Database
#from math import pi
from pygmin.systems.oxdna import OXDNATakestep, export_xyz, OXDNAScrewStep
# number of trial configurations to try
nconf = 1000
# generate these from the n lowest minima
from_nlowest = 100
# open the database with minima
db = Database(db = "storage.sqlite")
minima = db.minima()
# make sure from_nlowest is not larger than # of minima
from_nlowest = max(from_nlowest, len(minima))
# you can try a different step routine
step = OXDNATakestep(displace=0.0, rotate=0.8, rotate_around_backbone=False)
trial_configurations = []
for i in xrange(nconf):
x = random.choice(minima[0:nconf])
coords = x.coords.copy()
step.takeStep(coords)
trial_configurations.append(coords)
pickle.dump(trial_configurations, open("quench_benchmark.dat", "w"))
fl = open("quench_benchmark.xyz", "w")
step1 = takestep.AdaptiveStepsize(OXDNATakestep(displace=parameters.displace,
rotate=0.),
frequency=50)
step2 = takestep.AdaptiveStepsize(OXDNATakestep(displace=0.,
rotate=parameters.rotate),
frequency=50)
group.addBlock(100, step1)
group.addBlock(100, step2)
# with a generate random configuration
genrandom = OXDNAReseed()
# in a reseeding takestep procedure
reseed = takestep.Reseeding(group, genrandom, maxnoimprove=parameters.reseed)
# store all minima in a database
db = Database(db="storage.sqlite", accuracy=1e-2)
# create Basinhopping object
opt = BasinHopping(coords,
potential,
reseed,
db.minimum_adder(),
temperature=parameters.temperature)
# run for 100 steps
opt.run(parameters.nsteps)
# now dump all the minima
i = 0
for m in db.minima():
i += 1
import random
import pickle
from pygmin.storage.database import Database
#from math import pi
from pygmin.systems.oxdna import OXDNATakestep, export_xyz, OXDNAScrewStep
# number of trial configurations to try
nconf = 1000
# generate these from the n lowest minima
from_nlowest = 100
# open the database with minima
db = Database(db="storage.sqlite")
minima = db.minima()
# make sure from_nlowest is not larger than # of minima
from_nlowest = max(from_nlowest, len(minima))
# you can try a different step routine
step = OXDNATakestep(displace=0.0, rotate=0.8, rotate_around_backbone=False)
trial_configurations = []
for i in xrange(nconf):
x = random.choice(minima[0:nconf])
coords = x.coords.copy()
step.takeStep(coords)
trial_configurations.append(coords)
pickle.dump(trial_configurations, open("quench_benchmark.dat", "w"))
fl = open("quench_benchmark.xyz", "w")
dumpcoords = False
opts, args = getopt.gnu_getopt(sys.argv[1:], "h",
["help", "dist", "dump-coords="])
for o, a in opts:
if o == "--dist":
printdist = True
elif o in ("-h", "--help"):
print usage
exit(1)
elif o == "--dump-coords":
dumpcoords = True
id = int(a)
else:
assert False, "unhandled option"
if len(args) == 0:
print usage
exit()
else:
dbfile = args[0]
database = Database(dbfile)
if dumpcoords:
printCoords(id, database)
exit(1)
if printe: printEnergies(database)
if printts: printTS(database)
if printdist: printDist(database)
# print help if no input file is given
if(len(args) != 1):
parser.print_help()
exit(-1)
infile = args[0]
outfile = infile
# initialize GMIN
GMIN.initialize()
pot = gminpotential.GMINPotential(GMIN)
crystals.GMIN = GMIN
# open the storage class
db_in = Database(db=infile)
if(options.out!=None):
outfile = options.out
db_out = Database(db=outfile)
print "Start to reoptimize minima"
for m in db_in.minima():
print "optimizing minima",m._id,", energy", m.energy
ret = dmagmin.quenchCrystal(m.coords, pot.getEnergyGradient, tol=options.tol, maxErise=options.maxErise)
print "new energy",ret[1],"(difference %f)"%(ret[1] - m.energy)
print
if(options.out!=None):
db_out.addMinimum(ret[1], ret[0])
else:
m.energy = ret[1]
m.coords = ret[0]
import oxdnagmin_ as GMIN
from pygmin.potentials.gminpotential import GMINPotential
import pygmin.basinhopping as bh
from pygmin.takestep import displace
from pygmin.storage.database import Database
# initialize GMIN
GMIN.initialize()
# create a potential which calls GMIN
potential = GMINPotential(GMIN)
# get the initial coorinates
coords=potential.getCoords()
coords=np.random.random(coords.shape)
# create takestep routine
step = displace.RandomDisplacement(stepsize=1.)
# store all minima in a database
db = Database(db="storage.sqlite", accuracy=1e-2)
# create Basinhopping object
opt = bh.BasinHopping(coords, potential, step, db.minimum_adder())
# run for 100 steps
opt.run(1000)
# now dump all the minima
i=0
for m in db.minima():
i+=1
GMIN.userpot_dump("lowest_%03d.dat"%(i), m.coords)
import numpy as np
import oxdnagmin_ as GMIN
from pygmin.potentials.gminpotential import GMINPotential
import pygmin.basinhopping as bh
from pygmin.takestep import displace
from pygmin.storage.database import Database
# initialize GMIN
GMIN.initialize()
# create a potential which calls GMIN
potential = GMINPotential(GMIN)
# get the initial coorinates
coords = potential.getCoords()
coords = np.random.random(coords.shape)
# create takestep routine
step = displace.RandomDisplacement(stepsize=1.)
# store all minima in a database
db = Database(db="storage.sqlite", accuracy=1e-2)
# create Basinhopping object
opt = bh.BasinHopping(coords, potential, step, db.minimum_adder())
# run for 100 steps
opt.run(1000)
# now dump all the minima
i = 0
for m in db.minima():
i += 1
GMIN.userpot_dump("lowest_%03d.dat" % (i), m.coords)
def main():
# add some program options
parser = OptionParser(usage = "usage: %prog [options] storage")
parser.add_option("--write-disconnect",
dest="writeDPS", action="store_true",
help="generate min.dat and ts.dat to use with disconnectDPS")
parser.add_option("-m",
dest="writeMinima", action="store_true",
help="dump minima to screen")
parser.add_option("-t",
dest="writeTS", action="store_true",
help="dump transition states to screen")
parser.add_option("--coords",
dest="writeCoords", action="store_true",
help="export coordinates files")
parser.add_option("--xyz",
dest="writeXYZ", action="store_true",
help="export xyz files")
(options, args) = parser.parse_args()
# print help if no input file is given
if(len(args) != 1):
parser.print_help()
exit(-1)
db = Database(db=args[0])
if(options.writeMinima):
print "List of minima:"
print "---------------"
for m in db.minima():
print "%f\t\tid %d"%(m.energy, m._id)
print "END\n"
if(options.writeTS):
print "List of transition states:"
print "--------------------------"
for ts in db.transition_states():
print "%d\t<->\t%d\tid %d\tenergies %f %f %f"%\
(ts.minimum1._id, ts.minimum2._id, ts._id, ts.minimum1.energy, ts.energy, ts.minimum2.energy)
print "END\n"
if(options.writeDPS):
writeDPS(db)
if(options.writeCoords):
GMIN.initialize()
i=0
for m in db.minima():
i+=1
filename = "lowest/lowest%03d.cif"%(i)
print "minimum",i, "energy",m.energy,"to",filename
GMIN.userpot_dump(filename, m.coords)
if(not TO_PDB is None):
os.system(TO_PDB%filename)
np.savetxt("lowest/coords_%03d.txt"%(i), m.coords)
if(options.writeXYZ):
traj=open("lowest/traj.xyz", "w")
i=0
for m in db.minima():
i+=1
filename = "lowest/lowest%03d.xyz"%(i)
print "minimum",i, "energy",m.energy,"to",filename
export_xyz(open(filename, "w"), m.coords)
export_xyz(traj, m.coords)
traj.close()
