def testProdyNMDWriter(self):
evec_path = os.path.join(anmichelpers.writers.test.__path__[0], "data",
"eigenvectors.npy")
eval_path = os.path.join(anmichelpers.writers.test.__path__[0], "data",
"eigenvalues.npy")
output_path = os.path.join(anmichelpers.writers.test.__path__[0],
"data", "calculated.nmd")
expected_path = os.path.join(anmichelpers.writers.test.__path__[0],
"data", "expected.nmd")
pdb_file_path = os.path.join(anmichelpers.writers.test.__path__[0],
"data", "protein.pdb")
eigenvalues = numpy.load(eval_path)
eigenvectors = numpy.load(evec_path)
ProdyNMDWriter.write(output_path, "TEST",
prody.parsePDB(pdb_file_path), eigenvalues,
eigenvectors)
self.assertEqual("".join(open(expected_path).readlines()[1:]),
"".join(open(output_path).readlines())[1:])
# global data
header = g_header
evals = l_evals
evecs = fill_with_zeros(l_evecs,
options.from_res,
options.to_res,
len(g_evecs[0])/3)
else: # "GLOBAL_TO_LOCAL"
header = {}
assert "resnames" in g_header, "The global file must define the 'resnames' section"
evals = g_evals
ext_evecs, ext_sec = extract_evecs(g_evecs,
options.from_res,
options.to_res,
g_header["resnames"]) # The extracted sequence
header["resnames"] = ext_sec
if "coordinates" in g_header:
header["coordinates"] = extract_coords(g_header["coordinates"] ,
options.from_res,
options.to_res)
evecs = ext_evecs
header["title"] = options.output
ProdyNMDWriter.write(options.output, evals, evecs, header)
else:
offset = i * 2
if res == "PRO":
#only psi
new_eigenvectors.append(old_eigenvectors[offset])
else:
# phi
new_eigenvectors.append(old_eigenvectors[offset - 1])
# psi
new_eigenvectors.append(old_eigenvectors[offset])
return numpy.array(new_eigenvectors).T
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-i", dest="input")
parser.add_option("-s", dest="sequence")
parser.add_option("-o", dest="output")
(options, args) = parser.parse_args()
eigenvalues, eigenvectors = GeoPCA.load(options.input)
sequences = load_sequences(options.sequence)
pro_eigenvectors = treat_prolines_in_eigenvectors(sequences[0],
eigenvectors)
# And save it as nmd
header = {"type": "ic:pca"}
ProdyNMDWriter.write(options.output, eigenvalues, pro_eigenvectors, header)
'''
Created on 04/05/2015
@author: user
'''
from optparse import OptionParser
import numpy
from anmichelpers.tools.measure import calculate_angle_differences
from anmichelpers.writers.pronmd import ProdyNMDWriter
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-f", dest="_from")
parser.add_option("-t", dest="_to")
parser.add_option("-o", dest="output")
(options, args) = parser.parse_args()
from_file_v = numpy.loadtxt(options._from)
to_file_v = numpy.loadtxt(options._to)
difference = calculate_angle_differences(to_file_v, from_file_v)
##############
for i in range(len(difference)):
if not i in range(98*2, 110*2):
difference[i] = 0.
##############
ProdyNMDWriter.write(options.output, [1.0], numpy.array([difference]), {"type":"ic:pca"})
parser.add_option("-o", dest="output")
(options, args) = parser.parse_args()
name, extension = os.path.splitext(options.input)
betas = None
if extension == ".nmd":
print "There's no need to convert this file."
sys.exit()
elif extension == ".evec":
# Imods file
eigenvalues, eigenvectors = ImodServerFilesParser.read(options.input)
elif extension == ".slwevs":
# Bahar server file
eigenvalues, eigenvectors = BaharServerFilesParser.read(
options.input_evals, options.input)
if options.input_beta is not None:
betas = BaharServerFilesParser.read_beta(options.input_beta)
else:
print "I don't know how to convert this file."
sys.exit()
structure = prody.proteins.pdbfile.parsePDB(options.protein_path)
ca_indices = ProdyNMDWriter.get_alpha_indices(structure)
ca_evecs = ProdyNMDWriter.filter_eigvecs(ca_indices, eigenvectors)
ProdyNMDWriter.write(options.output, "conversion from %s" % options.input,
structure.select("name CA").copy(), ca_evecs,
eigenvectors, betas)
new_mode.extend(ca_mode_v)
else:
n_atom = Atom("N", atom.resid)
#look for the atoms into the "ordered atoms" vector
ca_atom_o = find(lambda a: a == ca_atom,
ordered_atoms)
n_atom_o = find(lambda a: a == n_atom,
ordered_atoms)
# vector from N to CA
n_c = n_atom_o.coords - ca_atom_o.coords
# vector from CA to Atom
c_a = atom.coords - ca_atom_o.coords
# cross
n_cxmode = numpy.cross(n_c, ca_mode_v)
# cross again
c_axn_cxmode = numpy.cross(c_a, n_cxmode)
# module is CA mode v module
new_mode.extend(
c_axn_cxmode *
(math.sqrt(numpy.dot(ca_mode_v, ca_mode_v)) /
math.sqrt(
numpy.dot(c_axn_cxmode, c_axn_cxmode))))
new_eigenvectors.append(new_mode)
new_eigenvectors = numpy.array(new_eigenvectors)
# Write it
ProdyNMDWriter.write(name, eigenvalues, new_eigenvectors, new_header)
numpy.savetxt(name + ".values", eigenvalues)
numpy.savetxt(name + ".vectors", new_eigenvectors)
options.input_evals, options.input)
if options.input_beta is not None:
betas = BaharServerFilesParser.read_beta(options.input_beta)
else:
print "I don't know how to convert this file."
sys.exit()
if extension != ".nmd":
new_header = {}
# Get a new header from the structural info
structure = prody.proteins.pdbfile.parsePDB(options.protein_path)
header["name"] = options.input
header["type"] = "cc:pca"
header["atomnames"] = structure.getNames()
header["coordinates"] = structure.getCoordsets()[0].flatten()
header["chainids"] = structure.getChids()
if betas is not None:
header["bfactors"] = betas
else:
header["bfactors"] = structure.getBetas()
header["resnames"] = structure.getResnames()
header["resids"] = structure.getResindices()
if options.ca_only:
new_header, final_evecs = get_CA_modes(header, eigenvectors)
else:
final_evecs = eigenvectors
new_header = header
ProdyNMDWriter.write(options.output, eigenvalues, final_evecs, new_header)