# IODATA is an input and output module for quantum chemistry.
# Copyright (C) 2011-2019 The IODATA Development Team
#
# This file is part of IODATA.
#
# IODATA is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 3
# of the License, or (at your option) any later version.
#
# IODATA is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>
# --
"""PDB file format.
There are different formats of pdb files. The convention used here is the
last updated one and is described in this link:
http://www.wwpdb.org/documentation/file-format-content/format33/v3.3.html
"""
from typing import TextIO, Iterator
import numpy as np
from ..docstrings import (document_load_one, document_load_many, document_dump_one,
document_dump_many)
from ..iodata import IOData
from ..periodic import sym2num, num2sym, bond2num
from ..utils import angstrom, LineIterator
__all__ = []
PATTERNS = ['*.pdb']
def _parse_pdb_atom_line(line, lit):
"""Parse an ATOM or HETATM line from a PDB file.
Parameters
----------
line
A string with a single ATOM or HETATM line.
lit
The line iterator which read the line, used for generating warnings when needed.
Returns
-------
atnum
Atomic number.
atname
The atom name.
resname
The residua name.
chainid
The chain ID.
resnum
The residue number.
atcoord
Cartesian coordinates of the atomic nucleus.
occupancy
The occupancy (usually from the XRD analysis).
bfactor
The temperature factor (usually from the XRD analysis).
"""
# Overview of ATOM records
# COLUMNS DATA TYPE FIELD DEFINITION
# -------------------------------------------------------------------------------------
# 1 - 6 Record name "ATOM "
# 7 - 11 Integer serial Atom serial number.
# 13 - 16 Atom name Atom name.
# 17 Character altLoc Alternate location indicator.
# 18 - 20 Residue name resName Residue name.
# 22 Character chainID Chain identifier.
# 23 - 26 Integer resSeq Residue sequence number.
# 27 AChar iCode Code for insertion of residues.
# 31 - 38 Real(8.3) x Orthogonal coordinates for X in Angstroms.
# 39 - 46 Real(8.3) y Orthogonal coordinates for Y in Angstroms.
# 47 - 54 Real(8.3) z Orthogonal coordinates for Z in Angstroms.
# 55 - 60 Real(6.2) occupancy Occupancy.
# 61 - 66 Real(6.2) tempFactor Temperature factor.
# 77 - 78 LString(2) element Element symbol, right-justified.
# 79 - 80 LString(2) charge Charge on the atom.
# Get element symbol from position 77:78 in pdb format
symbol = line[76:78].strip()
if len(symbol) > 0:
atnum = sym2num.get(symbol)
else:
# If not present, guess it from position 13:16 (atom name)
atname = line[12:16].strip()
atnum = sym2num.get(atname, sym2num.get(atname[:2].title(), sym2num.get(atname[0], None)))
lit.warn("Using the atom name in the PDB file to guess the chemical element.")
if atnum is None:
atnum = 0
lit.warn(f"Failed to determine the atomic number. atname='{atname}' symbol='{symbol}'")
# atom name, residue name, chain id, & residue sequence number
atname = line[12:16].strip()
resname = line[17:20].strip()
chainid = line[21]
resnum = int(line[22:26])
# add x, y, and z
atcoord = [
float(line[30:38]) * angstrom,
float(line[38:46]) * angstrom,
float(line[46:54]) * angstrom,
]
# get occupancies & temperature factor
occupancy = float(line[54:60])
bfactor = float(line[60:66])
return atnum, atname, resname, chainid, resnum, atcoord, occupancy, bfactor
def _parse_pdb_conect_line(line):
# Overview of CONECT records
# COLUMNS DATA TYPE FIELD DEFINITION
# -------------------------------------------------------------------------
# 1 - 6 Record name "CONECT"
# 7 - 11 Integer serial Atom serial number
# 12 - 16 Integer serial Serial number of bonded atom
# 17 - 21 Integer serial Serial number of bonded atom
# 22 - 26 Integer serial Serial number of bonded atom
# 27 - 31 Integer serial Serial number of bonded atom
iatom0 = int(line[7:12]) - 1
for ipos in 12, 17, 22, 27:
serial_str = line[ipos: ipos + 5].strip()
if serial_str != "":
iatom1 = int(serial_str) - 1
if iatom1 > iatom0:
yield iatom0, iatom1
[docs]@document_load_one("PDB", ['atcoords', 'atnums', 'atffparams', 'extra'], ['title', 'bonds'])
def load_one(lit: LineIterator) -> dict: # pylint: disable=too-many-branches, too-many-statements
"""Do not edit this docstring. It will be overwritten."""
title_lines = []
compnd_lines = []
atnums = []
attypes = []
restypes = []
chainids = []
resnums = []
atcoords = []
occupancies = []
bfactors = []
bonds = []
molecule_found = False
end_reached = False
while True:
try:
line = next(lit)
except StopIteration:
break
# If the PDB file has a title, replace the default.
if line.startswith("TITLE"):
title_lines.append(line[10:].strip())
if line.startswith("COMPND"):
compnd_lines.append(line[10:].strip())
if line.startswith("ATOM") or line.startswith("HETATM"):
(atnum, attype, restype, chainid, resnum, atcoord, occupancy,
bfactor) = _parse_pdb_atom_line(line, lit)
atnums.append(atnum)
attypes.append(attype)
restypes.append(restype)
chainids.append(chainid)
resnums.append(resnum)
atcoords.append(atcoord)
occupancies.append(occupancy)
bfactors.append(bfactor)
molecule_found = True
if line.startswith("CONECT"):
for iatom0, iatom1 in _parse_pdb_conect_line(line):
bonds.append([iatom0, iatom1, bond2num["un"]])
if line.startswith("END") and molecule_found:
end_reached = True
break
if not molecule_found:
lit.error("Molecule could not be read!")
if not end_reached:
lit.warn("The END is not found, but the parsed data is returned!")
# Data related to force fields
atffparams = {
"attypes": np.array(attypes),
"restypes": np.array(restypes),
"resnums": np.array(resnums),
}
# Extra data
extra = {
"occupancies": np.array(occupancies),
"bfactors": np.array(bfactors),
}
if len(compnd_lines) > 0:
extra["compound"] = "\n".join(compnd_lines)
# add chain id, if it wasn't all empty
if not np.all(chainids == [' '] * len(chainids)):
extra["chainids"] = np.array(chainids)
# Set a useful title
if len(title_lines) == 0:
# Some files use COMPND instead of TITLE, in which case COMPND will be
# used as title.
if "compound" in extra:
title = extra["compound"]
del extra["compound"]
else:
title = "PDB file loaded by IOData"
else:
title = "\n".join(title_lines)
result = {
'atcoords': np.array(atcoords),
'atnums': np.array(atnums),
'atffparams': atffparams,
'title': title,
'extra': extra,
}
# assign bonds only if some were present
if len(bonds) > 0:
result["bonds"] = np.array(bonds)
return result
[docs]@document_load_many("PDB", ['atcoords', 'atnums', 'atffparams', 'extra'], ['title'])
def load_many(lit: LineIterator) -> Iterator[dict]:
"""Do not edit this docstring. It will be overwritten."""
# PDB files with more molecules are a simple concatenation of individual PDB files,'
# making it trivial to load many frames.
while True:
try:
yield load_one(lit)
except IOError:
return
def _dump_multiline_str(f: TextIO, key: str, value: str):
r"""Write a multiline string in PDB format.
Parameters
----------
f
A file object to write to.
key
The key used to prefix the multiline string, e.g. `"TITLE"`.
value
A (multiline) string, with multiple lines separated by `\n`.
"""
prefix = key.ljust(10)
for iline, line in enumerate(value.split("\n")):
print(prefix + line, file=f)
prefix = key + str(iline + 2).rjust(10 - len(key)) + " "
[docs]@document_dump_one("PDB", ['atcoords', 'atnums', 'extra'], ['atffparams', 'title', 'bonds'])
def dump_one(f: TextIO, data: IOData):
"""Do not edit this docstring. It will be overwritten."""
_dump_multiline_str(f, "TITLE", data.title or "Created with IOData")
if "compound" in data.extra:
_dump_multiline_str(f, "COMPND", data.extra["compound"])
# Prepare for ATOM lines.
attypes = data.atffparams.get('attypes', None)
restypes = data.atffparams.get('restypes', None)
resnums = data.atffparams.get('resnums', None)
occupancies = data.extra.get('occupancies', None)
bfactors = data.extra.get('bfactors', None)
chainids = data.extra.get('chainids', None)
# Write ATOM lines.
for i in range(data.natom):
n = num2sym[data.atnums[i]]
resnum = -1 if resnums is None else resnums[i]
x, y, z = data.atcoords[i] / angstrom
occ = 1.00 if occupancies is None else occupancies[i]
b = 0.00 if bfactors is None else bfactors[i]
attype = str(n + str(i + 1)) if attypes is None else attypes[i]
restype = "XXX" if restypes is None else restypes[i]
chain = " " if chainids is None else chainids[i]
out1 = f'{i+1:>5d} {attype:<4s} {restype:3s} {chain:1s}{resnum:>4d} '
out2 = f'{x:8.3f}{y:8.3f}{z:8.3f}{occ:6.2f}{b:6.2f}{n:>12s}'
print("ATOM " + out1 + out2, file=f)
if data.bonds is not None:
# Prepare for CONECT lines.
connections = [[] for iatom in range(data.natom)]
for iatom0, iatom1 in data.bonds[:, :2]:
connections[iatom0].append(iatom1)
connections[iatom1].append(iatom0)
# Write CONECT lines.
for iatom0, iatoms1 in enumerate(connections):
if len(iatoms1) > 0:
# Write connection in groups of max 4
for ichunk in range(len(iatoms1) // 4 + 1):
other_atoms_str = "".join(
"{:5d}".format(iatom1 + 1)
for iatom1 in iatoms1[ichunk * 4:ichunk * 4 + 4])
conect_line = f"CONECT{iatom0 + 1:5d}{other_atoms_str}"
print(conect_line, file=f)
print("END", file=f)
[docs]@document_dump_many("PDB", ['atcoords', 'atnums', 'extra'], ['atffparams', 'title'])
def dump_many(f: TextIO, datas: Iterator[IOData]):
"""Do not edit this docstring. It will be overwritten."""
# Similar to load_many, this is relatively easy.
for data in datas:
dump_one(f, data)