def test_rmsfit_with_autoimage_compared_to_cpptraj(self):
# assert to cpptraj: need to set mass
traj = self.traj.copy()
txt = '''
parm {0}
trajin {1}
autoimage
rms first {2} mass
trajout tmp.nc
'''.format(traj.top.filename, traj.filename, self.mask)
with tempfolder():
state = pt.datafiles.load_cpptraj_output(txt, dtype='state')
state.run()
# need to load to memory (not iterload)
saved_traj = pt.load('tmp.nc', traj.top)
fa1 = traj[:]
fa1.autoimage()
pt.superpose(fa1, ref=0, mask=self.mask, mass=True)
aa_eq(fa1.xyz, saved_traj.xyz)
fa_saved_nowat = saved_traj['!:WAT']
fa1_nowat = fa1['!:WAT']
aa_eq(fa_saved_nowat.xyz, fa1_nowat.xyz)
def test_frame_indices(self):
# load frames to immutable traj
traj = pt.iterload("data/tz2.nc", "data/tz2.parm7")
# convert to numpy traj
frame_indices = [0, 3, 5]
t00 = traj[:]
t01 = traj[:]
t10 = traj[frame_indices]
t11 = traj[frame_indices]
aa_eq(t00[frame_indices].xyz, t11.xyz)
ref = traj[-1]
t00.superpose(ref=ref, frame_indices=frame_indices)
ref = traj[-1]
pt.superpose(t01, ref=ref, frame_indices=frame_indices)
ref = traj[-1]
t10.superpose(ref=ref)
ref = traj[-1]
pt.superpose(t11, ref=ref, frame_indices=frame_indices)
aa_eq(t00.xyz, t01.xyz)
aa_eq(t10.xyz, t11.xyz)
aa_eq(t00[frame_indices].xyz, t10.xyz)
def test_fit_and_then_nofit(self):
traj = pt.iterload(tc5b_trajin, 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 test_rmsfit_with_autoimage_compared_to_cpptraj(self):
# assert to cpptraj: need to set mass
traj = self.traj.copy()
txt = '''
parm {0}
trajin {1}
autoimage
rms first {2} mass
trajout tmp.nc
'''.format(traj.top.filename, traj.filename, self.mask)
with tempfolder():
state = pt.datafiles.load_cpptraj_output(txt, dtype='state')
state.run()
# need to load to memory (not iterload)
saved_traj = pt.load('tmp.nc', traj.top)
fa1 = traj[:]
fa1.autoimage()
pt.superpose(fa1, ref=0, mask=self.mask, mass=True)
aa_eq(fa1.xyz, saved_traj.xyz)
fa_saved_nowat = saved_traj['!:WAT']
fa1_nowat = fa1['!:WAT']
aa_eq(fa_saved_nowat.xyz, fa1_nowat.xyz)
def test_frame_indices(self):
# load frames to immutable traj
traj = pt.iterload("data/tz2.nc", "data/tz2.parm7")
# convert to numpy traj
frame_indices = [0, 3, 5]
t00 = traj[:]
t01 = traj[:]
t10 = traj[frame_indices]
t11 = traj[frame_indices]
aa_eq(t00[frame_indices].xyz, t11.xyz)
ref = traj[-1]
t00.superpose(ref=ref, frame_indices=frame_indices)
ref = traj[-1]
pt.superpose(t01, ref=ref, frame_indices=frame_indices)
ref = traj[-1]
t10.superpose(ref=ref)
ref = traj[-1]
pt.superpose(t11, ref=ref, frame_indices=frame_indices)
aa_eq(t00.xyz, t01.xyz)
aa_eq(t10.xyz, t11.xyz)
aa_eq(t00[frame_indices].xyz, t10.xyz)
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 test_projection_for_pca(self):
traj = pt.load("./data/tz2.nc", "./data/tz2.parm7")
state = pt.load_cpptraj_state(command)
state.run()
cpp_modes = state.data['MyEvecs']
cpp_arr_crd = np.array(cpp_modes._get_avg_crd())
cpp_arr_crd = cpp_arr_crd.reshape(117, 3)
mask = '!@H='
pt.superpose(traj, mask=mask)
avg = pt.mean_structure(traj)
atom_indices = traj.top(mask).indices
strip_avg_coords = avg.xyz[atom_indices]
pt.superpose(traj, mask=mask, ref=avg)
avg2 = pt.mean_structure(traj, mask=mask)
mat = pt.matrix.covar(traj, mask)
modes = pt.matrix.diagonalize(mat, n_vecs=2, dtype='dataset')[0]
aa_eq(cpp_arr_crd, avg2.xyz)
aa_eq(np.abs(modes.eigenvalues), np.abs(state.data['MyEvecs'].eigenvalues))
aa_eq(np.abs(modes.eigenvectors), np.abs(state.data['MyEvecs'].eigenvectors))
projection_data = pt.all_actions.projection(traj, mask=mask, average_coords=avg2.xyz,
eigenvalues=modes.eigenvalues,
eigenvectors=modes.eigenvectors,
scalar_type='covar')
aa_eq(np.abs(projection_data), np.abs(state.data[-2:].values), decimal=3)
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 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_center_autoimagesuperpose(self):
traj = pt.iterload("./data/tz2.ortho.nc", "./data/tz2.ortho.parm7")
t0 = traj[:]
t1 = traj[:]
pt.center(t0)
pt.autoimage(t0)
pt.superpose(t0)
aa_eq(pt.center(t1).autoimage().superpose().xyz, t0.xyz)
def test_center_autoimagesuperpose(self):
traj = pt.iterload("./data/tz2.ortho.nc", "./data/tz2.ortho.parm7")
t0 = traj[:]
t1 = traj[:]
pt.center(t0)
pt.autoimage(t0)
pt.superpose(t0)
aa_eq(pt.center(t1).autoimage().superpose().xyz, t0.xyz)
def test_center_autoimagesuperpose(self):
traj = pt.iterload(fn('tz2.ortho.nc'), fn('tz2.ortho.parm7'))
t0 = traj[:]
t1 = traj[:]
pt.center(t0)
pt.autoimage(t0)
pt.superpose(t0)
aa_eq(pt.center(t1).autoimage().superpose().xyz, t0.xyz)
def _update(event):
start = time.time()
while time.time() - start <= timeout and not event.is_set():
time.sleep(every)
traj = pt.load(self.restart, top=self.top)
if callback is not None:
callback(traj)
else:
mask = '@C,N,O,CA,P'
pt.superpose(traj, mask=mask, ref=self.reference_traj)
self._update_coordinates(traj[0].xyz)
def _update(event):
start = time.time()
while time.time() - start <= timeout and not event.is_set():
time.sleep(every)
traj = pt.load(self.restart, top=self.top)
if callback is not None:
callback(traj)
else:
mask = '@C,N,O,CA,P'
pt.superpose(traj, mask=mask, ref=self.reference_traj)
self._update_coordinates(traj[0].xyz)
def testget_common_objects(self):
# raises
# raise if try to index traj()
with pytest.raises(TypeError):
get_reference(self.traj(), 3)
with pytest.raises(TypeError):
get_reference(self.traj(), None)
# specify wrong mask
with pytest.raises(TypeError):
pt.superpose(self.traj[:], 3)
def test_RMSF(self):
traj = pt.iterload(fn('tz2.nc'), fn('tz2.parm7'))
state = pt.load_batch(traj, '''
rms first
average crdset MyAvg
run
rms ref MyAvg
atomicfluct out fluct.agr''')
state.run()
t0 = traj[:]
pt.superpose(t0, ref=0)
avg = pt.mean_structure(t0)
pt.superpose(t0, ref=avg)
data = pt.rmsf(t0)
aa_eq(data, state.data[-1].values)
def testget_common_objects(self):
# raises
# raise if try to index traj()
self.assertRaises(TypeError, lambda: get_reference(self.traj(), 3))
self.assertRaises(TypeError, lambda: get_reference(self.traj(), None))
# specify wrong mask
self.assertRaises(TypeError, lambda: pt.superpose(self.traj[:], 3))
def test_RMSF(self):
traj = pt.iterload("./data/tz2.nc", "./data/tz2.parm7")
state = pt.load_batch(traj, '''
rms first
average crdset MyAvg
run
rms ref MyAvg
atomicfluct out fluct.agr''')
state.run()
t0 = traj[:]
pt.superpose(t0, ref=0)
avg = pt.mean_structure(t0)
pt.superpose(t0, ref=avg)
data = pt.rmsf(t0)
aa_eq(data, state.data[-1].values)
def testget_common_objects(self):
from pytraj.get_common_objects import get_reference
# raises
# raise if try to index traj()
self.assertRaises(TypeError, lambda: get_reference(self.traj(), 3))
self.assertRaises(TypeError, lambda: get_reference(self.traj(), None))
# specify wrong mask
self.assertRaises(TypeError, lambda: pt.superpose(self.traj[:], 3))
def test_action_bounds(self):
# creat mutable trajectory
traj = pt.load(fn('tz2.ortho.nc'), fn('tz2.ortho.parm7'))
pt.autoimage(traj)
pt.superpose(traj, ref=0, mask=':1-13&!@H=', mass=True)
grid_data = pt._grid(traj, mask=':1-13', grid_spacing=[0.5, 0., 0.])
text = '''
parm {}
trajin {}
autoimage
rms first :1-13&!@H= mass
bounds :1-13 dx .5 name MyGrid
'''.format(fn('tz2.ortho.parm7'), fn('tz2.ortho.nc'))
state = pt.load_cpptraj_state(text)
state.run()
cpp_grid = state.data['MyGrid'].values
aa_eq(cpp_grid, grid_data)
def test_frame_indices(self):
# load frames to immutable traj
traj = pt.iterload(fn('tz2.nc'), fn('tz2.parm7'))
# convert to numpy traj
frame_indices = [0, 3, 5]
t00 = traj[:]
t01 = traj[:]
t10 = traj[frame_indices].copy()
ref = traj[-1]
t00.superpose(ref=ref, frame_indices=frame_indices)
ref = traj[-1]
pt.superpose(t01, ref=ref, frame_indices=frame_indices)
ref = traj[-1]
t10.superpose(ref=ref)
aa_eq(t00.xyz, t01.xyz)
aa_eq(t00[frame_indices].xyz, t10.xyz)
def test_projection_for_pca(self):
traj = pt.load(fn('tz2.nc'), fn('tz2.parm7'))
state = pt.load_cpptraj_state(command)
state.run()
cpp_modes = state.data['MyEvecs']
cpp_arr_crd = np.array(cpp_modes._get_avg_crd())
cpp_arr_crd = cpp_arr_crd.reshape(117, 3)
mask = '!@H='
pt.superpose(traj, mask=mask)
avg = pt.mean_structure(traj)
atom_indices = traj.top(mask).indices
avg.xyz[atom_indices]
pt.superpose(traj, mask=mask, ref=avg)
avg2 = pt.mean_structure(traj, mask=mask)
mat = pt.matrix.covar(traj, mask)
modes = pt.matrix.diagonalize(mat, n_vecs=2, dtype='dataset')[0]
aa_eq(cpp_arr_crd, avg2.xyz)
aa_eq(np.abs(modes.eigenvalues),
np.abs(state.data['MyEvecs'].eigenvalues))
aa_eq(np.abs(modes.eigenvectors),
np.abs(state.data['MyEvecs'].eigenvectors))
projection_data = pt.all_actions.projection(
traj,
mask=mask,
average_coords=avg2.xyz,
eigenvalues=modes.eigenvalues,
eigenvectors=modes.eigenvectors,
scalar_type='covar')
aa_eq(np.abs(projection_data),
np.abs(state.data[-2:].values),
decimal=3)
def test_superpose_trajectory_iterator_pytraj_method(self):
traj_on_disk = pt.iterload(fn('Tc5b.x'), fn('Tc5b.top'))
traj_on_disk2 = pt.iterload(fn('Tc5b.x'), fn('Tc5b.top'))
traj_on_mem = pt.load(fn('Tc5b.x'), fn('Tc5b.top'))
ref = pt.iterload(fn("Tc5b.crd"), fn('Tc5b.top'))[0]
pt.superpose(traj_on_mem, ref=ref, mask='@CA')
pt.superpose(traj_on_disk, ref=ref, mask='@CA')
assert traj_on_disk._being_transformed == True, '_being_transformed must be True'
aa_eq(traj_on_mem.xyz, traj_on_disk.xyz)
# test saving
with tempfolder():
traj_on_mem.save('t0.nc', overwrite=True)
traj_on_disk.save('t1.nc', overwrite=True)
aa_eq(
pt.load('t0.nc', traj_on_mem.top).xyz,
pt.load('t1.nc', traj_on_disk.top).xyz)
# turn off superpose
traj_on_disk._being_transformed = False
aa_eq(traj_on_disk.xyz, traj_on_disk2.xyz)
it=501 # First index of the short MD simulation folder (e.g. it=0 for P0)
en=1027 # Last index of the short MD simulation folder (e.g. it=6000 for P6000)
frq=1 # frequencing of the folder index, e.g. frq=10 if your folders are P0, P10, ... P5990, P6000
iit=1 # first replica in the above P* folder
ien=10 # last replica in the above P* folder
#################################################################################################
######### Don Not Change Anything After This Line Unless You Know What You Are Doing ############
#################################################################################################
# Step 1: load metadynamics trajectory (to perform PCA)
traj = pt.load(TRAJ, TOP)
# Step 2: superpose the protein to a reference structure, provided as refpdb
refpdb = pt.iterload(PDB )
pt.superpose(traj, ref=refpdb, mask=mask)
# Step 3: read the metadynamics trajectory into memory by chunk
print("Loading metadynamics trajectories")
nframe = traj.n_frames
chunksize = min([200, nframe])
nchunk = int(np.floor(nframe/chunksize))+1 if nframe%chunksize !=0 else int(np.floor(nframe/chunksize))
pile = []
for i in range(nchunk):
tmp = traj[i*chunksize:min((i+1)*chunksize, nframe)][pca_sel_rule[0]][pca_sel_rule[1]]
pile.append(tmp.xyz.reshape(tmp.n_frames, tmp.n_atoms*3))
# Step 3: Standardize data (Cartesian coordinates of selected atoms) for PCA
proteinUNK_2d = np.concatenate(pile,axis=0)[:4700]
import matplotlib
import matplotlib.pyplot as plt
matplotlib.rcParams['savefig.dpi'] = 2 * matplotlib.rcParams['savefig.dpi'] # larger image
from sklearn.decomposition import PCA
import pytraj as pt
# we use `load` method to load all data to memory. This is good for small data size.
# use `pytraj.iterload` for out-of-core traj.
traj = pt.load('../tests/data/tz2.nc', '../tests/data/tz2.parm7')
pca = PCA(n_components=2)
# superpose to 1st frame
pt.superpose(traj, ref=0, mask='!@H=')
# create average structure
avg = pt.mean_structure(traj)
# superpose all structures to average frame
pt.superpose(traj, ref=avg, mask='!@H=')
# perform PCA calculation and get transformed coords
# we need to reshape 3D traj.xyz array to 2D to make sklearn happy
# make a new traj by stripping all H atoms
traj_new = traj['!@H=']
xyz_2d = traj_new.xyz.reshape(traj_new.n_frames, traj_new.n_atoms * 3)
print(xyz_2d.shape) # (n_frames, n_dimensions)
reduced_cartesian = pca.fit_transform(xyz_2d)
import matplotlib.pyplot as plt
matplotlib.rcParams['savefig.dpi'] = 2 * matplotlib.rcParams[
'savefig.dpi'] # larger image
from sklearn.decomposition import PCA
import pytraj as pt
# we use `load` method to load all data to memory. This is good for small data size.
# use `pytraj.iterload` for out-of-core traj.
traj = pt.load('../tests/data/tz2.nc', '../tests/data/tz2.parm7')
pca = PCA(n_components=2)
# superpose to 1st frame
pt.superpose(traj, ref=0, mask='!@H=')
# create average structure
avg = pt.mean_structure(traj)
# superpose all structures to average frame
pt.superpose(traj, ref=avg, mask='!@H=')
# perform PCA calculation and get transformed coords
# we need to reshape 3D traj.xyz array to 2D to make sklearn happy
# make a new traj by stripping all H atoms
traj_new = traj['!@H=']
xyz_2d = traj_new.xyz.reshape(traj_new.n_frames, traj_new.n_atoms * 3)
print(xyz_2d.shape) # (n_frames, n_dimensions)
reduced_cartesian = pca.fit_transform(xyz_2d)
