def readPDBFromStream(stream: Base.IOStream):
from Protein import Protein
from MoleculeTools import sanitize_mol
r = Biomol.PDBMoleculeReader(stream)
mol = Chem.BasicMolecule()
r.read(mol)
sanitize_mol(mol, makeHydrogenComplete=True)
return Protein(mol)
def cdfMol_pdb(pdb, output, name):
initial_time = time.time()
cdf_mol = Chem.BasicMolecule()
pdb_mol = Chem.BasicMolecule()
pdb_str = open(pdb, 'r').read().replace('WAT', 'HOH').replace('HIE', 'HIS')
pdb_reader = Biomol.PDBMoleculeReader(Base.StringIOStream(pdb_str))
Biomol.setPDBApplyDictAtomBondingToNonStdResiduesParameter(
pdb_reader, True)
if not pdb_reader.read(pdb_mol):
return None
Chem.calcImplicitHydrogenCounts(pdb_mol, False)
Chem.perceiveHybridizationStates(pdb_mol, False)
Chem.setAtomSymbolsFromTypes(pdb_mol, False)
Chem.perceiveSSSR(pdb_mol, False)
Chem.setRingFlags(pdb_mol, False)
Chem.setAromaticityFlags(pdb_mol, False)
cdf_mol.assign(pdb_mol)
for atom in cdf_mol.atoms:
Chem.set3DCoordinatesArray(atom, Math.Vector3DArray())
i = 0
while i < cdf_mol.numAtoms:
Chem.get3DCoordinatesArray(cdf_mol.getAtom(i)).addElement(
Chem.get3DCoordinates(pdb_mol.getAtom(i)))
i += 1
tmp_output = output + name + ".cdf"
try:
Chem.FileCDFMolecularGraphWriter(tmp_output).write(cdf_mol)
except:
print('> Cdf_mol writing failure.')
raise
residues = Biomol.ResidueList(cdf_mol)
tmp_output = output + name + "_residue_info.txt"
with open(tmp_output, 'w') as txt_writer:
txt_writer.write('residue name_resid_chain\n')
for res in residues:
res_id = getResidueID(res)
txt_writer.write('{}: \n'.format(res_id))
calc_time = time.time() - initial_time
print('> Cdf and amino acid residue number list files generated in {}s'.
format(int(calc_time)))
def _CDPLreadFromPDBFile(pdb_file):
'''
PRIVAT METHOD
reads a pdb file and is used by the CDPLreadProteinFile method.
Input: \n
pdb_file (string): the path to the pdb file \n
Return: \n
(CDPL BasicMolecule): the corresponding pdb molecule
'''
ifs = Base.FileIOStream(pdb_file, 'r')
pdb_reader = Biomol.PDBMoleculeReader(ifs)
pdb_mol = Chem.BasicMolecule()
Biomol.setPDBApplyDictAtomBondingToNonStdResiduesParameter(
pdb_reader, False
) #TODO Should this be there for the pdb readin? or also in the config?
if not pdb_reader.read(pdb_mol):
log.error("COULD NOT READ PDB", pdb_file)
return False
return pdb_mol
def generate_ph(pdb, key):
ifs = Base.FileIOStream(pdb, 'r')
tlc = self.ligand_3_letter_code
pdb_reader = Biomol.PDBMoleculeReader(ifs)
pdb_mol = Chem.BasicMolecule()
print '- Reading input: ', pdb, ' ...'
if not pdb_reader.read(pdb_mol):
print '!! Could not read input molecule'
return
print '- Processing macromolecule', pdb, ' ...'
i = 0
while i < pdb_mol.getNumBonds():
bond = pdb_mol.getBond(i)
if Chem.isMetal(bond.atoms[0]) or Chem.isMetal(bond.atoms[1]):
pdb_mol.removeBond(i)
else:
i += 1
Chem.calcImplicitHydrogenCounts(pdb_mol, True)
Chem.perceiveHybridizationStates(pdb_mol, True)
Chem.makeHydrogenComplete(pdb_mol)
Chem.setAtomSymbolsFromTypes(pdb_mol, False)
Chem.calcImplicitHydrogenCounts(pdb_mol, True)
Biomol.setHydrogenResidueSequenceInfo(pdb_mol, False)
Chem.setRingFlags(pdb_mol, True)
Chem.setAromaticityFlags(pdb_mol, True)
Chem.generateHydrogen3DCoordinates(pdb_mol, True)
ligand = Chem.Fragment()
print '- Extracting ligand ', tlc, ' ...'
for atom in pdb_mol.atoms:
if Biomol.getResidueCode(atom) == tlc:
Biomol.extractResidueSubstructure(atom, pdb_mol, ligand,
False)
break
if ligand.numAtoms == 0:
print '!! Could not find ligand', tlc, 'in input file'
return
Chem.perceiveSSSR(ligand, True)
lig_env = Chem.Fragment()
Biomol.extractEnvironmentResidues(ligand, pdb_mol, lig_env, 7.0)
Chem.perceiveSSSR(lig_env, True)
print '- Constructing pharmacophore ...'
lig_pharm = Pharm.BasicPharmacophore()
env_pharm = Pharm.BasicPharmacophore()
pharm_gen = Pharm.DefaultPharmacophoreGenerator(False)
pharm_gen.generate(ligand, lig_pharm)
pharm_gen.generate(lig_env, env_pharm)
analyzer = Pharm.DefaultInteractionAnalyzer()
interactions = Pharm.FeatureMapping()
analyzer.analyze(lig_pharm, env_pharm, interactions)
#------------------------- XVOLS
int_env_ftrs = Pharm.FeatureSet()
Pharm.getFeatures(int_env_ftrs, interactions, False)
int_core_ftrs = Pharm.FeatureSet()
Pharm.getFeatures(int_core_ftrs, interactions, True)
int_pharm = Pharm.BasicPharmacophore(int_core_ftrs)
for ftr in int_env_ftrs:
if Pharm.getType(
ftr
) == Pharm.FeatureType.H_BOND_DONOR or Pharm.getType(
ftr) == Pharm.FeatureType.H_BOND_ACCEPTOR:
Pharm.setTolerance(ftr, 1.0)
else:
Pharm.setTolerance(ftr, 1.5)
Pharm.createExclusionVolumes(int_pharm, int_env_ftrs, 0.0, 0.1,
False)
int_env_ftr_atoms = Chem.Fragment()
Pharm.getFeatureAtoms(int_env_ftrs, int_env_ftr_atoms)
int_residue_atoms = Chem.Fragment()
Biomol.extractResidueSubstructures(int_env_ftr_atoms, lig_env,
int_residue_atoms, True)
Chem.makeHydrogenDeplete(int_residue_atoms)
def isAlphaAtom(atom):
return Biomol.getResidueAtomName(atom) == 'CA'
Chem.removeAtomsIfNot(int_residue_atoms, isAlphaAtom)
Pharm.createExclusionVolumes(int_pharm, int_residue_atoms,
Chem.Atom3DCoordinatesFunctor(), 1.0,
2.0, False)
features_in_ph = []
for int_ftr in int_pharm:
if Pharm.hasSubstructure(int_ftr) == False:
continue
elif ftype_names[Pharm.getType(int_ftr)] == 'XV':
continue
feature_id = generate_key(int_ftr)
features_in_ph.append(str(feature_id))
self.unique_feature_vector.add(str(feature_id))
int_pharm.fv = features_in_ph
int_pharm.path_to_pdb = pdb
return int_pharm
def generate_ph(pdb, args, df_constructor, ts):
ifs = Base.FileIOStream(pdb, 'r')
tlc = args.ligand_three_letter_code
pdb_reader = Biomol.PDBMoleculeReader(ifs)
pdb_mol = Chem.BasicMolecule()
print '- Reading input: ', pdb, ' ...'
if not pdb_reader.read(pdb_mol):
print '!! Could not read input molecule'
return
print '- Processing macromolecule', pdb, ' ...'
i = 0
while i < pdb_mol.getNumBonds():
bond = pdb_mol.getBond(i)
if Chem.isMetal(bond.atoms[0]) or Chem.isMetal(bond.atoms[1]):
pdb_mol.removeBond(i)
else:
i += 1
for a in pdb_mol.atoms:
Chem.setImplicitHydrogenCount(a, 0)
Chem.calcImplicitHydrogenCounts(pdb_mol, True)
Chem.perceiveHybridizationStates(pdb_mol, True)
Chem.makeHydrogenComplete(pdb_mol)
Chem.setAtomSymbolsFromTypes(pdb_mol, False)
Chem.calcImplicitHydrogenCounts(pdb_mol, True)
Biomol.setHydrogenResidueSequenceInfo(pdb_mol, False)
Chem.setRingFlags(pdb_mol, True)
Chem.setAromaticityFlags(pdb_mol, True)
Chem.generateHydrogen3DCoordinates(pdb_mol, True)
Chem.calcFormalCharges(pdb_mol, True)
ligand = Chem.Fragment()
print '- Extracting ligand ', tlc, ' ...'
for atom in pdb_mol.atoms:
if Biomol.getResidueCode(atom) == tlc:
Biomol.extractResidueSubstructure(atom, pdb_mol, ligand, False)
break
if ligand.numAtoms == 0:
print '!! Could not find ligand', tlc, 'in input file'
return
Chem.perceiveSSSR(ligand, True)
lig_env = Chem.Fragment()
Biomol.extractEnvironmentResidues(ligand, pdb_mol, lig_env, 7.0)
Chem.perceiveSSSR(lig_env, True)
print '- Constructing pharmacophore ...'
lig_pharm = Pharm.BasicPharmacophore()
env_pharm = Pharm.BasicPharmacophore()
pharm_gen = Pharm.DefaultPharmacophoreGenerator(True)
pharm_gen.generate(ligand, lig_pharm)
pharm_gen.generate(lig_env, env_pharm)
#Pharm.FilePMLFeatureContainerWriter('./test/lig_ph_' + str(ts) + '.pml').write(lig_pharm)
analyzer = Pharm.DefaultInteractionAnalyzer()
interactions = Pharm.FeatureMapping()
analyzer.analyze(lig_pharm, env_pharm, interactions)
df_constructor, interaction_at_ts = outputInteractions(
lig_pharm, env_pharm, interactions, df_constructor)
#Chem.FileSDFMolecularGraphWriter('./test/ligand_' + str(ts) + '.sdf').write(ligand)
return df_constructor, interaction_at_ts
def readPDBFromStream(stream: Base.IOStream):
r = Biomol.PDBMoleculeReader(stream)
mol = Chem.BasicMolecule()
r.read(mol)
return Protein(mol)