def preliminaryAnalysis(obj, top):
aligner1 = align.AlignTraj(obj, obj, verbose=True, in_memory=True)
cAlpha = obj.select_atoms("name CA")
#computing Radius of gyration
print("Computing Radius of gyration along the trajectory:")
gyro_list = list()
for ts in obj.trajectory:
gyro_list.append(obj.atoms.radius_of_gyration())
s_gyro = pd.Series(gyro_list)
#computing rmsd with first frame as reference
print("Computing c-alphas RMSD with the first frame as reference:")
rmsd1 = RMSD(cAlpha, verbose=True).run()
rmsd_df = pd.DataFrame(rmsd1.rmsd)
#computind rmsf
print("Computing c-alphas RMSF:")
ref_coordinates = obj.trajectory.timeseries(asel=cAlpha).mean(axis=1)
ref = Merge(cAlpha).load_new(ref_coordinates[:, None, :], order="afc")
re_align = align.AlignTraj(obj, ref, select="name CA").run()
# need to write the trj to disk (issue 15)?
with Writer("rmsfit.xtc", n_atoms=obj.atoms.n_atoms) as w:
for ts in obj.trajectory:
w.write(obj.atoms)
#creating the fitted trj
rmsfObj = Universe("rmsfit.xtc", top)
#backboneRef = rmsfObj.select_atoms("backbone")
rmsf = RMSF(cAlpha, verbose=True).run()
rmsf_df = pd.DataFrame(rmsf.rmsf, index=cAlpha.resnums)
return s_gyro, rmsd_df, rmsf_df
def RMSFcalculation(topology, trajectory, threshold):
u = mda.Universe("%s" % trajectory,
in_memory=True) # Initialization in MDAnalysis
ref = mda.Universe("%s" %
topology) # The backbone file has 3 atoms per residue
prealigner = align.AlignTraj(
u, ref, select="protein and name CA", in_memory=True).run(
) # Fit to the best frame to get a better average structure
protein = u.select_atoms("protein")
reference_coordinates = u.trajectory.timeseries(asel=protein).mean(axis=1)
#print ("The atomic coordinates are\n%s" % reference_coordinates)
reference = mda.Merge(protein).load_new(reference_coordinates[:, None, :],
order="afc")
aligner = align.AlignTraj(u,
reference,
select="protein and name CA",
in_memory=True).run()
calphas = protein.select_atoms("name CA")
rmsfer = RMSF(calphas, verbose=True).run()
# rmsf_data = numpy.zeros(rmsfer.rmsf.size)
resnums = calphas.resnums
rmsf_data = rmsfer.rmsf
plot(resnums, rmsf_data, threshold)
selection_residue = []
index = 1
for rmsf_pointer in rmsf_data:
if rmsf_pointer >= threshold:
selection_residue.append(index)
index += 1
return selection_residue, rmsf_data
def test_AlignTraj_custom_weights(self, universe, reference, tmpdir):
weights = np.zeros(universe.atoms.n_atoms)
ca = universe.select_atoms('name CA')
weights[ca.indices] = 1
outfile = str(tmpdir.join('align_test.dcd'))
x = align.AlignTraj(universe, reference,
filename=outfile, select='name CA').run()
x_weights = align.AlignTraj(universe, reference,
filename=outfile, weights=weights).run()
assert_array_almost_equal(x.rmsd, x_weights.rmsd)
def test_AlignTraj_outfile_default_exists(self, universe, reference, tmpdir):
reference.trajectory[-1]
outfile = str(tmpdir.join('align_test.dcd'))
align.AlignTraj(universe, reference, filename=outfile).run()
fitted = mda.Universe(PSF, outfile)
# ensure default file exists
with mda.Writer(str(tmpdir.join('rmsfit_align_test.dcd')),
n_atoms=fitted.atoms.n_atoms) as w:
w.write(fitted.atoms)
align.AlignTraj(fitted, reference)
# we are careful now. The default does nothing
with pytest.raises(IOError):
align.AlignTraj(fitted, reference, force=False)
def test_AlignTraj_custom_weights(self):
weights = np.zeros(self.universe.atoms.n_atoms)
ca = self.universe.atoms.CA
weights[ca.indices] = 1
x = align.AlignTraj(self.universe,
self.reference,
filename=self.outfile,
select='name CA').run()
x_weights = align.AlignTraj(self.universe,
self.reference,
filename=self.outfile,
weights=weights).run()
assert_array_almost_equal(x.rmsd, x_weights.rmsd)
def align_universe(u: mda.Universe,
align_type: AlignType,
sel: str = STANDARD_SELECTION):
align.AlignTraj(u, u, select=sel, in_memory=True).run()
return u
def extract_aligned_coords(struc_a, xtc_a, struc_b, xtc_b):
"""
Writes out combined atomgroup density for both input simulations.
Parameters
----------
struc_a : str
File name for the reference file (PDB or GRO format).
xtc_a : str
File name for the trajectory (xtc format).
struc_b : str
File name for the reference file (PDB or GRO format).
xtc_b : str
File name for the trajectory (xtc format).
"""
if not os.path.exists('dens/'):
os.makedirs('dens/')
# # Before we extract the water densities, we need to first align the trajectories
# # so that we can featurize water sites in both ensembles using the same coordinates
condition_a = mda.Universe(struc_a, xtc_a)
condition_b = mda.Universe(struc_b, xtc_b)
align_xtc_name = 'dens/' + struc_a.split('/')[-1][:-4] + 'aligned.xtc'
#align condition a to condition b
align.AlignTraj(
condition_a, # trajectory to align
condition_b, # reference
select='name CA', # selection of atoms to align
filename=align_xtc_name, # file to write the trajectory to
match_atoms=True, # whether to match atoms based on mass
).run()
def align_with_mdanalysis(X_FT, smpl):
import MDAnalysis as mda
from MDAnalysis.analysis import align
from MDAnalysis.analysis.rms import rmsd
trj = mda.Universe(smpl.model.modelName+'.pdb', X_FT)
ref = mda.Universe(smpl.model.modelName+'.pdb')
# trj = mda.Universe('/Users/zofia/github/DFM/alanine.xyz', X_FT)
# print(trj.trajectory)
# ref = mda.Universe('/Users/zofia/github/DFM/alanine.xyz')#, X_FT[0,:,:])
alignment = align.AlignTraj(trj, ref)#, filename='rmsfit.dcd')
alignment.run()
X_aligned = np.zeros(X_FT.shape)
ci=0
for ts in trj.trajectory:
X_aligned[ci] = trj.trajectory.ts.positions
ci=ci+1
#X_aligned = (trj.trajectory.positions)
#print(X_aligned.shape)
#print(alignment)
return X_aligned
def test_mean(pca_aligned, u):
v = mda.Universe(PSF, DCD, in_memory=True)
a = align.AlignTraj(v, v, select=SELECTION).run()
coords = v.trajectory.timeseries(v.select_atoms(SELECTION), order='fac')
assert_almost_equal(pca_aligned.mean,
coords.mean(axis=0).ravel(),
decimal=5)
def calcDensity(cutoff, **kwargs):
"""Retrive the density in Molar of density_sel"""
for k, v in kwargs.items():
exec(k + '=v')
for co in cutoff:
filenames = str(
glob.glob(results_dir +
'structures/NAC_frames-{}-{}-{}-{}-*.gro'.format(
results_dir, prot, mol, c, co)))
for f in filenames:
xtc = f[:-4] + '.xtc'
fit = f + '-fit.xtc'
ref = mda.Universe(f)
mobile = mda.Universe(f, xtc)
alignment = align.AlignTraj(mobile, ref, filename=fit)
alignment.run()
fit_u = mda.Universe(filename + '.gro', fit)
density = density_from_Universe(
fit_u, delta=0.5
) #, atomselection=density_sel, update_selection=True)
density.convert_density('Molar')
density.export(filename + '-density_Molar.dx', type=double)
def align_coordinates(ref,
pdb,
trj_list,
out_name,
sel_string='all',
start_frame=0):
"""
Aligns selected coordinates from a trajectory file.
Parameters
----------
ref : str
File name for reference topology.
Can read all MDAnalysis-compatible topology formats.
pdb : str
File name for reference PDB file.
trj_list : list of str
File names for the input trajectory.
Can read all MDAnalysis-compatible trajectory formats.
out_name : str
Core of the file names for the output files
start_frame : int, optional
First frame to read from the trajectory.
"""
# Read the reference+PDB files and align selected parts.
u = mda.Universe(ref, pdb)
for trj in trj_list:
mobile = mda.Universe(ref, trj)
#mobile.trajectory = mobile.trajectory[start_frame:]
alignment = align.AlignTraj(mobile,
u,
select=sel_string,
filename=f'{out_name}.xtc')
alignment.run()
def _get_aligned_average_positions(ref_files, ref, select="all", **kwargs):
u = mda.Universe(*ref_files, in_memory=True)
prealigner = align.AlignTraj(u, ref, select=select, **kwargs).run()
ag = u.select_atoms(select)
reference_coordinates = u.trajectory.timeseries(asel=ag).mean(axis=1)
rmsd = sum(prealigner.rmsd / len(u.trajectory))
return reference_coordinates, rmsd
def test_AlignTraj_partial_fit(self):
# fitting on a partial selection should still write the whole topology
align.AlignTraj(self.universe,
self.reference,
select='resid 1-20',
filename=self.outfile,
weights='mass').run()
mda.Universe(PSF, self.outfile)
def test_AlignTraj_outfile_default(self, universe, reference, tmpdir):
with tmpdir.as_cwd():
reference.trajectory[-1]
x = align.AlignTraj(universe, reference)
try:
assert os.path.basename(x.filename) == 'rmsfit_adk_dims.dcd'
finally:
x._writer.close()
def test_AlignTraj_partial_fit(self, universe, reference, tmpdir):
outfile = str(tmpdir.join('align_test.dcd'))
# fitting on a partial selection should still write the whole topology
align.AlignTraj(universe,
reference,
select='resid 1-20',
filename=outfile,
weights='mass').run()
mda.Universe(PSF, outfile)
def affinity_propagation(self, preference=-6.0):
'''Performing Affinity Propagation clustering of AMOEBA-run Trp-Cage folding trajectory:-
Default parameter values from MDAnalysis - damping=0.9, max_iter=500, convergence_iter=50
Preference reduced to -10 from -1 to reflect local homogenity within the trajectory'''
print("Performing Affinity Propagation with input preference = %f" %
preference)
clust = encore.cluster(self.univ_cut,
method=encore.AffinityPropagation(
preference=preference, verbose=True))
centroids = [cluster.centroid * self.ncut for cluster in clust]
ids = [cluster.id for cluster in clust]
print(
"Clustering complete! - %d clusters formed with average size = %d frames"
% (len(ids), np.average([cluster.size for cluster in clust])))
coords_centroids = np.zeros((len(centroids), 304, 3), dtype=np.float64)
coords_centroids[:, :, :] = [
self.coords_protein[centroids[i], :, :]
for i in np.arange(0, len(centroids))
]
protein = self.univ2.select_atoms("protein")
univ_centroids = mda.Merge(protein)
univ_centroids.load_new(coords_centroids, format=MemoryReader)
ref = mda.Universe("folded.pdb")
nframes = len(univ_centroids.trajectory)
alignment = align.AlignTraj(univ_centroids,
ref,
select='protein and name CA',
in_memory=True,
verbose=True)
alignment.run()
idvscenter = {
'Cluster ID': [ids[i] for i in range(0, len(ids))],
'Centroid Time (ps)':
[centroids[i] * 10 for i in range(0, len(centroids))],
'Cluster Size': [cluster.size for cluster in clust]
}
idtable = pd.DataFrame(data=idvscenter)
#Visualisation representation set for Trp-Cage - will expand to general proteins later
view = nglview.show_mdanalysis(univ_centroids)
view.add_cartoon(selection="protein")
view.add_licorice('TRP')
view.add_licorice('PRO')
view.center(selection='protein', duration=nframes)
view.player.parameters = dict(frame=True)
return view, idtable, univ_centroids
def f(u, selection, align_with='protein'):
align.AlignTraj(u, u, select=align_with, in_memory=True).run()
sele = u.select_atoms(selection)
rmsfer = RMSF(sele, verbose=True).run()
x = [(a.name, a.id) for a in rmsfer.atomgroup.atoms]
df = pd.DataFrame(x, columns=('Name', 'ID'))
df['RMSF'] = rmsfer.rmsf
return df.set_index(['Name', 'ID'])
def test_AlignTraj_outfile_default(self, universe, reference):
# NOTE: Remove the line os.remove() with release 1.0,
# when the default behavior of AlignTraj changes.
with tempdir.in_tempdir():
reference.trajectory[-1]
x = align.AlignTraj(universe, reference)
try:
assert os.path.basename(x.filename) == 'rmsfit_adk_dims.dcd'
finally:
x._writer.close()
os.remove(x.filename)
def test_ensemble_superimposition_to_reference_non_weighted(self):
aligned_ensemble1 = mda.Universe(PSF, DCD)
align.AlignTraj(aligned_ensemble1,
aligned_ensemble1,
select="name CA",
in_memory=True).run()
aligned_ensemble2 = mda.Universe(PSF, DCD)
align.AlignTraj(aligned_ensemble2,
aligned_ensemble2,
select="name *",
in_memory=True).run()
rmsfs1 = rms.RMSF(aligned_ensemble1.select_atoms('name *'))
rmsfs1.run()
rmsfs2 = rms.RMSF(aligned_ensemble2.select_atoms('name *'))
rmsfs2.run()
assert sum(rmsfs1.rmsf) > sum(rmsfs2.rmsf), "Ensemble aligned on all " \
"atoms should have lower full-atom RMSF than ensemble aligned on only CAs."
def test_AlignTraj_in_memory(self):
self.reference.trajectory[-1]
x = align.AlignTraj(self.universe,
self.reference,
filename=self.outfile,
in_memory=True).run()
assert_almost_equal(x.rmsd[0], 6.9290, decimal=3)
assert_almost_equal(x.rmsd[-1], 5.2797e-07, decimal=3)
# check in memory trajectory
self._assert_rmsd(self.universe, 0, 6.929083044751061)
self._assert_rmsd(self.universe, -1, 0.0)
def test_AlignTraj_in_memory(self, universe, reference, tmpdir):
outfile = str(tmpdir.join('align_test.dcd'))
reference.trajectory[-1]
x = align.AlignTraj(universe, reference, filename=outfile,
in_memory=True).run()
assert x.filename is None
assert_almost_equal(x.rmsd[0], 6.9290, decimal=3)
assert_almost_equal(x.rmsd[-1], 5.2797e-07, decimal=3)
# check in memory trajectory
self._assert_rmsd(reference, universe, 0, 6.929083044751061)
self._assert_rmsd(reference, universe, -1, 0.0)
def test_AlignTraj_weighted(self, universe, reference, tmpdir):
outfile = str(tmpdir.join('align_test.dcd'))
x = align.AlignTraj(universe, reference,
filename=outfile, weights='mass').run()
fitted = mda.Universe(PSF, outfile)
assert_almost_equal(x.rmsd[0], 0, decimal=3)
assert_almost_equal(x.rmsd[-1], 6.9033, decimal=3)
self._assert_rmsd(reference, fitted, 0, 0.0,
weights=universe.atoms.masses)
self._assert_rmsd(reference, fitted, -1, 6.929083032629219,
weights=universe.atoms.masses)
def test_AlignTraj(self, universe, reference, tmpdir):
reference.trajectory[-1]
outfile = str(tmpdir.join('align_test.dcd'))
x = align.AlignTraj(universe, reference, filename=outfile).run()
fitted = mda.Universe(PSF, outfile)
assert_almost_equal(x.rmsd[0], 6.9290, decimal=3)
assert_almost_equal(x.rmsd[-1], 5.2797e-07, decimal=3)
# RMSD against the reference frame
# calculated on Mac OS X x86 with MDA 0.7.2 r689
# VMD: 6.9378711
self._assert_rmsd(reference, fitted, 0, 6.929083044751061)
self._assert_rmsd(reference, fitted, -1, 0.0)
def test_AlignTraj_custom_mass_weights(self):
x = align.AlignTraj(self.universe,
self.reference,
filename=self.outfile,
weights=self.reference.atoms.masses).run()
fitted = mda.Universe(PSF, self.outfile)
assert_almost_equal(x.rmsd[0], 0, decimal=3)
assert_almost_equal(x.rmsd[-1], 6.9033, decimal=3)
self._assert_rmsd(fitted, 0, 0.0, weights=self.universe.atoms.masses)
self._assert_rmsd(fitted,
-1,
6.929083032629219,
weights=self.universe.atoms.masses)
def pairwise_rmsds(universes: List[mda.Universe]):
"""Compute pairwise RMSDs for position snapshots."""
size = len(universes)
rmsd_matrix = np.zeros(shape=(size, size))
for i, universe_i in enumerate(universes):
for j, universe_j in enumerate(universes):
if i == j:
rmsd = 0
else:
align.AlignTraj(universe_i,
universe_i,
select=STANDARD_SELECTION,
in_memory=True)
align.AlignTraj(universe_i,
universe_j,
select=STANDARD_SELECTION,
in_memory=True)
pos_i = extract_positions(universe_i)
pos_j = extract_positions(universe_j)
rmsd = rms.rmsd(
pos_i.mean(axis=1)[:, None, :],
pos_j.mean(axis=1)[:, None, :],
)
# rmsd = rms.rmsd(
# pos_i,
# pos_j
# )
rmsd_matrix[i, j] = rmsd
rmsd_matrix[j, i] = rmsd
return rmsd_matrix
def test_ensemble_superimposition():
aligned_ensemble1 = mda.Universe(PSF, DCD)
align.AlignTraj(aligned_ensemble1,
aligned_ensemble1,
select="name CA",
in_memory=True).run()
aligned_ensemble2 = mda.Universe(PSF, DCD)
align.AlignTraj(aligned_ensemble2,
aligned_ensemble2,
select="name *",
in_memory=True).run()
rmsfs1 = rms.RMSF(aligned_ensemble1.select_atoms('name *'))
rmsfs1.run()
rmsfs2 = rms.RMSF(aligned_ensemble2.select_atoms('name *'))
rmsfs2.run()
assert_equal(
sum(rmsfs1.rmsf) > sum(rmsfs2.rmsf),
True,
err_msg=
"Ensemble aligned on all atoms should have lower full-atom RMSF "
"than ensemble aligned on only CAs.")
def get_rmsf(t, label=None):
sel = 'protein and not name H*'
prot = t.select_atoms(sel)
average_coordinates = t.trajectory.timeseries(asel=prot).mean(axis=1)
# make a reference structure (need to reshape into a 1-frame "trajectory")
reference = MDAnalysis.Merge(prot).load_new(average_coordinates[:,
None, :],
order="afc")
aligner = align.AlignTraj(t, reference, select=sel, in_memory=True).run()
print('\tDone Aligning... calculating RMSF')
rmsfer = RMSF(prot).run()
ret = pd.DataFrame(zip(prot.resids, prot.resnames, rmsfer.rmsf),
columns=('resid', 'resname', 'rmsf'))
if label != None:
ret['label'] = label
return ret
def test_AlignTraj_weights_deprecated(self):
with warnings.catch_warnings(record=True) as warn:
warnings.simplefilter('always')
x = align.AlignTraj(self.universe,
self.reference,
filename=self.outfile,
mass_weighted=True).run()
assert_equal(len(warn), 1)
fitted = mda.Universe(PSF, self.outfile)
assert_almost_equal(x.rmsd[0], 0, decimal=3)
assert_almost_equal(x.rmsd[-1], 6.9033, decimal=3)
self._assert_rmsd(fitted, 0, 0.0, weights=self.universe.atoms.masses)
self._assert_rmsd(fitted,
-1,
6.929083032629219,
weights=self.universe.atoms.masses)
def to_mda_traj(pos_traj,
frame_traj,
all_steps,
ncp_bp_frames,
bp_num_map,
mute=True,
alignTrj=False):
#gen topology in pdb
pdb_string = ''
bp_frames, octamers = gen_fiber(pos_traj[0], frame_traj[0], all_steps,
ncp_bp_frames, bp_num_map)
num = 1
pdb_string = pdb_string + 'MODEL 1\n'
for row in bp_frames[:, 3, :3] / 10:
pdb_string = pdb_string + "ATOM %5d N DNA A 1 %8.3f%8.3f%8.3f\n" % (
num, row[0], row[1], row[2])
num += 1
for row in octamers / 10:
pdb_string = pdb_string + "ATOM %5d O NUC B 1 %8.3f%8.3f%8.3f\n" % (
num, row[0], row[1], row[2])
num += 1
pdb_string = pdb_string + "ENDMDL\n"
#gen trajectory np array
coords = np.zeros((len(pos_traj), bp_frames.shape[0] + len(octamers), 3))
for frame, (positions, frames) in tqdm(enumerate(zip(pos_traj,
frame_traj)),
total=len(pos_traj),
disable=mute):
bp_frames, octamers = gen_fiber(positions, frames, all_steps,
ncp_bp_frames, bp_num_map)
coords[frame] = np.vstack([bp_frames[:, 3, :3], octamers])
u = mda.Universe(StringIO(pdb_string),
coords / 10.0,
topology_format='pdb',
format=MemoryReader,
order='fac')
if alignTrj:
alignment = align.AlignTraj(u, u, in_memory=True)
alignment.run()
return (u)
def test_rmsf_xtc(run):
"""Align multiple times + RMSF"""
u = mda.Universe(TPR, XTC)
u2 = u.copy()
average = align.AverageStructure(u2, u2, select='protein and name CA',
ref_frame=0).run()
ref = average.universe
aligner = align.AlignTraj(u2, ref,
select='protein and name CA',
in_memory=True).run()
c_alphas = u2.select_atoms('protein and name CA')
R = rms.RMSF(c_alphas).run()
assert 1 == 1
