def calculateSASA(trajectory, topology, res_name):
"""
Calculate the SASA of a ligand in a trajectory
:param trajectory: Name of the trajectory file
:type trajectory: str
:param topology: Topology of the trajectory (needed for non-pdb trajs)
:type topology: str
:param res_name: Ligand resname
:type res_name: str
"""
utilities.print_unbuffered("Processing", trajectory)
t = md.load(trajectory, top=topology)
t.remove_solvent(inplace=True)
res_atoms = t.top.select("resname '%s'" % res_name)
if not len(res_atoms):
raise ValueError("Nothing found using resname %s" % res_name)
t2 = t.atom_slice(res_atoms)
for atom in t2.top.atoms:
# mdtraj complains if the ligand residue index is not 0 when
# isolated
atom.residue.index = 0
res_index = t.top.atom(res_atoms[0]).residue.index
sasa = md.shrake_rupley(t, mode="residue")
sasa_empty = md.shrake_rupley(t2, mode="residue")
return sasa[:, res_index] / sasa_empty[:, 0]
def accessible_surface_area(traj, nanoparticle_radius, probe_radius=0.25):
radii_exchange = {'C': nanoparticle_radius, 'N': MMM_sigma/2, 'O': MME_sigma/2}
sasa = md.shrake_rupley(traj, mode='residue', change_radii=radii_exchange,
probe_radius=probe_radius, n_sphere_points=1000)
return np.column_stack((traj.time, sasa[:,0]))
def main():
import mdtraj as md
import pickle
args = parser()
trj_file, top = args.traj, args.top
probe_radius, n_sphere_points = args.probe_radius, args.n_sphere_points
traj = md.load(trj_file, top=top)
print(traj)
keys = get_residue_tag(top)
print(keys)
trj_sasa = md.shrake_rupley(
traj,
probe_radius=probe_radius,
n_sphere_points=n_sphere_points, # the default value of gmx sasa is 24
mode='residue')
print('sasa data shape', trj_sasa.shape)
print(len(trj_sasa[0, :]))
i = 0
sasa_dict = {}
for key in keys:
sasa_dict[key] = trj_sasa[:, i]
i += 1
fout1 = open('dict_sasa.pkl', 'wb')
pickle.dump(sasa_dict, fout1)
def run(project, atom_indices=None, traj_fn = 'all'):
n_atoms = project.load_conf().n_atoms
if traj_fn.lower() == 'all':
SASA = np.ones((project.n_trajs, np.max(project.traj_lengths), n_atoms)) * -1
for traj_ind in xrange(project.n_trajs):
traj_asa = []
logger.info("Working on Trajectory %d", traj_ind)
traj_fn = project.traj_filename(traj_ind)
chunk_ind = 0
for traj_chunk in md.iterload(traj_fn, atom_indices=atom_indices, chunk=1000):
traj_asa.extend(md.shrake_rupley(traj_chunk))
chunk_ind += 1
SASA[traj_ind, 0:project.traj_lengths[traj_ind]] = traj_asa
else:
traj_asa = []
for traj_chunk in Trajectory.enum_chunks_from_lhdf( traj_fn, AtomIndices=atom_indices ):
traj_asa.extend( asa.calculate_asa( traj_chunk ) )
SASA = np.array(traj_asa)
return SASA
def main():
import numpy as np
args = parser()
file_names = args.file
for file_name in file_names:
traj = md.load(file_name, top=file_name)
keys = get_residue_tag(file_name)
print(keys)
trj_sasa = md.shrake_rupley(
traj,
probe_radius=0.14,
n_sphere_points=100, # the default value of gmx sasa is 24
mode='residue')
print('sasa data shape', trj_sasa.shape)
i = 0
sasa_dict = {}
for key in keys:
sasa_dict[key] = trj_sasa[:, i]
i += 1
name = file_name.split('.')[0].upper()
np.savetxt(f'sasa_{name}.dat',
trj_sasa,
fmt='%.2f',
header=f'SASA in isolation of {name}')
def test_single(pdb_id):
file_name = join(data_dir, pdb_id + ".pdb")
# Single atom SASA, compare with MDTraj
file = pdb.PDBFile()
file.read(file_name)
array = file.get_structure(model=1)
sasa = struc.sasa(array, vdw_radii="Single", point_number=5000)
from biotite.structure.info.radii import _SINGLE_RADII as radii
import mdtraj
# Use the same atom radii
radii = {
element.capitalize(): radius / 10
for element, radius in radii.items()
}
traj = mdtraj.load(file_name)
# Conversion from nm^2 to A^2
sasa_exp = mdtraj.shrake_rupley(
traj, change_radii=radii, n_sphere_points=5000)[0] * 100
# Assert that more than 90% of atoms
# have less than 10% SASA difference
assert np.count_nonzero(np.isclose(sasa, sasa_exp, rtol=1e-1,
atol=1e-1)) / len(sasa) > 0.9
# Assert that more than 98% of atoms
# have less than 1% SASA difference
assert np.count_nonzero(np.isclose(sasa, sasa_exp, rtol=1e-2,
atol=1e-1)) / len(sasa) > 0.98
def _test_sasa_featurizer(t, value):
sasa = md.shrake_rupley(t)
rids = np.array([a.residue.index for a in t.top.atoms])
for i, rid in enumerate(np.unique(rids)):
mask = (rids == rid)
eq(value[:, i], np.sum(sasa[:, mask], axis=1))
def _test_sasa_featurizer(t, value):
sasa = md.shrake_rupley(t)
rids = np.array([a.residue.index for a in t.top.atoms])
for i, rid in enumerate(np.unique(rids)):
mask = (rids == rid)
eq(value[:, i], np.sum(sasa[:, mask], axis=1))
def get_sasa():
import mdtraj as md
save_dir = f'/home/hyang/bio/erf/data/design/cullpdb_val_deep/'
protein_sample = pd.read_csv(
'/home/hyang/bio/erf/data/design/cullpdb_val_deep/sample.csv')
pdb_selected = protein_sample['pdb'].values
for p in pdb_selected:
pdb_id = p[:4]
structure = md.load(
f'/home/hyang/bio/openmm/data/{pdb_id}/production_T300.pdb')
topology = structure.topology
trj = md.load(
f'/home/hyang/bio/openmm/data/{pdb_id}/production_T300.dcd',
top=topology)
topology.create_standard_bonds()
trj = trj.remove_solvent()
sasa = md.shrake_rupley(trj, mode='residue')
sasa *= 100
fig = pl.figure()
for i in range(sasa.shape[0]):
pl.plot(sasa[i])
pl.xlabel('Residue Number')
pl.ylabel('SASA (A^2)')
pl.savefig(f'{save_dir}/{p}_sasa.pdf')
pl.close(fig)
df = pd.read_csv(f'{save_dir}/{p}_bead.csv')
df['sasa'] = np.mean(sasa, axis=0)
df.to_csv(f'{save_dir}/{p}_bead_sasa.csv')
def _test_atom_group(t, value):
sasa = md.shrake_rupley(t, mode="atom")
rids = np.array([a.residue.index for a in t.top.atoms])
for i, rid in enumerate(np.unique(rids)):
mask = rids == rid
eq(value[:, i], np.sum(sasa[:, mask], axis=1))
def run(project, atom_indices=None, traj_fn='all'):
n_atoms = project.load_conf().n_atoms
if traj_fn.lower() == 'all':
SASA = np.ones(
(project.n_trajs, np.max(project.traj_lengths), n_atoms)) * -1
for traj_ind in xrange(project.n_trajs):
traj_asa = []
logger.info("Working on Trajectory %d", traj_ind)
traj_fn = project.traj_filename(traj_ind)
chunk_ind = 0
for traj_chunk in md.iterload(traj_fn,
atom_indices=atom_indices,
chunk=1000):
traj_asa.extend(md.shrake_rupley(traj_chunk))
chunk_ind += 1
SASA[traj_ind, 0:project.traj_lengths[traj_ind]] = traj_asa
else:
traj_asa = []
for traj_chunk in Trajectory.enum_chunks_from_lhdf(
traj_fn, AtomIndices=atom_indices):
traj_asa.extend(asa.calculate_asa(traj_chunk))
SASA = np.array(traj_asa)
return SASA
def calc_sasa(traj, chain=0, featurizer=None):
small_traj = traj.atom_slice(
atom_indices=featurizer.select(f'chainid == {chain}'))
res = md.shrake_rupley(small_traj,
probe_radius=0.14,
n_sphere_points=960,
mode='residue')
return res
def get_sasa(cluster_indices, type_of_clustering):
sasa_of_states = {}
max_sasa = 0.0
for index in cluster_indices:
f = md.load_pdb(type_of_clustering + "_" + str(index) + ".pdb")
sasa = md.shrake_rupley(f)
total_sasa = sasa.sum(axis=1)
sasa_of_states[index] = float(total_sasa)
return sasa_of_states
def compute_SASA(self, PDB): """ compute the Solvent Accessible Surface Area with MDTraj. The Shrake Rupley algorithm is relatively expensive and difficult to code, so I borrowed from MDTraj. """ struc = md.load(PDB) self.SASA.append(md.shrake_rupley(struc).sum(axis=1)[0]) return None
def get_sasa(trajectory, topology, coreruns=10):
"""
Calculates Solvent Accessible Surface area, currently step size of trajectory is reduced due to memory limits
:param trajectory: string, path to trajectory location
:param topology: string, path to topology location
:param step: int, number of operations to split between serial runs to prevent memory overload
:return: list, mean SASA for each residue amide hydrogen
"""
print('Calculating SASA')
print('step index')
traj = md.load(trajectory, top=topology)
topology = traj.topology
max_frames = int(traj.n_frames)
mem_max = 15000 #max number of frames per serial run, set due to memory limits
stepsize = int(max_frames / mem_max)
print('stepsize:', stepsize)
if coreruns * mem_max > max_frames:
print('ERROR')
sasaoutputavg = pd.DataFrame()
sasaoutputmax = pd.DataFrame()
sasaoutput_all = pd.DataFrame()
for i in range(0, coreruns):
sasa = md.shrake_rupley(traj[0 + i:max_frames:stepsize],
probe_radius=0.014,
n_sphere_points=960,
mode='atom')
amidesasa = sasa[:, topology.select('name H')]
print(amidesasa)
amidesasa_all = pd.DataFrame(amidesasa)
np.savetxt('amidesasa_all', amidesasa_all)
amidesasaavg = pd.DataFrame(amidesasa.mean(axis=0),
columns=[str(f"sasa{i}_mean")])
amidesasamax = pd.DataFrame(amidesasa.max(axis=0),
columns=[str(f"sasa{i}_max")])
d = f"sasa{i}"
sasaoutput_all = pd.concat((sasaoutput_all, amidesasa_all), axis=0)
sasaoutputavg = pd.concat((sasaoutputavg, amidesasaavg), axis=1)
sasaoutputmax = pd.concat((sasaoutputmax, amidesasamax), axis=1)
np.savetxt('amidesasa_all.out', sasaoutput_all)
sasaoutputavg = sasaoutputavg.mean(axis=1)
np.savetxt('amidesasaavg_allframe.out', sasaoutputavg)
sasaoutputmax = sasaoutputmax.mean(axis=1)
np.savetxt('amidesasamax_allframe.out', sasaoutputmax)
return (sasaoutputavg, sasaoutputmax)
def sasa_atoms(macromolecule, probe_radius=0.227, n_sphere_points=5000):
#0.227 rdw NA
topology_mdtraj = md.Topology.from_openmm(macromolecule.topology)
positions_mdtraj = macromolecule.positions._value
aux_traj = md.Trajectory(positions_mdtraj, topology_mdtraj)
sasa = md.shrake_rupley(aux_traj,
probe_radius=probe_radius,
n_sphere_points=n_sphere_points,
mode='atom')
return sasa
def compute_sasa(traj):
# define number of frames and atoms
N = traj.xyz.shape[0]
M = traj.xyz.shape[1]
# compute solvent accessible surface area for each frame for each atom
sasa = np.zeros((N, M), dtype=np.float32)
for k in tqdm(range(traj.xyz.shape[0])):
sasa[k] = md.shrake_rupley(traj[k]).ravel()
return sasa
def SASA(self):
for seedi in range(len(self.FNSeeds)):
self.SASAs[seedi] = md.shrake_rupley(self.trajectories[seedi],
probe_radius=0.14,
mode='residue',
get_mapping=False)
nframes = (self.SASAs[seedi]).shape[0]
nres = (self.SASAs[seedi]).shape[1]
self.totSASAs[seedi] = np.zeros((nframes))
for i in range(nframes):
self.totSASAs[seedi][i] = np.sum(self.SASAs[seedi][i])
print("SASA:")
print((self.totSASAs[seedi]).shape)
def calculateSASA(trajectory, topology, res_name):
"""
Calculate the SASA of a ligand in a trajectory
:param trajectory: Name of the trajectory file
:type trajectory: str
:param topology: Topology of the trajectory (needed for non-pdb trajs)
:type topology: str
:param res_name: Ligand resname
:type res_name: str
"""
t = md.load(trajectory, top=topology)
res_atoms = t.top.select("resname '%s'" % res_name)
t2 = t.atom_slice(res_atoms)
for atom in t2.top.atoms:
# mdtraj complains if the ligand residue index is not 0 when
# isolated
atom.residue.index = 0
res_index = t.top.atom(res_atoms[0]).residue.index
sasa = md.shrake_rupley(t, mode="residue")
sasa_empty = md.shrake_rupley(t2, mode="residue")
return sasa[:, res_index] / sasa_empty[:, 0]
def map_sasa_core(trajectoryfile, topologyfile, probe_radius):
import mdtraj as md
print("computing using threading ", probe_radius, "nm sasa for",
trajectoryfile, "using topology", topologyfile)
if topologyfile:
trj = md.load(trajectoryfile, top=topologyfile)
else:
trj = md.load(trajectoryfile)
print("loaded", trajectoryfile, 'with topology', topologyfile)
sasas = md.shrake_rupley(trj, probe_radius=probe_radius)
return sasas
def test_sasa_4():
def _test_atom_group(t, value):
sasa = md.shrake_rupley(t, mode='atom')
rids = np.array([a.residue.index for a in t.top.atoms])
for i, rid in enumerate(np.unique(rids)):
mask = (rids == rid)
eq(value[:, i], np.sum(sasa[:, mask], axis=1))
t = md.load(get_fn('frame0.h5'))
value = md.shrake_rupley(t, mode='residue')
assert value.shape == (t.n_frames, t.n_residues)
yield lambda: _test_atom_group(t, value)
# scramle the order of the atoms, and which residue each is a
# member of
df, bonds = t.top.to_dataframe()
df['resSeq'] = np.random.permutation(df['resSeq'])
df['resName'] = df['resSeq']
t.top = md.Topology.from_dataframe(df, bonds)
value = md.shrake_rupley(t, mode='residue')
yield lambda: _test_atom_group(t, value)
def compute_sasa(self, radius=0.14, mode="residue"):
"""
Compute the solvent accessible surface area of each atom or residue in each simulation frame
:param radius: The radius of the probe, in nm
:param mode: In mode == atom the extracted areas are resolved peratom In mode == residue,
this is consolidated down to the per-residue SASA by summing over the atoms in each residue
:return: The accessible surface area of each atom or residue in every frame. If mode == atom,
the second dimension will index the atoms in the trajectory,
whereas if mode == residue, the second dimension will index the residues. ( np.array, shape=(n_frames, n_features)
"""
return md.shrake_rupley(self.traj, probe_radius=radius, mode=mode)
def test_sasa_4():
def _test_atom_group(t, value):
sasa = md.shrake_rupley(t, mode='atom')
rids = np.array([a.residue.index for a in t.top.atoms])
for i, rid in enumerate(np.unique(rids)):
mask = (rids == rid)
eq(value[:, i], np.sum(sasa[:, mask], axis=1))
t = md.load(get_fn('frame0.h5'))
value = md.shrake_rupley(t, mode='residue')
assert value.shape == (t.n_frames, t.n_residues)
yield lambda: _test_atom_group(t, value)
# scramle the order of the atoms, and which residue each is a
# member of
df, bonds = t.top.to_dataframe()
df['resSeq'] = np.random.permutation(df['resSeq'])
df['resName'] = df['resSeq']
t.top = md.Topology.from_dataframe(df, bonds)
value = md.shrake_rupley(t, mode='residue')
yield lambda: _test_atom_group(t, value)
def calc_sasa(trajectory, parallel=True, parallel_way='multiprocessing', n_sphere_points=960):
if parallel is False:
sasa = md.shrake_rupley(trajectory, n_sphere_points=n_sphere_points)
print(trajectory)
print('sasa data shape', sasa.shape)
total_sasa = sasa.sum(axis=1)
print('total sasa shape ', total_sasa.shape)
else:
if parallel_way == 'ipyparallel':
# TODO start by for single machine ipcluster start -n 4
print('Parallel calculation Haha')
# from IPython.parallel import Client
from ipyparallel import Client
c = Client()
results = c[:].map(md.shrake_rupley, trajectory)
sasa_list = results.get()
sasa = np.vstack(sasa_list)
# sasa_temp = [x[0] for x in sasa_list]
# sasa = np.array(sasa_temp)
# print('sasa shape ', sasa.shape)
total_sasa = sasa.sum(axis=1)
print('total sasa shape ', total_sasa.shape)
else:
import multiprocessing
num_proc = multiprocessing.cpu_count()
print('Your number of CPUs is ', num_proc)
pool = multiprocessing.Pool(num_proc)
results = pool.map(md.shrake_rupley, trajectory)
sasa_list = results
sasa = np.vstack(sasa_list)
# sasa_temp = [x[0] for x in sasa_list]
# sasa = np.array(sasa_temp)
# print('sasa shape ', sasa.shape)
total_sasa = sasa.sum(axis=1)
print('total sasa shape ', total_sasa.shape)
return sasa, total_sasa
def calc_sasa(ag,
normalize=True,
change_radii: dict = None,
probe_radius=0.14):
traj = _load_traj(ag)
vdw_radii = VDW_RADII.copy()
if change_radii is not None:
vdw_radii.update(change_radii)
max_sasa = {k: 4 * math.pi * r * r * 0.01 for k, r in vdw_radii.items()}
atom_sasa = md.shrake_rupley(traj,
change_radii=change_radii,
probe_radius=probe_radius)[0]
if normalize:
atom_sasa /= np.array([max_sasa[x] for x in ag.getElements()])
return atom_sasa
def sasa_mdtraj(pdbfile):
"""
Calculate the SASA per residue using the Shrake & Rupley algorithm [1]
as implemented in mdtraj [2]. Return values in angstrom^2.
[1] A. Shrake and J. A. Rupley, "Environment and exposure to solvent
of protein atoms. Lysozyme and insulin", Journal of Molecular
Biology, vol. 79, no. 2, pp. 351-371, 1973.
[2] R. T. McGibbon et al., "MDTraj: A Modern Open Library for the
Analysis of Molecular Dynamics Trajectories", Biophysical Journal,
vol. 109, no. 8, pp. 1528-1532, 2015.
"""
pdb = mdtraj.load(pdbfile)
res = [residue.name for residue in pdb.topology.residues]
sasa = mdtraj.shrake_rupley(pdb, mode='residue')[0] * 100.0
return res, sasa
def sasa_calculation(system_specs, specs):
"""
Parameters
----------
system_specs : TYPE
DESCRIPTION.
specs : TYPE
DESCRIPTION.
Returns
-------
TYPE
DESCRIPTION.
"""
(trajectory, topology, results_folder, name) = system_specs
(selection, start, stop, timestep, stride, units_x, units_y, task,
store_traj, subset) = specs
names, indexes, column_index = Featurize.df_template(system_specs,
unit=[units_y])
traj = Trajectory.Trajectory.loadTrajectory(system_specs, specs)
if traj != None:
atom_indices = traj.topology.select(selection)
sasa = md.shrake_rupley(traj[start:stop:stride],
traj[start:stop:stride],
mode='residue')
print(sasa)
rows = rows = pd.Index(np.arange(0, len(sasa)), name='Index')
column_index = pd.MultiIndex.from_product(indexes, names=names)
df_system = pd.DataFrame(
sasa, columns=column_index,
index=rows) #index=np.arange(start, stop, stride)
#df_system.index.rename ='Index'
#Remove non-sense
#df_system=df_system.mask(df_system > 90)
return df_system
else:
return pd.DataFrame()
def SASA(grofile, trajfile, frame_iterator):
"""
TOO SLOW | NOT COMPLETED
Calculate the SASA - Solvent Accessible Surface Area
"""
traj = mdtraj.load(trajfile, top=grofile)
sasa = mdtraj.shrake_rupley(traj[frame_iterator],
probe_radius=0.14,
n_sphere_points=960,
mode='residue',
change_radii=None,
get_mapping=True)
print(sasa)
return sasa
def run_SASA(self):
PROBE_RADIUS, N_SPHERE_POINTS = 0.14, 100
print(self.__traj_data)
def get_residue_tag():
"""
Todo:
I want to do this function by mdtraj instead of MDAnalysis
Return:
residue_tags: List; e.g, [PHE1A, ARG2A, ...]
"""
from MDAnalysis import Universe
u = Universe(self.__ref)
residue_tags = []
nchains = len(set(u.select_atoms('protein').segids))
print(f'n chains = {nchains}')
for chain, resn, resi in zip(u.residues.segids, u.residues.resnames, u.residues.resids):
if chain == 'SYSTEM':
self.chain = chain.replace('SYSTEM', 'A') # self.chain should have default vaule in __init__
else:
self.chain = chain
residue_tags.append(resn + str(resi) + self.chain)
return residue_tags
keys = get_residue_tag()
print(keys)
sasa_matrix = md.shrake_rupley(self.__traj_data,
probe_radius = PROBE_RADIUS ,
n_sphere_points = N_SPHERE_POINTS,
mode='residue')
print('sasa data shape', sasa_matrix.shape)
print(len(sasa_matrix[0,:]))
### Save a table storing sasa values
df_sasa = pd.DataFrame(sasa_matrix).round(4)
df_sasa.columns = keys
df_sasa.index.name = 'Frame No'
df_sasa.to_csv(f'sasa_{self.__out_suffix}.csv')
return df_sasa
def get_cluster_ids_for_start_and_end(initial_id, cluster_indices,
type_of_clustering):
start = initial_id # initial frame is folded structure
# choose structure with maximum SASA as unfolded structure
unfolded_structure_cluster_id = start
max_sasa = 0.0
for index in cluster_indices:
try:
f = md.load_pdb(type_of_clustering + "_" + str(index) + ".pdb")
except:
continue
sasa = md.shrake_rupley(f)
total_sasa = sasa.sum(axis=1)
if total_sasa > max_sasa:
max_sasa = total_sasa
unfolded_structure_cluster_id = index
end = unfolded_structure_cluster_id
# end = gaussian_cluster_ids[str(frames.shape[0] - 1)]
return start, end
def get_sasa (molecular_system, target='atom', selection='all', structure_indices='all', syntaxis='MolSysMT',
engine='MDTraj'):
engine = digest_engine(engine)
target = digest_target(target)
if engine == 'MDTraj':
from mdtraj import shrake_rupley
tmp_item = convert(molecular_system, structure_indices=structure_indices, to_form='mdtraj.Trajectory')
sasa_array = shrake_rupley(tmp_item, mode='atom') # tiene probe_radius y n_sphere_points
if target=='atom':
if selection is not 'all':
atom_indices = select(molecular_system, selection=selection, syntaxis=syntaxis)
sasa_array = sasa_array[:,atom_indices]
else:
sets_atoms = get(molecular_system, target=target, selection=selection, syntaxis=syntaxis, atom_index=True)
n_sets = len(sets_atoms)
n_structures = sasa_array.shape[0]
new_sasa_array = np.empty([n_structures, n_sets], dtype='float')
for ii in range(n_sets):
new_sasa_array[:,ii] = sasa_array[:,sets_atoms[ii].astype(int)].sum(axis=1)
sasa_array = new_sasa_array
sasa_array = puw.quantity(sasa_array, 'nm**2')
sasa_array = puw.standardize(sasa_array)
else:
raise NotImplementedError("Engine not implemented yet")
return sasa_array
def featurize_sasa_individual(traj_file, bp_residues, anton, stride): print(traj_file) traj = md.load(traj_file, stride = stride) top = traj.topology protein_atoms = [a.index for a in top.atoms if a.residue.is_protein] traj = traj.atom_slice(protein_atoms) print(traj) #try: traj = fix_traj(traj) top = traj.topology sasa = md.shrake_rupley(traj, mode = 'atom') #except: # return [] bp_atoms = [a.index for a in top.atoms if a.residue.resSeq in bp_residues] print(np.shape(sasa)) sasa = sasa[:, bp_atoms] total_sasa = sasa.sum(axis=1) return(total_sasa)
def analyse_ligand_sasa(self): """Analysis of ligand SASA.""" i=0 start = timer() if self.trajectory == []: self.trajectory = [self.topology_data.universe.filename] try: for traj in self.trajectory: new_traj = mdtraj.load(traj,top=self.topology_data.universe.filename) #Analyse only non-H ligand ligand_slice = new_traj.atom_slice(atom_indices=self.topology_data.universe.ligand_noH.ids) self.sasa = mdtraj.shrake_rupley(ligand_slice) self.atom_sasa[i]=self.assign_per_atom_sasa() i+=1 self.total_sasa = self.get_total_per_atom_sasa() except KeyError as e: print "WARNING: SASA analysis cannot be performed due to incorrect atom names in" print "the topology ", e print "SASA: "+str(timer()-start)
def calc_sasa(chimera: Chimera = None, filename: str = None,
probe_radius: float = 0.14, n_sphere_points: int = 960, sasa_type='total'):
"""
Computes the Solvent Accessible Surface Area of the protein.
This funcion uses the MDtraj shrake_rupley implementation as a basis.
:param chimera: A Chimera object.
:param filename: Path to a pdb file
:param probe_radius: The radius of the probe, in nm.
:param n_sphere_points: the number of points representing the sufrace of each atom. Higher values lead to more accuracy.
:param sasa_type: Type of calculation to perform. To select from polar, apolar, or total.
:return: areas: np.array containing the area of the chimera in Angstrom^2
"""
sasa_types = ["polar", "apolar", "total"]
if sasa_type not in sasa_types:
raise ValueError(f"Invalid type. Expected one of {sasa_types}")
if chimera and filename:
raise ValueError("Only a Chimera object or the path to a pdb file must be specified")
if not chimera and not filename:
raise ValueError("At least a Chimera object or the path to a pdb file must be specified")
if chimera:
filename = "/tmp/structure.pdb"
chimera.write(filename)
polars = ['SER', 'THR', 'CYS', 'TYR', 'ASN', 'GLN', 'ASP', 'GLU', 'LYS', 'ARG', 'HIS']
apolars = ['GLY', 'ALA', 'VAL', 'LEU', 'ILE', 'MET', 'TRP', 'PHE', 'PRO']
structure = md.load(filename)
if sasa_type == 'polar':
indices = [index for index, residue in enumerate(structure.topology.residues) if residue.name in polars]
elif sasa_type == 'apolar':
indices = [index for index, residue in enumerate(structure.topology.residues) if residue.name in apolars]
else:
indices = [index for index, residue in enumerate(structure.topology.residues)]
sasa = md.shrake_rupley(structure, probe_radius=probe_radius, n_sphere_points=n_sphere_points, mode="residue")
area = sasa[0][indices].sum()
logger.info(f"Area is {area} (nm)^2")
return area
def protein_calcs(self, struc):
"""
Run calculations specified in self.calcs. Before running calculation, check
to make sure it wasn't already done. If it was done before, load the data.
"""
coors = struc.xyz[0]
CA_coors = struc.atom_slice(struc.topology.select('name CA'))[0].xyz[0]
self.nres = struc.n_residues
if 'Gyr' in self.calcs:
L = sa_core.gyration_tensor(coors)
if 'Rg' in self.calcs:
#self.Rg.append(md.compute_rg(struc)[0])
self.Rg.append(sa_core.compute_Rg(L))
if 'Asph' in self.calcs:
self.Asph.append(sa_core.compute_Asph(L))
if 'EED' in self.calcs:
self.EED.append(np.linalg.norm(CA_coors[0] - CA_coors[-1]))
if 'SASA' in self.calcs:
SASA = md.shrake_rupley(struc)
self.SASA.append(SASA.sum(axis=1)[0])
if 'cmaps' in self.calcs:
dist = sa_core.contact_maps(CA_coors)
self.cmaps.append(dist)
if 'gcmaps' in self.calcs:
self.gcmaps.append(sa_core.gremlin_contact_maps(dist))
if 'SS' in self.calcs:
self.SS.append(md.compute_dssp(struc))
if 'flory' in self.calcs:
self.fex.append(polymer.compute_flory(struc, self.nres))
if 'rama' in self.calcs:
self.dihedrals.append(rama.compute_phipsi(struc))
if 'surface_contacts' in self.calcs:
#self.resnames = [struc.atom_slice(struc.topology.select('name CA')).topology.atom(r).residue.name for r in range(self.nres)]
# above was replaced by self.seq
self.scmaps.append(sa_core.surface_contacts(struc, SASA))
return None
def from_mdtraj(self, a_traj, probe_radius=1.4, **kwargs):
r"""Calculate solvent accessible surface for frames in a trajectory
SASA units are Angstroms squared
Parameters
----------
a_traj: :class:`~mdtraj.Trajectory`
mdtraj trajectory instance
probe_radius: float
The radius of the probe, in Angstroms
kwargs: dict
Optional arguments for the underlying mdtraj.shrake_rupley
algorithm doing the actual SaSa calculation
Returns
-------
self: :class:`~idpflex.properties.SaSa`
Instantiated SaSa property object
"""
self.y = 100 * mdtraj.shrake_rupley(
a_traj, probe_radius=probe_radius / 10.0, **kwargs).sum(axis=1)[0]
return self
def partial_transform(self, traj):
return md.shrake_rupley(traj, mode=self.mode, **self.kwargs)
