def test_constructor_from_command_list_Trajectory(self):
'''mutable Trajectory'''
# use `load` method rather `iterload`
traj = pt.load("data/tz2.ortho.nc", "data/tz2.ortho.parm7")
# make sure no space-sensitivity
# make the code (commands) ugly is my intention.
commands = [
'autoimage ',
'autoimage',
'rmsd @CA',
'distance :3 :7',
'distance :3 :7',
'vector :2 :3',
' distance :3 :7',
'rms @C,N,O',
]
dslist = CpptrajDatasetList()
actlist = ActionList(commands, traj.top, dslist=dslist)
for frame in traj:
actlist.compute(frame)
aa_eq(pt.rmsd(traj, mask='@CA'), dslist[0])
aa_eq(pt.distance(traj, ':3 :7'), dslist[1])
aa_eq(pt.distance(traj, ':3 :7'), dslist[2])
# do not need to perform rmsfit again.
aa_eq(pt.vector.vector_mask(traj, ':2 :3'), dslist[3].values)
aa_eq(pt.distance(traj, ':3 :7'), dslist[4])
aa_eq(pt.rmsd(traj, mask='@C,N,O'), dslist[5])
def test_check_valid_command(self):
from pytraj.parallel.base import check_valid_command
assert check_valid_command(['rms', ]) == (['rms refindex 0 '], True)
assert check_valid_command(['distrmsd', ]) == (['distrmsd refindex 0 '], True)
assert check_valid_command(['nativecontacts', ]) == (['nativecontacts refindex 0 '], True)
assert check_valid_command(['nastruct', ]) == (['nastruct refindex 0 '], True)
assert check_valid_command(['symmetricrmsd', ]) == (['symmetricrmsd refindex 0 '], True)
traj = pt.iterload("data/tz2.nc", "data/tz2.parm7")
aa_eq(pt.tools.dict_to_ndarray(
pt.pmap(['rmsd'], traj, ref=traj[3], n_cores=3)),
pt.rmsd(traj, ref=traj[3]))
# provide refindex
aa_eq(pt.tools.dict_to_ndarray(
pt.pmap(['rmsd refindex 0'], traj, ref=traj[3], n_cores=3)),
pt.rmsd(traj, ref=traj[3]))
aa_eq(pt.tools.dict_to_ndarray(
pt.pmap(['rmsd refindex 0'], traj, ref=[traj[3], traj[0]], n_cores=3)),
pt.rmsd(traj, ref=traj[3]))
# if user does not provide reference, need to give it to them
aa_eq(pt.tools.dict_to_ndarray(
pt.pmap(['rmsd'], traj, n_cores=3)),
pt.rmsd(traj, ref=traj[0]))
# does not support matrix
self.assertRaises(ValueError, lambda: pt.pmap(['matrix'], traj, n_cores=2))
# do not accept any c analysis command
for word in c_commands.analysis_commands:
self.assertRaises(ValueError, lambda: pt.pmap(word, traj, n_cores=2))
def test_loading(self):
for frame_slice in [(0, -1, 1), (0, 8, 2), (3, 9, 3)]:
traj = pt.iterload('data/tz2.nc',
'./data/tz2.parm7',
frame_slice=frame_slice)
# load from text
text = '''
rms @CA
radgyr @CA nomax
'''
s = load_batch(traj, text)
s.run()
rmsd0 = pt.rmsd(traj, '@CA', ref=0)
r0 = pt.radgyr(traj, '@CA')
s.data._pop(0)
aa_eq(rmsd0, s.data[0])
aa_eq(r0, s.data[1])
assert len(s.data[0]) == traj.n_frames
# load from list
lines = ['rms @CA', ' radgyr @CA nomax']
s = load_batch(traj, lines)
s.run()
s.data._pop(0)
rmsd0 = pt.rmsd(traj, '@CA', ref=0)
r0 = pt.radgyr(traj, '@CA')
aa_eq(rmsd0, s.data[0])
aa_eq(r0, s.data[1])
assert len(s.data[0]) == traj.n_frames
def test_1(self):
traj = mdio.iterload("./data/Tc5b.x", "./data/Tc5b.top")
i = 0
for farray in traj.iterchunk(chunksize=4, stop=8):
i += 1
assert i == 2
i = 0
for farray in traj.iterchunk(chunksize=4):
i += 1
assert i == 3
i = 0
for farray in traj.iterchunk(chunksize=2):
i += 1
assert i == 5
i = 0
for farray in traj.iterchunk(start=3, chunksize=4, stop=8):
i += 1
assert i == 2
# action on chunk_iter
pt.calc_distance(
[traj.iterchunk(), traj.iterchunk(), traj[0]],
'@CA @CB',
top=traj.top)
rmsd0 = pt.rmsd(traj.iterchunk(3), ref=traj[-1], top=traj.top)
rmsd1 = pt.rmsd(traj, ref=-1)
assert_almost_equal(rmsd0, rmsd1)
def test_drmsd(self):
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
txt = '''
parm data/tz2.parm7
trajin data/tz2.nc
drmsd drms_nofit out drmsd.dat
rms rms_nofit out drmsd.dat nofit
rms rms_fit out drmsd.dat
drmsd drms_fit out drmsd.dat
'''
state = pt.load_cpptraj_state(txt)
state.run()
cpp_data = state.data[1:]
# distance_rmsd
data_drmsd = pt.distance_rmsd(traj)
aa_eq(data_drmsd, cpp_data[0])
aa_eq(pt.drmsd(traj), cpp_data[0])
# rms_nofit
aa_eq(cpp_data[1], pt.rmsd(traj, nofit=True))
# rms_fit
aa_eq(cpp_data[2], pt.rmsd(traj, nofit=False))
# drmsd with rmsfit
aa_eq(cpp_data[3], pt.distance_rmsd(traj(rmsfit=0), ref=traj[0]))
def test_crdframes(self):
'''test crdframes in cpptraj
'''
max_frames = 50
traj = pt.iterload('data/tz2.nc',
'data/tz2.parm7',
frame_slice=(0, max_frames, 2))
state = pt.load_cpptraj_state('''
parm {0}
trajin {1} 1 {2} 2
trajin {1} 1 {2} 2
loadtraj name traj
crdaction traj rms crdframes 1,10
crdaction traj rms crdframes 1,30,2
'''.format(traj.top.filename, traj.filename, max_frames))
state.run()
rmsd_0 = pt.rmsd(traj, ref=0, frame_indices=range(10))
rmsd_crdframes = state.data[2].values
aa_eq(rmsd_0, rmsd_crdframes)
traj2 = traj.copy()
assert traj2.n_frames == traj.n_frames, 'must have the same n_frames'
traj2._load(traj.filename, frame_slice=(0, max_frames, 2))
assert traj2.n_frames == 2 * traj.n_frames, 'n_frames must be doubled after reload'
rmsd_1 = pt.rmsd(traj2, ref=0, frame_indices=range(0, 30, 2))
rmsd_crdframes = state.data[3].values
aa_eq(rmsd_1, rmsd_crdframes)
def testsuperpose_vs_rmsd(self):
# load frames to immutable traj
traj = pt.iterload("data/tz2.nc", "data/tz2.parm7")
t0 = traj[:]
t1 = traj[:]
pt.rmsd(t0, ref=traj[0], mask='@CA')
pt.superpose(t1, ref=traj[0], mask='@CA')
aa_eq(t0.xyz, t1.xyz)
def test_not_update_coordinates(self):
traj = self.traj[:]
data = pt.rmsd(traj, ref=3, update_coordinate=False)
# make sure coordinates are not updated
aa_eq(traj.xyz, self.traj.xyz)
# make sure give the same rmsd values
aa_eq(pt.rmsd(traj, ref=3), data)
def test_0(self):
traj = pt.iterload("./data/tz2.ortho.nc", "./data/tz2.ortho.parm7")
cout = pt.datafiles.load_cpptraj_output("""
parm ./data/tz2.ortho.parm7
trajin ./data/tz2.ortho.nc
rms first nofit
rms first mass
""")
aa_eq(pt.rmsd(traj, nofit=True), cout[1])
aa_eq(pt.rmsd(traj, mass=True), cout[2])
def test_frame_indices(self):
traj = pt.iterload("data/tz2.truncoct.nc", "data/tz2.truncoct.parm7")
traj2 = pt.iterload("data/tz2.truncoct.nc",
"data/tz2.truncoct.parm7",
frame_slice=(2, 8))
txt = '''
reference ./data/tz2.truncoct.nc 2 2
rmsd :2-11 refindex 0 perres perresout center.agr range 1 perrescenter
'''
state = pt.load_batch(traj2, txt)
state.run()
frame_indices = range(2, 8)
rmsd0 = pt.rmsd(traj, ref=1, mask=':2-11', frame_indices=frame_indices)
rmsdperres = pt.rmsd_perres(traj,
ref=1,
mask=':2-11',
perres_mask='*',
resrange='1',
perres_center=True,
frame_indices=frame_indices)
aa_eq(rmsd0, state.data[2])
aa_eq(rmsdperres[1], state.data[3].values)
def test_fit_and_then_nofit(self):
traj = pt.iterload("data/Tc5b.x", "data/Tc5b.top")
t0 = traj[:]
pt.superpose(t0, ref=traj[3], mask='@CA')
rmsd_0 = pt.rmsd_nofit(traj, ref=traj[3], mask='@CB')
rmsd_1 = pt.rmsd(traj, ref=traj[3], mask='@CB', nofit=True)
aa_eq(rmsd_1, rmsd_0)
def calc(traj0, traj1, mask='@P'):
import numpy as np
arr = np.empty((traj0.n_frames, traj1.n_frames), dtype='f8')
for idx, frame in enumerate(traj1):
arr[idx] = pt.rmsd(traj0, ref=frame, mask=mask)
return arr
def test_pytraj_do(self):
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
ref0 = pt.autoimage(traj[0], top=traj.top)
ref1 = pt.autoimage(traj[1], top=traj.top)
data = pt.tools.dict_to_ndarray(pt.compute(
['autoimage', 'radgyr nomax @CA', 'rms refindex 0',
'rms refindex 1'],
traj,
ref=[ref0, ref1]))
t0 = pt.autoimage(traj[:])
aa_eq(pt.radgyr(t0, '@CA'), data[0])
aa_eq(pt.rmsd(t0, ref=ref0), data[1])
aa_eq(pt.rmsd(t0, ref=ref1), data[2])
# pytraj's method
aa_eq(pt.compute(pt.radgyr, t0, '@CA'), data[0])
def test_reference_with_different_topology_basic(self):
traj1 = pt.iterload(filename="./data/Tc5b.x",
top="./data/Tc5b.top")
traj2 = pt.iterload('data/tz2.nc', 'data/tz2.parm7')
# re-establish ActionList
dslist = CpptrajDatasetList()
dslist.add('reference', name='myref')
dslist[0].top = traj2.top
dslist[0].add_frame(traj2[0])
actlist = pt.ActionList(['rmsd @1-11 @CB ref myref'], top=traj1.top,
dslist=dslist)
for frame in traj1:
actlist.compute(frame)
# raise if ref_mask is given but not mask
self.assertRaises(ValueError, lambda:
pt.rmsd(traj1, ref=3, ref_mask='@CB'))
self.assertRaises(ValueError, lambda:
pt.rmsd(traj1, ref=traj2[:1], ref_mask='@CB'))
# assert to cpptraj
tc5b_traj = traj1[:]
tz2_traj = traj2[:1]
cm = '''
parm data/Tc5b.top [tc5b]
trajin data/Tc5b.x [tc5b]
parm data/tz2.parm7 [tz2]
reference data/tz2.nc parm [tz2] 1 [myref]
rms myrmsd ref [myref] @1-10 @11-20
'''
state = pt.load_cpptraj_state(cm)
state.run()
expected_rmsd = state.data[-1].values
rmsd_data = pt.rmsd(tc5b_traj, mask='@1-10',
ref=tz2_traj,
ref_mask='@11-20')
aa_eq(expected_rmsd, rmsd_data)
def test_reference_2(self):
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
from pytraj.c_action.c_action import Action_Rmsd
from pytraj.datasets.c_datasetlist import DatasetList
act = Action_Rmsd()
ref = traj[2]
dslist = DatasetList()
dslist.add('ref_frame', 'myref')
dslist[-1].top = traj.top
dslist[-1].add_frame(ref)
act('myrmsd refindex 0 @CA', traj, top=traj.top, dslist=dslist)
aa_eq(pt.rmsd(traj, ref=traj[2], mask='@CA'),
dslist[-1].values)
def test_rmsd_with_mask(self):
TRAJ = pt.iterload(filename="./data/Tc5b.x",
top="./data/Tc5b.top")
cpptraj_rmsd = np.loadtxt(
"./data/rmsd_to_firstFrame_CA_allres.Tc5b.dat",
skiprows=1).transpose()[1]
f0 = TRAJ[0]
arr0 = np.zeros(TRAJ.n_frames)
arr1 = np.zeros(TRAJ.n_frames)
mask = "@CA"
atm = AtomMask(mask)
TRAJ.top.set_integer_mask(atm)
for i, frame in enumerate(TRAJ):
arr0[i] = frame.rmsd(f0, mask=mask, top=TRAJ.top)
arr1[i] = frame.rmsd(f0, atommask=atm)
arr2 = pt.rmsd(TRAJ, mask=mask, ref=f0)
arr3 = pt.rmsd(TRAJ, mask=mask, ref=0)
aa_eq(arr0, cpptraj_rmsd, decimal=3)
aa_eq(arr1, cpptraj_rmsd, decimal=3)
aa_eq(arr2, cpptraj_rmsd, decimal=3)
aa_eq(arr3, cpptraj_rmsd, decimal=3)
def test_combine_nofit_mass_nomod(self):
cm = '''
parm data/tz2.parm7
trajin data/tz2.nc
rms @CA nofit mass nomod
'''
state = pt.load_cpptraj_state(cm)
state.run()
unmut_traj = pt.iterload('data/tz2.nc', 'data/tz2.parm7')
mut_traj = unmut_traj[:]
data = pt.rmsd(mut_traj, mask='@CA', mass=True, nofit=True, update_coordinate=False)
aa_eq(data, state.data[-1])
def test_1(self):
traj = pt.iterload("./data/Tc5b.x", "./data/Tc5b.top")
trajectory_t0 = pt.trajectory.Trajectory(traj)
# __iter__
for f in trajectory_t0:
pass
f.xyz[0, 0] = 10.
assert f.xyz[0, 0] == 10.
assert trajectory_t0.xyz[-1, 0, 0] == 10.
# __getitem__
# make a new copy
trajectory_t0 = pt.trajectory.Trajectory(traj)
f0 = trajectory_t0[0]
f0.xyz[0, 0] = 200.
assert trajectory_t0.xyz[0, 0, 0] == 200.
# translate
# make a new copy
trajectory_t0 = pt.trajectory.Trajectory(traj)
t0 = traj[:]
pt.translate(trajectory_t0, 'x 1.2')
pt.translate(t0, 'x 1.2')
aa_eq(trajectory_t0.xyz, t0.xyz)
try:
import mdtraj as md
pt.rmsd(t0, ref=0)
pt.rmsd(trajectory_t0, ref=0)
except ImportError:
pass
# test rmsfit
trajectory_t0.rmsfit(ref=0)
def test_reference(self):
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
text = '''
parm {0}
trajin {1}
reference {1} 3 3 [ref0]
reference {1} 2 2 [ref1]
rms ref [ref0] @CA
rms ref [ref1] @CA
'''.format(traj.top.filename, traj.filename)
state = pt.load_cpptraj_state(text)
state.run()
rmsd_0 = pt.rmsd(traj, ref=2, mask='@CA')
def test_rotation_matrix_in_rmsd_calculation(self):
traj = pt.iterload("data/tz2.nc", "data/tz2.parm7")
saved_mat = pt.rotation_matrix(traj, ref=traj[3], mask='@CA')
saved_rmsd = pt.rmsd(traj, ref=traj[3], mask='@CA')
for n_cores in [2, 3]:
out = pt.pmap(pt.rotation_matrix, traj, ref=traj[3], mask='@CA')
out_with_rmsd = pt.pmap(pt.rotation_matrix,
traj,
ref=traj[3],
mask='@CA',
with_rmsd=True)
mat = out[list(out.keys())[0]]
mat2, rmsd_ = out_with_rmsd[list(out_with_rmsd.keys())[0]]
aa_eq(saved_mat, mat)
aa_eq(saved_mat, mat2)
aa_eq(saved_rmsd, rmsd_)
def test_actionlist(self):
traj = pt.iterload("./data/Tc5b.x", "./data/Tc5b.top")
standard_rmsd = pt.rmsd(traj, mask='@CA')
def test_rmsd(input_traj):
from pytraj.c_action.c_action import Action_Rmsd
from pytraj.datasets import DatasetList
dslist = DatasetList()
act = Action_Rmsd()
act.read_input('first @CA', top=input_traj.top, dslist=dslist)
act.check_topology(input_traj.top)
for frame in input_traj:
act.compute(frame)
return (dslist.values)
def test_rmsd_actlist(input_traj):
from pytraj.c_action.c_action import Action_Rmsd
from pytraj import ActionList
from pytraj.datasets import DatasetList
alist = ActionList()
dslist = DatasetList()
act = Action_Rmsd()
alist.add(act,
'first @CA',
top=input_traj.top,
dslist=dslist)
for frame in input_traj:
alist.compute(frame)
return (dslist.values)
rmsd0 = test_rmsd(traj)
rmsd1 = test_rmsd(traj[:])
rmsd2 = test_rmsd_actlist(traj)
rmsd3 = test_rmsd_actlist(traj[:])
t0 = traj[:]
rmsd4 = test_rmsd_actlist(t0)
aa_eq(standard_rmsd, rmsd0)
aa_eq(standard_rmsd, rmsd1)
aa_eq(standard_rmsd, rmsd2)
aa_eq(standard_rmsd, rmsd3)
aa_eq(standard_rmsd, rmsd4)
def test_reference(self):
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
for n_cores in [2, 3]:
# use 4-th Frame for reference
data = pt.pmap(['rms @CA refindex 0'],
traj,
ref=traj[3],
n_cores=n_cores)
# another way to get reference
data2 = pt.pmap(['rms @CA reference'],
traj,
ref=traj[3],
n_cores=n_cores)
# use int for ref
data3 = pt.pmap(pt.rmsd,
traj,
ref=3,
mask='@CA',
n_cores=n_cores)
# use int for ref: use cpptraj's commmand style
data4 = pt.pmap(['rms @CA reference'],
traj,
ref=3,
n_cores=n_cores)
arr = pt.tools.dict_to_ndarray(data)[0]
arr2 = pt.tools.dict_to_ndarray(data2)[0]
arr3 = pt.tools.dict_to_ndarray(data3)[0]
arr4 = pt.tools.dict_to_ndarray(data4)[0]
aa_eq(arr, pt.rmsd(traj, ref=3, mask='@CA'))
aa_eq(arr2, pt.rmsd(traj, ref=3, mask='@CA'))
aa_eq(arr3, pt.rmsd(traj, ref=3, mask='@CA'))
aa_eq(arr4, pt.rmsd(traj, ref=3, mask='@CA'))
# use 4-th and 5-th Frame for reference
data = pt.pmap(
['rms @CA refindex 0', 'rms @CB refindex 1'],
traj,
ref=[traj[3], traj[4]],
n_cores=n_cores)
arr = pt.tools.dict_to_ndarray(data)[0]
aa_eq(arr, pt.rmsd(traj, '@CA', 3))
arr1 = pt.tools.dict_to_ndarray(data)[1]
aa_eq(arr1, pt.rmsd(traj, ref=4, mask='@CB'))
# no ref
data = pt.pmap(['radgyr', ], traj, n_cores=n_cores)
arr = pt.tools.dict_to_ndarray(data)[0]
aa_eq(arr, pt.radgyr(traj))
def test_constructor_from_command_list_TrajectoryIterator_no_DatasetList(
self):
traj = pt.iterload("./data/Tc5b.x", "./data/Tc5b.top")
commands = ['rmsd @CA', 'distance :3 :7', 'distance :3 :7',
'vector :2 :3']
actlist = ActionList(commands, top=traj.top)
for frame in traj:
actlist.compute(frame)
aa_eq(pt.rmsd(traj, mask='@CA'), actlist.data[0])
aa_eq(pt.distance(traj, ':3 :7'), actlist.data[1])
aa_eq(pt.distance(traj, ':3 :7'), actlist.data[2])
aa_eq(
pt.vector.vector_mask(
traj(rmsfit=(0, '@CA')),
':2 :3'),
actlist.data[3].values)
def test_reference(self):
traj = pt.iterload("./data/tz2.truncoct.nc", "data/tz2.truncoct.parm7")
txt = '''
reference data/tz2.truncoct.nc 2 2
rmsd :2-11 refindex 0 perres perresout center.agr range 1 perrescenter
'''
state = pt.load_batch(traj, txt).run()
# state.data has 3 datasets: ref, rmsd, rmsd perres
# cpptraj use 2nd reference
rmsd0 = pt.rmsd(traj, ref=1, mask=':2-11')
rmsdperres = pt.rmsd_perres(traj,
ref=1,
mask=':2-11',
perres_mask='*',
resrange='1',
perres_center=True)
aa_eq(rmsd0, state.data[2])
aa_eq(rmsdperres[1], state.data[3].values)
def test_reference(self):
traj = pt.iterload("data/tz2.ortho.nc", "data/tz2.ortho.parm7")
# store reference
dslist = CpptrajDatasetList()
ref = dslist.add_new('reference')
ref.top = traj.top
ref.append(traj[3])
fi = pt.pipe(traj,
['autoimage', 'rms refindex 0 @CA'],
dslist=dslist)
xyz = np.array([frame.xyz.copy() for frame in fi])
t0 = (traj[:]
.autoimage()
.superpose(ref=traj[3], mask='@CA'))
print('ok')
aa_eq(xyz, t0.xyz)
t1 = traj[:].autoimage()
aa_eq(pt.rmsd(t1, ref=traj[3], mask='@CA'), dslist[-1].values)
def test_constructor_from_command_list_TrajectoryIterator(self):
traj = pt.iterload("./data/Tc5b.x", "./data/Tc5b.top")
commands = [
'rmsd @CA', 'distance :3 :7', 'distance :3 :7', 'vector :2 :3'
]
dslist = CpptrajDatasetList()
actlist = ActionList(commands, traj.top, dslist=dslist)
d0 = dslist.add('ref_frame', 'my_ref')
d0.add_frame(traj[3])
for frame in traj:
actlist.compute(frame)
aa_eq(pt.rmsd(traj, mask='@CA'), dslist[0])
aa_eq(pt.distance(traj, ':3 :7'), dslist[1])
aa_eq(pt.distance(traj, ':3 :7'), dslist[2])
aa_eq(pt.vector.vector_mask(traj(rmsfit=(0, '@CA')), ':2 :3'),
dslist[3].values)
def test_reference(self):
traj = pt.iterload(fn("tz2.truncoct.nc"), fn("tz2.truncoct.parm7"))
txt = '''
reference {} 2 2
rmsd :2-11 refindex 0 perres perresout center.agr range 1 perrescenter
'''.format(fn('tz2.truncoct.nc'))
with tempfolder():
state = pt.load_batch(traj, txt).run()
# state.data has 3 datasets: ref, rmsd, rmsd perres
# cpptraj use 2nd reference
rmsd0 = pt.rmsd(traj, ref=1, mask=':2-11')
rmsdperres = pt.rmsd_perres(traj,
ref=1,
mask=':2-11',
perres_mask='*',
resrange='1',
perres_center=True)
aa_eq(rmsd0, state.data[2])
aa_eq(rmsdperres[1], state.data[3].values)
def test_reference(self):
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
for n_cores in [2, 3]:
# use 4-th Frame for reference
data = pt.pmap(['rms @CA refindex 0'],
traj,
ref=traj[3],
n_cores=n_cores)
# another way to get reference
data2 = pt.pmap(['rms @CA reference'],
traj,
ref=traj[3],
n_cores=n_cores)
# use int for ref
data3 = pt.pmap(pt.rmsd, traj, ref=3, mask='@CA', n_cores=n_cores)
# use int for ref: use cpptraj's commmand style
data4 = pt.pmap(['rms @CA reference'],
traj,
ref=3,
n_cores=n_cores)
arr = pt.tools.dict_to_ndarray(data)[0]
arr2 = pt.tools.dict_to_ndarray(data2)[0]
arr3 = pt.tools.dict_to_ndarray(data3)[0]
arr4 = pt.tools.dict_to_ndarray(data4)[0]
aa_eq(arr, pt.rmsd(traj, ref=3, mask='@CA'))
aa_eq(arr2, pt.rmsd(traj, ref=3, mask='@CA'))
aa_eq(arr3, pt.rmsd(traj, ref=3, mask='@CA'))
aa_eq(arr4, pt.rmsd(traj, ref=3, mask='@CA'))
# use 4-th and 5-th Frame for reference
data = pt.pmap(['rms @CA refindex 0', 'rms @CB refindex 1'],
traj,
ref=[traj[3], traj[4]],
n_cores=n_cores)
arr = pt.tools.dict_to_ndarray(data)[0]
aa_eq(arr, pt.rmsd(traj, '@CA', 3))
arr1 = pt.tools.dict_to_ndarray(data)[1]
aa_eq(arr1, pt.rmsd(traj, ref=4, mask='@CB'))
# no ref
data = pt.pmap([
'radgyr',
], traj, n_cores=n_cores)
arr = pt.tools.dict_to_ndarray(data)[0]
aa_eq(arr, pt.radgyr(traj))
def main():
pdblist = open(sys.argv[1]).read().split()
csv_files = [pdb + '.csv' for pdb in pdblist]
for fn in csv_files:
print("processing {}".format(fn))
native_pdb = native_dir + fn[:6] + '_complex.pdb'
print(native_pdb)
ref = pt.iterload(native_pdb)
root = '../{}/'.format(fn.split('.')[0])
with open(fn) as fh:
rst7_files = [root + line.split(',')[0].strip('../') for line in fh.readlines()]
traj = pt.iterload(rst7_files, root + 'prmtop')
ca_rmsd = pt.rmsd(traj, ref=ref, mask='@CA')
with open(fn) as fh:
lines = [','.join((line.strip('\n'), str(rmsd))) for line, rmsd in zip(fh.readlines(), ca_rmsd)]
with open('output/' + fn, 'w') as fw:
fw.write('\n'.join(lines))
def main(traj, pdb):
'''
计算RMSD/RMSF
Parameters
----------
traj: MD轨迹 Pytraj对象
pdb: PDB ID字符串
'''
print('\nStart RMSD/RMSF Analysis...')
data_rmsd_first = pt.rmsd(traj, ref=0,
mask="@CA") # 计算αC原子RMSD Ref=0以第一帧为参考
command = "awk '$4 ~ /MOL/ {print $5}' ./" + pdb + 'comsolvate.pdb' # 提取位于残基后的配体分子序号
temp = os.popen(command)
mol_resnum = str(temp.readlines()[-1]).strip()
res_mask = ':1-' + mol_resnum + '@CA'
data_rmsf = pt.rmsf(traj, mask=res_mask, options='byres') # 计算RMSF 所有非水分子
# 保存数据
print('RMSD Data:')
print(data_rmsd_first)
with open('./pynalysis/rmsd_rmsf/rmsd.dat', 'w') as rmsdfile:
for rmsd in data_rmsd_first[:]:
rmsdfile.write(str(rmsd) + '\n')
rmsdfile.close()
print('rmsd.dat saved.', end='\n')
print('RMSF Data:')
print(data_rmsf)
with open('./pynalysis/rmsd_rmsf/rmsf.dat', 'w') as rmsffile:
for rmsfdata in data_rmsf[:]:
rmsffile.write(str(rmsfdata[1]) + '\n')
rmsffile.close()
print('rmsf.dat saved.', end='\n')
print('\n\nRMSD/RMSF Analysis Complete.')
print(''.center(80, '*'))
def test_different_cores(self):
# use different frame_slice with different n_cores to test
REF_0 = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")[0]
for frame_slice in [(0, 100),
(10, 100, 3),
(50, 80, 2),
(51, 80, 3), ]:
traj = pt.iterload("./data/tz2.nc",
"./data/tz2.parm7",
frame_slice=frame_slice)
saved_angle = pt.angle(traj, ':3 :7 :9')
saved_dist = pt.distance(traj, ':2 :10')
saved_rmsd = pt.rmsd(traj, ref=REF_0, mask='@CA')
lines = ['angle :3 :7 :9', 'distance :2 :10']
for n_cores in [2, 3]:
data_list = [worker_state(rank, n_cores, traj, lines)
for rank in range(n_cores)]
final_data = concat_dict([x[1] for x in data_list])
aa_eq(final_data['Ang_00002'], saved_angle)
aa_eq(final_data['Dis_00003'], saved_dist)
def test_constructor_from_command_list_TrajectoryIterator(self):
traj = pt.iterload("./data/Tc5b.x", "./data/Tc5b.top")
commands = ['rmsd @CA', 'distance :3 :7', 'distance :3 :7',
'vector :2 :3']
dslist = CpptrajDatasetList()
actlist = ActionList(commands, traj.top, dslist=dslist)
d0 = dslist.add('ref_frame', 'my_ref')
d0.add_frame(traj[3])
for frame in traj:
actlist.compute(frame)
aa_eq(pt.rmsd(traj, mask='@CA'), dslist[0])
aa_eq(pt.distance(traj, ':3 :7'), dslist[1])
aa_eq(pt.distance(traj, ':3 :7'), dslist[2])
aa_eq(
pt.vector.vector_mask(
traj(rmsfit=(0, '@CA')),
':2 :3'),
dslist[3].values)
#!/usr/bin/env python
import pytraj as pt
from pytraj.testing import aa_eq
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.rank
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
data_ref3 = pt.pmap_mpi(pt.rmsd, traj, '@CA', ref=3)
# data_ref0 = pt.pmap_mpi(pt.rmsd, traj, '@CA')
if rank == 0:
# saved_data_ref0 = pt.rmsd(traj, '@CA')
saved_data_ref3 = pt.rmsd(traj, '@CA', ref=3)
# aa_eq(data_ref0['RMSD_00001'], saved_data_ref0)
aa_eq(data_ref3['RMSD_00001'], saved_data_ref3)
import pytraj as pt
# use `iterload` to save memory
traj = pt.iterload("../tests/data/tz2.ortho.nc",
"../tests/data/tz2.ortho.parm7")
print(traj)
# perform rmsd calculation to first frame, all atoms
pt.rmsd(traj, ref=0)
# perform rmsd calculation to last frame, all atoms but H
pt.rmsd(traj, mask='!@H=', ref=-1)
# perform rmsd calculation to last frame, CA atoms
pt.rmsd(traj, '@CA', ref=-1)
# perform rmsd calculation to stripped-atom reference
pt.rmsd(traj(mask='@CA'), ref=traj[2:3, '@CA'])
# `ref=traj[2:3, '@CA']` is equal to `ref=traj[2:3]['@CA'][0]`
def main():
traj = pt.load(args.traj, args.parm)
rnd_iter = args.riter
rnd_vecs = args.evec
pairs = list()
if args.mask_proj == None:
args.mask_proj = args.mask
print "Mask : ", args.mask
print "Mask proj: ", args.mask_proj
if rnd_vecs < 1:
rnd_vecs = 3 * traj[args.mask].xyz.shape[1] - 6
#make pairs
for n_i in range(rnd_vecs):
for n_j in range(rnd_vecs):
if n_i < n_j:
pairs.append((n_i, n_j))
sele = pt.select(traj.top, args.mask)
sele_txt = ""
for s_i, s in enumerate(sele):
sele_txt += "%d %s\n" % (s_i, traj.top.atomlist[s])
o = open("%s_sele.dat" % args.prefix, "w")
o.write(sele_txt)
o.close()
n_vecs = rnd_vecs
pca_data, eigen = pt.pca(traj[args.start:], mask=args.mask, n_vecs=n_vecs)
eigen_val = eigen[0]
eigen_vec = eigen[1]
np.savetxt("%s_eigen_vec.dat" % args.prefix,
np.c_[eigen_vec[0], eigen_vec[1], eigen_vec[2]])
np.savetxt("%s_pcadata.dat" % args.prefix, pca_data.T)
#h = hist(pca_data[0], pca_data[1])
#h.plot2d(xlab="PC1 [$\AA$]", ylab="PC2 [$\AA$]", title="PCA", name=args.out)
# Plot PCA
for pc_i, pc_j in pairs:
plt.scatter(pca_data[pc_i],
pca_data[pc_j],
marker='o',
c="r",
alpha=0.5)
plt.xlabel("PC%d [$\AA$]" % pc_i)
plt.ylabel("PC%d [$\AA$]" % pc_j)
plt.title("PCA PC%d vs. PC%d" % (pc_i, pc_j))
plt.savefig("PC%d-vs-PC%s_%s.png" % (pc_i, pc_j, args.prefix))
plt.close('all')
# Plot atom contritbuion
for pc_i in range(3):
l = eigen_vec[pc_i].shape[0]
c = np.linalg.norm(eigen_vec[pc_i].reshape((l / 3, 3)), axis=1)
a = np.arange(l / 3) + 1
plt.plot(a, c, label="PC%s" % pc_i, alpha=0.5)
plt.legend()
plt.xlim(0, l / 3 + 1)
plt.xlabel("Atom ID")
plt.ylabel("Eigenvector components")
plt.title("Eigenvectors")
plt.savefig("Eigenvectors_%s.png" % args.prefix)
plt.close('all')
total_var = np.sum(eigen_val)
plt.scatter(range(1, n_vecs + 1), (np.cumsum(eigen_val) / total_var) * 100,
label="Cumulative Variance")
plt.plot(range(1, n_vecs + 1), (eigen_val / total_var) * 100,
"g--",
label="Variance")
plt.legend()
#plt.xticks(range(1, n_vecs+1, 2))
plt.xlabel("Eigenvector #")
plt.ylabel("Variance explained [%]")
plt.title("Variance explained by PC Eigenvectors")
plt.savefig("Variance_%s.png" % args.prefix, dpi=1000)
plt.close('all')
if args.traj_proj != None and args.parm_proj != None:
traj_proj = pt.load(args.traj_proj, args.parm_proj)
pt.rmsd(traj_proj, mask=args.mask_proj)
#avg_proj = pt.mean_structure(traj_proj, mask=args.mask)
#pt.rmsd(traj_proj, mask=args.mask, ref=avg_proj)
projection_data = pt.projection(traj_proj[args.start_proj:], args.mask_proj, eigenvalues=eigen_val,\
eigenvectors=eigen_vec,\
scalar_type='covar')
np.savetxt("%s_pcadata_proj.dat" % args.prefix, projection_data.T)
#h = hist(projection_data[0], projection_data[1])
#h.plot2d(xlab="PC1 [$\AA$]", ylab="PC2 [$\AA$]", title="PCA projection", name=args.out_proj)
for pc_i, pc_j in pairs:
plt.scatter(pca_data[pc_i],
pca_data[pc_j],
marker='o',
c="r",
alpha=0.5)
plt.scatter(projection_data[pc_i],
projection_data[pc_j],
marker='o',
c="g",
alpha=0.5)
plt.xlabel("PC%d [$\AA$]" % pc_i)
plt.ylabel("PC%d [$\AA$]" % pc_j)
plt.title("PCA PC%d vs. PC%d with projection" % (pc_i, pc_j))
plt.savefig("PC%d-vs-PC%s_%s_projection.png" %
(pc_i, pc_j, args.prefix))
plt.close('all')
plt.scatter(projection_data[pc_i],
projection_data[pc_j],
marker='o',
c="g",
alpha=0.5)
plt.xlabel("PC%d [$\AA$]" % pc_i)
plt.ylabel("PC%d [$\AA$]" % pc_j)
plt.title("PCA PC%d vs. PC%d only projection" % (pc_i, pc_j))
plt.savefig("PC%d-vs-PC%d_%s_only_projection.png" %
(pc_i, pc_j, args.prefix))
plt.close('all')
pca_data_2, eigen_2 = pt.pca(traj_proj[args.start_proj:],
mask=args.mask_proj,
n_vecs=n_vecs)
eigen_val_2 = eigen_2[0]
eigen_vec_2 = eigen_2[1]
overlap = 0
for pc_i in range(rnd_vecs):
for pc_j in range(rnd_vecs):
overlap += (np.dot(eigen_vec[pc_i], eigen_vec_2[pc_j]) /
(np.linalg.norm(eigen_vec[pc_i]) *
np.linalg.norm(eigen_vec_2[pc_j])))**2
overlap /= rnd_vecs
print "Vector space spanned by traj-1 overlap with traj-2 subspace (%d vecs): %6.3f" % (
rnd_vecs, overlap)
if args.zscore != None:
overlap_rnd = np.zeros(rnd_iter)
for r in range(rnd_iter):
### make random traj
t1_rnd = traj
for f in range(t1_rnd.xyz[args.start:].shape[0]):
idxs = np.arange(t1_rnd.xyz[args.start + f, ].shape[0])
sele = np.random.permutation(idxs)
t1_rnd[f] = t1_rnd.xyz[args.start + f, ][sele]
pca_t1_rnd, eigen_t1_rnd = pt.pca(t1_rnd[args.start:],
mask=args.mask,
n_vecs=n_vecs)
eigen_vec_1_rnd = eigen_t1_rnd[1]
for pc_i in range(n_vecs):
for pc_j in range(n_vecs):
overlap_rnd[r] += (
np.dot(eigen_vec[pc_i], eigen_vec_1_rnd[pc_j]) /
(np.linalg.norm(eigen_vec[pc_i]) *
np.linalg.norm(eigen_vec_1_rnd[pc_j])))**2
overlap_rnd[r] /= n_vecs
z_score = (overlap - np.mean(overlap_rnd)) / np.std(overlap_rnd)
print "Z-score : %6.3f" % z_score
def test_raise_savematrices_if_not_dataset(self):
traj = self.traj.copy()
with pytest.raises(ValueError):
pt.rmsd(traj, mask='@CA savematrices', dtype='ndarray')
import pytraj as pt
from pytraj.testing import Timer
from time import time
traj = pt.iterload('md*.nc', 'prmtop', frame_slice=(0, 1000))
print(traj)
mask = '!:WAT,Na+'
t0 = time()
pt.rmsd(traj, mask=mask)
t_serial = time() - t0
for n_cores in [1, 2, 3, 4, 5, 6, 7, 8]:
t0 = time()
pt.pmap(pt.rmsd, traj, mask=mask, ref=traj[0], n_cores=n_cores)
t_par = time() - t0
efficiency = (t_serial / t_par) / n_cores
print('n_cores = {}, time = {}, speed up = {}, efficiency = {}'.format(
n_cores, t_par, t_serial / t_par, efficiency))
def test_add_new_for_CpptrajDatasetList(self):
# TODO:
dslist = CpptrajDatasetList()
# integer
dslist.add_new(dtype='integer', name='my_int')
dslist[-1].data = [2, 3]
aa_eq(dslist[-1].values, [2, 3])
# double
dslist.add_new(dtype='double', name='my_double')
dslist[-1].data = [2, 3]
aa_eq(dslist[-1].values, [2, 3])
# float
dslist.add_new(dtype='float', name='my_float')
dslist[-1].data = [2, 3]
aa_eq(dslist[-1].values, [2, 3])
# string
dslist.add_new(dtype='string', name='my_string')
dslist[-1].data = ['H', 'T']
assert dslist[-1].values.tolist() == ['H', 'T'], 'string must be equal'
# reference
dslist.add_new(dtype='reference', name='my_reference')
dslist[-1].data = self.traj[-2]
aa_eq(dslist[-1].xyz, self.traj[-2].xyz)
# matrix3x3
dslist.add_new(dtype='matrix3x3', name='my_mat3x3')
mat = pt.calc_rotation_matrix(self.traj, ref=0, mask='@CA')
# there is no assignment. Need to update by another method
dslist[-1]._append_from_array(mat)
aa_eq(dslist[-1].values, mat)
# TRAJ
dslist.add_new(dtype='traj', name='my_traj')
dslist[-1].top = self.traj.top
dslist[-1]._load(self.traj.filename)
traj_new = dslist[-1]
# FIXME: segmentation fault
# CRD
dslist.add_new(dtype='coords', name='my_crd')
dslist[-1].top = self.traj.top
dslist[-1].load(self.traj.filename)
traj_new = dslist[-1]
aa_eq(traj_new.xyz, self.traj.xyz)
aa_eq(pt.rmsd(traj_new), pt.rmsd(self.traj))
# vector
dslist.add_new(dtype='vector', name='my_vec')
vecs = pt.vector.vector_mask(self.traj, ':3 :2')
dslist[-1].data = vecs
aa_eq(dslist[-1].values, vecs)
# grid
dslist.add_new(dtype='grid', name='my_grid')
arr = np.random.rand(8, 9, 3).astype('f4')
dslist[-1].data = arr
aa_eq(dslist[-1].values, arr)
# mesh
dslist.add_new(dtype='xymesh', name='my_mesh')
arr = np.random.rand(8, 2).astype('f8')
# there is not easy method to update, use _append_from_array
dslist[-1]._append_from_array(arr)
aa_eq(dslist[-1].values, arr)
# modes
mat = pt.matrix.covar(self.traj, '@CA')
modes = pt.matrix.diagonalize(mat,
n_vecs=mat.shape[0],
dtype='dataset')[0]
modes2 = modes.__class__()
# dummy test to set name and scalar_type
# (prepare for pca)
modes2.name = 'test_mode'
modes2.scalar_type = 'covar'
modes2._set_modes(False, mat.shape[0], modes.eigenvectors.shape[0],
modes.eigenvalues, modes.eigenvectors.flatten())
aa_eq(modes.eigenvalues, modes2.eigenvalues)
aa_eq(modes.eigenvectors, modes2.eigenvectors)
import numpy as np
import pytraj as pt
import os
traj = pt.iterload("../tests/data/Tc5b.x", "../tests/data/Tc5b.top")
ref = pt.iterload("../tests/data/Tc5b.nat.crd", traj.top)
data = pt.rmsd(traj, ref=ref, mask='@CA')
print(data)
pt.write_traj("test_indices.pdb",
traj,
frame_indices=[2, 8, 9],
overwrite=True)
indices = np.where(data < 5.0)[0]
# filter, write only frames having rmsd < 5.0
pt.write_traj("test_indices_2.pdb",
traj,
frame_indices=indices,
overwrite=True)
# make sure we did save the traj
os.system("ls test_indices.pdb")
os.system("ls test_indices_2.pdb")
def main(argv):
args = sys.argv
native = ''
outfile = ''
try:
opts, args = getopt.getopt(sys.argv[1:], "ho:n:o:",
["in:file:n=", "out:file:scorefile="])
except getopt.GetoptError:
print('Unknown flag given.\nKnown flags:\n\t-h\n\t-n <native>')
sys.exit()
for opt, arg in opts:
if opt == '-h':
print(
'Something.py --in:file:s <input_pdb_id> --out:file:scorefile <output_filename>'
)
sys.exit()
elif opt in ("-n", "--in:file:n"):
native = arg
elif opt in ("-o", "--out:file:scorefile"):
outfile = arg
if native == '':
print('No native rst7 supplied.')
sys.exit()
if outfile == '':
outfile = 'Scores.sc'
print("===== Native RST7: %s =====" % native)
os.chdir(PATH_TO_DECOYDISC)
min_decoys = os.popen('ls min*.rst7').readlines(
) ## List of rst7s ["<rst7_1>\n", "<rst7_2>\n", ...]
for m in range(len(min_decoys)):
min_decoys[m] = min_decoys[m].rstrip()
if native in min_decoys:
min_decoys.remove(native)
print("== Analyzing %i mols==" % len(min_decoys))
min_decoys.insert(0, native)
parmfile = '_'.join(native.split('_')[1:]).rstrip('rst7') + 'parm7'
print("\t=== Loading Trajectories ===")
traj = pt.iterload(min_decoys, parmfile)
print("\t=== Getting RMSDs ===")
ca_rmsd_data = pt.rmsd(traj, mask=['@CA'])
print("\t=== Getting Energy Decomposition ===")
energy_data = pt.energy_decomposition(traj, igb=8)
print("\t\tFinished")
with open(outfile, 'w') as scorefile:
header = 'pdb\t'
for s in energy_data.keys():
header += s + '\t'
header += 'rmsd\n'
scorefile.write(header)
for pdb_index in range(len(min_decoys)):
scoreline = min_decoys[pdb_index] + '\t'
for s in energy_data.keys():
scoreline += '%s\t' % str(energy_data[s][pdb_index])
scoreline += '%s\n' % str(ca_rmsd_data[pdb_index])
scorefile.write(scoreline)
def test_ComparetoMDtraj(self):
import mdtraj as md
traj = pt.load(filename=tc5b_trajin, top=tc5b_top)
m_top = md.load_prmtop(tc5b_top)
m_traj = md.load_mdcrd(tc5b_trajin, m_top)
m_traj.xyz = m_traj.xyz * 10 # convert `nm` to `Angstrom` unit
arr0 = pt.rmsd(traj, ref=0)
arr1 = pt.rmsd(traj, ref=0)
arr2 = pt.rmsd(traj, )
a_md0 = md.rmsd(m_traj, m_traj, 0)
aa_eq(arr0, arr1)
aa_eq(arr0, arr2)
aa_eq(arr0, a_md0)
arr0 = pt.rmsd(traj, ref=-1)
arr1 = pt.rmsd(traj, ref=-1)
a_md = md.rmsd(m_traj, m_traj, -1)
aa_eq(arr0, arr1)
aa_eq(arr0, a_md)
mask = ":3-18@CA,C"
atm = traj.top(mask)
arr0 = pt.rmsd(traj, ref=-1, mask=mask)
arr1 = pt.rmsd(traj, mask=atm.indices, ref=-1)
arr2 = pt.rmsd(traj, mask=list(atm.indices), ref=-1)
arr3 = pt.rmsd(traj, mask=tuple(atm.indices), ref=-1)
a_md = md.rmsd(m_traj, m_traj, -1, atm.indices)
aa_eq(arr0, a_md)
aa_eq(arr1, a_md)
aa_eq(arr2, a_md)
aa_eq(arr3, a_md)
fa = Trajectory(traj)
arr0 = pt.rmsd(fa, ref=-1, mask=mask)
arr1 = pt.rmsd(fa, mask=atm.indices, ref=-1)
arr2 = pt.rmsd(fa, mask=list(atm.indices), ref=-1)
arr3 = pt.rmsd(fa, mask=tuple(atm.indices), ref=-1)
a_md = md.rmsd(m_traj, m_traj, -1, atm.indices)
aa_eq(arr0, a_md)
aa_eq(arr1, a_md)
aa_eq(arr2, a_md)
aa_eq(arr3, a_md)
fa = Trajectory(traj)
mask = "!@H="
atm = fa.top(mask)
arr0 = pt.rmsd(fa, ref=4, mask=mask)
a_md = md.rmsd(m_traj, m_traj, 4, atm.indices)
# exclude 0-th frame for ref
aa_eq(arr0, a_md)
def test_rmsd():
# OK
pt.rmsd(traj, ref=0)
def test_list_of_masks(self):
traj = self.traj.copy()
mask = ['@CA', '@CB', ':3-18@CA,C']
arr = pt.rmsd(traj, mask=mask)
for idx, m in enumerate(mask):
aa_eq(arr[idx], pt.rmsd(traj, mask=m))
aa_eq(arr[idx], pt.rmsd(traj, mask=traj.top.select(m)))
mask = ['@CA', '@CB', ':3-18@CA,C', [0, 3, 5]]
self.assertRaises(ValueError, lambda: pt.rmsd(traj, mask=mask))
mask_2 = [[0, 3, 6], range(50)]
aa_eq(pt.rmsd(traj, mask=mask_2)[0], pt.rmsd(traj, mask=mask_2[0]))
aa_eq(pt.rmsd(traj, mask=mask_2)[1], pt.rmsd(traj, mask=mask_2[1]))
ca = pt.select('@CA', traj.top)
cb = pt.select('@CB', traj.top)
aa_eq(pt.rmsd(traj, mask=ca), pt.rmsd(traj, mask=[ca, cb])[0])
aa_eq(pt.rmsd(traj, mask=cb), pt.rmsd(traj, mask=[ca, cb])[1])
def test_raise_savematrices_if_not_dataset(self):
traj = self.traj.copy()
self.assertRaises(
ValueError,
lambda: pt.rmsd(traj, mask='@CA savematrices', dtype='ndarray'))
import pytraj as pt
# to update coordinates, we need to load all data to memory
# so we use `load` method instead of `iterload`
traj = pt.load("../tests/data/Tc5b.x", "../tests/data/Tc5b.top")
print(traj)
# nofit rmsd before fitting
print(pt.rmsd(traj, ref=-1, mask='@CA nofit'))
# superpose to last frame with mask='@CA'
traj.superpose(ref=-1, mask='@CA')
# make sure we DID superpose by calculate rmsd
print(pt.rmsd(traj, ref=-1, mask='@CA nofit'))
type=str,
help="the atom mask",
default="backbone")
args = parser.parse_args()
inputfile = args.traj
topfile = args.prmtop
mask = args.mask
traj = pj.load(inputfile, top=topfile)
len_traj = len(traj)
rmsd_matrix = np.zeros((len_traj, len_traj))
for i in range(len_traj):
rmsd_matrix[i,
i + 1:] = pj.rmsd(traj=traj,
mask=mask,
ref=i,
frame_indices=np.arange(i + 1, len_traj))
rmsd_matrix[i + 1:, i] = rmsd_matrix[i, i + 1:]
index = np.argmin(np.mean(rmsd_matrix, axis=1))
with open("allign.tcl", "r") as f:
s = f.read()
s = re.sub("replace_prmtop", topfile, s)
s = re.sub("need_to_decide", str(index), s)
s = re.sub("mdcrdfile", inputfile, s)
a = open("allign_temp.tcl", "w")
a.write(s)
a.close()
subprocess.call("vmd -e allign_temp.tcl", shell=True)
os.remove("allign_temp.tcl")
