def test_hbond_structure(pdb_id):
file_name = join(data_dir("structure"), pdb_id + ".mmtf")
array = load_structure(file_name)
# Only consider amino acids for consistency
# with bonded hydrogen detection in MDTraj
array = array[..., struc.filter_amino_acids(array)]
if isinstance(array, struc.AtomArrayStack):
# For consistency with MDTraj 'S' cannot be acceptor element
# https://github.com/mdtraj/mdtraj/blob/master/mdtraj/geometry/hbond.py#L365
triplets, mask = struc.hbond(array, acceptor_elements=("O", "N"))
else:
triplets = struc.hbond(array, acceptor_elements=("O", "N"))
# Save to new pdb file for consistent treatment of inscode/altloc
# im MDTraj
temp = NamedTemporaryFile("w+", suffix=".pdb")
save_structure(temp.name, array)
# Compare with MDTraj
import mdtraj
traj = mdtraj.load(temp.name)
temp.close()
triplets_ref = mdtraj.baker_hubbard(traj, freq=0, periodic=False)
# Both packages may use different order
# -> use set for comparison
triplets_set = set([tuple(tri) for tri in triplets])
triplets_ref_set = set([tuple(tri) for tri in triplets_ref])
assert triplets_set == triplets_ref_set
def write_atom_to_pdb(pdb_outname, atom_location, atom_ID, atomgroup):
"""
Write a new atom to a reference structure to visualise conserved non-protein atom sites.
Parameters
----------
pdb_outname : str
Filename of reference structure.
atom_location : array
(x,y,z) coordinates of the atom location with respect to the reference structure.
atom_ID : str
A unique ID for the atom.
atomgroup : str
MDAnalysis atomgroup to describe the atom.
"""
##PDB_VISUALISATION
##rescursively add waters to the pdb file one by one as they are processed
# # Read the file into Biotite's structure object (atom array)
atom_array = strucio.load_structure(pdb_outname)
res_id = atom_array.res_id[-1] + 1
# Add an HETATM
atom = struc.Atom(
coord=atom_location,
chain_id="X",
# The residue ID is the last ID in the file +1
res_id=res_id,
res_name=atom_ID,
hetero=True,
atom_name=atomgroup,
element="O")
atom_array += struc.array([atom])
# Save edited structure
strucio.save_structure(pdb_outname, atom_array)
def test_dihedral_backbone_result(file_name):
import mdtraj
mmtf_file = mmtf.MMTFFile.read(file_name)
array = mmtf.get_structure(mmtf_file, model=1)
array = array[struc.filter_amino_acids(array)]
if array.array_length() == 0:
# Structure contains no protein
# -> determination of backbone angles makes no sense
return
for chain in struc.chain_iter(array):
print("Chain: ", chain.chain_id[0])
if len(struc.check_res_id_continuity(chain)) != 0:
# Do not test discontinuous chains
return
test_phi, test_psi, test_ome = struc.dihedral_backbone(chain)
temp = NamedTemporaryFile("w+", suffix=".pdb")
strucio.save_structure(temp.name, chain)
traj = mdtraj.load(temp.name)
temp.close()
_, ref_phi = mdtraj.compute_phi(traj)
_, ref_psi = mdtraj.compute_psi(traj)
_, ref_ome = mdtraj.compute_omega(traj)
ref_phi, ref_psi, ref_ome = ref_phi[0], ref_psi[0], ref_ome[0]
assert test_phi[1:] == pytest.approx(ref_phi, abs=1e-5, rel=5e-3)
assert test_psi[:-1] == pytest.approx(ref_psi, abs=1e-5, rel=5e-3)
assert test_ome[:-1] == pytest.approx(ref_ome, abs=1e-5, rel=5e-3)
def test_saving(suffix):
"""
Check if loading a structure from a file written via
:func:`save_structure()` gives the same result as the input to
:func:`save_structure()`.
"""
path = join(data_dir("structure"), "1l2y.mmtf")
ref_array = strucio.load_structure(path)
if suffix in ("trr", "xtc", "tng", "dcd", "netcdf"):
# Reading a trajectory file requires a template
template = path
else:
template = None
temp = NamedTemporaryFile("w", suffix=f".{suffix}", delete=False)
strucio.save_structure(temp.name, ref_array)
temp.close()
test_array = strucio.load_structure(temp.name, template)
os.remove(temp.name)
for category in ref_array.get_annotation_categories():
if category == "chain_id" and suffix == "gro":
# The chain ID is not written to GRO files
continue
assert test_array.get_annotation(category).tolist() \
== ref_array.get_annotation(category).tolist()
assert test_array.coord.flatten().tolist() == pytest.approx(
ref_array.coord.flatten().tolist(), abs=1e-2)
def create(pdb_id, directory, include_gro):
# Create *.pdb", *.cif and *.mmtf
for file_format in ["pdb", "cif", "mmtf"]:
rcsb.fetch(pdb_id, file_format, directory, overwrite=True)
try:
array = strucio.load_structure(join(directory, pdb_id + ".pdb"))
except biotite.InvalidFileError:
# Structure probably contains multiple models with different
# number of atoms
# -> Cannot load AtomArrayStack
# -> Skip writing GRO and NPZ file
return
# Create *.gro file
strucio.save_structure(join(directory, pdb_id + ".npz"), array)
# Create *.gro files using GROMACS
# Clean PDB file -> remove inscodes and altlocs
if include_gro:
cleaned_file_name = biotite.temp_file("pdb")
strucio.save_structure(cleaned_file_name, array)
# Run GROMACS for file conversion
subprocess.run([
"editconf", "-f", cleaned_file_name, "-o",
join(directory, pdb_id + ".gro")
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
def test_dihedral_backbone_result(file_name):
import mdtraj
mmtf_file = mmtf.MMTFFile()
mmtf_file.read(file_name)
array = mmtf.get_structure(mmtf_file, model=1)
array = array[struc.filter_amino_acids(array)]
for chain in struc.chain_iter(array):
print("Chain: ", chain.chain_id[0])
if len(struc.check_id_continuity(chain)) != 0:
# Do not test discontinuous chains
return
test_phi, test_psi, test_ome = struc.dihedral_backbone(chain)
temp_file_name = biotite.temp_file("pdb")
strucio.save_structure(temp_file_name, chain)
traj = mdtraj.load(temp_file_name)
_, ref_phi = mdtraj.compute_phi(traj)
_, ref_psi = mdtraj.compute_psi(traj)
_, ref_ome = mdtraj.compute_omega(traj)
ref_phi, ref_psi, ref_ome = ref_phi[0], ref_psi[0], ref_ome[0]
assert test_phi[1:] == pytest.approx(ref_phi, abs=1e-5, rel=5e-3)
assert test_psi[:-1] == pytest.approx(ref_psi, abs=1e-5, rel=5e-3)
assert test_ome[:-1] == pytest.approx(ref_ome, abs=1e-5, rel=5e-3)
def test_saving_with_extra_args(suffix):
"""
Test if giving a wrong optional parameter to
:func:`save_structure()` raises a :class:`TypeError`
"""
array = strucio.load_structure(join(data_dir("structure"), "1l2y.mmtf"))
temp = NamedTemporaryFile("w+", suffix=f".{suffix}")
with pytest.raises(TypeError):
strucio.save_structure(temp.name, array, answer=42)
temp.close()
def test_small_molecule():
"""
Check if loading a small molecule file written via
:func:`save_structure()` gives the same result as the input to
:func:`save_structure()`.
"""
path = join(data_dir("structure"), "molecules", "TYR.sdf")
ref_array = strucio.load_structure(path)
temp = NamedTemporaryFile("w", suffix=".sdf", delete=False)
strucio.save_structure(temp.name, ref_array)
temp.close()
test_array = strucio.load_structure(temp.name)
os.remove(temp.name)
assert test_array == ref_array
def create(pdb_id, directory, include_gro):
# Create *.pdb", *.cif and *.mmtf
for file_format in ["pdb", "cif", "mmtf"]:
rcsb.fetch(pdb_id, file_format, directory)
if include_gro:
# Create *.gro files using GROMACS
# Clean PDB file -> remove inscodes and altlocs
array = strucio.load_structure(join(directory, pdb_id + ".pdb"))
cleaned_file_name = biotite.temp_file("pdb")
strucio.save_structure(cleaned_file_name, array)
# Run GROMACS for file conversion
subprocess.run([
"gmx", "editconf", "-f", cleaned_file_name, "-o",
join(directory, pdb_id + ".gro")
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
def test_gro_id_overflow():
# Create an oversized AtomArray where atom_id > 100000 and res_id > 10000
num_atoms = 100005
atoms = array([
Atom([1, 2, 3],
atom_name="CA",
element="C",
res_name="X",
res_id=i + 1) for i in range(num_atoms)
])
atoms.box = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
# Write .gro file
tmp_file_name = biotite.temp_file(".gro")
io.save_structure(tmp_file_name, atoms)
# Read .gro file
gro_file = gro.GROFile.read(tmp_file_name)
s = gro_file.get_structure()
assert s.array_length() == num_atoms
def test_gro_no_box():
"""
.gro file format requires valid box parameters at the end of each
model. However, if we read such a file in, the resulting object should not
have an assigned box.
"""
# Create an AtomArray
atom = Atom([1, 2, 3], atom_name="CA", element="C", res_name="X", res_id=1)
atoms = array([atom])
# Write .gro file
tmp_file_name = biotite.temp_file(".gro")
io.save_structure(tmp_file_name, atoms)
# Read in file
gro_file = gro.GROFile.read(tmp_file_name)
s = gro_file.get_structure()
# Assert no box with 0 dimension
assert s.box is None
def get_water_features(structure_input,
xtc_input,
atomgroup,
grid_wat_model=None,
grid_input=None,
top_waters=30,
write=None,
pdb_vis=True):
u = mda.Universe(structure_input, xtc_input)
if pdb_vis is True:
protein = u.select_atoms("protein")
pdb_outname = structure_input[0:-4] + "_WaterSites.pdb"
u.trajectory[0]
protein.write(pdb_outname)
if grid_input is None:
density_atomgroup = u.select_atoms("name " + atomgroup)
# a resolution of delta=1.0 ensures the coordinates of the maxima match the coordinates of the simulation box
D = DensityAnalysis(density_atomgroup, delta=1.0)
D.run()
if grid_wat_model is not None:
D.density.convert_density(grid_wat_model)
D.density.export(structure_input[:-4] + atomgroup + "_density.dx",
type="double")
grid_input = atomgroup + "_density.dx"
g = D.density
else:
g = Grid(grid_input)
xyz, val = local_maxima_3D(g.grid)
##negate the array to get descending order from most prob to least prob
val_sort = np.argsort(-1 * val.copy())
coords = [xyz[i] for i in val_sort]
maxdens_coord_str = [str(item)[1:-1] for item in coords]
water_frequencies = []
if top_waters > len(coords):
top_waters = len(coords)
print('\n')
print('Featurizing ', top_waters, ' Waters')
for wat_no in range(top_waters):
print('\n')
print('Water no: ', wat_no)
print('\n')
philist = []
psilist = []
###extracting (psi,phi) coordinates for each water dipole specific to the frame they are bound
counting = []
for frame_no in tqdm(range(len(u.trajectory))):
# for frame_no in tqdm(range(100)):
u.trajectory[frame_no]
##list all water oxygens within sphere of radius X centered on water prob density maxima
radius = ' 3.5'
atomgroup_IDS = u.select_atoms('name ' + atomgroup +
' and point ' +
maxdens_coord_str[wat_no] +
radius).indices
counting.append(atomgroup_IDS)
##making a list of the water IDs that appear in the simulation in that pocket
flat_list = [item for sublist in counting for item in sublist]
###extracting (psi,phi) coordinates for each water dipole specific to the frame they are bound
# for frame_no in tqdm(range(100)):
for frame_no in tqdm(range(len(u.trajectory))):
u.trajectory[frame_no]
waters_resid = counting[frame_no]
##extracting the water coordinates for inside the pocket
if len(waters_resid) == 1:
##(x,y,z) positions for the water atom (residue) at frame i
water_atom_positions = [
list(pos)
for pos in u.select_atoms('byres index ' +
str(waters_resid[0])).positions
]
psi, phi = get_dipole(water_atom_positions)
psilist.append(psi)
philist.append(phi)
##if multiple waters in pocket then use water with largest frequency of pocket occupation
elif len(waters_resid) > 1:
freq_count = []
for ID in waters_resid:
freq_count.append([flat_list.count(ID), ID])
freq_count.sort(key=lambda x: x[0])
water_atom_positions = [
list(pos)
for pos in u.select_atoms('byres index ' +
str(freq_count[-1][1])).positions
]
psi, phi = get_dipole(water_atom_positions)
psilist.append(psi)
philist.append(phi)
##10000.0 = no waters bound
elif len(waters_resid) < 1:
psilist.append(10000.0)
philist.append(10000.0)
water_out = [psilist, philist]
water_ID = "O" + str(wat_no + 1)
water_pocket_occupation_frequency = 1 - psilist.count(10000.0) / len(
psilist)
atom_location = coords[wat_no] + g.origin
water_frequencies.append(
[water_ID, atom_location, water_pocket_occupation_frequency])
##WRITE OUT WATER FEATURES INTO SUBDIRECTORY
if write is True:
if not os.path.exists('water_features/'):
os.makedirs('water_features/')
filename = 'water_features/' + structure_input[
0:-4] + water_ID + '.txt'
with open(filename, 'w') as output:
for row in water_out:
output.write(str(row)[1:-1] + '\n')
##PDB_VISUALISATION
##rescursively add waters to the pdb file one by one as they are processed
if pdb_vis is True:
# # Read the file into Biotite's structure object (atom array)
atom_array = strucio.load_structure(pdb_outname)
# Shifting the coordinates by the grid origin
atom_location = coords[wat_no] + g.origin
# Add an HETATM
atom = struc.Atom(
coord=atom_location,
chain_id="W",
# The residue ID is the last ID in the file +1
res_id=atom_array.res_id[-1] + 1,
res_name=water_ID,
hetero=True,
atom_name=atomgroup,
element="O")
atom_array += struc.array([atom])
# Save edited structure
strucio.save_structure(pdb_outname, atom_array)
if pdb_vis is True:
u_pdb = mda.Universe(pdb_outname)
u_pdb.add_TopologyAttr('tempfactors')
# Write values as beta-factors ("tempfactors") to a PDB file
for res in range(len(water_frequencies)):
#scale the water resid by the starting resid
water_resid = len(u_pdb.residues) - top_waters + res
u_pdb.residues[water_resid].atoms.tempfactors = water_frequencies[
res][2]
u_pdb.atoms.write(pdb_outname)
if write is True:
filename = 'water_features/' + structure_input[
0:-4] + 'WaterPocketFrequencies.txt'
with open(filename, 'w') as output:
for row in water_frequencies:
output.write(str(row)[1:-1] + '\n')
return water_frequencies
def test_saving_with_extra_args(suffix):
array = strucio.load_structure(join(data_dir, "1l2y.mmtf"))
with pytest.raises(TypeError):
strucio.save_structure(biotite.temp_file("1l2y." + suffix),
array,
answer=42)
def test_saving(suffix):
array = strucio.load_structure(join(data_dir, "1l2y.mmtf"))
strucio.save_structure(biotite.temp_file("1l2y." + suffix), array)
mode_vectors = vectors[MODE].reshape((-1, 3))
# Rescale, so that the largest vector has the length 'MAX_AMPLITUDE'
vector_lenghts = np.sqrt(np.sum(mode_vectors**2, axis=-1))
scale = MAX_AMPLITUDE / np.max(vector_lenghts)
mode_vectors *= scale
# Stepwise application of eigenvectors as smooth sine oscillation
time = np.linspace(0, 2 * np.pi, FRAMES, endpoint=False)
deviation = np.sin(time)[:, newaxis, newaxis] * mode_vectors
# Apply oscillation of CA atom to all atoms in the corresponding residue
oscillation = np.zeros((FRAMES, len(protein_chain), 3))
residue_starts = struc.get_residue_starts(
protein_chain,
# The last array element will be the length of the atom array,
# i.e. no valid index
add_exclusive_stop=True)
for i in range(len(residue_starts) - 1):
res_start = residue_starts[i]
res_stop = residue_starts[i + 1]
oscillation[:, res_start:res_stop, :] \
= protein_chain.coord[res_start:res_stop, :] + deviation[:, i:i+1, :]
# An atom array stack containing all frames
oscillating_structure = struc.from_template(protein_chain, oscillation)
# Save as PDB for rendering a video with PyMOL
temp = NamedTemporaryFile(suffix=".pdb")
strucio.save_structure(temp.name, oscillating_structure)
# biotite_static_image = normal_modes.gif
temp.close()
leaflet_masks[i] = struc.get_residue_masks(structure, head_leaflet) \
.any(axis=0)
return leaflet_masks
# Suppress warning that elements were guessed,
# as this PDB file omits the 'chemical element' column
with warnings.catch_warnings():
warnings.simplefilter("ignore")
structure = strucio.load_structure(PDB_FILE_PATH)
# We cannot go over periodic boundaries in this case,
# because the input PDB does not define a box -> periodic=False
# However, as we have a planer lipid bilayer,
# periodicity should not matter
leaflets = find_leaflets(
structure,
head_atom_mask=(structure.res_name == "DPP") & (structure.atom_name == "P")
)
# Bilayer -> Expect two leaflets
assert len(leaflets) == 2
# Mark leaflets using different chain IDs
for chain_id, leaflet_mask in zip(("A", "B"), leaflets):
structure.chain_id[leaflet_mask] = chain_id
# Save marked lipids to structure file
temp = NamedTemporaryFile(suffix=".pdb")
strucio.save_structure(temp.name, structure)
# Visualization with PyMOL...
temp.close()
# Since programmers are usually lazy and do not want to write more code
# than necessary, there are two convenient function for loading and
# saving atom arrays or stacks, unifying the forementioned file formats:
# :func:`load_structure()` takes a file path and outputs an array
# (or stack, if the files contains multiple models).
# Internally, this function uses the appropriate :class:`File` class,
# depending on the file format.
# The analogous :func:`save_structure()` function provides a shortcut for
# writing to structure files.
# The desired file format is inferred from the the extension of the
# provided file name.
import biotite.structure.io as strucio
stack_from_pdb = strucio.load_structure(pdb_file_path)
stack_from_cif = strucio.load_structure(cif_file_path)
strucio.save_structure(biotite.temp_file("cif"), stack_from_pdb)
########################################################################
# Reading trajectory files
# ^^^^^^^^^^^^^^^^^^^^^^^^
#
# If the package *MDtraj* is installed *Biotite* provides a read/write
# interface for different trajectory file formats.
# More information can be found in the API reference.
#
# Array indexing and filtering
# ----------------------------
#
# .. currentmodule:: biotite.structure
#
# Atom arrays and stacks can be indexed in a similar way a
& (peptide.atom_name == "O"))[0][0]
coord_oxt = calculate_atom_coord_by_z_rotation(peptide.coord[index_c],
peptide.coord[index_o],
connect_angle, C_O_LENGTH)
coord_hxt = calculate_atom_coord_by_z_rotation(coord_oxt,
peptide.coord[index_c],
connect_angle, O_H_LENGTH)
atom_oxt = struc.Atom(coord_oxt,
chain_id="A",
res_id=last_id,
res_name=peptide[index_c].res_name,
atom_name="OXT",
element="O")
atom_hxt = struc.Atom(coord_hxt,
chain_id="A",
res_id=last_id,
res_name=peptide[index_c].res_name,
atom_name="HXT",
element="H")
peptide = peptide + struc.array([atom_oxt, atom_hxt])
peptide.bonds.add_bond(index_c, -2, struc.BondType.SINGLE) # C-OXT
peptide.bonds.add_bond(-2, -1, struc.BondType.SINGLE) # OXT-HXT
return peptide
sequence = seq.ProteinSequence("TITANITE")
atom_array = assemble_peptide(sequence)
strucio.save_structure(biotite.temp_file("mmtf"), atom_array)
# Visualization with PyMOL...
# biotite_static_image = peptide_assembly.png
assemblies = pdbx.list_assemblies(pdbx_file)
print("ID name")
print()
for assembly_id, name in assemblies.items():
print(f"{assembly_id:2} {name}")
########################################################################
# ``'complete icosahedral assembly'`` sounds good.
# In fact, often the first assembly is the complete one.
# Hence, the :func:`get_assembly()` function builds the first assembly
# by default.
# Since we know the ID we want (``'1'``), we will provide it to this
# function anyway.
# It returns the chosen assembly as :class:`AtomArray`.
# Note that the assembly ID is a string, not an integer.
biological_unit = pdbx.get_assembly(pdbx_file, assembly_id="1", model=1)
print("Number of protein chains:", struc.get_chain_count(biological_unit))
########################################################################
# Now we could do some analysis on the biological unit.
# But for this example we will simply save the entire assembly as *PDB*
# file for later visualization.
# For brevity, save only CA atoms to file for visualization
biological_unit = biological_unit[biological_unit.atom_name == "CA"]
temp = NamedTemporaryFile(suffix=".cif")
strucio.save_structure(temp.name, biological_unit)
# Visualization with PyMOL...
temp.close()
def test_saving(suffix):
array = strucio.load_structure(join(data_dir("structure"), "1l2y.mmtf"))
temp = NamedTemporaryFile("w+", suffix=f".{suffix}")
strucio.save_structure(temp.name, array)
temp.close()
# saving atom arrays or stacks, unifying the forementioned file formats: # :func:`load_structure()` takes a file path and outputs an array # (or stack, if the file contains multiple models). # Internally, this function uses the appropriate :class:`File` class, # depending on the file format. # The analogous :func:`save_structure()` function provides a shortcut # for writing to structure files. # The desired file format is inferred from the the extension of the # provided file name. import biotite.structure.io as strucio stack_from_pdb = strucio.load_structure(pdb_file_path) stack_from_cif = strucio.load_structure(cif_file_path) temp_file = NamedTemporaryFile(suffix=".cif") strucio.save_structure(temp_file.name, stack_from_pdb) temp_file.close() ######################################################################## # Reading trajectory files # ^^^^^^^^^^^^^^^^^^^^^^^^ # # If the package *MDtraj* is installed, *Biotite* provides a read/write # interface for different trajectory file formats. # All supported trajectory formats have in common, that they store # only coordinates. # These can be extracted as :class:`ndarray` with the # :func:`get_coord()` method. from tempfile import NamedTemporaryFile import requests
def test_saving_with_extra_args(suffix):
array = strucio.load_structure(join(data_dir("structure"), "1l2y.mmtf"))
temp = NamedTemporaryFile("w+", suffix=f".{suffix}")
with pytest.raises(TypeError):
strucio.save_structure(temp.name, array, answer=42)
temp.close()
def get_atom_features(structure_input,
xtc_input,
atomgroup,
element,
grid_input=None,
top_atoms=None,
write=None,
pdb_vis=True,
grid_write=None):
u = mda.Universe(structure_input, xtc_input)
if pdb_vis is True:
protein = u.select_atoms("protein")
pdb_outname = structure_input[0:-4] + "_IonSites.pdb"
u.trajectory[0]
protein.write(pdb_outname)
## The density will be obtained from the universe which depends on the .xtc and .gro
if grid_input is None:
density_atomgroup = u.select_atoms("name " + atomgroup)
D = DensityAnalysis(density_atomgroup, delta=1.0)
D.run()
if grid_write is not None:
D.density.convert_density("Angstrom^{-3}")
D.density.export(structure_input[:-4] + atomgroup + "_density.dx",
type="double")
grid_input = atomgroup + "_density.dx"
g = D.density
else:
g = Grid(grid_input)
##converting the density to a probability
atom_number = len(u.select_atoms('name ' + atomgroup))
grid_data = np.array(g.grid) * atom_number / np.sum(np.array(g.grid))
##mask all probabilities below the average water probability
average_probability_density = atom_number / sum(
1 for i in grid_data.flat if i)
##mask all grid centers with density less than threshold density
grid_data[grid_data <= average_probability_density] = 0.0
xyz, val = local_maxima_3D(grid_data)
##negate the array to get descending order from most prob to least prob
val_sort = np.argsort(-1 * val.copy())
# values = [val[i] for i in val_sort]
coords = [xyz[i] for i in val_sort]
maxdens_coord_str = [str(item)[1:-1] for item in coords]
atom_frequencies = []
if top_atoms is None:
top_atoms = len(coords)
elif top_atoms > len(coords):
top_atoms = len(coords)
print('\n')
print('Featurizing ', top_atoms, ' Atoms')
for atom_no in range(top_atoms):
print('\n')
print('Atom no: ', atom_no)
print('\n')
counting = []
for i in tqdm(range(len(u.trajectory))):
# for i in tqdm(range(100)):
u.trajectory[i]
##list all water resids within sphere of radius 2 centered on water prob density maxima
atomgroup_IDS = list(
u.select_atoms('name ' + atomgroup + ' and point ' +
maxdens_coord_str[atom_no] + ' 2').indices)
##select only those resids that have all three atoms within the water pocket
if len(atomgroup_IDS) == 0:
atomgroup_IDS = [-1]
counting.append(atomgroup_IDS)
atom_ID = element + str(atom_no + 1)
pocket_occupation_frequency = 1 - counting.count(-1) / len(counting)
atom_location = coords[atom_no] + g.origin
atom_frequencies.append(
[atom_ID, atom_location, pocket_occupation_frequency])
##PDB_VISUALISATION
##rescursively add waters to the pdb file one by one as they are processed
if pdb_vis is True:
# # Read the file into Biotite's structure object (atom array)
atom_array = strucio.load_structure(pdb_outname)
# Shifting the coordinates by the grid origin
atom_location = coords[atom_no] + g.origin
# Add an HETATM
atom = struc.Atom(
coord=atom_location,
chain_id="W",
# The residue ID is the last ID in the file +1
res_id=atom_array.res_id[-1] + 1,
res_name=atom_ID,
hetero=True,
atom_name=atomgroup,
element=element)
atom_array += struc.array([atom])
# Save edited structure
strucio.save_structure(pdb_outname, atom_array)
if pdb_vis is True:
u_pdb = mda.Universe(pdb_outname)
u_pdb.add_TopologyAttr('tempfactors')
# Write values as beta-factors ("tempfactors") to a PDB file
for res in range(len(atom_frequencies)):
atom_resid = len(u_pdb.residues) - top_atoms + res
u_pdb.residues[atom_resid].atoms.tempfactors = atom_frequencies[
res][2]
u_pdb.atoms.write(pdb_outname)
if write is True:
if not os.path.exists('atom_features/'):
os.makedirs('atom_features/')
filename = 'atom_features/PocketFrequencies.txt'
with open(filename, 'w') as output:
for row in atom_frequencies:
output.write(str(row)[1:-1] + '\n')
return atom_frequencies
assert (trajectory_kinase_left.coord.shape[0] > 0)
# Get simulation time for plotting purposes
time = xtc_file.get_time()
time = 10**(-3) * time
#ind_stable = np.where(time == 75)[0][0]
#print(" stable after 75ns which is frame[" +str(ind_stable) + "] ")
print("start time is ::" + str(time[0]))
print("end time is :: " + str(time[-1]))
print(" ... writing start frame ...")
frame_start = template_model.copy()
frame_start.coord = trajectory[0].coord
save_structure("frame_start_coord.pdb", frame_start)
save_structure("frame_start.pdb", trajectory[0])
print(" ... done ... ")
print(" ... writing frame[1] ... ")
frame_1 = template_model.copy()
frame_1.coord = trajectory[1].coord
save_structure("frame_1_coord.pdb", frame_1)
save_structure("frame_1.pdb", trajectory[1])
print(" ... done ... ")
print(" ... writing end frame ...")
frame_end = template_model.copy()
frame_end.coord = trajectory[-1].coord
save_structure("frame_end_coord.pdb", frame_end)
save_structure("frame_end.pdb", trajectory[-1])
peptide.coord[index_o],
connect_angle, C_O_LENGTH)
coord_hxt = calculate_atom_coord_by_z_rotation(coord_oxt,
peptide.coord[index_c],
connect_angle, O_H_LENGTH)
atom_oxt = struc.Atom(coord_oxt,
chain_id="A",
res_id=last_id,
res_name=peptide[index_c].res_name,
atom_name="OXT",
element="O")
atom_hxt = struc.Atom(coord_hxt,
chain_id="A",
res_id=last_id,
res_name=peptide[index_c].res_name,
atom_name="HXT",
element="H")
peptide = peptide + struc.array([atom_oxt, atom_hxt])
peptide.bonds.add_bond(index_c, -2, struc.BondType.SINGLE) # C-OXT
peptide.bonds.add_bond(-2, -1, struc.BondType.SINGLE) # OXT-HXT
return peptide
sequence = seq.ProteinSequence("TITANITE")
atom_array = assemble_peptide(sequence)
out_file = NamedTemporaryFile(suffix=".mmtf", delete=False)
strucio.save_structure(out_file.name, atom_array)
# Visualization with PyMOL...
out_file.close()
