def test_1(self):
import StringIO
mol1 = read.readxyz(StringIO.StringIO(test_in_1))
mol2 = read.readxyz(StringIO.StringIO(test_in_2))
self.assertAlmostEqual(_rmsd.rmsd(mol1, mol2), 1.001, 3)
self.assertAlmostEqual(_rmsd.rmsd(mol1.coords.take([0], axis=0),
mol2.coords.take([0], axis=0)),
0.0)
def main():
if len(sys.argv) != 3:
import os.path
sys.stderr.write('Usage: %s xyzfname1 xyzfname2\n'
'result unit is degree\n'
% os.path.basename(sys.argv[0]))
sys.exit(1)
mol1 = read.readxyz(file(sys.argv[1]))
mol2 = read.readxyz(file(sys.argv[2]))
print math.degrees(catordiff(mol1, mol2))
def __setstate__(self, dicts):
self.__dict__.update(dicts)
self.olddir = os.getcwd()
self.newdir = tempfile.mkdtemp("itcc")
os.chdir(self.newdir)
if self.tmp_mtxyz_fname is not None:
self.tmp_mtxyz_fname = os.path.join(self.olddir, os.path.basename(self.tmp_mtxyz_fname))
self.tmp_mtxyz_file = file(self.tmp_mtxyz_fname, "ab+")
for i in range(len(self._tasks)): # pylint: disable-msg=W0612
read.readxyz(self.tmp_mtxyz_file)
self.tmp_mtxyz_file.truncate()
else:
self.tmp_mtxyz_file = None
self.mutex = threading.Lock()
def printbonds():
if len(sys.argv) != 2:
sys.stderr.write('Usage: %s <xyzfname>\n' % os.path.basename(sys.argv[0]))
sys.exit(1)
mol = read.readxyz(file(sys.argv[1]))
a = relalist.Relalist(mol)
print a
def mirrormol():
if len(sys.argv) != 2:
sys.stderr.write('Usage: %s <xyzfname>\n' % os.path.basename(sys.argv[0]))
sys.exit(1)
mol = read.readxyz(file(sys.argv[1]))
mol.coords = -mol.coords
write.writexyz(mol)
def shake(xyz_ifile, dat_ifile):
mol = read.readxyz(xyz_ifile)
dats = read_dat(dat_ifile)
for i in range(1):
ofile = file("ello%03i.xyz" % i, "w")
shake1(mol, dats, ofile)
ofile.close()
def parmfit(datfname, idxfname, param):
fnames, enes, weights = tools.readdat(datfname)
idxs, folds = readidx(idxfname)
params = getparams(idxs, param)
A = []
B = []
for fname, E_qm, weight in zip(fnames, enes, weights):
mol = read.readxyz(file(fname))
tors = analyze.gettorsbytype(mol, idxs)
newmol, E_mm = tinker.minimize_file(fname, param)
E_tor = getetor(newmol, tors, params)
E_fit = E_qm - E_mm + E_tor
weight = math.sqrt(weight)
B.append(E_fit * weight)
A.append([x*weight for x in getA(newmol, idxs, folds, tors)])
A = numpy.array(A)
B = numpy.array(B)
result = numpy.linalg.lstsq(A, B)
newparam = list(result[0][:-1])
errors = numpy.dot(A, result[0]) - B
errors = [error/math.sqrt(weight) for error, weight in zip(errors, weights)]
error = extra_tools.weightedsd(errors, weights)
printprm(newparam, idxs, folds)
print error
def settype(xyzfile, typefile):
mol = read.readxyz(xyzfile)
types = tuple(_gettypes(typefile))
assert len(mol) == len(types), "%s - %s" % (len(mol), len(types))
for idx, atype in enumerate(types):
mol.settype(idx, atype)
write.writexyz(mol, sys.stdout)
def test_1(self):
mol = read.readxyz(StringIO(test_in))
mol = loads(dumps(mol))
ofile = StringIO()
write.writexyz(mol, ofile)
for line1, line2 in zip(ofile.getvalue().splitlines(),
test_in.splitlines()):
self.assertEqual(line1, line2)
def dmddummy(xyzfname):
mol = read.readxyz(file(xyzfname))
rlist = relalist.Relalist(mol)
tors = rlist.torsions
for tor in tors:
if mol.atoms[tor[0]].no == 1 or mol.atoms[tor[-1]].no == 1:
print tor[0]+1, tor[-1]+1
def main():
from optparse import OptionParser
parser = OptionParser(usage="\n\t%prog [options] xyzfname1 xyzfname2\n\t%prog -h")
parser.set_defaults(chiral=False)
parser.add_option("-c", "--chiral",
action="store_true",
dest="chiral",
help="also check chiral")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.error("incorrect number of arguments")
mol1 = read.readxyz(file(sys.argv[1]))
mol2 = read.readxyz(file(sys.argv[2]))
if cmpxyztop(mol1, mol2, options.chiral):
sys.exit(0)
else:
sys.exit(1)
def cache_mol(fname1, mol_cache):
if fname1 in mol_cache:
mol1 = mol_cache[fname1]
else:
ifile1 = sys.stdin
if fname1 != '-':
ifile1 = file(fname1)
mol1 = read.readxyz(ifile1)
mol_cache[fname1] = mol1
return mol1
def main():
import sys
if len(sys.argv) != 3:
import os.path
sys.stderr.write('Usage: %s molname forcefield\n'
% os.path.basename(sys.argv[0]))
sys.exit(1)
from itcc.molecule import read
mol = read.readxyz(file(sys.argv[1]))
print solvent_caflisch(mol, sys.argv[2], 1)
def mtxyz2txyz(ifile, ofilenamepattern):
i = 1
while 1:
try:
ofname = ofilenamepattern % i
mol = read.readxyz(ifile)
write.writexyz(mol, file(ofname, 'w'))
except:
break
i += 1
def mol2tor(molfname, ofile=sys.stdout):
if(not hasattr(molfname, 'read')):
ifile = file(molfname)
else:
ifile = molfname
mol = read.readxyz(ifile)
tors = Relalist(mol).torsions
for tor in tors:
if all([mol.atoms[idx].no != 1 for idx in tor]):
ofile.write('%s\n' % ' '.join([str(idx+1) for idx in tor]))
def main():
if len(sys.argv) != 2:
import os.path
sys.stderr.write('Usage: %s molfname\n' % os.path.basename(sys.argv[0]))
sys.exit(1)
mol = read.readxyz(file(sys.argv[1]))
res = molcenter(mol)
for i in range(3):
print res[i],
print
def rg():
if len(sys.argv) < 2:
sys.stderr.write('Usage: %s XYZFNAME...\n' % os.path.basename(sys.argv[0]))
sys.exit(1)
from itcc.molecule import radius_of_gyration
for fname in sys.argv[1:]:
ifile = sys.stdin
if fname != '-':
ifile = file(fname)
mol = read.readxyz(ifile)
print ifile.name, radius_of_gyration(mol)
def cached_fname2tors(fname, idxs, cache):
if fname in cache:
return cache[fname]
ifile1 = sys.stdin
if fname != '-':
ifile1 = file(fname)
mol1 = read.readxyz(ifile1)
data1 = numpy.array([mol1.calctor(idx[0], idx[1], idx[2], idx[3]) for idx in idxs])
cache[fname] = data1
return data1
def main():
if len(sys.argv) != 3:
import os.path
sys.stderr.write('Usage: %s mol1fname mol2fname\n' % os.path.basename(sys.argv[0]))
sys.exit(1)
mol1_ifile = sys.stdin
if sys.argv[1] != '-':
mol1_ifile = file(sys.argv[1])
mol1 = read.readxyz(mol1_ifile)
mol2_ifile = sys.stdin
if sys.argv[2] != '-':
mol2_ifile = file(sys.argv[2])
mol2 = read.readxyz(mol2_ifile)
res = moldiff(mol1, mol2)
for i, x in enumerate(res):
print i+1, '%f' % x
def test_2(self):
import StringIO
mol1 = read.readxyz(StringIO.StringIO(test_in_1))
mol2 = read.readxyz(StringIO.StringIO(test_in_2))
res = _rmsd.rmsd2(mol1, mol2)
self.assertAlmostEqual(res[0], 1.001, 3)
for i in range(3):
self.assertAlmostEqual(res[1][3][i], 0.0)
self.assertAlmostEqual(res[1][3][3], 1.0)
mat = numpy.array([x[:3] for x in res[1][:3]])
self.assertAlmostEqual(abs((numpy.dot(mat, mat.transpose()) - numpy.eye(3))).max(), 0.0)
self.assertAlmostEqual(numpy.linalg.det(mat), 1.0)
newcoords2 = numpy.dot(mat, mol2.coords.transpose()).transpose() \
+ numpy.array([res[1][i][3] for i in range(3)])
diff = newcoords2 - mol1.coords
self.assertAlmostEqual(((diff**2).sum()/(len(mol1)-1)) ** 0.5, res[0])
res2 = _rmsd.rmsd2(mol1, mol1)
self.assertAlmostEqual(res2[0], 0.0)
self.assertAlmostEqual(abs(res2[1] - numpy.eye(4)).max(), 0.0)
def dmddat2mtxyz(dmddatfile, molfile, ofile, select_frames=None):
aDmddat = dmddat.Dmddat(dmddatfile)
mol = read.readxyz(molfile)
if select_frames is None:
select_frames = range(aDmddat.framenum)
for frame_idx in select_frames:
aDmddat.seek_frame(frame_idx)
frame = aDmddat.next().coords
for i in range(len(frame)):
mol.coords[i] = molecule.CoordType(frame[i])
write.writexyz(mol, ofile, comment = 'frame: %i' % (frame_idx+1))
def main():
if len(sys.argv) != 4:
import os.path
sys.stderr.write('Usage: %s <mol1|-> <mol2|-> <corr|->\n'
% os.path.basename(sys.argv[0]))
sys.exit(1)
mol1_ifile = sys.stdin
if sys.argv[1] != '-':
mol1_ifile = file(sys.argv[1])
mol1 = read.readxyz(mol1_ifile)
mol2_ifile = sys.stdin
if sys.argv[2] != '-':
mol2_ifile = file(sys.argv[2])
mol2 = read.readxyz(mol2_ifile)
corr_ifile = sys.stdin
if sys.argv[3] != '-':
corr_ifile = file(sys.argv[3])
corr = read_corr(corr_ifile)
verify_correspoding(mol1, mol2, corr)
def main():
mol = read.readxyz(file(sys.argv[1]))
loop = detectloop.loopdetect(mol)[0]
loopc = loopclosure.LoopClosure()
shakedata = loopclosure.getshakedata(mol, loop)
loopc.shakedata = shakedata
loopc.forcefield = "oplsaa"
loopc.log_level = 0
for r6 in peptide.Peptide(mol).getr6s(loop):
for mol, ene in loopc.findneighbor(mol, r6):
print ene
def __call__(self, ifile, ofile, idxs):
mol = read.readxyz(ifile)
ns = []
for i in range(len(mol)):
if mol.atoms[i].no == 7:
ns.append(i)
for i in idxs:
assert i < len(ns)
self.add_one_methyl(mol, ns[i])
write.writexyz(mol, ofile)
def sumxyz_torsion(list_, filelist):
if len(list_) != 4:
raise ValueError
result = []
for x in filelist:
if x == '-':
ifile = sys.stdin
else:
ifile = file(x)
mol = read.readxyz(ifile)
print ifile.name, math.degrees(mol.calctor(list_[0], list_[1],
list_[2], list_[3]))
def constrain(ifname, param = None):
"""constrain(ifname, param = None) -> List of String
return the content of the constrain key file based on mol specified by ifname.
restrain all torsions on mol.
"""
mol = read.readxyz(file(ifname))
rel = relalist.Relalist(mol)
lines = ['restrain-torsion %d %d %d %d\n' % x for x in rel.torsions]
if param is not None:
lines.append('parameters %s\n' % param)
return lines
def newton_mol(self, mol, forcefield,
converge = 0.01, prefix=None):
"""newton_mol(mol, forcefield, converge = 0.01, prefix=None) -> (Molecule, Float)
optimized the mol with newton, and return the optimized energy
"""
forcefield = getparam(forcefield)
if curdir:
if prefix is None:
ifname = 'tinker.xyz'
else:
ifname = prefix + '.xyz'
ofile = file(ifname, 'w')
else:
ofile = tempfile.NamedTemporaryFile(suffix='.xyz')
ifname = ofile.name
write.writexyz(mol, ofile)
ofile.flush()
ofname = ifname + '_2'
ifile = subprocess.Popen(['newton', ifname, forcefield, 'A', 'A', str(converge)],
stdout=subprocess.PIPE).communicate()[0]
result = None
lines = ifile.splitlines()
if self.log_iter:
self.do_log_iter(lines)
for line in lines:
if line.startswith(' Final Function'):
result = float(line.split()[-1])
break
if result is None:
sys.stdout.writelines(lines)
raise RuntimeError, ifname
try:
newmol = read.readxyz(file(ofname))
except:
print ifname, ofname
raise
ofile.close()
os.remove(ofname)
if curdir:
os.remove(ifname)
return newmol, result
def printefit(datfname, idxfname, param):
'''Only print E_fit'''
import csv
fnames, enes, weights = tools.readdat(datfname)
idxs, folds = parmfit.readidx(idxfname)
params = parmfit.getparams(idxs, param)
writer = csv.writer(sys.stdout)
writer.writerow(['Filename', 'weight', 'E_qm', 'E_mm', 'E_tor', 'E_fit'])
for fname, E_qm, weight in zip(fnames, enes, weights):
mol = read.readxyz(file(fname))
tors = analyze.gettorsbytype(mol, idxs)
newmol, E_mm = tinker.minimize_file(fname, param)
E_tor = parmfit.getetor(newmol, tors, params)
E_fit = E_qm - E_mm + E_tor
writer.writerow([fname, weight, E_qm, E_mm, E_tor, E_fit])
def sub_pyramid_check(fname, atoms):
mol = read.readxyz(file(fname))
if atoms is None:
atoms = range(len(mol))
res = []
for atom in atoms:
neis = neighbours(mol, atom)
if len(neis) != 4:
continue
if is_pyramid(mol.coords[atom],
mol.coords[neis[0]],
mol.coords[neis[1]],
mol.coords[neis[2]],
mol.coords[neis[3]]):
res.append(atom)
return res
def optimize_minimize_mol(cmdname, mol, forcefield,
converge = 0.01, prefix=None):
"""optimizemol(mol, forcefield, converge = 0.01) -> (Molecule, Float)
optimized the mol, and return the optimized energy
"""
progpath = os.path.join(TINKERDIR, cmdname)
forcefield = getparam(forcefield)
if curdir:
if prefix is None:
ifname = 'tinker.xyz'
else:
ifname = prefix + '.xyz'
ofile = file(ifname, 'w')
else:
ofile = tempfile.NamedTemporaryFile(suffix='.xyz')
ifname = ofile.name
write.writexyz(mol, ofile)
ofile.flush()
ofname = ifname + '_2'
lines = subprocess.Popen([progpath, ifname, forcefield, str(converge)],
stdout=subprocess.PIPE).communicate()[0].splitlines()
result = None
for line in lines:
if line.find('Function') != -1:
result = float(line.split()[-1])
break
if result is None:
sys.stdout.writelines(lines)
raise RuntimeError, ifname
try:
newmol = read.readxyz(file(ofname))
except:
print ifname, ofname
raise
ofile.close()
os.remove(ofname)
if curdir:
os.remove(ifname)
return newmol, result
