def buildPdb(map_dict,
npts,
name='DlgBuilt',
ctr=0,
outputfile='results.pdb',
scale=1.0):
if debug: print "in buildPdb: tolerance=", tolerance
name = 'DlgBuilt'
mol = Protein(name=name)
mol.curChain = Chain()
mol.chains = ChainSet([mol.curChain])
mol.curRes = Residue()
mol.curChain.adopt(mol.curRes)
mol.allAtoms = AtomSet()
mol.curRes.atoms = mol.allAtoms
nzpts = nypts = nxpts = npts
#nxpts, nypts, nzpts = npts
ctr = 0
for ADtype, m in map_dict.items():
if debug:
print "PROCESSING ", ADtype, " array:", max(m.ravel()), ':', min(
m.ravel())
vals = []
tctr = 0 #for number of each type
for z in range(nzpts):
for y in range(nypts):
for x in range(nxpts):
val = scale * abs(m[x, y, z])
vals.append(val)
#if abs(val)>.005:
if val > tolerance * scale:
ctr += 1
name = ADtype + str(ctr)
#version3:
#info_lo = (xcen - numxcells*spacing,
# ycen - numycells*spacing,
# zcen - numzcells *spacing)
#using lower back pt of cube, i think
#xcoord = (x-info_lo[0])/spacing
#ycoord = (y-info_lo[1])/spacing
#zcoord = (z-info_lo[2])/spacing
#version2:
xcoord = (x - numxcells) * spacing + xcen
ycoord = (y - numycells) * spacing + ycen
zcoord = (z - numzcells) * spacing + zcen
coords = (xcoord, ycoord, zcoord)
tctr += 1
# #print "addAtom: name=",name,"ADtype=", ADtype," val=", val, "coords=", coords,"ctr=", ctr
addAtom(mol, name, ADtype, val, coords, ctr)
print "added ", tctr, '<-', ADtype, " atoms"
if debug:
print ADtype, ':', tctr, ' ', ctr
print "total atoms=", ctr
writer = PdbWriter()
writer.write(outputfile, mol.allAtoms, records=['ATOM'])
def parse_PDB_atoms(self, atoms):
#name = '/home/ktchan/pmvproject/debug.txt'
#self.f = open(name, 'w')
self.mol.curChain = Chain()
self.mol.curRes = Residue()
self.mol.levels = [Protein, Chain, Residue, Atom]
cid = self.get_Field_Value(atoms[0], 'chainID')
if cid: # we know the chains
atm = list(filter(lambda x, cid = cid, f = self.get_Field_Value:
f(x, 'chainID')==cid, atoms))
else: atm = atoms # assume they are all of one chain
list(map( self.parse_PDB_ATOM_record,atm))
if cid: # only if we know the chains
atoms = list(filter(lambda x, cid = cid, f = self.get_Field_Value:
f(x, 'chainID')!=cid, atoms))
if len(atoms)>0: self.parse_PDB_atoms(atoms)
def getMolecule(self, molInd):
molecules = []
if molInd == len(self.molIndex) - 1:
lastLine = -1
else:
lastLine = self.molIndex[molInd + 1]
# lines fotr that molecule
lines = self.allLines[self.molIndex[molInd]:lastLine]
lineIndex = 0
atomsSeen = {} # dict of atom types and number of atoms seen
# parser header
molName = lines[lineIndex].strip()
lineIndex += 3
# create molecule
mol = Protein(name=molName)
mol.info = lines[lineIndex + 1]
mol.comment = lines[lineIndex + 1]
#self.mol.parser = self
chain = Chain(id='1', parent=mol, top=mol)
res = Residue(type='UNK', number='1', parent=chain, top=mol)
mol.levels = [Protein, Chain, Residue, Atom]
# parse count line
line = lines[lineIndex]
assert line[
33:
39] == " V2000", "Format error: only V2000 is suported, got %s" % line[
33:39]
nba = int(line[0:3]) # number of atoms
nbb = int(line[3:6]) # number of bonds
nbal = int(line[6:9]) # number of atom lists
ccc = int(line[12:15]) # chiral flag: 0=not chiral, 1=chiral
sss = int(line[15:18]) # number of stext entries
lineIndex += 1
# parse atoms
for anum in range(nba):
line = lines[lineIndex]
element = line[31:34].strip()
if element in atomsSeen:
atomsSeen[element] += 1
else:
atomsSeen[element] = 1
atom = Atom(name='%s_%s' % (element, atomsSeen[element]),
parent=res,
chemicalElement=element,
top=mol)
atom._coords = [[
float(line[0:10]),
float(line[10:20]),
float(line[20:30])
]]
atom._charges['sdf'] = int(line[35:38])
atom.chargeSet = 'sdf'
mol.allAtoms.append(atom)
atom.massDiff = int(line[34:36])
atom.stereo = int(line[38:41])
atom.hcount = line[41:44]
atom.valence = int(line[47:50])
atom.hetatm = 1
atom.occupancy = 0.0
atom.temperatureFactor = 0.0
lineIndex += 1
# parse bonds
for bnum in range(nba):
line = lines[lineIndex]
at1 = mol.allAtoms[int(line[0:3]) - 1]
at2 = mol.allAtoms[int(line[3:6]) - 1]
if at1.isBonded(at2): continue
bond = Bond(at1, at2, check=0)
bond.bondOrder = int(line[6:9])
#1 = Single, 2 = Double,
#3 = Triple, 4 = Aromatic,
#5 = Single or Double,
#6 = Single or Aromatic,
#7 = Double or Aromatic, 8 = Any
bond.stereo = int(line[9:12])
#Single bonds: 0 = not stereo,
#1 = Up, 4 = Either,
#6 = Down, Double bonds: 0 = Use x-, y-, z-coords
#from atom block to determine cis or trans,
#3 = Cis or trans (either) double bond
bond.topo = int(line[15:18])
# 0 = Either, 1 = Ring, 2 = Chain
try:
bond.ReactionCenter = int(line[18:21])
except ValueError:
bond.ReactionCenter = 0
#0 = unmarked, 1 = a center, -1 = not a center,
#Additional: 2 = no change,
#4 = bond made/broken,
#8 = bond order changes
#12 = 4+8 (both made/broken and changes);
#5 = (4 + 1), 9 = (8 + 1), and 13 = (12 + 1)
# "M END" and properties are not parsed at this point
self.mol = mol
mname = mol.name
strRpr = mname + ':::'
mol.allAtoms.setStringRepr(strRpr)
strRpr = mname + ':'
mol.chains.setStringRepr(strRpr)
for c in mol.chains:
cname = c.id
strRpr = mname + ':' + cname + ':'
c.residues.setStringRepr(strRpr)
for r in c.residues:
rname = r.name
strRpr = mname + ':' + cname + ':' + rname + ':'
r.atoms.setStringRepr(strRpr)
molList = mol.setClass()
molList.append(mol)
mol.parser = self
for n in molList.name:
name = n + ','
name = name[:-1]
molList.setStringRepr(name)
strRpr = name + ':::'
molList.allAtoms.setStringRepr(strRpr)
return molList
def parse( self, objClass=Protein ):
if self.allLines is None and self.filename:
self.readFile()
if self.allLines is None or len(self.allLines)==0:
return
mol = Protein()
self.mol = mol
molList = mol.setClass()
molList.append( mol )
current_residue_number = None
current_chain = None
current_residue = None
number_of_atoms = int(self.allLines[1][:5])
self.configureProgressBar( init=1, mode='increment',
authtext='parse atoms', max=number_of_atoms )
current_chain = Chain( id='GRO',)
#FIX this: The existence of allAtoms attribute (and the fact that it is an empty set rather than all atoms in the chain) causes getNodesByMolecule() to return wrong values
if hasattr(current_chain, "allAtoms"):
del(current_chain.allAtoms)
#current_chain = Chain( id='GRO',parent = mol)
mol.adopt( current_chain, setChildrenTop=1 )
for index in range( 2,number_of_atoms+2 ):
residue_number = int(self.allLines[index][:5])
if residue_number!=current_residue_number:#
#current_chain should adopt the current residue if there is one
#create new residue
res_type = self.allLines[index][5:10]
residue_type = res_type.split(' ')[0]
current_residue = Residue( type=residue_type, number=residue_number )
current_residue_number = residue_number
if current_residue is not None: #REMEMBER TO ADOPT THE LAST ONE!!!
current_chain.adopt( current_residue, setChildrenTop=1 )
n = self.allLines[index][10:15]
name = n.split(' ')[-1]
element = name
if element in babel_elements.keys():
element = element
else:
if residue_type == "System" or residue_type == "SOL":
#if element[1] == 'W':
# element = 'H'
# group is treated as one particle
#else:
element = element[0]
elif element[:2] == 'Me':
element = 'C'
else:
element = element[0]
#if len(element)>1:
# if type(element[1]) == types.StringType:
#
# if element[1] == element[1].lower():
# element =element
# else:
# element = element[0]
#
# else:
# element = element[0]
atom = Atom( name, current_residue, element, top=mol )
c = self.allLines[index][15:20]
cx = self.allLines[index][20:28]
cy = self.allLines[index][28:36]
cz = self.allLines[index][36:44]
x = float(cx)*10
y = float(cy)*10
z = float(cz)*10
atom._coords = [[x, y, z]]
atom._charges = []
atom.segID = mol.name
atom.normalname = name
atom.number = int(self.allLines[index][15:20])
atom.elementType = name[0]
mol.atmNum[atom.number] = atom
atom.altname = None
atom.hetatm = 0
mol.name = os.path.split(os.path.splitext(self.filename)[0])[-1]
mol.allAtoms = mol.chains.residues.atoms
mol.parser = self
mol.levels = [Protein, Chain, Residue, Atom]
name = ''
for n in molList.name:
name = n + ','
name = name[:-1]
molList.setStringRepr( name )
strRpr = name + ':::'
molList.allAtoms.setStringRepr( strRpr )
for m in molList:
mname = m.name
strRpr = mname + ':::'
m.allAtoms.setStringRepr( strRpr )
strRpr = mname + ':'
m.chains.setStringRepr( strRpr )
for c in m.chains:
cname = c.id
strRpr = mname + ':' + cname + ':'
c.residues.setStringRepr( strRpr )
for r in c.residues:
rname = r.name
strRpr = mname + ':' + cname + ':' + rname + ':'
r.atoms.setStringRepr( strRpr )
return molList
def parse(self, objClass=Protein):
"""Parses mmCIF dictionary (self.mmCIF_dict) into MolKit object"""
if self.allLines is None and self.filename:
self.readFile()
if self.allLines is None or len(self.allLines)==0:
return
self.mmCIF2Dict()
type_symbol = None
B_iso_or_equiv = None
mmCIF_dict = self.mmCIF_dict
fileName, fileExtension = os.path.splitext(self.filename)
molName = os.path.basename(fileName)
if mmCIF_dict.has_key('_entry.id'):
molName = mmCIF_dict['_entry.id']
if mmCIF_dict.has_key('_atom_site.id'):
#The description of the data names can be found in the following link
#http://mmcif.pdb.org/dictionaries/mmcif_pdbx.dic/Items
ids = mmCIF_dict['_atom_site.id'] #1 number
group_PDB = mmCIF_dict['_atom_site.group_PDB'] #2 atom/hetatm
atom_id = mmCIF_dict['_atom_site.label_atom_id'] #3 name
comp_id = mmCIF_dict['_atom_site.label_comp_id'] #4 residue type
label_asym_id = mmCIF_dict['_atom_site.label_asym_id'] #5 chain
#Note: chain ID from mmCIF file might be different from PDB file
seq_id = mmCIF_dict['_atom_site.label_seq_id'] #6 residue number
x_coords = mmCIF_dict['_atom_site.Cartn_x'] #7 xcoord
y_coords = mmCIF_dict['_atom_site.Cartn_y'] #8 ycoord
z_coords = mmCIF_dict['_atom_site.Cartn_z'] #9 zcoord
occupancy = mmCIF_dict['_atom_site.occupancy'] #10
B_iso_or_equiv = mmCIF_dict['_atom_site.B_iso_or_equiv']#11
type_symbol = mmCIF_dict['_atom_site.type_symbol']
elif mmCIF_dict.has_key('_atom_site_label'):
#ftp://ftp.iucr.org/pub/cif_core.dic
atom_id = mmCIF_dict['_atom_site_label']
len_atoms = len(atom_id)
ids = range(len_atoms)
group_PDB = len_atoms*['HETATM']
comp_id = len_atoms*["CIF"]
label_asym_id = len_atoms*['1']
seq_id = len_atoms*[1]
from mglutil.math.crystal import Crystal
a = mmCIF_dict['_cell.length_a'] = float(mmCIF_dict['_cell_length_a'].split('(')[0])
b = mmCIF_dict['_cell.length_b'] = float(mmCIF_dict['_cell_length_b'].split('(')[0])
c = mmCIF_dict['_cell.length_c'] = float(mmCIF_dict['_cell_length_c'].split('(')[0])
alpha = mmCIF_dict['_cell.angle_alpha'] = float(mmCIF_dict['_cell_angle_alpha'].split('(')[0])
beta = mmCIF_dict['_cell.angle_beta'] = float(mmCIF_dict['_cell_angle_beta'].split('(')[0])
gamma = mmCIF_dict['_cell.angle_gamma'] = float(mmCIF_dict['_cell_angle_gamma'].split('(')[0])
cryst = Crystal((a, b, c), (alpha, beta, gamma))
x = []
for item in mmCIF_dict['_atom_site_fract_x']:
x.append(float(item.split('(')[0]))
y = []
for item in mmCIF_dict['_atom_site_fract_y']:
y.append(float(item.split('(')[0]))
z = []
for item in mmCIF_dict['_atom_site_fract_z']:
z.append(float(item.split('(')[0]))
x_coords = []
y_coords = []
z_coords = []
B_iso_or_equiv = []
for i in ids:
trans = cryst.toCartesian([x[i], y[i], z[i]])
x_coords.append(trans[0])
y_coords.append(trans[1])
z_coords.append(trans[2])
if mmCIF_dict.has_key('_atom_site_U_iso_or_equiv'):
B_iso_or_equiv.append(mmCIF_dict['_atom_site_U_iso_or_equiv'][i].split('(')[0])
if mmCIF_dict.has_key('_atom_site_type_symbol'):
type_symbol = mmCIF_dict['_atom_site_type_symbol']
if mmCIF_dict.has_key('_atom_site_occupancy'):
occupancy = mmCIF_dict['_atom_site_occupancy']
if mmCIF_dict.has_key('_chemical_name_common'):
molName = mmCIF_dict['_chemical_name_common']
elif mmCIF_dict.has_key('_chemical_name_mineral'):
molName = mmCIF_dict['_chemical_name_mineral']
if mmCIF_dict.has_key('_symmetry_space_group_name_H-M'):
mmCIF_dict['_symmetry.space_group_name_H-M'] = mmCIF_dict['_symmetry_space_group_name_H-M']
else:
print 'No _atom_site.id or _atom_site_label record is available in %s' % self.filename
return None
mol = Protein()
self.mol = mol
self.mol.allAtoms = AtomSet([])
molList = mol.setClass()
molList.append( mol )
current_chain_id = None
current_residue_number = None
current_chain = None
current_residue = None
number_of_atoms = len(ids)
self.configureProgressBar(init=1, mode='increment',
authtext='parse atoms', max=number_of_atoms)
for index in range(number_of_atoms):
#make a new atom for the current index
chain_id = label_asym_id[index]
if chain_id != current_chain_id: #make a new chain
#molecule should adopt the current chain if there is one
current_chain = Chain(id=chain_id)
# FIXME: current_chain should not have allAtoms attribute
delattr(current_chain, "allAtoms")
current_chain_id = chain_id
if current_chain is not None: #REMEMBER TO ADOPT THE LAST ONE!!!
mol.adopt(current_chain, setChildrenTop=1)
residue_number = seq_id[index]
if residue_number != current_residue_number or chain_id != label_asym_id[index-1]: #make a new chain:
#current_chain should adopt the current residue if there is one
#create new residue
residue_type = comp_id[index]
current_residue = Residue(type=residue_type, number=residue_number)
current_residue_number = residue_number
if current_residue is not None: #REMEMBER TO ADOPT THE LAST ONE!!!
current_chain.adopt(current_residue, setChildrenTop=1)
name = atom_id[index]
if type_symbol:
element = type_symbol[index]
else:
element = None
atom = Atom( name, current_residue, element, top=mol )
atom._coords = [[float(x_coords[index]), float(y_coords[index]), float(z_coords[index])]]
atom._charges = {}
atom.segID = mol.name
atom.normalname = name
atom.number = int(ids[index])
mol.atmNum[atom.number] = atom
atom.occupancy = float(occupancy[index])
if B_iso_or_equiv:
atom.temperatureFactor = float(B_iso_or_equiv[index])
atom.altname = None
atom.hetatm = 0
if group_PDB[index]=='HETATM':
atom.hetatm = 1
self.updateProgressBar()
self.parse_MMCIF_CELL()
try:
self.parse_MMCIF_HYDBND()
except:
print >>sys.stderr,"Parsing Hydrogen Bond Record Failed in",self.filename
mol.name = molName
mol.allAtoms = mol.chains.residues.atoms
mol.parser = self
mol.levels = [Protein, Chain, Residue, Atom]
name = ''
for n in molList.name:
name = n + ','
name = name[:-1]
molList.setStringRepr(name)
strRpr = name + ':::'
molList.allAtoms.setStringRepr(strRpr)
for m in molList:
mname = m.name
strRpr = mname + ':::'
m.allAtoms.setStringRepr(strRpr)
strRpr = mname + ':'
m.chains.setStringRepr(strRpr)
for c in m.chains:
cname = c.id
strRpr = mname + ':' + cname + ':'
c.residues.setStringRepr(strRpr)
for r in c.residues:
rname = r.name
strRpr = mname + ':' + cname + ':' + rname + ':'
r.atoms.setStringRepr(strRpr)
self.buildBonds()
return molList
def makeMoleculeFromAtoms(molname, atomSet):
"""
create a new molecule from a list of atoms
mol <- makeMoleculeFromAtoms(molname, atomSet)
"""
from MolKit.molecule import Atom, AtomSet
from MolKit.protein import Protein, Chain, Residue
# create the top object
mol = Protein(name=molname)
# find out all residues
residues = atomSet.parent.uniq()
# find out all chains
chains = residues.parent.uniq()
# create all chains
chainsd = {}
for c in chains:
newchain = Chain(c.id, mol, top=mol)
chainsd[c] = newchain
# create all residues
resd = {}
for res in residues:
newres = Residue(res.name[:3],
res.name[3:],
res.icode,
chainsd[res.parent],
top=mol)
resd[res] = newres
newres.hasCA = 0
newres.hasO = 0
# create all the atoms
newats = []
for num, at in enumerate(atomSet):
name = at.name
res = resd[at.parent]
name1 = name
if hasattr(at, "altname") and at.altname != None:
name = at.name.split("@")[0]
if name == 'CA':
res.hasCA = 1
if name == 'O' or name == 'OXT' or (len(name) > 3
and name[:3] == 'OCT'):
res.hasO = 2
newat = Atom(name, res, at.element, top=mol)
if name != name1:
newat.name = name1
newat.altname = at.altname
newats.append(newat)
# set constructotr attributes
newat._coords = []
for coords in at._coords:
newat._coords.append(coords[:])
newat.conformation = at.conformation
newat.chemElem = at.chemElem
newat.atomicNumber = at.atomicNumber
newat.bondOrderRadius = at.bondOrderRadius
newat.covalentRadius = at.covalentRadius
newat.vdwRadius = at.vdwRadius
newat.maxBonds = at.maxBonds
newat.organic = at.organic
newat.colors = at.colors.copy()
newat.opacities = at.opacities.copy()
newat._charges = at._charges.copy()
newat.chargeSet = at.chargeSet
# set attributes from PDB parser
try: # pdbqs do not have this
newat.segID = at.segID
except AttributeError:
pass
newat.hetatm = at.hetatm
try: # pdbqs do not have this
newat.normalname = at.normalname
except AttributeError:
pass
newat.number = num #at.number
newat.occupancy = at.occupancy
newat.temperatureFactor = at.temperatureFactor
newat.altname = at.altname
# attribute created by PQR parser
if hasattr(at, 'pqrRadius'):
newat.pqrRadius = at.pqrRadius
# attribute created by F2D parser
if hasattr(at, 'hbstatus'):
newat.hbstatus = at.hbstatus
# attribute created by PDBQ parser
if hasattr(at, 'autodock_element'):
newat.autodock_element = at.autodock_element
# attribute created by PDBQT parser
#if hasattr(at, ''):
# newat. = at.
# attribute created by PDBQS parser
if hasattr(at, 'AtVol'):
newat.AtVol = at.AtVol
newat.AtSolPar = at.AtSolPar
mol.allAtoms = AtomSet(newats)
return mol
def parse(self, objClass=Protein):
"""Parses mmCIF dictionary (self.mmCIF_dict) into MolKit object"""
if self.allLines is None and self.filename:
self.readFile()
if self.allLines is None or len(self.allLines) == 0:
return
self.mmCIF2Dict()
type_symbol = None
B_iso_or_equiv = None
mmCIF_dict = self.mmCIF_dict
fileName, fileExtension = os.path.splitext(self.filename)
molName = os.path.basename(fileName)
if mmCIF_dict.has_key('_entry.id'):
molName = mmCIF_dict['_entry.id']
if mmCIF_dict.has_key('_atom_site.id'):
#The description of the data names can be found in the following link
#http://mmcif.pdb.org/dictionaries/mmcif_pdbx.dic/Items
ids = mmCIF_dict['_atom_site.id'] #1 number
group_PDB = mmCIF_dict['_atom_site.group_PDB'] #2 atom/hetatm
atom_id = mmCIF_dict['_atom_site.label_atom_id'] #3 name
comp_id = mmCIF_dict['_atom_site.label_comp_id'] #4 residue type
label_asym_id = mmCIF_dict['_atom_site.label_asym_id'] #5 chain
#Note: chain ID from mmCIF file might be different from PDB file
seq_id = mmCIF_dict['_atom_site.label_seq_id'] #6 residue number
x_coords = mmCIF_dict['_atom_site.Cartn_x'] #7 xcoord
y_coords = mmCIF_dict['_atom_site.Cartn_y'] #8 ycoord
z_coords = mmCIF_dict['_atom_site.Cartn_z'] #9 zcoord
occupancy = mmCIF_dict['_atom_site.occupancy'] #10
B_iso_or_equiv = mmCIF_dict['_atom_site.B_iso_or_equiv'] #11
type_symbol = mmCIF_dict['_atom_site.type_symbol']
elif mmCIF_dict.has_key('_atom_site_label'):
#ftp://ftp.iucr.org/pub/cif_core.dic
atom_id = mmCIF_dict['_atom_site_label']
len_atoms = len(atom_id)
ids = range(len_atoms)
group_PDB = len_atoms * ['HETATM']
comp_id = len_atoms * ["CIF"]
label_asym_id = len_atoms * ['1']
seq_id = len_atoms * [1]
from mglutil.math.crystal import Crystal
a = mmCIF_dict['_cell.length_a'] = float(
mmCIF_dict['_cell_length_a'].split('(')[0])
b = mmCIF_dict['_cell.length_b'] = float(
mmCIF_dict['_cell_length_b'].split('(')[0])
c = mmCIF_dict['_cell.length_c'] = float(
mmCIF_dict['_cell_length_c'].split('(')[0])
alpha = mmCIF_dict['_cell.angle_alpha'] = float(
mmCIF_dict['_cell_angle_alpha'].split('(')[0])
beta = mmCIF_dict['_cell.angle_beta'] = float(
mmCIF_dict['_cell_angle_beta'].split('(')[0])
gamma = mmCIF_dict['_cell.angle_gamma'] = float(
mmCIF_dict['_cell_angle_gamma'].split('(')[0])
cryst = Crystal((a, b, c), (alpha, beta, gamma))
x = []
for item in mmCIF_dict['_atom_site_fract_x']:
x.append(float(item.split('(')[0]))
y = []
for item in mmCIF_dict['_atom_site_fract_y']:
y.append(float(item.split('(')[0]))
z = []
for item in mmCIF_dict['_atom_site_fract_z']:
z.append(float(item.split('(')[0]))
x_coords = []
y_coords = []
z_coords = []
B_iso_or_equiv = []
for i in ids:
trans = cryst.toCartesian([x[i], y[i], z[i]])
x_coords.append(trans[0])
y_coords.append(trans[1])
z_coords.append(trans[2])
if mmCIF_dict.has_key('_atom_site_U_iso_or_equiv'):
B_iso_or_equiv.append(
mmCIF_dict['_atom_site_U_iso_or_equiv'][i].split(
'(')[0])
if mmCIF_dict.has_key('_atom_site_type_symbol'):
type_symbol = mmCIF_dict['_atom_site_type_symbol']
if mmCIF_dict.has_key('_atom_site_occupancy'):
occupancy = mmCIF_dict['_atom_site_occupancy']
if mmCIF_dict.has_key('_chemical_name_common'):
molName = mmCIF_dict['_chemical_name_common']
elif mmCIF_dict.has_key('_chemical_name_mineral'):
molName = mmCIF_dict['_chemical_name_mineral']
if mmCIF_dict.has_key('_symmetry_space_group_name_H-M'):
mmCIF_dict['_symmetry.space_group_name_H-M'] = mmCIF_dict[
'_symmetry_space_group_name_H-M']
else:
print 'No _atom_site.id or _atom_site_label record is available in %s' % self.filename
return None
mol = Protein()
self.mol = mol
self.mol.allAtoms = AtomSet([])
molList = mol.setClass()
molList.append(mol)
current_chain_id = None
current_residue_number = None
current_chain = None
current_residue = None
number_of_atoms = len(ids)
self.configureProgressBar(init=1,
mode='increment',
authtext='parse atoms',
max=number_of_atoms)
for index in range(number_of_atoms):
#make a new atom for the current index
chain_id = label_asym_id[index]
if chain_id != current_chain_id: #make a new chain
#molecule should adopt the current chain if there is one
current_chain = Chain(id=chain_id)
# FIXME: current_chain should not have allAtoms attribute
delattr(current_chain, "allAtoms")
current_chain_id = chain_id
if current_chain is not None: #REMEMBER TO ADOPT THE LAST ONE!!!
mol.adopt(current_chain, setChildrenTop=1)
residue_number = seq_id[index]
if residue_number != current_residue_number or chain_id != label_asym_id[
index - 1]: #make a new chain:
#current_chain should adopt the current residue if there is one
#create new residue
residue_type = comp_id[index]
current_residue = Residue(type=residue_type,
number=residue_number)
current_residue_number = residue_number
if current_residue is not None: #REMEMBER TO ADOPT THE LAST ONE!!!
current_chain.adopt(current_residue, setChildrenTop=1)
name = atom_id[index]
if type_symbol:
element = type_symbol[index]
else:
element = None
atom = Atom(name, current_residue, element, top=mol)
atom._coords = [[
float(x_coords[index]),
float(y_coords[index]),
float(z_coords[index])
]]
atom._charges = {}
atom.segID = mol.name
atom.normalname = name
atom.number = int(ids[index])
mol.atmNum[atom.number] = atom
atom.occupancy = float(occupancy[index])
if B_iso_or_equiv:
atom.temperatureFactor = float(B_iso_or_equiv[index])
atom.altname = None
atom.hetatm = 0
if group_PDB[index] == 'HETATM':
atom.hetatm = 1
self.updateProgressBar()
self.parse_MMCIF_CELL()
try:
self.parse_MMCIF_HYDBND()
except:
print >> sys.stderr, "Parsing Hydrogen Bond Record Failed in", self.filename
mol.name = molName
mol.allAtoms = mol.chains.residues.atoms
mol.parser = self
mol.levels = [Protein, Chain, Residue, Atom]
name = ''
for n in molList.name:
name = n + ','
name = name[:-1]
molList.setStringRepr(name)
strRpr = name + ':::'
molList.allAtoms.setStringRepr(strRpr)
for m in molList:
mname = m.name
strRpr = mname + ':::'
m.allAtoms.setStringRepr(strRpr)
strRpr = mname + ':'
m.chains.setStringRepr(strRpr)
for c in m.chains:
cname = c.id
strRpr = mname + ':' + cname + ':'
c.residues.setStringRepr(strRpr)
for r in c.residues:
rname = r.name
strRpr = mname + ':' + cname + ':' + rname + ':'
r.atoms.setStringRepr(strRpr)
self.buildBonds()
return molList
def parse(self, objClass=Protein):
if self.allLines is None and self.filename:
self.readFile()
if self.allLines is None or len(self.allLines) == 0:
return
mol = Protein()
self.mol = mol
molList = mol.setClass()
molList.append(mol)
current_residue_number = None
current_chain = None
current_residue = None
number_of_atoms = int(self.allLines[1][:5])
self.configureProgressBar(init=1,
mode='increment',
authtext='parse atoms',
max=number_of_atoms)
current_chain = Chain(id='GRO', )
# FIX this: The existence of allAtoms attribute (and the fact that it is an empty set rather than all atoms in
# the chain) causes getNodesByMolecule() to return wrong values
if hasattr(current_chain, "allAtoms"):
del current_chain.allAtoms
# current_chain = Chain( id='GRO',parent = mol)
mol.adopt(current_chain, setChildrenTop=1)
for index in range(2, number_of_atoms + 2):
residue_number = int(self.allLines[index][:5])
if residue_number != current_residue_number: #
# current_chain should adopt the current residue if there is one
# create new residue
res_type = self.allLines[index][5:10]
residue_type = res_type.split(' ')[0]
current_residue = Residue(type=residue_type,
number=residue_number)
current_residue_number = residue_number
if current_residue is not None: # REMEMBER TO ADOPT THE LAST ONE!!!
current_chain.adopt(current_residue, setChildrenTop=1)
n = self.allLines[index][10:15]
name = n.split(' ')[-1]
element = name
if element in list(babel_elements.keys()):
element = element
else:
if residue_type == "System" or residue_type == "SOL":
# if element[1] == 'W':
# element = 'H'
# group is treated as one particle
# else:
element = element[0]
elif element[:2] == 'Me':
element = 'C'
else:
element = element[0]
# if len(element)>1:
# if type(element[1]) == types.StringType:
#
# if element[1] == element[1].lower():
# element =element
# else:
# element = element[0]
#
# else:
# element = element[0]
atom = Atom(name, current_residue, element, top=mol)
c = self.allLines[index][15:20]
cx = self.allLines[index][20:28]
cy = self.allLines[index][28:36]
cz = self.allLines[index][36:44]
x = float(cx) * 10
y = float(cy) * 10
z = float(cz) * 10
atom._coords = [[x, y, z]]
atom._charges = []
atom.segID = mol.name
atom.normalname = name
atom.number = int(self.allLines[index][15:20])
atom.elementType = name[0]
mol.atmNum[atom.number] = atom
atom.altname = None
atom.hetatm = 0
mol.name = os.path.split(os.path.splitext(self.filename)[0])[-1]
mol.allAtoms = mol.chains.residues.atoms
mol.parser = self
mol.levels = [Protein, Chain, Residue, Atom]
name = ''
for n in molList.name:
name = n + ','
name = name[:-1]
molList.setStringRepr(name)
strRpr = name + ':::'
molList.allAtoms.setStringRepr(strRpr)
for m in molList:
mname = m.name
strRpr = mname + ':::'
m.allAtoms.setStringRepr(strRpr)
strRpr = mname + ':'
m.chains.setStringRepr(strRpr)
for c in m.chains:
cname = c.id
strRpr = mname + ':' + cname + ':'
c.residues.setStringRepr(strRpr)
for r in c.residues:
rname = r.name
strRpr = mname + ':' + cname + ':' + rname + ':'
r.atoms.setStringRepr(strRpr)
return molList
def build4LevelsTree(self, subst_chain, atomlines):
"""
Function to build a 4 level hierarchy Protein-Chain-Residue-Atom.
"""
self.mol = Protein()
self.mol.allAtoms = AtomSet()
self.mol.atmNum = {}
self.mol.parser = self
if self.mol.name == 'NoName':
self.mol.name = os.path.basename(
os.path.splitext(self.filename)[0])
self.mol.curChain = Chain()
self.mol.curRes = Residue()
self.mol.levels = [Protein, Chain, Residue, Atom]
i = 1
for atmline in atomlines:
if len(atmline) >= 10:
status = string.split(atmline[9], '|')
else:
status = None
if len(atmline) == 8:
tmp = [atmline[5][:5], atmline[5][5:]]
atmline[5] = tmp[0]
atmline.insert(6, tmp[1])
if status and status[0] == 'WATER':
chainID = 'W'
atmline[7] = 'HOH' + str(i)
subst_chain[atmline[7]] = chainID
i = i + 1
if subst_chain == {}:
chainID = 'default'
elif not subst_chain.has_key(atmline[7]):
if subst_chain.has_key('****'):
try:
chainID = subst_chain[atmline[7]]
except:
chainID = 'default'
else:
chainID = 'default'
elif type(subst_chain[atmline[7]]) is types.StringType:
# that is to say that only chains has this substructure name.
chainID = subst_chain[atmline[7]]
elif type(subst_chain[atmline[7]]) is types.ListType:
# That is to say that several chains have the same substructure.
chainID = subst_chain[atmline[7]][0]
subst_chain[atmline[7]] = subst_chain[atmline[7]].remove(
chainID)
if chainID != self.mol.curChain.id:
if not self.mol.chains.id or not chainID in self.mol.chains.id:
self.mol.curChain = Chain(chainID, self.mol, top=self.mol)
else:
self.mol.curChain = self.mol.chains.get(chainID)[0]
if len(atmline) < 7:
# test if the atmline has a res name and resseq:
resName = 'RES'
resSeq = '1'
else:
resName = atmline[7][:3]
resSeq = atmline[7][3:]
if resSeq != self.mol.curRes.number or \
resName != self.mol.curRes.type:
# check if this residue already exists
na = string.strip(resName) + string.strip(resSeq)
res = self.mol.curChain.get(na)
if res:
self.mol.curRes = res[0]
else:
self.mol.curRes = Residue(resName,
resSeq,
'',
self.mol.curChain,
top=self.mol)
name = atmline[1]
if name == 'CA': self.mol.curRes.hasCA = 1
if name == 'O': self.mol.curRes.hasO = 2
atom = Atom(name,
self.mol.curRes,
top=self.mol,
chemicalElement=string.split(atmline[5], '.')[0])
#atom.element = atmline[5][0]
atom.element = atom.chemElem
atom.number = int(atmline[0])
self.mol.atmNum[atom.number] = atom
atom._coords = [[
float(atmline[2]),
float(atmline[3]),
float(atmline[4])
]]
if len(atmline) >= 9:
atom._charges['mol2'] = float(atmline[8])
atom.chargeSet = 'mol2'
# atom.conformation = 0
atom.hetatm = 0
#Add a data member containing a list of string describing
# the Sybyl status bis of the atoms.
atom.status = status
#add altname so buildBondsByDist doesn't croak
atom.altname = None
self.mol.allAtoms.append(atom)
delattr(self.mol, 'curRes')
delattr(self.mol, 'curChain')
class FloodPlayer(Player):
def __init__(self, command, file):
master = command.vf.GUI.ROOT
self.autoLigandCommand = command.vf.AutoLigandCommand
self.autoLigandCommand.spheres.Set(visible=1)
self.autoLigandCommand.halo.Set(visible=1)
pkl_file = open(file, 'rb')
self.floods = []
try:
data = cPickle.load(pkl_file)
except Exception, inst:
print "Error loading ", __file__, "\n", inst
self.xcent = data[0]
self.ycent = data[1]
self.zcent = data[2]
self.centerx = data[3]
self.centery = data[4]
self.centerz = data[5]
self.spacing = data[6]
self.centers = []
data = cPickle.load(pkl_file)
self.floods.append(data[1])
try:
while data:
data = cPickle.load(pkl_file)
flood = copy.copy(self.floods[-1])
for item in data[0]:
flood.remove(item)
for item in data[1]:
flood.append(item)
self.floods.append(flood)
except EOFError:
pass
pkl_file.close()
fileName = os.path.splitext(os.path.split(file)[-1])[0]
self.mol = Protein(fileName)
self.mol.allAtoms = AtomSet([])
chain = Chain()
self.residue = Residue(type="UNK")
chain.adopt(self.residue, setChildrenTop=1)
self.mol.adopt(chain, setChildrenTop=1)
self.mol.parser = None
self.filename = file
fl = self.floods[0][0]
x = (fl[1] - self.xcent) * self.spacing + self.centerx
y = (fl[2] - self.ycent) * self.spacing + self.centery
z = (fl[3] - self.zcent) * self.spacing + self.centerz
if fl[4] == 7:
atomchr = 'P'
# note, this will color the NA atom pink (the PDB color for Phosphorus)
radius = AAradii[13][0]
if fl[4] == 6:
atomchr = 'S'
radius = AAradii[13][0]
if fl[4] == 5:
atomchr = 'A'
radius = AAradii[10][0]
if fl[4] == 4:
atomchr = 'O'
radius = AAradii[1][0]
if fl[4] == 3:
atomchr = 'N'
radius = AAradii[4][0]
if fl[4] == 2:
atomchr = 'C'
radius = AAradii[10][0]
if fl[4] == 1:
atomchr = 'H'
radius = AAradii[15][0]
a = Atom(atomchr, self.residue, atomchr, top=self.mol)
a._coords = [[x, y, z]]
a._charges = {}
a.hetatm = 1
a.number = 0
a.radius = radius
self.mol.allAtoms = self.residue.atoms
self.mol = self.autoLigandCommand.vf.addMolecule(self.mol, False)
self.mol.levels = [Protein, Chain, Residue, Atom]
self.autoLigandCommand.vf.displayCPK(self.mol, scaleFactor=0.4)
self.autoLigandCommand.vf.colorByAtomType(self.mol, ['cpk'], log=0)
self.autoLigandCommand.vf.displayLines(self.mol,
negate=True,
displayBO=False,
lineWidth=2,
log=0,
only=False)
self.colorKeys = a.colors.keys()
maxLen = len(self.floods) - 1
Player.__init__(self,
master=master,
endFrame=maxLen,
maxFrame=maxLen,
titleStr="AutoLigand Flood Player",
hasSlider=True)
try: # withdrew SetAnim button
self.form.ifd.entryByName['setanimB']['widget'].grid_forget()
self.form.autoSize()
except:
pass
self.nextFrame(0)
self.form.root.protocol('WM_DELETE_WINDOW', self.hide_cb)
def parse_PDB_ATOM_record(self, rec):
"""Parse PDB ATOM records using the pdb columns specifications"""
self.atomCounter = self.atomCounter + 1 # not sure about altLoc
if self.specType == 'i':
rec = rec.split()
# Handle the alternate location using a flag.
altLoc = self.get_Field_Value(rec, 'altLoc')
if altLoc != ' ':
self.altLoc = altLoc
else:
self.altLoc = '' # changed from None to ''
# check for chains break
# self.modlflag = modlflag
# chainID = rec[21]+ modlflag
hascid = 1
chainID = self.get_Field_Value(rec, 'chainID')
if not chainID:
hascid = 0
chainID = str(self.chaincounter) ## should be unk???
if chainID != self.mol.curChain.id:
# has to check if the chain exists already or not !!!
if not self.mol.chains.id or chainID not in self.mol.chains.id or hascid == 0:
self.chaincounter = self.chaincounter + 1
if hascid == 0:
chainID = str(self.chaincounter)
self.mol.curChain = Chain(chainID, self.mol, top=self.mol)
self.residueCounter = 0
else:
self.mol.curChain = self.mol.chains.get(chainID)[0]
# check for residue break
resName = self.get_Field_Value(rec, 'resName')
resSeq = self.get_Field_Value(rec, 'resSeq').strip()
# WARNING reSeq is a STRING
noresSeq = 0
if not resSeq and resName == self.mol.curRes.type and resName != 'HOH':
noresSeq = 1
resSeq = self.mol.curRes.number
if resSeq != self.mol.curRes.number or \
resName != self.mol.curRes.type:
# check if this residue already exists
na = resName.strip() + resSeq.strip()
res = self.mol.curChain.get(na)
if res:
self.mol.curRes = res[0]
else:
self.residueCounter = self.residueCounter + 1
if resName == 'HOH':
self.HOHCounter = self.HOHCounter + 1
if not resSeq:
if resName == 'HOH':
resSeq = self.HOHCounter
else:
resSeq = self.residueCounter
## FIXME icodes are ignored
self.mol.curRes = Residue(resName,
resSeq,
'',
self.mol.curChain,
top=self.mol)
icode = self.get_Field_Value(rec, 'iCode')
if not icode:
pass
elif icode != ' ':
self.mol.curRes.icode = icode
# parse atom info
# handle atom names (calcium, hydrogen) and find element type
# check validity of chemical element column and charge column
## only works if 'name' is in the pdb format! FIX!
n = self.get_Field_Value(rec, 'name')
el = self.get_Field_Value(rec, 'element')
if n:
name, element = self.getPDBAtomName(n, el)
# if there is not resSeq spec, use first N to figure out new res
if noresSeq and name == 'N':
At = self.mol.curRes.get('N')
if At:
self.residueCounter = self.residueCounter + 1
resSeq = self.residueCounter
self.mol.curRes = Residue(resName,
resSeq,
self.mol.curChain,
top=self.mol)
atom = Atom(name, self.mol.curRes, element, top=self.mol)
else:
element = el
if element:
atom = Atom(parent=self.mol.curRes,
chemicalElement=element,
top=self.mol)
else:
atom = Atom(parent=self.mol.curRes, top=self.mol)
## elem = string.lower(element) # moved to getPDBAtomName
## if elem =='lp' or elem =='ld':
## element = 'Xx'
atom.charge = self.get_Field_Value(rec, 'charge')
# should have atom.charge if no charge?
# coords are required; where to set default or check?
xcoord = self.get_Field_Value(rec, 'x')
ycoord = self.get_Field_Value(rec, 'y')
zcoord = self.get_Field_Value(rec, 'z')
assert xcoord and ycoord and zcoord
atom._coords = [[float(xcoord), float(ycoord), float(zcoord)]]
atom.segID = self.get_Field_Value(rec, 'segID').strip()
if rec[:4] == 'ATOM' or rec[0] == 'ATOM':
atom.hetatm = 0
else:
atom.hetatm = 1
# atom.alternate = []
atom.element = element
num = self.get_Field_Value(rec, 'serial')
if num:
atom.number = int(num)
else:
atom.number = self.atomCounter
occupancy = self.get_Field_Value(rec, 'occupancy')
if occupancy:
atom.occupancy = float(occupancy)
# must check that it is a number
atom.conformation = 0
tempFactor = self.get_Field_Value(rec, 'tempFactor')
if tempFactor:
atom.temperatureFactor = float(tempFactor)
# add in user defined fields to atom attributes
for field_name in list(self.recSpecs.UserFieldsDict.keys()):
value = self.get_Field_Value(rec, field_name)
type = self.recSpecs.get(field_name, 'var_type')
if value:
if type == 'int':
atom.__setattr__(field_name, int(value))
elif type == 'float':
atom.__setattr__(field_name, float(value))
else:
atom.__setattr__(field_name, value)
else:
atom.__setattr__(field_name, value)
if self.altLoc:
# check if the name of the atom is the same than the
# name of the previous atom .
name = name + '@' + self.altLoc
atom.name = name
if len(self.mol.curRes.atoms) > 1:
# the new atom has been add to the current residue
# You have to go to the one before.
lastAtom = self.mol.curRes.atoms[-2]
altname = lastAtom.name.split('@')[0]
if name.split('@')[0] == altname:
# Add the new alternate atom to the LastAtom.alternate and
# add the lastAtom to the atom.alternate.
lastAtom.alternate.append(atom)
atom.alternate.append(lastAtom)
for l in lastAtom.alternate:
if atom.name != l.name:
atom.alternate.append(l)
l.alternate.append(atom)
return atom