'''
Created on 7 Aug 2013
@author: jmht
Classes for holding data from PDB files
'''
import copy
import os
import types
[docs]class OriginInfo( object ):
def __init__(self, spaceGroupLabel=None ):
# These are reset on each call
self._spaceGroup = None
self._redundantSet = None
self._nonRedundantSet = None
self._floating = False
self._setData()
if spaceGroupLabel:
self._getAlternateOrigins(spaceGroupLabel)
return
def _setData(self):
# Non-redundant origins from:
# http://www.ccp4.ac.uk/dist/html/alternate_origins.html
# Organised in tuples, with True for the second item if the origin is one of the non-redundant set
self._origins = {
# TRICLINIC
'1aP' : [
( [ 'x', 'y', 'z' ], True ),
],
# MONOCLINIC
'2mP' : [
( [ 0.0, 'y', 0.0 ], True ),
( [ 0.0, 'y', 0.5 ], True ),
( [ 0.5, 'y', 0.0 ], True ),
( [ 0.5, 'y', 0.5 ], True ),
] ,
'2mC' : [
( [ 0.0, 'y', 0.0 ], True ),
( [ 0.0, 'y', 0.5 ], True ),
( [ 0.5, 'y', 0.0 ], False ),
( [ 0.5, 'y', 0.5 ], False ),
] ,
'2mA' : [
( [ 0.0, 'y', 0.0 ], True ),
( [ 0.0, 'y', 0.5 ], False ),
( [ 0.5, 'y', 0.0 ], True ),
( [ 0.5, 'y', 0.5 ], False ),
] ,
'2mI' : [
( [ 0.0, 'y', 0.0 ], True ),
( [ 0.0, 'y', 0.5 ], True ),
( [ 0.5, 'y', 0.0 ], False ),
( [ 0.5, 'y', 0.5 ], False ),
] ,
# ORTHORHOMBIC
'222oP' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
( [ 0.0, 0.5, 0.0 ], True ),
( [ 0.0, 0.5, 0.5 ], True ),
( [ 0.5, 0.0, 0.0 ], True ),
( [ 0.5, 0.0, 0.5 ], True ),
( [ 0.5, 0.5, 0.0 ], True ),
( [ 0.5, 0.5, 0.5 ], True ),
] ,
'222oC' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.5, 0.0 ], False ),
( [ 0.0, 0.5, 0.5 ], False ),
( [ 0.0, 0.0, 0.5 ], True ),
( [ 0.5, 0.0, 0.0 ], True ),
( [ 0.5, 0.0, 0.5 ], True ),
( [ 0.5, 0.5, 0.0 ], False ),
( [ 0.5, 0.5, 0.5 ], False ),
] ,
'222oF' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], False ),
( [ 0.0, 0.5, 0.0 ], False ),
( [ 0.0, 0.5, 0.5 ], False ),
( [ 0.25, 0.25, 0.25 ], True ),
( [ 0.25, 0.25, 0.75 ], False ),
( [ 0.25, 0.75, 0.25 ], False ),
( [ 0.25, 0.75, 0.75 ], False ),
( [ 0.5, 0.0, 0.0 ], False ),
( [ 0.5, 0.0, 0.5 ], False ),
( [ 0.5, 0.5, 0.0 ], False ),
( [ 0.5, 0.5, 0.5 ], True ),
( [ 0.75, 0.25, 0.25 ], False ),
( [ 0.75, 0.25, 0.75 ], False ),
( [ 0.75, 0.75, 0.25 ], False ),
( [ 0.75, 0.75, 0.75 ], True ),
] ,
'222oI' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
( [ 0.0, 0.5, 0.0 ], True ),
( [ 0.0, 0.5, 0.5 ], False ),
( [ 0.5, 0.0, 0.0 ], True ),
( [ 0.5, 0.0, 0.5 ], False ),
( [ 0.5, 0.5, 0.0 ], False ),
( [ 0.5, 0.5, 0.5 ], False ),
] ,
# TETRAGONAL
'4tP' : [
( [ 0.0, 0.0, 'z' ], True ),
( [ 0.5, 0.5, 'z' ], True ),
] ,
'4tI' : [
( [ 0.0, 0.0, 'z' ], True ),
( [ 0.5, 0.5, 'z' ], False ),
] ,
'422tP' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
( [ 0.5, 0.5, 0.0 ], True ),
( [ 0.5, 0.5, 0.5 ], True ),
] ,
'422tI' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
( [ 0.5, 0.5, 0.0 ], False ),
( [ 0.5, 0.5, 0.5 ], False ),
] ,
# TRIGONAL
'3hP' : [
( [ 0.0, 0.0, 'z' ], True ),
( [ float(1/3), float(2/3), 'z' ], True ),
( [ float(2/3), float(1/3), 'z' ], True ),
] ,
'3hR_1' : [
( [ 0.0, 0.0, 'z' ], True ),
( [float(1/3), float(2/3), 'z' ], False ),
( [float(2/3), float(1/3), 'z' ], False ),
] ,
'3hR_2' : [
( [ 'x', 'x', 'x' ], True ),
] ,
'312hP' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
( [ float(1/3), float(2/3), 0.0 ], True ),
( [ float(1/3), float(2/3), 0.5 ], True ),
( [ float(2/3), float(1/3), 0.0 ], True ),
( [ float(2/3), float(1/3), 0.5 ], True ),
] ,
'321hP' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
] ,
'32hR_1' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
( [ float(1/3), float(2/3), float(1/6) ], False ),
( [ float(1/3), float(2/3), float(2/3) ], False ),
( [ float(2/3), float(1/3), float(1/3) ], False ),
( [ float(2/3), float(1/3), float(5/6) ], False ),
] ,
'32hR_2' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.5, 0.5, 0.5 ], True ),
] ,
# HEXAGONAL
'6hP' : [
( [ 0.0, 0.0, 'z' ], True ),
] ,
'622hP' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], True ),
] ,
# CUBIC
'23cP' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.5, 0.5, 0.5 ], True ),
] ,
'23cF' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], False ),
( [ 0.0, 0.5, 0.0 ], False ),
( [ 0.0, 0.5, 0.5 ], False ),
( [ 0.25, 0.25, 0.25 ], True ),
( [ 0.25, 0.25, 0.75 ], False ),
( [ 0.25, 0.75, 0.25 ], False ),
( [ 0.25, 0.75, 0.75 ], False ),
( [ 0.5, 0.0, 0.0 ], False ),
( [ 0.5, 0.0, 0.5 ], False ),
( [ 0.5, 0.5, 0.0 ], False ),
( [ 0.5, 0.5, 0.5 ], True ),
( [ 0.75, 0.25, 0.25 ], False ),
( [ 0.75, 0.25, 0.75 ], False ),
( [ 0.75, 0.75, 0.25 ], False ),
( [ 0.75, 0.75, 0.75 ], True ),
] ,
'23cI' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.5, 0.5, 0.5 ], False ),
] ,
'432cP' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.5, 0.5, 0.5 ], True ),
] ,
'432cF' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.0, 0.0, 0.5 ], False ),
( [ 0.0, 0.5, 0.0 ], False ),
( [ 0.0, 0.5, 0.5 ], False ),
( [ 0.5, 0.0, 0.0 ], False ),
( [ 0.5, 0.0, 0.5 ], False ),
( [ 0.5, 0.5, 0.0 ], False ),
( [ 0.5, 0.5, 0.5 ], True ),
] ,
'432cI' : [
( [ 0.0, 0.0, 0.0 ], True ),
( [ 0.5, 0.5, 0.5 ], False ),
] ,
}
self._spacegroup2origin = {
# Primitive
'P1' : self._origins[ '1aP' ],
# MONOCLINIC
'P2' : self._origins[ '2mP' ],
'P21' : self._origins[ '2mP' ],
'C2' : self._origins[ '2mC' ],
'A2' : self._origins[ '2mA' ],
'I2' : self._origins[ '2mI' ],
# ORTHORHOMBIC
'P 2 2 2' : self._origins[ '222oP' ],
'P 21 2 2' : self._origins[ '222oP' ],
'P 2 21 2' : self._origins[ '222oP' ],
'P 2 2 21' : self._origins[ '222oP' ],
'P 2 21 21' : self._origins[ '222oP' ],
'P 21 2 21' : self._origins[ '222oP' ],
'P 21 21 2' : self._origins[ '222oP' ],
'P 21 21 21' : self._origins[ '222oP' ],
'C 2 2 21' : self._origins[ '222oC' ],
'C 2 2 2' : self._origins[ '222oC' ],
'F 2 2 2' : self._origins[ '222oF' ],
'I 2 2 2' : self._origins[ '222oI' ],
'I 21 21 21' : self._origins[ '222oI' ],
# TETRAGONAL
'P 4' : self._origins[ '4tP' ],
'P 41' : self._origins[ '4tP' ],
'P 42' : self._origins[ '4tP' ],
'P 43' : self._origins[ '4tP' ],
'I 4' : self._origins[ '4tI' ],
'I 41' : self._origins[ '4tI' ],
'P 4 2 2' : self._origins[ '422tP' ],
'P 4 21 2' : self._origins[ '422tP' ],
'P 41 2 2' : self._origins[ '422tP' ],
'P 41 21 2' : self._origins[ '422tP' ],
'P 42 2 2' : self._origins[ '422tP' ],
'P 42 21 2' : self._origins[ '422tP' ],
'P 43 2 2' : self._origins[ '422tP' ],
'P 43 21 2' : self._origins[ '422tP' ],
'I 4 2 2' : self._origins[ '422tI' ],
'I 41 2 2' : self._origins[ '422tI' ],
# TRIGONAL
'P 3' : self._origins[ '3hP' ],
'P 31' : self._origins[ '3hP' ],
'P 32' : self._origins[ '3hP' ],
'H 3' : self._origins[ '3hR_1' ],
'R 3' : self._origins[ '3hR_2' ],
'P 3 1 2' : self._origins[ '312hP' ],
'P 31 1 2' : self._origins[ '312hP' ],
'P 32 1 2' : self._origins[ '312hP' ],
'P 3 2 1' : self._origins[ '321hP' ],
'P 31 2 1' : self._origins[ '321hP' ],
'P 32 2 1' : self._origins[ '321hP' ],
'H 3 2' : self._origins[ '32hR_1' ],
'R 3 2' : self._origins[ '32hR_2' ],
# HEXAGONAL
'P 6' : self._origins[ '6hP' ],
'P 61' : self._origins[ '6hP' ],
'P 65' : self._origins[ '6hP' ],
'P 62' : self._origins[ '6hP' ],
'P 64' : self._origins[ '6hP' ],
'P 63' : self._origins[ '6hP' ],
'P 6 2 2' : self._origins[ '622hP' ],
'P 61 2 2' : self._origins[ '622hP' ],
'P 65 2 2' : self._origins[ '622hP' ],
'P 62 2 2' : self._origins[ '622hP' ],
'P 64 2 2' : self._origins[ '622hP' ],
'P 63 2 2' : self._origins[ '622hP' ],
# CUBIC
'P 2 3' : self._origins[ '23cP' ],
'P 21 3' : self._origins[ '23cP' ],
'F 2 3' : self._origins[ '23cF' ],
'I 2 3' : self._origins[ '23cI' ],
'I 21 3' : self._origins[ '23cI' ],
'P 4 3 2' : self._origins[ '432cP' ],
'P 42 3 2' : self._origins[ '432cP' ],
'P 43 3 2' : self._origins[ '432cP' ],
'P 41 3 2' : self._origins[ '432cP' ],
'F 4 3 2' : self._origins[ '432cF' ],
'F 41 3 2' : self._origins[ '432cF' ],
'I 4 3 2' : self._origins[ '432cI' ],
'I 41 3 2' : self._origins[ '432cI' ],
}
return
[docs] def spaceGroup(self):
return self._spaceGroup
[docs] def isFloating(self, spaceGroupLabel=None ):
if spaceGroupLabel is not None and self.spaceGroup() != spaceGroupLabel:
self._getAlternateOrigins( spaceGroupLabel )
return self._floating
[docs] def redundantAlternateOrigins(self, spaceGroupLabel=None ):
if spaceGroupLabel is not None and self.spaceGroup() != spaceGroupLabel:
self._getAlternateOrigins( spaceGroupLabel )
return copy.copy(self._redundantSet)
[docs] def nonRedundantAlternateOrigins(self, spaceGroupLabel=None ):
if spaceGroupLabel is not None and self.spaceGroup() != spaceGroupLabel:
self._getAlternateOrigins( spaceGroupLabel )
return copy.copy(self._nonRedundantSet)
def _getAlternateOrigins( self, spaceGroupLabel ):
"""Given a space group label, return a list of (non-redundant) alternate
origins as a list of float triples"""
label = spaceGroupLabel
if label not in self._spacegroup2origin:
label = self._altlabel( label )
self._spaceGroup = label
originl = self._spacegroup2origin[ label ]
# We build up a list of the full set (redundant) and also the non-redundant that are
# the only ones we need to loop through when we are checking
self._nonRedundantSet = []
self._redundantSet = []
self._floating = False
for o in originl:
if o[1]:
self._nonRedundantSet.append( o[0] )
self._redundantSet.append( o[0] )
self._floating = any( map( lambda o: 'x' in o or 'y' in o or 'z' in o, self._redundantSet ) )
return
#symoplib = "/Applications/ccp4-6.4.0/lib/data/symop.lib"
def _altlabel( self, spaceGroup, symoplib=None ):
if not symoplib:
symoplib = os.path.join( os.environ['CCP4'], "lib/data/symop.lib" )
for line in open( symoplib, 'r' ):
if "'" in line:
# Assume first single-quote enclosed string is the one we want
i = line.index( "'" )
j = line.index("'", i+1 )
sg = line[ i+1:j ]
if spaceGroup == sg:
return line.split()[ 3 ]
raise KeyError(spaceGroup)
[docs]class CrystalInfo(object):
def __init__(self, line=None):
"""foo"""
self._reset()
if line:
self.fromLine( line )
return
def _reset( self ):
self.a = None
self.b = None
self.c = None
self.alpha = None
self.beta = None
self.gamma = None
self.spaceGroup = None
self.z = None
return
[docs] def fromLine(self, line ):
self.a = float(line[6:15].strip())
self.b = float( line[15:24].strip() )
self.c = float( line[24:33].strip() )
self.alpha = float( line[33:40] )
self.beta = float( line[40:47] )
self.gamma = float( line[47:54] )
self.spaceGroup = line[55:66].strip()
try:
self.z = int( line[66:70] )
except ValueError:
# Z-info could be missing (shelxe output pdb)
pass
return
[docs]class PdbInfo(object):
"""A class to hold information extracted from a PDB file"""
def __init__(self ):
self.models = [] # List of PdbModel objects
self.pdbCode=None
self.title = None # First line of the title
self.resolution = None
# http://www.wwpdb.org/documentation/format33/remarks1.html#REMARK%20280
self.solventContent = None
self.matthewsCoefficient = None
self.crystalInfo = None
return
[docs] def getSequence(self):
"""Return the sequence for the first model/chain"""
assert len(self.models) >= 1,"Need at least one model!"
assert len(self.models[0].chains) >= 1,"Need at least one chain!"
return self.sequences[0]
[docs] def numAtoms(self, modelIdx=0):
"""Return the total number of ATOM atoms in the model"""
assert len(self.models) >= 1,"Need at least one model!"
assert len(self.models[modelIdx].chains) >= 1,"Need at least one chain!"
natoms = 0
for chainAtoms in self.models[ modelIdx ].atoms:
natoms += len( chainAtoms )
return natoms
[docs] def numChains(self, modelIdx=0):
"""Return the total number of chains in the model"""
assert len(self.models) >= 1,"Need at least one model!"
assert len(self.models[modelIdx].chains) >= 1,"Need at least one chain!"
return len(self.models[ modelIdx ].chains)
[docs] def numCalpha(self, modelIdx=0):
"""Return the total number of CA ATOM atoms in the model"""
assert len(self.models) >= 1,"Need at least one model!"
assert len(self.models[modelIdx].chains) >= 1,"Need at least one chain!"
ncalpha = 0
for chainAtoms in self.models[ modelIdx ].atoms:
for atom in chainAtoms:
if atom.name.strip() == 'CA':
ncalpha += 1
return ncalpha
[docs]class PdbModel(object):
"""A class to hold information on a single model in a PDB file"""
def __init__(self ):
self.pdb = None
self.serial = None
self.chains = [] # Ordered list of chain IDs
self.atoms = [] # List of atoms in each chain
self.resSeqs = [] # Ordered list of list of resSeqs for each chain - matches order in self.chains
self.sequences = [] # Ordered list of list of sequences for each chain - matches order in self.chains
self.caMask = [] # Ordered list of list of booleans of residues with no CA atoms - matches order in self.chains
self.bbMask = [] # Ordered list of list of boleans of residues with no backbone atoms - matches order in self.chains
return
[docs]class PdbAtom(object):
"""
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.
73 - 76 LString(4) segID Segment identifier, left-justified.
77 - 78 LString(2) element Element symbol, right-justified.
79 - 80 LString(2) charge Charge on the atom.
"""
def __init__(self, line=None):
"""Set up attributes"""
self._setAtomType()
if line:
self.fromLine( line )
return
def _setAtomType(self):
"""This gets overridden in HETATM - otherwise everything the same"""
self._atomType = "ATOM "
return
def _reset(self):
self.line = None # the line we were created from
self.serial = None
self.name = None
self.altLoc = None
self.resName = None
self.chainID = None
self.resSeq = None
self.iCode = None
self.x = None
self.y = None
self.z = None
self.occupancy = None
self.tempFactor = None
self.segID = None
self.element = None
self.charge = None
return
def _readCharge(self, line):
s = line[78:80]
minus = '-'
signs = ['+', minus]
mult = +1
if s[0] in signs:
sign = s[0]
val = s[1]
elif s[1] in signs:
sign = s[1]
val = s[0]
else:
raise RuntimeError("Error getting charge sign ({0}) from line: {1}".format(line[78:80], line))
if sign == minus:
mult = -1
try:
return int(val) * mult
except:
raise RuntimeError("Error getting charge ({0}) from line: {1}".format(line[78:80], line))
def _sanityCheck( self, line ):
assert line[0:6] == self._atomType, "Line did not begin with an {0} record!: {1}".format(self._atomType, line)
assert len(line) >= 54, "Line length was: {0}\n{1}".format(len(line),line)
[docs] def fromLine(self,line):
"""Initialise from the line from a PDB"""
self._sanityCheck(line)
self._reset()
self.line = line
self.serial = int(line[6:11])
self.name = line[12:16]
# Use for all so None means an empty field
if line[16].strip():
self.altLoc = line[16]
self.resName = line[17:20].strip()
if line[21].strip():
self.chainID = line[21]
if line[22:26].strip():
self.resSeq = int(line[22:26])
if line[26].strip():
self.iCode = line[26]
self.x = float(line[30:38])
self.y = float(line[38:46])
self.z = float(line[46:54])
if len(line) >= 60 and line[54:60].strip():
self.occupancy = float(line[54:60])
if len(line) >= 66 and line[60:66].strip():
self.tempFactor = float(line[60:66])
if len(line) >= 76 and line[72:76].strip():
self.segID = line[72:76].strip()
if len(line) >= 77 and line[76:78].strip():
self.element = line[76:78].strip()
if len(line) >= 80 and line[78:80].strip():
self.charge = self._readCharge(line)
return
[docs] def toLine(self):
"""Create a line suitable for printing to a PDB file"""
s = self._atomType # 1-6
s += "{0:5d}".format( self.serial ) # 7-11
s += " " # 12 blank
if len(self.name) != 4:
raise RuntimeError("Name must be 4 characters long!")
s += "{0:4}".format( self.name ) # 13-16
if not self.altLoc: #17
s += " "
else:
s += "{0:1}".format( self.altLoc )
s += "{0:3}".format( self.resName ) # 18-20
s += " " # 21 blank
if not self.chainID: #22
s += " "
else:
s += "{0:1}".format( self.chainID )
s += "{0:4}".format( self.resSeq ) #23-26
if not self.iCode: #27
s += " "
else:
s += "{0:1}".format( self.iCode )
s += " " # 28-30 blank
s += "{0:8.3F}".format( self.x ) #31-38
s += "{0:8.3F}".format( self.y ) #39-46
s += "{0:8.3F}".format( self.z ) #47-54
if not self.occupancy: # 55-60
s += " "
else:
s += "{0:6.2F}".format( self.occupancy )
if not self.tempFactor: # 61-66
s += " "
else:
s += "{0:6.2F}".format( self.tempFactor )
s += " " # 67-72 blank
if not self.segID: # 73-76
s += " "
else:
s += "{0:>4}".format( self.segID )
if not self.element: #77-78
s += " "
else:
s += "{0:>2}".format( self.element )
if not self.charge: #79-80
s += " "
else:
s += "{0:2d}".format( self.charge )
return s
[docs] def fromHetatm( self, hetatm ):
"""Create Atom from Hetatm"""
self.serial = hetatm.serial
self.name = hetatm.name
self.altLoc = hetatm.altLoc
self.resName = hetatm.resName
self.chainID = hetatm.chainID
self.resSeq = hetatm.resSeq
self.iCode = hetatm.iCode
self.x = hetatm.x
self.y = hetatm.y
self.z = hetatm.z
self.occupancy = hetatm.occupancy
self.tempFactor = hetatm.tempFactor
self.segID = hetatm.segID
self.element = hetatm.element
self.charge = hetatm.charge
return self
def __str__(self):
"""List the data attributes of this object"""
me = {}
for slot in dir(self):
attr = getattr(self, slot)
if not slot.startswith("__") and not ( isinstance(attr, types.MethodType) or
isinstance(attr, types.FunctionType) ):
me[slot] = attr
return "{0} : {1}".format(self.__repr__(),str(me))
[docs]class PdbHetatm( PdbAtom ):
"""Identical to PdbAtom but just with a different _atomType"""
def _setAtomType(self):
self._atomType = "HETATM"
return
[docs]class PdbModres(object):
"""
COLUMNS DATA TYPE FIELD DEFINITION
--------------------------------------------------------------------------------
1 - 6 Record name "MODRES"
8 - 11 IDcode idCode ID code of this entry.
13 - 15 Residue name resName Residue name used in this entry.
17 Character chainID Chain identifier.
19 - 22 Integer seqNum Sequence number.
23 AChar iCode Insertion code.
25 - 27 Residue name stdRes Standard residue name.
30 - 70 String comment Description of the residue modification.
"""
def __init__(self, line):
"""Set up attributes"""
self.fromLine( line )
def _reset(self):
self.idCode = None
self.resName = None
self.chainID = None
self.seqNum = None
self.iCode = None
self.stdRes = None
self.comment = None
return
[docs] def fromLine(self,line):
"""Initialise from the line from a PDB"""
assert line[0:6] == "MODRES","Line did not begin with an MODRES record!: {0}".format(line)
self._reset()
self.idCode = line[7:11]
self.resName = line[12:15].strip()
# Use for all so None means an empty field
if line[16].strip():
self.chainID = line[16]
self.seqNum = int(line[18:22])
if line[22].strip():
self.iCode = line[22]
self.stdRes = line[24:27].strip()
if line[29:70].strip():
self.comment = line[29:70].strip()
return
[docs] def toLine(self):
"""Create a line suitable for printing to a PDB file"""
s = "MODRES" # 1-6
s += " " # 7 blank
s += "{0:4}".format( self.idCode ) # 8-11
s += " " # 12 blank
s += "{0:>3}".format( self.resName ) # 13-15
s += " " # 16 blank
if not self.chainID: #17
s += " "
else:
s += "{0:1}".format( self.chainID )
s += " " # 18 blank
s += "{0:4d}".format( self.seqNum ) # 19-22
if not self.iCode: #23
s += " "
else:
s += "{0:1}".format( self.iCode )
s += " " # 24 blank
s += "{0:>3}".format( self.stdRes ) # 25-27
s += " " # 28-29 blank
if self.comment: # 30-70
s += "{:<}".format( self.comment )
return s
def __str__(self):
"""List the data attributes of this object"""
me = {}
for slot in dir(self):
attr = getattr(self, slot)
if not slot.startswith("__") and not ( isinstance(attr, types.MethodType) or
isinstance(attr, types.FunctionType) ):
me[slot] = attr
return "{0} : {1}".format(self.__repr__(),str(me))
