Reading large PDB files

From Biopython
Revision as of 08:52, 20 August 2009 by Orbeckst (Talk | contribs)
Jump to: navigation, search

If one is using Biopython to work with PDB files that have been produced by molecular dynamics (MD) codes then one quickly runs into problems with missing atoms on reading. The typical error message says that atoms will be missing:

WARNING: Residue (' ', 1, ' ') redefined at line 31.
PDBConstructionException: Blank altlocs in duplicate residue SOL (' ', 1, ' ') at line 31.
Exception ignored.
Some atoms or residues will be missing in the data structure.

The problem is simply that these files can be large with hundreds of thousand of atoms and residues (for instance, each water molecule is a separate residue) and the PDB format has not enough space in the appropriate columns of the ATOM or HETATM record to accommodate atom numbers (serial) >99,999 and residue numbers (resSeq) > 9999. Thus, these numbers are simply written modulo 100,000 (serial) or modulo 10,000 (resSeq). This creates duplicate entries in the chain and the Bio.PDB.PDBParser (or rather, the StructureBuilder) complains. The effect is that not all atoms are read.

The code below derives a new class from Bio.PDB.StructureBuilder.StructureBuilder that simply increases the resSeq if necessary. Because it is not very careful it is called a SloppyStructureBuilder.

There's also a new class named SloppyPDBIO that writes pdb files with serial and resSeq wrapped so that the resulting pdb files are legal PDB format.


Load a big pdb file and write it out again. How to do interesting things to the pdb file such as deleting some water molecules around a ligand is left for another article.

import Bio.PDB
import xpdb
# read
sloppyparser = Bio.PDB.PDBParser(PERMISSIVE=True,structure_builder=xpdb.SloppyStructureBuilder())
structure = sloppyparser.get_structure('MD_system','my_big_fat.pdb')
# ... do something here ...
# write
sloppyio = xpdb.SloppyPDBIO()


This is the python implementation. Store it as a module somewhere on your PYTHONPATH.

# -- extensions to Bio.PDB
# (c) 2009 Oliver Beckstein
# Relased under the same license as Biopython.
# See
import sys
import Bio.PDB
import Bio.PDB.StructureBuilder
class SloppyStructureBuilder(Bio.PDB.StructureBuilder.StructureBuilder):
    """Cope with resSeq < 10,000 limitation by just incrementing internally.
    # Q: What's wrong here??
    #   Some atoms or residues will be missing in the data structure.
    #   WARNING: Residue (' ', 8954, ' ') redefined at line 74803.
    #   PDBConstructionException: Blank altlocs in duplicate residue SOL (' ', 8954, ' ') at line 74803.
    # A: resSeq only goes to 9999 --> goes back to 0 (PDB format is not really good here)
    # NOTE/TODO:
    # - H and W records are probably not handled yet (don't have examples to test)
    def __init__(self,verbose=False):
        self.max_resseq = -1
        self.verbose = verbose
    def init_residue(self, resname, field, resseq, icode):
        Initiate a new Residue object.
        o resname - string, e.g. "ASN"
        o field - hetero flag, "W" for waters, "H" for 
            hetero residues, otherwise blanc.
        o resseq - int, sequence identifier
        o icode - string, insertion code
        if field!=" ":
            if field=="H":
                # The hetero field consists of H_ + the residue name (e.g. H_FUC)
        res_id=(field, resseq, icode)
        if resseq > self.max_resseq:
            self.max_resseq  = resseq
        if field==" ":
            fudged_resseq = False
            while (self.chain.has_id(res_id) or resseq == 0):
                # There already is a residue with the id (field, resseq, icode).
                # resseq == 0 catches already wrapped residue numbers which do not
                # trigger the has_id() test.
                # Be sloppy and just increment...
                # (This code will not leave gaps in resids... I think)
                # XXX: shouldn't we also do this for hetero atoms and water??
                self.max_resseq += 1
                resseq = self.max_resseq
                res_id = (field, resseq, icode)    # use max_resseq!
                fudged_resseq = True
            if fudged_resseq and self.verbose:
                sys.stderr.write("Residues are wrapping (Residue ('%s', %i, '%s') at line %i)." 
                                 % (field, resseq, icode, self.line_counter) +
                                 ".... assigning new resid %d.\n" % self.max_resseq)
        residue=Residue(res_id, resname, self.segid)
class SloppyPDBIO(Bio.PDB.PDBIO):
    """PDBIO class that can deal with large pdb files as used in MD simulations.
    - resSeq simply wrap and are printed modulo 10,000.
    - atom numbers wrap at 99,999 and are printed modulo 100,000    
    # directly copied from
    # (has to be copied because of the package layout it is not externally accessible)
    _ATOM_FORMAT_STRING="%s%5i %-4s%c%3s %c%4i%c   %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n"
    def _get_atom_line(self, atom, hetfield, segid, atom_number, resname, 
        resseq, icode, chain_id, element="  ", charge="  "):
        Returns an ATOM PDB string that is guaranteed to fit into the ATOM format.
        - Resid (resseq) is wrapped (modulo 10,000) to fit into %4i (4I) format
        - Atom number (atom_number) is wrapped (modulo 100,000) to fit into %4i (4I) format
        if hetfield!=" ":
            record_type="ATOM  "
        x, y, z=atom.get_coord()
        args=(record_type, atom_number % 100000, name, altloc, resname, chain_id,
            resseq % 10000, icode, x, y, z, occupancy, bfactor, segid,
            element, charge)
        return self._ATOM_FORMAT_STRING % args
# convenience functions
sloppyparser = Bio.PDB.PDBParser(PERMISSIVE=True,structure_builder=SloppyStructureBuilder())
def get_structure(pdbfile,pdbid='system'):
    return sloppyparser.get_structure(pdbid,pdbfile)
Personal tools