def test_process_part2(self):
"""
check results of calls to removeNeighbors, filterBasedOnAngs,
removeBadAts...
"""
hb_builder = HydrogenBondBuilder()
hb_builder.check_babel_types(self.mol.allAtoms)
result = hb_builder.buildD(self.mol.allAtoms, hb_builder.paramDict)
hAts = result['hAts']
acceptorAts = result['acceptorAts']
dist = hb_builder.paramDict['distCutoff']
atDict = hb_builder.distSelector.select(hAts, acceptorAts, dist)
self.assertEqual(len(atDict), 40)
atDict = hb_builder.removeNeighbors(atDict)
self.assertEqual(len(atDict), 30)
donor2Ats = result['donor2Ats']
donor3Ats = result['donor3Ats']
acceptor2Ats = result['acceptor2Ats']
acceptor3Ats = result['acceptor3Ats']
badAtDict = hb_builder.filterBasedOnAngs(atDict, donor2Ats, donor3Ats,
acceptor2Ats, acceptor3Ats,
hb_builder.paramDict)
self.assertEqual(len(badAtDict), 30)
atDict = hb_builder.removeBadAts(atDict, badAtDict)
self.assertEqual(len(atDict), 28)
def __init__(self, receptor_file, percentCutoff=1., detect_pi=False, dist_cutoff=6, verbose=False,
distanceSelector=None, hydrogen_bond_builder=None, distanceSelectorWithCutoff=None,
aromatic_cycle_bond_selector=None):
self.receptor_file = receptor_file
receptor = Read(receptor_file)
assert(len(receptor)==1)
assert isinstance(receptor, MoleculeSet)
self.macro = receptor[0]
self.macro_atoms = self.macro.allAtoms
self.macro.buildBondsByDistance()
self.verbose = verbose
#??useful??
self.percentCutoff = percentCutoff
self.detect_pi = detect_pi
self.distanceSelector = distanceSelector
if self.distanceSelector is None:
self.distanceSelector = CloserThanVDWSelector(return_dist=0)
self.hydrogen_bond_builder = hydrogen_bond_builder
if self.hydrogen_bond_builder is None:
self.hydrogen_bond_builder = HydrogenBondBuilder()
self.distanceSelectorWithCutoff = distanceSelectorWithCutoff
if self.distanceSelectorWithCutoff is None:
self.distanceSelectorWithCutoff = DistanceSelector()
self.dist_cutoff=float(dist_cutoff)
self.results = d = {}
self.report_list =['lig_hb_atoms','lig_close_atoms']
self.aromatic_cycle_bond_selector = aromatic_cycle_bond_selector
if self.aromatic_cycle_bond_selector is None:
self.aromatic_cycle_bond_selector = AromaticCycleBondSelector()
if detect_pi:
self.report_list.extend(['pi_cation','pi_pi', 'cation_pi', 't_shaped'])
if self.verbose: print("self.report_list=", self.report_list)
def test_buildD(self):
"""
test buildD: donor3Ats, acceptor3Ats, acceptor2Ats, donor2Ats
"""
hb_builder = HydrogenBondBuilder()
hb_builder.check_babel_types(self.mol.allAtoms)
result = hb_builder.buildD(self.mol.allAtoms, hb_builder.paramDict)
#result_keys = ['donor3Ats', 'acceptor3Ats', 'acceptor2Ats', 'donor2Ats']
result_keys = [
'donor3Ats', 'acceptor3Ats', 'hAts', 'acceptorAts', 'acceptor2Ats',
'donor2Ats'
]
d = {}
d['donor3Ats'] = [
'N', 'OG1', 'OG1', 'SG', 'SG', 'OG', 'OG', 'SG', 'OG1', 'SG',
'OG1', 'OH', 'OG1', 'SG', 'OG1', 'SG', 'OH'
]
d['acceptor3Ats'] = [
'OG1', 'OG1', 'SG', 'SG', 'OG', 'OG', 'SG', 'OG1', 'SG', 'OG1',
'OH', 'OG1', 'SG', 'OG1', 'SG', 'OH'
]
d['hAts'] = [
'HN1', 'HN2', 'HN3', 'HG1', 'HN', 'HG1', 'HN', 'HN', 'HN', 'HG',
'HN', 'HN', 'HN', 'HN', 'HE', 'HH11', 'HH12', 'HH21', 'HH22', 'HN',
'HG', 'HN', 'HD21', 'HD22', 'HN', 'HN', 'HD21', 'HD22', 'HN', 'HN',
'HN', 'HE', 'HH11', 'HH12', 'HH21', 'HH22', 'HN', 'HN', 'HN',
'HG1', 'HN', 'HN', 'HN', 'HN', 'HN', 'HN', 'HG1', 'HN', 'HH', 'HN',
'HG1', 'HN', 'HN', 'HN', 'HN', 'HN', 'HN', 'HN', 'HN', 'HG1', 'HN',
'HN', 'HN', 'HN', 'HH', 'HN', 'HN', 'HD21', 'HD22'
]
d['donor2Ats'] = [
'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'NE', 'NH1', 'NH2', 'N',
'N', 'ND2', 'N', 'N', 'ND2', 'N', 'N', 'N', 'NE', 'NH1', 'NH2',
'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N',
'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N', 'ND2'
]
d['acceptor2Ats'] = [
'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'OD1',
'O', 'O', 'OD1', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O',
'OE1', 'OE2', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O',
'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'OD1', 'OD2',
'O', 'O', 'O', 'OD1', 'OXT'
]
#acceptorAts = acceptor2Ats + acceptor3Ats
d['acceptorAts'] = [
'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'OD1',
'O', 'O', 'OD1', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O',
'OE1', 'OE2', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O',
'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'OD1', 'OD2',
'O', 'O', 'O', 'OD1', 'OXT', 'OG1', 'OG1', 'SG', 'SG', 'OG', 'OG',
'SG', 'OG1', 'SG', 'OG1', 'OH', 'OG1', 'SG', 'OG1', 'SG', 'OH'
]
for k in result_keys:
#print 'testing ', k, ': '
if result[k] is not None and len(result[k]):
self.assertEqual(result[k].name, d[k])
else:
self.assertEqual(result[k], d[k])
def test_process_part1(self):
"""
check hAts and acceptorAts from buildD
"""
hb_builder = HydrogenBondBuilder()
hb_builder.check_babel_types(self.mol.allAtoms)
result = hb_builder.buildD(self.mol.allAtoms, hb_builder.paramDict)
hAts = result['hAts']
self.assertEqual(len(hAts), 69)
acceptorAts = result['acceptorAts']
self.assertEqual(len(acceptorAts), 70)
def construct_hydrogen_bonds(receptor_atoms, ligand_atoms, verbose=False):
atDict = HydrogenBondBuilder().build(receptor_atoms, ligand_atoms)
num_hbonds = len(atDict)
if verbose:
print "found ", num_hbonds, " hydrogen bonds"
for k, v in atDict.items():
print k.full_name(), ' ', len(v), " hydrogen bond(s) to ",
for a in atDict[k]:
print a.full_name(), " ",
print
ostr = "%2d," % num_hbonds
return ostr
def test_buildHbonds(self):
"""
check results of single call to build
"""
hb_builder = HydrogenBondBuilder()
hb_builder.build(self.mol)
hbond_ats = self.mol.allAtoms.get(lambda x: hasattr(x, 'hbonds'))
self.assertEquals(len(hbond_ats), 82)
d = {}
for a in self.mol.allAtoms:
if hasattr(a, 'hbonds'):
for b in a.hbonds:
d[b] = 1
self.assertEquals(len(d.keys()), 28)
def test_buildHbonds_babelTypes(self):
"""
test assigning babel_types
"""
hb_builder = HydrogenBondBuilder()
hb_builder.check_babel_types(self.mol.allAtoms)
d = {}
for a in self.mol.allAtoms:
d[a.babel_type] = 1
all_types = d.keys()
all_types.sort()
#print "all_types=", all_types
#note: these are polar only hydrogens so no type 'HC'
canned_list = [
'C+', 'C2', 'C3', 'Cac', 'H', 'N3+', 'Nam', 'Ng+', 'O-', 'O2',
'O3', 'S3'
]
for k, v in zip(all_types, canned_list):
self.assertEqual(k, v)
def construct_hydrogen_bonds(receptor_atoms, ligand_atoms):
atDict = HydrogenBondBuilder().build(receptor_atoms, ligand_atoms)
num_hbonds = len(atDict)
ostr = "%2d," % num_hbonds
return ostr
ref = ref[0]
coords = ref.allAtoms.coords
refCoords = coords[:]
d.clusterer.rmsTool = RMSDCalculator(coords)
d.clusterer.make_clustering(rms_tolerance)
# for building hydrogen bonds or reporting energy breakdown
# setup receptor:
if build_hydrogen_bonds or report_energy_breakdown:
d.ligMol.buildBondsByDistance()
receptor_filename = directory + '/' + receptor_filename
receptor = Read(receptor_filename)[0]
receptor.buildBondsByDistance()
if build_hydrogen_bonds:
hbondBuilder = HydrogenBondBuilder()
#do next two lines for each conf
#d.ligMol.set_conformation(conf)
#atDict = hbondBuilder.build(receptor.allAtoms, d.ligMol.allAtoms)
#num_hbonds= len(atDict)
if report_energy_breakdown:
ms = MolecularSystem()
ms.add_entities(receptor.allAtoms)
ms.add_entities(d.ligMol.allAtoms)
ad305scorer = AutoDock305Scorer()
ad305scorer.set_molecular_system(ms)
#whenever the ligMol changes conf,
#need to call ms.set_coords(1, new_coords)
mode = 'w'
first = True
def test_constructor(self):
"""
instantiate an HydrogenBuilder
"""
hb_builder = HydrogenBondBuilder()
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
def test_constructorOptions(self):
"""
test possible constructor options
options = distCutoff, distCutoff2, d2min, d2max,
d2min, d3max, a2min, a2max, a3min, a3max,
donorTypes, acceptorTypes, distOnly
"""
val = 1.0
hb_builder = HydrogenBondBuilder(distCutoff=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['distCutoff'], val)
hb_builder = HydrogenBondBuilder(distCutoff2=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['distCutoff2'], val)
val = 85
hb_builder = HydrogenBondBuilder(d2max=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['d2max'], val)
hb_builder = HydrogenBondBuilder(d2min=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['d2min'], val)
hb_builder = HydrogenBondBuilder(a2min=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['a2min'], val)
hb_builder = HydrogenBondBuilder(a2max=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['a2max'], val)
hb_builder = HydrogenBondBuilder(d3min=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['d3min'], val)
hb_builder = HydrogenBondBuilder(d3max=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['d3max'], val)
hb_builder = HydrogenBondBuilder(a3min=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['a3min'], val)
hb_builder = HydrogenBondBuilder(a3max=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['a3max'], val)
val = ['Nam', 'Ng+']
hb_builder = HydrogenBondBuilder(donorTypes=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['donorTypes'], val)
val = ['S3', '03']
hb_builder = HydrogenBondBuilder(acceptorTypes=val)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['acceptorTypes'], val)
val = True
hb_builder = HydrogenBondBuilder(distOnly=True)
self.assertEquals(hb_builder.__class__, HydrogenBondBuilder)
self.assertEquals(hb_builder.paramDict['distOnly'], val)
if not directory:
print('process_VSResults: directory must be specified.')
usage()
sys.exit()
intF = None
if len(custom_hb_parameters):
if verbose: print("using custom hb parameters!")
#custom_hb_parameters "distCutoff=3.00,distCutoff2=3.25"
hb_list = custom_hb_parameters.split(',')
kw = {}
for item in hb_list:
param, value = item.split('=')
kw[param] = float(value)
if verbose: print(param, '=', value)
hbB = HydrogenBondBuilder(*(), **kw)
intF = InteractionDetector(receptor_filename,
detect_pi=detect_pi,
hydrogen_bond_builder=hbB)
drp = DockingResultProcessor(rms_tolerance=rms_tolerance,
rms_reference=rms_reference,
receptor_filename=receptor_filename,
write_both=write_both,
best_only=best_only,
largestCl_only=largestCl_only,
lc_stem=lc_stem,
max_cl_to_write=max_cl_to_write,
include_interactions=include_interactions,
detect_pi=detect_pi,
build_hbonds=build_hbonds,
def getHBAtoms(mol):
"""
Function to identify donor and acceptor atoms for hydrogen bonds
d2, d3, a2, a3 <- getHBAtoms(mol)
The function will first build bonds then assign atom hybridization
and bond orders. Next it will use a HydrogenBondBuilder to identify and'
report donor and acceptor atoms in sets corresponding to Sp2 and Sp3
hybridization.
A .hbstatus is added to all atoms. The value can be:
NE: NEutral
D2: Sp2 donor
D3: Sp3 donor
A2: Sp2 acceptor
A3: Sp3 acceptor
B2: Sp2 acceptor and donor
B3: Sp3 acceptor and donor
"""
# add bonds
mol.buildBondsByDistance()
atoms = mol.allAtoms
# assign .babel_type
from PyBabel.atomTypes import AtomHybridization
atyper = AtomHybridization()
atyper.assignHybridization(atoms)
# assign bond order
from PyBabel.bo import BondOrder
bond_orderer = BondOrder()
bond_orderer.assignBondOrder(atoms, atoms.bonds[0])
# get donors
from MolKit.hydrogenBondBuilder import HydrogenBondBuilder
hbbuilder = HydrogenBondBuilder()
donorTypes = hbbuilder.paramDict['donorTypes']
donorsp2Ats, donorsp3Ats = hbbuilder.getHBDonors(atoms, donorTypes)
# get acceptors
acceptorTypes = hbbuilder.paramDict['acceptorTypes']
acceptorsp2Ats, acceptorsp3Ats = hbbuilder.getHBAcceptors(
atoms, acceptorTypes)
# create hbstatus attribute
atoms.hbstatus = 'NE'
for a in donorsp2Ats:
a.hbstatus = 'D2'
for a in donorsp3Ats:
a.hbstatus = 'D3'
for a in acceptorsp2Ats:
a.hbstatus = 'A2'
for a in acceptorsp3Ats:
a.hbstatus = 'A3'
# handle atoms that are both donors and acceptor
for a in donorsp2Ats.inter(acceptorsp2Ats):
a.hbstatus = 'B2'
for a in donorsp3Ats.inter(acceptorsp3Ats):
a.hbstatus = 'B3'
return donorsp2Ats, donorsp3Ats, acceptorsp2Ats, acceptorsp3Ats
