def test_atom_map(self):
"""Test get atom map"""
from openeye import oechem
tagged_smiles = '[H:5][C:1]#[N+:4][C:3]([H:9])([H:10])[C:2]([H:6])([H:7])[H:8]'
mol_1 = openeye.smiles_to_oemol('CC[N+]#C')
inf = get_fn('ethylmethylidyneamonium.mol2')
ifs = oechem.oemolistream(inf)
mol_2 = oechem.OEMol()
oechem.OEReadMolecule(ifs, mol_2)
atom_map = utils.get_atom_map(tagged_smiles, mol_1)
for i, mapping in enumerate(atom_map):
atom_1 = mol_1.GetAtom(oechem.OEHasAtomIdx(atom_map[mapping]))
atom_1.SetAtomicNum(i+1)
atom_2 = mol_2.GetAtom(oechem.OEHasAtomIdx(mapping-1))
atom_2.SetAtomicNum(i+1)
self.assertEqual(oechem.OECreateCanSmiString(mol_1), oechem.OECreateCanSmiString(mol_2))
# Test aromatic molecule
tagged_smiles = '[H:10][c:4]1[c:3]([c:2]([c:1]([c:6]([c:5]1[H:11])[H:12])[C:7]([H:13])([H:14])[H:15])[H:8])[H:9]'
mol_1 = openeye.smiles_to_oemol('Cc1ccccc1')
inf = get_fn('toluene.mol2')
ifs = oechem.oemolistream(inf)
mol_2 = oechem.OEMol()
oechem.OEReadMolecule(ifs, mol_2)
atom_map = utils.get_atom_map(tagged_smiles, mol_1)
for i, mapping in enumerate(atom_map):
atom_1 = mol_1.GetAtom(oechem.OEHasAtomIdx(atom_map[mapping]))
atom_1.SetAtomicNum(i+1)
atom_2 = mol_2.GetAtom(oechem.OEHasAtomIdx(mapping-1))
atom_2.SetAtomicNum(i+1)
self.assertEqual(oechem.OECreateCanSmiString(mol_1), oechem.OECreateCanSmiString(mol_2))
def setup_yank_calculation(receptor_file_name, ligand_file_name, setup_directory_name, solvate=False):
# Cleanup setup directory
if os.path.exists(setup_directory_name):
shutil.rmtree(setup_directory_name)
os.makedirs(setup_directory_name)
# Read ligand and receptor molecule
ifs_mol2 = oechem.oemolistream()
ifs_mol2.open(ligand_file_name)
ligand_oemol = oechem.OEGraphMol()
oechem.OEReadMolecule(ifs_mol2, ligand_oemol)
ifs_mol2.close()
ifs_mol2 = oechem.oemolistream()
ifs_mol2.open(receptor_file_name)
receptor_oemol = oechem.OEGraphMol()
oechem.OEReadMolecule(ifs_mol2, receptor_oemol)
ifs_mol2.close()
# Push ligand close to receptor
pull_close(receptor_oemol, ligand_oemol, MIN_DISTANCE, MAX_DISTANCE)
# Add residue name 'MOL'
residue = oechem.OEResidue()
residue.SetName('MOL')
for atom in ligand_oemol.GetAtoms():
oechem.OEAtomSetResidue(atom, residue)
# Parametrize ligand
with working_directory(setup_directory_name):
# Save translated ligand
ofs = oechem.oemolostream()
ofs.open('ligand.mol2')
oechem.OEWriteMolecule(ofs, ligand_oemol)
ofs.close()
# Parametrize ligand
print "Parameterizing ligand with GAFF..."
run_command('antechamber -fi mol2 -i ligand.mol2 -fo mol2 -o ligand.gaff.mol2')
run_command('parmchk -i ligand.gaff.mol2 -o ligand.gaff.frcmod -f mol2')
# Copy receptor so that leap will know the PDB file name
shutil.copyfile(receptor_file_name, 'receptor.pdb')
# Create AMBER prmtop/inpcrd files.
print "Creating AMBER prmtop/inpcrd files..."
cmd = 'tleap -f {!s} > setup.leap.out'
if solvate:
run_command(cmd.format(LEAP_IN_EXPLICIT))
else:
run_command(cmd.format(LEAP_IN_IMPLICIT))
def main(argv=sys.argv):
if len(argv) != 2:
oechem.OEThrow.Usage("%s <infile (oeb file prefix)>" % argv[0])
ifs = oechem.oemolistream()
if not ifs.open(argv[1]+'.oeb'):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[1]+'.oeb' )
ofsff = oechem.oemolostream()
ofsff.SetFlavor( oechem.OEFormat_MOL2, oechem.OEOFlavor_MOL2_Forcefield )
if not ofsff.open(argv[1]+'_ff.mol2'):
oechem.OEThrow.Fatal("Unable to open %s for writing" % argv[1]+'_ff.mol2')
ofsTri = oechem.oemolostream()
ofsTri.SetFlavor( oechem.OEFormat_MOL2, oechem.OEOFlavor_MOL2_Forcefield )
if not ofsTri.open(argv[1]+'_tripos.mol2'):
oechem.OEThrow.Fatal("Unable to open %s for writing" % argv[1]+'_tripos.mol2')
for mol in ifs.GetOEMols():
oechem.OETriposAtomNames(mol)
oechem.OEWriteConstMolecule(ofsff, mol)
oechem.OETriposAtomTypeNames(mol)
oechem.OEWriteConstMolecule(ofsTri, mol)
ifs.close()
ofsff.close()
ofsTri.close()
def read_molecule(filename):
ifs = oechem.oemolistream()
ifs.open(filename)
molecule = oechem.OEMol()
oechem.OEReadMolecule(ifs, molecule)
ifs.close()
return molecule
def check_boxes(forcefield, description="", chargeMethod=None, verbose=False):
"""Test creation of System from boxes of mixed solvents.
"""
# Read monomers
mols = list()
monomers = ['cyclohexane', 'ethanol', 'propane', 'methane', 'butanol']
from openeye import oechem
mol = oechem.OEGraphMol()
for monomer in monomers:
filename = get_data_filename(os.path.join('systems', 'monomers', monomer + '.sdf'))
ifs = oechem.oemolistream(filename)
while oechem.OEReadMolecule(ifs, mol):
oechem.OETriposAtomNames(mol)
mols.append( oechem.OEGraphMol(mol) )
if verbose: print('%d reference molecules loaded' % len(mols))
# Read systems.
boxes = ['cyclohexane_ethanol_0.4_0.6.pdb', 'propane_methane_butanol_0.2_0.3_0.5.pdb']
from simtk.openmm.app import PDBFile
for box in boxes:
filename = get_data_filename(os.path.join('systems', 'packmol_boxes', box))
pdbfile = PDBFile(filename)
f = partial(check_system_creation_from_topology, forcefield, pdbfile.topology, mols, pdbfile.positions, chargeMethod=chargeMethod, verbose=verbose)
f.description = 'Test creation of System object from %s %s' % (box, description)
yield f
def convert_mdtraj_to_oemol(traj: md.Trajectory) -> oechem.OEMol:
"""
This method converts an mdtraj Trajectory to an OEMol via saving as a PDBfile
and reading in with OpenEye. Although this seems hacky, it seems less error-prone
than trying to manually construct the OEMol.
Parameters
----------
mdtraj: md.Trajectory
The trajectory to turn into an OEMol
Returns
-------
mol : oechem.OEMol
The trajectory represented as an OEMol
"""
#create a temporary file with a PDB suffix and save with MDTraj
pdb_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdb")
traj.save(pdb_file.name)
pdb_file.close()
#Now use the openeye oemolistream to read in this file as an OEMol:
ifs = oechem.oemolistream()
ifs.open(pdb_file.name)
ifs.SetFormat(oechem.OEFormat_PDB)
mol = oechem.OEMol()
oechem.OEReadMolecule(ifs, mol)
#close the stream and delete the temporary pdb file
ifs.close()
os.unlink(pdb_file.name)
return mol
def testConvertFromOEChem(self):
testfiles = [
'tests/files/jandor.sdf',
'tests/files/test_UID_corrected.mol2',
'tests/files/fused.sdf',
'tests/files/3RYZ.pdb',
'tests/files/1DUF.pdb',
]
for testfile in testfiles:
with oechem.oemolistream()(testfile) as ifs:
mol = oechem.OEMol()
with TimedLogMessage("OEReadMolecule"):
assert oechem.OEReadMolecule(ifs, mol)
if 'pdb' in testfile:
oechem.OEAddExplicitHydrogens(mol)
with TimedLogMessage("ConvertFromOEChem"):
system = msys.ConvertFromOEChem(mol)
if 'pdb' in testfile:
assert len(system.residues) > 1
if '1DUF' in testfile:
assert len(system.chains) > 1
with TimedLogMessage("ConvertToOEChem"):
new_oemol = msys.ConvertToOEChem(system)
with TimedLogMessage("OEMolToSmiles"):
oechem.OEMolToSmiles(new_oemol)
assert new_oemol.GetTitle() == mol.GetTitle()
assert oechem.OEMolToSmiles(new_oemol) == oechem.OEMolToSmiles(mol)
def read_molecules(filename):
"""Read a file into an OpenEye molecule (or list of molecules).
Parameters
----------
filename : str
The name of the file to read (e.g. mol2, sdf)
Returns
-------
molecule : openeye.oechem.OEMol
The OEMol molecule read, or a list of molecules if multiple molecules are read.
If no molecules are read, None is returned.
"""
ifs = oechem.oemolistream(filename)
molecules = list()
for mol in ifs.GetOEMols():
mol_copy = oechem.OEMol(mol)
molecules.append(mol_copy)
ifs.close()
if len(molecules) == 0:
return None
elif len(molecules) == 1:
return molecules[0]
else:
return molecules
def test_smirff_energies_vs_parmatfrosst(verbose=False):
"""Test evaluation of energies from parm@frosst ffxml files versus energies of equivalent systems."""
from openeye import oechem
prefix = 'AlkEthOH_'
molecules = [ 'r118', 'r12', 'c1161', 'r0', 'c100', 'c38', 'c1266' ]
# Loop over molecules, load OEMols and prep for comparison/do comparison
for molnm in molecules:
f_prefix = os.path.join('molecules', prefix+molnm )
mol2file = get_data_filename( f_prefix+'.mol2')
prmtop = get_data_filename( f_prefix+'.top')
crd = get_data_filename( f_prefix+'.crd')
# Load special parm@frosst with parm99/parm@frosst bugs re-added for testing
forcefield = ForceField( get_data_filename('forcefield/Frosst_AlkEtOH_parmAtFrosst.ffxml') )
# Load OEMol
mol = oechem.OEGraphMol()
ifs = oechem.oemolistream(mol2file)
flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield
ifs.SetFlavor( oechem.OEFormat_MOL2, flavor)
oechem.OEReadMolecule(ifs, mol )
oechem.OETriposAtomNames(mol)
# Do comparison
results = compare_molecule_energies( prmtop, crd, forcefield, mol, verbose = verbose )
def _construct_test_values(fp_func = None, num_bits=4096):
from openeye.oechem import oemolistream
from openeye.oegraphsim import OEFingerPrint, OEMakePathFP
fp = OEFingerPrint()
ifs = oemolistream()
assert ifs.open(PUBCHEM_SDF)
hex_data = []
if fp_func is None:
fp_func = OEMakePathFP
def _convert_to_chemfp_order(s):
# The FPS format allows either case but I prefer lowercase
s = s.lower()
# OpenEye orders hex values on nibbles. Chemfp orders on bytes.
return "".join( (s[i+1]+s[i]) for i in range(0, len(s), 2))
for mol in ifs.GetOEGraphMols():
fp_func(fp, mol)
# Set the byte values given the bit offsets
bytes = [0] * (num_bits//8)
i = fp.FirstBit()
while i >= 0:
bytes[i//8] |= 1<<(i%8)
i = fp.NextBit(i)
as_hex = "".join("%02x" % i for i in bytes)
assert len(as_hex) == 2*(num_bits//8), len(as_hex)
# Double-check that it matches the (reordered) ToHexString()
oe_hex = fp.ToHexString()[:-1]
assert as_hex == _convert_to_chemfp_order(oe_hex), (
as_hex, _convert_to_chemfp_order(oe_hex))
hex_data.append("%s\t%s" % (as_hex, mol.GetTitle()))
return hex_data
def read_oe_molecule(file_path):
from openeye import oechem
molecule = oechem.OEGraphMol()
ifs = oechem.oemolistream()
ifs.open(file_path)
oechem.OEReadMolecule(ifs, molecule)
ifs.close()
return molecule
def testConvertFromOEChemFailures(self):
mol = oechem.OEMol()
# SMILES has no coordinates or hydrogens
assert oechem.OESmilesToMol(mol, 'C1NCC[NH2+]C1')
self.assertRaises(ValueError, msys.ConvertFromOEChem, mol)
# This is a 2D SDF file
with oechem.oemolistream()('tests/files/methotrexate.sdf') as ifs:
assert oechem.OEReadMolecule(ifs, mol)
self.assertRaises(ValueError, msys.ConvertFromOEChem, mol)
# Suppressing hydrogens should cause ConvertFromOEChem to fail
with oechem.oemolistream()('tests/files/fused.sdf') as ifs:
assert oechem.OEReadMolecule(ifs, mol)
assert oechem.OESuppressHydrogens(mol)
self.assertRaises(ValueError, msys.ConvertFromOEChem, mol)
def generate_fragments(inputf, output_dir, pdf=False, combinatorial=True, MAX_ROTORS=2, strict_stereo=True, remove_map=True):
"""
This function generates fragment SMILES files sorted by rotatable bonds from an input molecule file.
The output .smi files are written out to `output_dir` and named `nrotor_n.smi` where n corresponds to the number
of rotatable bonds for all fragments in the file.
Parameters
----------
inputf: str
absolute path to input molecule file
output_dir: str
absolute path to output directory
pdf: bool
If true, visualization of the fragments will be written to pdf files. The pdf will be writtten in the directory
where this function is run from.
combinatorial: bool
If true, find all connected fragments from fragments and add all new fragments that have less than MAX_ROTORS
MAX_ROTORS: int
rotor threshold for combinatorial
"""
ifs = oechem.oemolistream()
smiles_unique = set()
mol = oechem.OEMol()
if ifs.open(inputf):
while oechem.OEReadMolecule(ifs, mol):
openeye.normalize_molecule(mol)
logger().info('fragmenting {}...'.format(mol.GetTitle()))
if remove_map:
# Remove tags from smiles. This is done to make it easier to find duplicate fragments
for a in mol.GetAtoms():
a.SetMapIdx(0)
frags = _generate_fragments(mol, strict_stereo=strict_stereo)
if not frags:
logger().warn('Skipping {}, SMILES: {}'.format(mol.GetTitle(), oechem.OECreateSmiString(mol)))
continue
charged = frags[0]
frags = frags[-1]
if combinatorial:
smiles = smiles_with_combined(frags, charged, MAX_ROTORS=MAX_ROTORS)
else:
smiles = frag_to_smiles(frags, charged)
smiles_unique.update(list(smiles.keys()))
if pdf:
oname = '{}.pdf'.format(mol.GetTitle())
ToPdf(charged, oname, frags)
del charged, frags
# Generate oedatabase for all fragments
split_fname = inputf.split('.')
base = split_fname[-2].split('/')[-1]
ofname = base + '_frags'
utils.to_smi(list(smiles_unique), output_dir, ofname)
ofname_ext = ofname + '.smi'
oedb_name = os.path.join(output_dir, ofname_ext)
utils.create_oedatabase_idxfile(oedb_name)
_sort_by_rotbond(oedb_name, outdir=output_dir)
def load_database(database, mol2_directory, verbose=False):
"""
This function prepares the database that will be use in sampling.
Arguments
---------
database : dict
an unpickled version of the FreeSolv database
mol2_directory : String
the path to the FreeSolv mol2 files containing geometry and charges
verbose : Boolean, optional
verbosity
Returns
-------
database : dict
An updated version of the database dict containing OEMols
"""
start_time = time.time()
if verbose:
print ("Reading all molecules in dataset. Will use charges and coordinates from dataset.")
for cid in database.keys():
entry = database[cid]
# Store temperature
# TODO: Get this from database?
entry["temperature"] = 300.0 * units.kelvin
# Extract relevant entry data from database.
smiles = entry["smiles"]
iupac_name = entry["iupac"]
experimental_DeltaG = entry["expt"] * units.kilocalories_per_mole
experimental_dDeltaG = entry["d_expt"] * units.kilocalories_per_mole
# Read molecule.
molecule = openeye.oechem.OEMol()
# Load the mol2 file.
tripos_mol2_filename = os.path.join(mol2_directory, cid + ".mol2")
omolstream = oechem.oemolistream(tripos_mol2_filename)
oechem.OEReadMolecule(omolstream, molecule)
omolstream.close()
molecule.SetTitle(iupac_name)
molecule.SetData("cid", cid)
# Add explicit hydrogens.
oechem.OEAddExplicitHydrogens(molecule)
# Store molecule.
entry["molecule"] = oechem.OEMol(molecule)
if verbose:
print "%d molecules read" % len(database.keys())
end_time = time.time()
elapsed_time = end_time - start_time
print "%.3f s elapsed" % elapsed_time
return database
def check_AlkEtOH(forcefield, description="", chargeMethod=None, verbose=False):
"""Test creation of System from AlkEtOH small molecules.
"""
from openeye import oechem
ifs = oechem.oemolistream(get_data_filename('molecules/AlkEtOH-tripos.mol2.gz'))
mol = oechem.OEGraphMol()
while oechem.OEReadMolecule(ifs, mol):
args = { 'verbose' : verbose, 'chargeMethod' : chargeMethod }
f = partial(check_system_creation_from_molecule, forcefield, mol, **args)
f.description ='Testing creation of system object from small molecules (%s) %s' % (mol.GetTitle(), description)
yield f
def ProtonateLig_openeye(file_in,file_out,protonate=True,type_in=None,type_out=None):
"""
Function to protonate small molecule using OpenEye's python libraries. Requires OpenEye licence.
More information found https://docs.eyesopen.com/toolkits/python/quickstart-python/index.html
Also doubles as a file conversion script. Files types can be specified or detected via the file extension. File types
supported by OpenEye listed here: https://docs.eyesopen.com/toolkits/python/oechemtk/molreadwrite.html
Parameters
----------
file_in: str
Name of the input file containing the coordinates of the molecule. One molecule expected.
file_out: str
Name of the output file.
type_in: str
File type of input file. Typically the file extension.
type_out: str
File type of the output file. Typically the file extension.
Returns
-------
The output is written to a file
"""
try:
import openeye.oechem as oechem
if type_in == None:
type_in = file_in.split('.')[-1]
if type_out == None:
type_out = file_out.split('.')[-1]
mol = oechem.OEGraphMol() # initialising molecule object
ifs = oechem.oemolistream() # initialising input stream for reading in data
ofs = oechem.oemolostream() # initialising the OUTPUT stream for writing data
ifs.SetFormat(eval('oechem.OEFormat_' + type_in.upper()))
ofs.SetFormat(eval('oechem.OEFormat_' + type_out.upper()))
ifs.open(file_in)
if oechem.OEReadMolecule(ifs,mol): # this function automatically returns True or False, to help spot for errors.
pass
else:
print "Problem loading molecule!"
mol = oechem.OEMol(mol)
oechem.OEAssignAromaticFlags(mol, oechem.OEAroModelOpenEye)
if protonate==True: oechem.OEAddExplicitHydrogens(mol)
ofs.open(file_out)
oechem.OEWriteMolecule(ofs,mol)
except ImportError:
print 'OpenEye python bindings not found'
def test_tagged_smiles(self):
"""Test index-tagges smiles"""
from openeye import oechem
inf = get_fn('ethylmethylidyneamonium.mol2')
ifs = oechem.oemolistream(inf)
inp_mol = oechem.OEMol()
oechem.OEReadMolecule(ifs, inp_mol)
tagged_smiles = utils.create_mapped_smiles(inp_mol)
# Tags should always be the same as mol2 molecule ordering
self.assertEqual(tagged_smiles, '[H:5][C:1]#[N+:4][C:3]([H:9])([H:10])[C:2]([H:6])([H:7])[H:8]')
def generate_forcefield(molecule_file, outfile):
ifs = oechem.oemolistream()
ifs.open(molecule_file)
# get the list of molecules
mol_list = [normalize_molecule(oechem.OEMol(mol)) for mol in ifs.GetOEMols()]
# TODO: HORRIBLE HACK ; WILL DIE AT > 999 RESIDUES!
for idx, mol in enumerate(mol_list):
mol.SetTitle("%03d" % idx)
ffxml = forcefield_generators.generateForceFieldFromMolecules(mol_list, normalize=False)
with open(outfile, 'w') as output_file:
output_file.write(ffxml)
def generate_ligand_topologies_and_positions(ligand_filename):
"""
Generate the topologies and positions for ligand-only systems
Parameters
----------
ligand_filename : str
The name of the file containing the ligands in any OpenEye supported format
Returns
-------
ligand_topologies : dict of str: md.Topology
A dictionary of the ligand topologies generated from the file indexed by SMILES strings
ligand_positions_dict : dict of str: unit.Quantity array
A dictionary of the corresponding positions, indexed by SMILES strings
"""
ifs = oechem.oemolistream()
ifs.open(ligand_filename)
# get the list of molecules
mol_list = [oechem.OEMol(mol) for mol in ifs.GetOEMols()]
for idx, mol in enumerate(mol_list):
mol.SetTitle("MOL{}".format(idx))
oechem.OETriposAtomNames(mol)
mol_dict = {oechem.OEMolToSmiles(mol) : mol for mol in mol_list}
ligand_topology_dict = {smiles : forcefield_generators.generateTopologyFromOEMol(mol) for smiles, mol in mol_dict.items()}
ligand_topologies = {}
ligand_positions_dict = {}
for smiles, ligand_topology in ligand_topology_dict.items():
ligand_md_topology = md.Topology.from_openmm(ligand_topology)
ligand_topologies[smiles] = ligand_md_topology
ligand_positions = extractPositionsFromOEMOL(mol_dict[smiles])
ligand_positions_dict[smiles] = ligand_positions
return ligand_topologies, ligand_positions_dict
def testConvertAtoms(self):
mol = msys.Load('tests/files/jandor.sdf')
omol = msys.ConvertToOEChem(mol.atoms)
assert omol.GetDimension() == 3
new = msys.ConvertFromOEChem(omol)
assert mol.positions.tolist() == new.positions.tolist()
assert [a.atomic_number for a in mol.atoms] == [a.atomic_number for a in new.atoms]
ifs = oechem.oemolistream()
assert ifs.open('tests/files/jandor.sdf')
oechem_mol = oechem.OEGraphMol()
assert oechem.OEReadMolecule(ifs, oechem_mol)
assert oechem.OEMolToSmiles(omol) == oechem.OEMolToSmiles(oechem_mol)
# testing disconnected components
atoms = mol.select('withinbonds 1 of hydrogen')
omol = msys.ConvertToOEChem(atoms)
new = msys.ConvertFromOEChem(omol)
assert [a.pos.tolist() for a in atoms] == new.positions.tolist()
assert [a.atomic_number for a in atoms] == [a.atomic_number for a in new.atoms]
def main(argv=sys.argv):
if len(argv) != 3:
oechem.OEThrow.Usage("%s <infile (forcefield types)> <outfile (Tripos types)>" % argv[0])
ifs = oechem.oemolistream()
flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield
ifs.SetFlavor(oechem.OEFormat_MOL2, flavor)
if not ifs.open(argv[1]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[1])
ofs = oechem.oemolostream()
if not ofs.open(argv[2]):
oechem.OEThrow.Fatal("Unable to open %s for writing" % argv[2])
for mol in ifs.GetOEMols():
oechem.OETriposAtomNames(mol)
oechem.OEWriteConstMolecule(ofs, mol)
ifs.close()
ofs.close()
def to_oemol(filename, title=True, verbose=True):
"""Create OEMol from file. If more than one mol in file, return list of OEMols.
Parameters
----------
filename: str
absolute path to
title: str, title
title for molecule. If None, IUPAC name will be given as title.
Returns
-------
mollist: list
list of OEMol for multiple molecules. OEMol if file only has one molecule.
"""
if not os.path.exists(filename):
raise Exception("File {} not found".format(filename))
if verbose:
logger().info("Loading molecules from {}".format(filename))
ifs = oechem.oemolistream(filename)
#moldb = oechem.OEMolDatabase(ifs)
mollist = []
molecule = oechem.OECreateOEGraphMol()
while oechem.OEReadMolecule(ifs, molecule):
molecule_copy = oechem.OEMol(molecule)
if title:
title = molecule_copy.GetTitle()
if verbose:
logger().infor("Reading molecule {}".format(title))
mollist.append(normalize_molecule(molecule_copy, title))
if len(mollist) <= 1:
mollist = mollist[0]
ifs.close()
return mollist
def __init__(self, prefix: str, ref_file: os.PathLike, **kwargs):
"""
:param prefix: Prefix to identify scoring function instance (e.g., Risperidone)
:param ref_file: Path to reference file to overlay query to (.pdb)
:param kwargs:
"""
self.prefix = prefix.replace(" ", "_")
self.rocs_metrics = ROCS.return_metrics
self.ref_file = ref_file
self.refmol = oechem.OEMol()
ifs = oechem.oemolistream(self.ref_file) # Set up input file stream
oechem.OEReadMolecule(ifs, self.refmol) # Read ifs to empty mol object
self.fitmol = None
self.rocs_results = None
self.best_overlay = None
omegaOpts = oeomega.OEOmegaOptions()
omegaOpts.SetStrictStereo(False)
omegaOpts.SetMaxSearchTime(1.0)
self.omega = oeomega.OEOmega(omegaOpts)
def main(argv=[__name__]):
if len(argv) != 2 and len(argv) != 3:
oechem.OEThrow.Usage("%s [-H] <mol-infile>" % argv[0])
hideAtoms = False
filename = argv[1]
if len(argv) == 3:
if argv[1] != "-H":
oechem.OEThrow.Fatal("Bad flag: %s (expecting -H)" % argv[1])
hideAtoms = True
filename = argv[2]
ifs = oechem.oemolistream()
if not ifs.open(filename):
oechem.OEThrow.Fatal("Unable to open %s for reading" % filename)
# need this flavor to read alt loc atoms
ifs.SetFlavor(oechem.OEFormat_PDB, oechem.OEIFlavor_PDB_ALTLOC)
for mol in ifs.GetOEGraphMols():
PrintLocations(mol, hideAtoms)
def read_csv_molecules(filename):
"""Read molecules from the specified path
Parameters
----------
filename : str
File from which molecules are to be read
Returns
-------
molecules : list of openeye.oechem.OEMol
The read molecules
"""
from openeye import oechem
mol = oechem.OEMol()
molecules = list()
with oechem.oemolistream(filename) as ifs:
while oechem.OEReadCSVFile(ifs, mol):
molecules.append(oechem.OEMol(mol))
return molecules
def main(argv=[__name__]):
if len(argv) != 3:
oechem.OEThrow.Usage("%s <reffile> <fitfile>" % argv[0])
reffs = oechem.oemolistream(argv[1])
refmol = oechem.OEMol()
oechem.OEReadMolecule(reffs, refmol)
print("Ref. Title:", refmol.GetTitle(), "Num Confs:", refmol.NumConfs())
fitfs = oechem.oemolithread(sys.argv[2])
thrds = []
for i in range(oechem.OEGetNumProcessors()):
thrd = MultiCoreOverlay(refmol, fitfs)
thrd.start()
thrds.append(thrd)
for thrd in thrds:
thrd.join()
return 0
def main(argv=[__name__]):
if len(argv) != 2:
oechem.OEThrow.Usage("%s <molfile>" % argv[0])
ifs = oechem.oemolistream()
if not ifs.open(argv[1]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[1])
mol = oechem.OEGraphMol()
oechem.OEReadMolecule(ifs, mol)
oechem.OEAssignBondiVdWRadii(mol)
oechem.OEMMFFAtomTypes(mol)
oechem.OEMMFF94PartialCharges(mol)
epsin = 1.0
zap = oezap.OEZap()
zap.SetInnerDielectric(epsin)
zap.SetMolecule(mol)
grid = oegrid.OEScalarGrid()
if zap.CalcPotentialGrid(grid):
oegrid.OEWriteGrid("zap.grd", grid)
def main(argv=[__name__]):
itf = oechem.OEInterface(InterfaceData)
oemolprop.OEConfigureFilterParams(itf)
if not oechem.OEParseCommandLine(itf, argv):
oechem.OEThrow.Fatal("Unable to interpret command line!")
iname = itf.GetString("-in")
oname = itf.GetString("-out")
ifs = oechem.oemolistream()
if not ifs.open(iname):
oechem.OEThrow.Fatal("Cannot open input file!")
ftype = oemolprop.OEGetFilterType(itf)
filt = oemolprop.OEFilter(ftype)
ver = itf.GetInt("-verbose")
oechem.OEThrow.SetLevel(ver)
oemolprop.OEWritePropertyDataToCSV(oname, ifs, filt)
def main(args):
if len(args) != 3:
oechem.OEThrow.Usage("%s <input> <output>" % args[0])
ifs = oechem.oemolistream()
if not ifs.open(args[1]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % args[1])
ofs = oechem.oemolostream()
if not ofs.open(args[2]):
oechem.OEThrow.Fatal("Unable to open %s for writing" % args[2])
mol = oechem.OEMol()
while oechem.OEReadMolecule(ifs, mol):
oechem.OEAddExplicitHydrogens(mol)
mmff = oeff.OEMMFF()
if not mmff.PrepMol(mol) or not mmff.Setup(mol):
oechem.OEThrow.Warning("Unable to process molecule: title = '%s'" %
mol.GetTitle())
oechem.OEWriteMolecule(ofs, mol)
continue
vecCoords = oechem.OEDoubleArray(3 * mol.GetMaxAtomIdx())
for conf in mol.GetConfs():
oechem.OEThrow.Info("Molecule: %s Conformer: %d" %
(mol.GetTitle(), conf.GetIdx() + 1))
conf.GetCoords(vecCoords)
energy = mmff(vecCoords)
oechem.OEThrow.Info("Initial energy: %d kcal/mol" % energy)
optimizer = oeff.OEBFGSOpt()
energy = optimizer(mmff, vecCoords, vecCoords)
oechem.OEThrow.Info("Optimized energy: %d kcal/mol" % energy)
conf.SetCoords(vecCoords)
oechem.OEWriteMolecule(ofs, mol)
return 0
def check_boxes(forcefield, description="", chargeMethod=None, verbose=False):
"""Test creation of System from boxes of mixed solvents.
"""
# Read monomers
mols = list()
monomers = [
'water', 'cyclohexane', 'ethanol', 'propane', 'methane', 'butanol'
]
from openeye import oechem
mol = oechem.OEGraphMol()
for monomer in monomers:
filename = get_data_filename(
os.path.join('systems', 'monomers', monomer + '.sdf'))
ifs = oechem.oemolistream(filename)
while oechem.OEReadMolecule(ifs, mol):
oechem.OETriposAtomNames(mol)
mols.append(oechem.OEGraphMol(mol))
if verbose: print('%d reference molecules loaded' % len(mols))
# Read systems.
boxes = [
'ethanol_water.pdb', 'cyclohexane_water.pdb',
'cyclohexane_ethanol_0.4_0.6.pdb',
'propane_methane_butanol_0.2_0.3_0.5.pdb'
]
from simtk.openmm.app import PDBFile
for box in boxes:
filename = get_data_filename(
os.path.join('systems', 'packmol_boxes', box))
pdbfile = PDBFile(filename)
f = partial(check_system_creation_from_topology,
forcefield,
pdbfile.topology,
mols,
pdbfile.positions,
chargeMethod=chargeMethod,
verbose=verbose)
f.description = 'Test creation of System object from %s %s' % (
box, description)
yield f
def test_molecular_atom_mapping():
"""
Test the creation of atom maps between pairs of molecules from the JACS benchmark set.
"""
from openeye import oechem
from perses.rjmc.topology_proposal import SmallMoleculeSetProposalEngine
from perses.tests.utils import createOEMolFromSMILES
from perses.tests.utils import render_atom_mapping
from itertools import combinations
# Test mappings for JACS dataset ligands
for dataset_name in ['CDK2']: #, 'p38', 'Tyk2', 'Thrombin', 'PTP1B', 'MCL1', 'Jnk1', 'Bace']:
# Read molecules
dataset_path = 'data/schrodinger-jacs-datasets/%s_ligands.sdf' % dataset_name
mol2_filename = resource_filename('perses', dataset_path)
ifs = oechem.oemolistream(mol2_filename)
molecules = list()
for mol in ifs.GetOEGraphMols():
molecules.append(oechem.OEGraphMol(mol))
# Build atom map for some transformations.
#for (molecule1, molecule2) in combinations(molecules, 2): # too slow
molecule1 = molecules[0]
for i, molecule2 in enumerate(molecules[1:]):
new_to_old_atom_map = SmallMoleculeSetProposalEngine._get_mol_atom_map(molecule1, molecule2)
# Make sure we aren't mapping hydrogens onto anything else
atoms1 = [atom for atom in molecule1.GetAtoms()]
atoms2 = [atom for atom in molecule2.GetAtoms()]
#for (index2, index1) in new_to_old_atom_map.items():
# atom1, atom2 = atoms1[index1], atoms2[index2]
# if (atom1.GetAtomicNum()==1) != (atom2.GetAtomicNum()==1):
filename = 'mapping-error-%d.png' % i
render_atom_mapping(filename, molecule1, molecule2, new_to_old_atom_map)
#msg = 'Atom atomic number %d is being mapped to atomic number %d\n' % (atom1.GetAtomicNum(), atom2.GetAtomicNum())
msg = 'molecule 1 : %s\n' % oechem.OECreateIsoSmiString(molecule1)
msg += 'molecule 2 : %s\n' % oechem.OECreateIsoSmiString(molecule2)
msg += 'Wrote atom mapping to %s for inspection; please check this.' % filename
msg += str(new_to_old_atom_map)
print(msg)
def test_mapped_xyz(self):
"""Test writing out mapped xyz"""
from openeye import oechem, oeomega
tagged_smiles = '[H:10][c:4]1[c:3]([c:2]([c:1]([c:6]([c:5]1[H:11])[H:12])[C:7]([H:13])([H:14])[H:15])[H:8])[H:9]'
mol_1 = openeye.smiles_to_oemol('Cc1ccccc1')
inf = get_fn('toluene.mol2')
ifs = oechem.oemolistream(inf)
mol_2 = oechem.OEMol()
oechem.OEReadMolecule(ifs, mol_2)
atom_map = utils.get_atom_map(tagged_smiles, mol_1)
for i, mapping in enumerate(atom_map):
atom_1 = mol_1.GetAtom(oechem.OEHasAtomIdx(atom_map[mapping]))
atom_1.SetAtomicNum(i + 1)
atom_2 = mol_2.GetAtom(oechem.OEHasAtomIdx(mapping - 1))
atom_2.SetAtomicNum(i + 1)
xyz_1 = utils.to_mapped_xyz(mol_1, atom_map)
# molecule generated from mol2 should be in the right order.
atom_map_mol2 = {
1: 0,
2: 1,
3: 2,
4: 3,
5: 4,
6: 5,
7: 6,
8: 7,
9: 8,
10: 9,
11: 10,
12: 11,
13: 12,
14: 13,
15: 14
}
xyz_2 = utils.to_mapped_xyz(mol_2, atom_map_mol2)
for ele1, ele2 in zip(xyz_1.split('\n')[:-1], xyz_2.split('\n')[:-1]):
self.assertEqual(ele1.split(' ')[2], ele2.split(' ')[2])
def test_merge_system():
"""Test merging of a system created from AMBER and another created from SMIRNOFF."""
from .utils import create_system_from_amber, get_amber_file_path, get_alkethoh_file_path
# Create System from AMBER
prmtop_filename, inpcrd_filename = get_amber_file_path(
'cyclohexane_ethanol_0.4_0.6')
system0, topology0, positions0 = create_system_from_amber(
prmtop_filename, inpcrd_filename)
# TODO:
from openeye import oechem
# Load simple OEMol
alkethoh_mol2_filepath = get_alkethoh_file_path('AlkEthOH_c100')[0]
ifs = oechem.oemolistream(alkethoh_mol2_filepath)
mol = oechem.OEMol()
flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield
ifs.SetFlavor(oechem.OEFormat_MOL2, flavor)
oechem.OEReadMolecule(ifs, mol)
oechem.OETriposAtomNames(mol)
# Load forcefield file.
AlkEthOH_offxml_filename = utils.get_data_file_path(
'test_forcefields/Frosst_AlkEthOH.offxml')
forcefield = ForceField(AlkEthOH_offxml_filename)
# Create OpenMM System and Topology.
off_mol = Molecule.from_openeye(mol, allow_undefined_stereo=True)
off_top = Topology.from_molecules([off_mol])
system1 = forcefield.create_openmm_system(off_top)
topology1 = structure.generateTopologyFromOEMol(mol)
positions1 = structure.extractPositionsFromOEMol(mol)
structure.merge_system(topology0,
topology1,
system0,
system1,
positions0,
positions1,
verbose=True)
def master():
mol = oechem.OEMol()
ifs = oechem.oemolistream(input_smiles_file)
ifs.SetConfTest(oechem.OEAbsCanonicalConfTest())
for pos, mol in enumerate(ifs.GetOEMols()):
smiles = oechem.OEMol(mol)
ligand_name = smiles.GetTitle()
status = MPI.Status()
comm.recv(source=MPI.ANY_SOURCE, tag=WORKTAG, status=status)
rank_from = status.Get_source()
data = (pos, smiles, ligand_name)
comm.send(data, dest=rank_from, tag=WORKTAG)
if args.v == 1 and pos % 1000 == 0:
print("sent", pos, "jobs", flush=True)
for i in range(1, world_size):
comm.send([], dest=i, tag=DIETAG)
comm.Barrier()
def main(argv=[__name__]):
if len(argv) != 3:
oechem.OEThrow.Usage("%s <protein> <ligands>" % argv[0])
protein = oechem.OEMol()
ifs = oechem.oemolistream()
if not ifs.open(argv[1]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[1])
oechem.OEReadMolecule(ifs, protein)
oechem.OEAssignBondiVdWRadii(protein)
oechem.OEMMFFAtomTypes(protein)
oechem.OEMMFF94PartialCharges(protein)
print("protein: " + protein.GetTitle())
epsin = 1.0
bind = oezap.OEBind()
bind.GetZap().SetInnerDielectric(epsin)
bind.SetProtein(protein)
results = oezap.OEBindResults()
if not ifs.open(argv[2]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[2])
ifs.SetConfTest(oechem.OEIsomericConfTest())
ligand = oechem.OEMol()
while oechem.OEReadMolecule(ifs, ligand):
oechem.OEAssignBondiVdWRadii(ligand)
oechem.OEMMFFAtomTypes(ligand)
oechem.OEMMFF94PartialCharges(ligand)
print("ligand: %s has %d conformers" %
(ligand.GetTitle(), ligand.NumConfs()))
for conf in ligand.GetConfs():
bind.Bind(conf, results)
print(" conf# %d be = %f" %
(conf.GetIdx(), results.GetBindingEnergy()))
return 0
def main(argv=[__name__]):
itf = oechem.OEInterface(InterfaceData, argv)
ifname = itf.GetString("-in")
ofname = itf.GetString("-ringdict")
ifs = oechem.oemolistream()
if not ifs.open(ifname):
oechem.OEThrow.Fatal("Unable to open %s for reading!" % ifname)
if not oechem.OEIs2DFormat(ifs.GetFormat()):
oechem.OEThrow.Fatal("Invalid input file format for 2D coordinates!")
ofs = oechem.oemolostream()
if not ofs.open(ofname):
oechem.OEThrow.Fatal("Unable to open %s for writing!" % ofname)
if ofs.GetFormat() != oechem.OEFormat_OEB:
oechem.OEThrow.Fatal("Output file has to be OEB format!")
opts = oechem.OE2DRingDictionaryCreatorOptions()
opts.SetRetainExistingBuiltInTemplates(itf.GetBool('-retain-built-in'))
ringdict = oechem.OE2DRingDictionary(opts)
dots = oechem.OEDots(10000, 100, "molecules")
for mol in ifs.GetOEGraphMols():
dots.Update()
ringdict.AddRings(mol)
nrrings = ringdict.NumRings()
oechem.OEThrow.Info("%d ring template(s) have been extracted!" % nrrings)
if nrrings != 0:
oechem.OEWrite2DRingDictionary(ofname, ringdict)
return 0
def main(argv=[__name__]):
if len(argv) != 3:
oechem.OEThrow.Usage("%s <mol-infile> <mol-outfile>" % argv[0])
ifs = oechem.oemolistream()
if not ifs.open(argv[1]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[1])
ofs = oechem.oemolostream()
if not ofs.open(argv[2]):
oechem.OEThrow.Fatal("Unable to open %s for writing" % argv[2])
mol = oechem.OEGraphMol()
while oechem.OEReadMolecule(ifs, mol):
if oequacpac.OESetNeutralpHModel(mol):
oechem.OEWriteMolecule(ofs, mol)
else:
msg = ("Unable to set a neutral pH model for molecule: %s" %
mol.GetTile())
oechem.OEThrow.Warning(msg)
return 0
def main(argv=[__name__]):
if len(argv) != 3:
oechem.OEThrow.Usage("%s <protein> <ligand>" % argv[0])
ifs = oechem.oemolistream()
if not ifs.open(argv[1]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[1])
protein = oechem.OEGraphMol()
oechem.OEReadMolecule(ifs, protein)
if not ifs.open(argv[2]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[2])
ligand = oechem.OEGraphMol()
oechem.OEReadMolecule(ifs, ligand)
oechem.OEAssignBondiVdWRadii(protein)
oechem.OEMMFFAtomTypes(protein)
oechem.OEMMFF94PartialCharges(protein)
oechem.OEAssignBondiVdWRadii(ligand)
oechem.OEMMFFAtomTypes(ligand)
oechem.OEMMFF94PartialCharges(ligand)
cmplx = oechem.OEGraphMol(protein)
oechem.OEAddMols(cmplx, ligand)
epsin = 1.0
spacing = 0.5
zap = oezap.OEZap()
zap.SetInnerDielectric(epsin)
zap.SetGridSpacing(spacing)
PrintHeader(protein.GetTitle(), ligand.GetTitle())
CalcBindingEnergy(zap, protein, ligand, cmplx)
zap.SetFocusTarget(ligand)
CalcBindingEnergy(zap, protein, ligand, cmplx)
return 0
def read_pdb_file(pdb_file):
print(f'Reading receptor from {pdb_file}...')
from openeye import oechem
ifs = oechem.oemolistream()
ifs.SetFlavor(oechem.OEFormat_PDB,
oechem.OEIFlavor_PDB_Default | oechem.OEIFlavor_PDB_DATA
| oechem.OEIFlavor_PDB_ALTLOC) # noqa
if not ifs.open(pdb_file):
oechem.OEThrow.Fatal("Unable to open %s for reading." % pdb_file)
temp_mol = oechem.OEGraphMol()
if not oechem.OEReadMolecule(ifs, temp_mol):
oechem.OEThrow.Fatal("Unable to read molecule from %s." % pdb_file)
ifs.close()
fact = oechem.OEAltLocationFactory(temp_mol)
mol = oechem.OEGraphMol()
mol.Clear()
fact.MakePrimaryAltMol(mol)
return (mol)
def GetUrlSDF2SMI(url, fout, ntries=20, poll_wait=10):
'''Get PubChem SDF.GZ, convert to SMILES using the SD tag PUBCHEM_OPENEYE_CAN_SMILES
or PUBCHEM_OPENEYE_ISO_SMILES, and PUBCHEM_COMPOUND_CID or PUBCHEM_COMPOUND_SID for name.'''
import openeye.oechem as oechem
def HandleOEErrors(oeerrs, nowarn):
errstr = oeerrs.str()
for line in errstr.split('\n'):
if not line.rstrip(): continue
if re.search('Warning', line, re.I) and nowarn: continue
sys.stderr.write("%s\n" % line)
oeerrs.clear()
fout_tmp = tempfile.NamedTemporaryFile(prefix='pubchem_ftp_',
suffix='.sdf.gz',
delete=False)
GetUrl(url, fout_tmp, ntries, poll_wait)
fpath_tmp = fout_tmp.name
logging.debug('fpath_tmp = %s' % fpath_tmp)
fout_tmp.close()
ims = oechem.oemolistream(fpath_tmp)
ims.SetFormat(oechem.OEFormat_SDF)
ims.Setgz(True)
mol = oechem.OEGraphMol()
nbytes = 0
oeerrs = oechem.oeosstream()
oechem.OEThrow.SetOutputStream(oeerrs)
while oechem.OEReadMolecule(ims, mol):
cid = oechem.OEGetSDData(mol, 'PUBCHEM_COMPOUND_CID')
cansmi = oechem.OEGetSDData(mol, 'PUBCHEM_OPENEYE_CAN_SMILES')
isosmi = oechem.OEGetSDData(mol, 'PUBCHEM_OPENEYE_ISO_SMILES')
buff = ("%s %s\n" % (isosmi, cid))
fout.write(buff)
nbytes += len(buff)
HandleOEErrors(oeerrs, True)
os.remove(fpath_tmp)
return nbytes
def smi2indivSdf(wdir, smiles):
"""
From a file containing smiles strings, generate omega conformers,
resolve steric clashes, do a quick MM opt, and write SDF output
as individual files.
Parameters
----------
wdir: str - working directory containing .smi file
smiles: str - name of the smiles file. E.g. "name.smi"
"""
os.chdir(wdir)
### Read in smiles file.
ifs = oechem.oemolistream()
if not ifs.open(smiles):
oechem.OEThrow.Warning("Unable to open %s for reading" % smiles)
### For each molecule: label atoms, generate 1 conf, write output.
for i, smimol in enumerate(ifs.GetOEMols()):
oechem.OETriposAtomNames(smimol)
mol = GenerateConfs(smimol)
### Open output file to write molecules.
sdfout = smiles.split('.')[0] + '-%d.sdf' %(i)
ofs = oechem.oemolostream()
if os.path.exists(sdfout):
#sys.exit("Output .sdf file already exists. Exiting.\n")
print("Output .sdf file already exists. Exiting.\n")
return
if not ofs.open(sdfout):
oechem.OEThrow.Fatal("Unable to open %s for writing" % sdfout)
oechem.OEWriteConstMolecule(ofs, mol)
ofs.close()
### Close files.
ifs.close()
def load_molecules(filename):
"""
Read molecules from the specified file
Parameters
----------
filename : str
The file name from which to read molecules in a format that OpenEye supports
Returns
-------
target_molecules : list of OEMol
The list of molecules read (without conformers if none were provided in file)
"""
from openeye import oechem
target_molecules = list()
with oechem.oemolistream(target_molecules_filename) as ifs:
for mol in ifs.GetOEGraphMols():
# Store a copy
target_molecules.append(oechem.OEGraphMol(mol))
return target_molecules
def __init__(self, pdb_file, xmax, ymax, zmax, xmin, ymin, zmin):
self.receptor = oechem.OEGraphMol()
self.scorers = {
'Shapegauss': oedocking.OEScore(oedocking.OEScoreType_Shapegauss),
'Chemscore': oedocking.OEScore(oedocking.OEScoreType_Chemscore),
'Chemgauss': oedocking.OEScore(oedocking.OEScoreType_Chemgauss),
'Chemgauss3': oedocking.OEScore(oedocking.OEScoreType_Chemgauss3),
'Chemgauss4': oedocking.OEScore(oedocking.OEScoreType_Chemgauss4),
}
proteinStructure = oechem.OEGraphMol()
ifs = oechem.oemolistream(pdb_file)
ifs.SetFormat(oechem.OEFormat_PDB)
oechem.OEReadMolecule(ifs, proteinStructure)
box = oedocking.OEBox(xmax, ymax, zmax, xmin, ymin, zmin)
receptor = oechem.OEGraphMol()
s = oedocking.OEMakeReceptor(receptor, proteinStructure, box)
for _, score in self.scorers.items():
assert (s != False)
score.Initialize(receptor)
def ParameterizeOE(path):
"""
Reads in the PDB from 'RunDocking' and outputs 'charged.mol2' of the ligand
Then runs antechamber to convert this to coordinate (.inpcrd) and
parameter (.prmtop) files.
"""
from openeye import oechem, oeomega, oequacpac
mol = oechem.OEMol()
ifs = oechem.oemolistream()
if ifs.open(f'{path}/lig.pdb'):
oechem.OEReadMolecule(ifs, mol)
ifs.close()
if not oequacpac.OEAssignCharges(mol, oequacpac.OEAM1BCCCharges()):
raise (RuntimeError("OEAssignCharges failed."))
ofs = oechem.oemolostream()
if ofs.open(f'{path}/charged.mol2'):
oechem.OEWriteMolecule(ofs, mol)
import subprocess
with working_directory(path):
subprocess.check_output(
f'antechamber -i lig.pdb -fi pdb -o lig.mol2 -fo mol2 -pf y -an y -a charged.mol2 -fa mol2 -ao crg',
shell=True)
subprocess.check_output(f'parmchk2 -i lig.mol2 -f mol2 -o lig.frcmod',
shell=True)
# Wrap tleap
with open(f'leap.in', 'w+') as leap:
leap.write("source leaprc.protein.ff14SBonlysc\n")
leap.write("source leaprc.gaff\n")
leap.write("set default PBRadii mbondi3\n")
leap.write("rec = loadPDB apo.pdb # May need full filepath?\n")
leap.write("saveAmberParm rec apo.prmtop apo.inpcrd\n")
leap.write("lig = loadmol2 lig.mol2\n")
leap.write("loadAmberParams lig.frcmod\n")
leap.write("com = combine {rec lig}\n")
leap.write("saveAmberParm lig lig.prmtop lig.inpcrd\n")
leap.write("saveAmberParm com com.prmtop com.inpcrd\n")
leap.write("quit\n")
subprocess.check_output(f'tleap -f leap.in', shell=True)
def __init__(self, ipf, keepAlts=F, verbose=T):
self.ipf = ipf
self.keepAlts = keepAlts
self.verbose = verbose
flavor = oechem.OEIFlavor_PDB_Default
ims = oechem.oemolistream()
ims.SetFlavor(oechem.OEFormat_PDB, flavor)
if not ims.open(self.ipf):
oechem.OEThrow.Fatal("Unable to open %s for reading." % self.ipf)
if not oechem.OEIs3DFormat(ims.GetFormat()):
oechem.OEThrow.Fatal("%s is not in a 3D format." % self.ipf)
iftp = oechem.OEGetFileType(oechem.OEGetFileExtension(self.ipf))
if (iftp == oechem.OEFormat_PDB) and not self.keepAlts:
oechem.OEThrow.Verbose(
"Default processing of alt locations (keep just 'A' and ' ').")
inmol = oechem.OEGraphMol()
if not oechem.OEReadMolecule(ims, inmol):
oechem.OEThrow.Fatal("Unable to read %s." % self.ipf)
ims.close()
if (inmol.NumAtoms() == 0):
oechem.OEThrow.Fatal("Input molecule %s contains no atoms." %
self.ipf)
if inmol.GetTitle() == "":
inmol.SetTitle(ipf[:-4])
oechem.OEThrow.Verbose("Processing %s." % inmol.GetTitle())
if not oechem.OEHasResidues(inmol):
oechem.OEPerceiveResidues(inmol, oechem.OEPreserveResInfo_All)
self.inmol = inmol
self.mol = inmol.CreateCopy()
def main(argv=sys.argv):
if len(argv) != 3:
oechem.OEThrow.Usage(
"%s <infile (forcefield types)> <outfile (Tripos types)>" %
argv[0])
ifs = oechem.oemolistream()
flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield
ifs.SetFlavor(oechem.OEFormat_MOL2, flavor)
if not ifs.open(argv[1]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[1])
ofs = oechem.oemolostream()
if not ofs.open(argv[2]):
oechem.OEThrow.Fatal("Unable to open %s for writing" % argv[2])
for mol in ifs.GetOEMols():
oechem.OETriposAtomNames(mol)
oechem.OEWriteConstMolecule(ofs, mol)
ifs.close()
ofs.close()
def read_oe_molecule(file_path, conformer_idx=None):
from openeye import oechem
# Open input file stream
ifs = oechem.oemolistream()
if not ifs.open(file_path):
oechem.OEThrow.Fatal('Unable to open {}'.format(file_path))
# Read all conformations
for mol in ifs.GetOEMols():
try:
molecule.NewConf(mol)
except UnboundLocalError:
molecule = oechem.OEMol(mol)
# Select conformation of interest
if conformer_idx is not None:
if molecule.NumConfs() <= conformer_idx:
raise ValueError('conformer_idx {} out of range'.format(conformer_idx))
molecule = oechem.OEGraphMol(molecule.GetConf(oechem.OEHasConfIdx(conformer_idx)))
return molecule
def confs2psi(insdf, method, basis, spe=False, memory=None):
"""
Parameters
----------
insdf: string - PATH+name of SDF file
method: string - method. E.g. "mp2"
basis: string - basis set. E.g. "def2-sv(p)"
spe: boolean. True for single point energy calcns, False for geom opt.
default option is False.
memory: string - memory specification. Psi4 default is 256 Mb. E.g. "1.5 Gb"
"""
wdir = os.getcwd()
### Read in .sdf file and distinguish each molecule's conformers
ifs = oechem.oemolistream()
ifs.SetConfTest( oechem.OEAbsoluteConfTest() )
if not ifs.open(insdf):
oechem.OEThrow.Warning("Unable to open %s for reading" % insdf)
return
### For each molecule: for each conf, generate input
for mol in ifs.GetOEMols():
print(mol.GetTitle(), mol.NumConfs())
if not mol.GetTitle():
sys.exit("ERROR: OEMol must have title assigned! Exiting.")
for i, conf in enumerate( mol.GetConfs()):
# change into subdirectory ./mol/conf/
subdir = os.path.join(wdir,"%s/%s" % (mol.GetTitle(), i+1))
if not os.path.isdir(subdir):
os.makedirs(subdir)
if os.path.exists(os.path.join(subdir,'input.dat')):
print("Input file (\"input.dat\") already exists. Skipping.\n")
continue
label = mol.GetTitle()+'_'+str(i+1)
ofile = open(os.path.join(subdir,'input.dat'), 'w')
ofile.write(make_psi_input( conf, label, method, basis, spe, memory))
ofile.close()
ifs.close()
def test_success(self):
print('Testing cube:', self.cube.name)
# File name
fname = ommutils.get_data_filename('examples', 'data/Bace_protein.pdb')
# Read OEMol molecule
mol = oechem.OEMol()
with oechem.oemolistream(fname) as ifs:
oechem.OEReadMolecule(ifs, mol)
atom_i = mol.GetMaxAtomIdx()
# Process the molecules
self.cube.process(mol, self.cube.intake.name)
# Assert that one molecule was emitted on the success port
self.assertEqual(self.runner.outputs['success'].qsize(), 1)
# Assert that zero molecules were emitted on the failure port
self.assertEqual(self.runner.outputs['failure'].qsize(), 0)
outmol = self.runner.outputs["success"].get()
atom_f = outmol.GetMaxAtomIdx()
self.assertEquals(atom_i, atom_f)
# Check Total number of atoms
prot, lig, wat, other = utils.split(outmol)
# Check protein, ligand, excipients and water number of atoms
npa = prot.GetMaxAtomIdx()
nla = lig.GetMaxAtomIdx()
noa = other.GetMaxAtomIdx()
nwa = wat.GetMaxAtomIdx()
self.assertEquals(npa, 6044)
self.assertEquals(nla, 0)
self.assertEquals(noa, 14)
self.assertEquals(nwa, 57)
def main(argv=[__name__]):
if len(argv) != 4:
oechem.OEThrow.Usage("%s <csvfile> <infile> <outsdfile>" % argv[0])
try:
csvfile = open(argv[1])
except Exception:
oechem.OEThrow.Fatal("Unable to open %s csv for reading" % argv[1])
ifs = oechem.oemolistream()
if not ifs.open(argv[2]):
oechem.OEThrow.Fatal("Unable to open %s for reading" % argv[2])
ofs = oechem.oemolostream()
if not ofs.open(argv[3]):
oechem.OEThrow.Fatal("Unable to open %s for writing" % argv[3])
if ofs.GetFormat() not in [oechem.OEFormat_SDF, oechem.OEFormat_OEB]:
oechem.OEThrow.Fatal("Only works for sdf or oeb output files")
CSV2SDF(csvfile, ifs, ofs)
csvfile.close()
def test_generat_torsions(self):
""" Tests finding torsion to drive """
from openeye import oechem
infile = get_fn('butane.pdb')
ifs = oechem.oemolistream(infile)
inp_mol = oechem.OEMol()
oechem.OEReadMolecule(ifs, inp_mol)
outfile_path = tempfile.mkdtemp()[1]
qmscan.generate_torsions(inp_mol=inp_mol, output_path=outfile_path, interval=30, tar=False)
input_files = []
pattern = '*.pdb'
for path, subdir, files in os.walk(outfile_path):
for name in files:
if fnmatch(name, pattern):
input_files.append(os.path.join(path, name))
contents = open(input_files[0]).read()
pdb = get_fn('butane_10_7_4_3_0.pdb')
compare_contents = open(pdb).read()
self.assertEqual(contents, compare_contents )
shutil.rmtree(outfile_path)
def deserializeOe(self, oeS):
"""Reconstruct an OE molecule from the input string serialization (OE binary).
The deserialized molecule is used to initialize the internal OE molecule
within this object.
Returns:
list: OE GraphMol list
"""
molList = []
try:
ims = oechem.oemolistream()
ims.SetFormat(oechem.OEFormat_OEB)
ims.openstring(oeS)
for mol in ims.GetOEGraphMols():
logger.debug("SMILES %s", oechem.OECreateCanSmiString(mol))
logger.debug("title %s", mol.GetTitle())
logger.debug("atoms %d", mol.NumAtoms())
molList.append(oechem.OEGraphMol(mol))
except Exception as e:
logger.exception("Failing with %s", str(e))
return molList
def request_structure(pdb_id, file_format):
# request structure
if file_format == 'mmcif':
url = f'https://files.rcsb.org/download/{pdb_id}.cif'
elif file_format == 'pdb':
url = f'https://files.rcsb.org/download/{pdb_id}.pdb'
else:
print(f'Unsupported file format: {file_format}. Returning None')
return None
response = requests.get(url)
# store structure in temporary file
with tempfile.NamedTemporaryFile(suffix='.' +
file_format) as temp_file:
temp_file.write(response.content)
# read structure from temporary file
with oechem.oemolistream() as ifs:
if file_format == 'mmcif':
ifs.SetFlavor(oechem.OEFormat_MMCIF,
oechem.OEIFlavor_MMCIF_Default)
elif file_format == 'pdb':
ifs.SetFlavor(
oechem.OEFormat_PDB, oechem.OEIFlavor_PDB_Default
| oechem.OEIFlavor_PDB_DATA
| oechem.OEIFlavor_PDB_ALTLOC)
else:
print(
f'Unsupported file format: {file_format}. Returning None'
)
return None
ifs.open(temp_file.name)
mol = oechem.OEGraphMol()
if not oechem.OEReadMolecule(ifs, mol):
mol = None
return mol
def read_file (filename):
"""
Reads a .mol2 file and returns title of molecule , base molecule object
and `OEMol' objects.
@type filename: C{str}
@param filename: Name of the structure file
"""
ret = []
istream = oechem.oemolistream()
istream.open(filename)
molecule = oechem.OEMol()
oechem.OEReadMolecule(istream, molecule)
istream.close()
struc = OeStruc(molecule)
for i in range(1, len(struc.atom) + 1) :
struc.atom_prop[i]["orig_index"] = i
ret.append(struc)
return ret
def test_change_parameters(verbose=False):
"""Test modification of forcefield parameters."""
from openeye import oechem
# Load simple OEMol
ifs = oechem.oemolistream(get_data_filename('molecules/AlkEthOH_c100.mol2'))
mol = oechem.OEMol()
flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield
ifs.SetFlavor( oechem.OEFormat_MOL2, flavor)
oechem.OEReadMolecule(ifs, mol )
oechem.OETriposAtomNames(mol)
# Load forcefield file
ffxml = get_data_filename('forcefield/Frosst_AlkEtOH.ffxml')
ff = ForceField(ffxml)
from smarty.forcefield import generateTopologyFromOEMol
topology = generateTopologyFromOEMol(mol)
# Create initial system
system = ff.createSystem(topology, [mol], verbose=verbose)
# Get initial energy before parameter modification
positions = positions_from_oemol(mol)
old_energy=get_energy(system, positions)
# Get params for an angle
params = ff.getParameter(smirks='[a,A:1]-[#6X4:2]-[a,A:3]')
# Modify params
params['k']='0.0'
ff.setParameter(params, smirks='[a,A:1]-[#6X4:2]-[a,A:3]')
# Write params
ff.writeFile( tempfile.TemporaryFile(suffix='.ffxml') )
# Make sure params changed energy! (Test whether they get rebuilt on system creation)
system=ff.createSystem(topology, [mol], verbose=verbose)
energy=get_energy(system, positions)
if verbose:
print("New energy/old energy:", energy, old_energy)
if np.abs(energy-old_energy)<0.1:
raise Exception("Error: Parameter modification did not change energy.")
def test_mapped_xyz(self):
"""Test writing out mapped xyz"""
from openeye import oechem, oeomega
tagged_smiles = '[H:10][c:4]1[c:3]([c:2]([c:1]([c:6]([c:5]1[H:11])[H:12])[C:7]([H:13])([H:14])[H:15])[H:8])[H:9]'
mol_1 = openeye.smiles_to_oemol('Cc1ccccc1')
inf = get_fn('toluene.mol2')
ifs = oechem.oemolistream(inf)
mol_2 = oechem.OEMol()
oechem.OEReadMolecule(ifs, mol_2)
atom_map = utils.get_atom_map(tagged_smiles, mol_1)
for i, mapping in enumerate(atom_map):
atom_1 = mol_1.GetAtom(oechem.OEHasAtomIdx(atom_map[mapping]))
atom_1.SetAtomicNum(i+1)
atom_2 = mol_2.GetAtom(oechem.OEHasAtomIdx(mapping-1))
atom_2.SetAtomicNum(i+1)
xyz_1 = utils.to_mapped_xyz(mol_1, atom_map)
# molecule generated from mol2 should be in the right order.
atom_map_mol2 = {1:0, 2:1, 3:2, 4:3, 5:4, 6:5, 7:6, 8:7, 9:8, 10:9, 11:10, 12:11, 13:12, 14:13, 15:14}
xyz_2 = utils.to_mapped_xyz(mol_2, atom_map_mol2)
for ele1, ele2 in zip(xyz_1.split('\n')[:-1], xyz_2.split('\n')[:-1]):
self.assertEqual(ele1.split(' ')[2], ele2.split(' ')[2])
def mol_to_tagged_smiles(infile, outfile):
"""
Generate .smi from input mol with index-tagged explicit hydrogen SMILES
Parameters
----------
infile: str
input molecule file
outfile: str
output smi file. Must be smi or ism
"""
ifs = oechem.oemolistream()
if not ifs.open(infile):
oechem.OEThrow.Fatal("Unable to open {} for reading".format(infile))
ofs = oechem.oemolostream()
if not ofs.open(outfile):
oechem.OEThrow.Fatal("Unable to open {} for writing".format(outfile))
if ofs.GetFormat() not in [oechem.OEFormat_ISM, oechem.OEFormat_SMI]:
oechem.OEThrow.Fatal("Output format must be SMILES")
for mol in ifs.GetOEMols():
smiles = create_mapped_smiles(mol)
oechem.OEWriteMolecule(ofs, mol)
def enumerate_conformations(name, smiles=None, pdbname=None):
"""Run Epik to get protonation states using PDB residue templates for naming.
Parameters
----------
name : str
Common name of molecule (used to create subdirectory)
smiles : str
Isomeric SMILES string
pdbname : str
Three-letter PDB code (e.g. 'DB8')
"""
# Create output subfolder
output_basepath = os.path.join(output_dir, name)
if not os.path.isdir(output_basepath):
os.mkdir(output_basepath)
output_basepath = os.path.join(output_basepath, name)
if pdbname:
# Make sure to only use one entry if there are mutliple
if ' ' in pdbname:
pdbnames = pdbname.split(' ')
print("Splitting '%s' into first entry only: '%s'" % (pdbname, pdbnames[0]))
pdbname = pdbnames[0]
# Retrieve PDB (for atom names)
url = 'http://ligand-expo.rcsb.org/reports/%s/%s/%s_model.pdb' % (pdbname[0], pdbname, pdbname)
pdb_filename = output_basepath + '-input.pdb'
retrieve_url(url, pdb_filename)
pdb_molecule = read_molecule(pdb_filename)
# Retrieve SDF (for everything else)
url = 'http://ligand-expo.rcsb.org/reports/%s/%s/%s_model.sdf' % (pdbname[0], pdbname, pdbname)
sdf_filename = output_basepath + '-input.sdf'
retrieve_url(url, sdf_filename)
sdf_molecule = read_molecule(sdf_filename)
# Replace atom names in SDF
for (sdf_atom, pdb_atom) in zip(sdf_molecule.GetAtoms(), pdb_molecule.GetAtoms()):
sdf_atom.SetName(pdb_atom.GetName())
# Assign Tripos atom types
oechem.OETriposAtomTypeNames(sdf_molecule)
oechem.OETriposBondTypeNames(sdf_molecule)
oe_molecule = sdf_molecule
# We already know the residue name
residue_name = pdbname
elif smiles:
# Generate molecule geometry with OpenEye
print("Generating molecule {}".format(name))
oe_molecule = openeye.smiles_to_oemol(smiles)
# Assign Tripos atom types
oechem.OETriposAtomTypeNames(oe_molecule)
oechem.OETriposBondTypeNames(oe_molecule)
try:
oe_molecule = openeye.get_charges(oe_molecule, keep_confs=1)
except RuntimeError as e:
traceback.print_exc()
print("Skipping molecule " + name)
return
residue_name = re.sub('[^A-Za-z]+', '', name.upper())[:3]
else:
raise Exception('Must provide SMILES string or pdbname')
# Save mol2 file, preserving atom names
print("Running epik on molecule {}".format(name))
mol2_file_path = output_basepath + '-input.mol2'
write_mol2_preserving_atomnames(mol2_file_path, oe_molecule, residue_name)
# Run epik on mol2 file
mae_file_path = output_basepath + '-epik.mae'
schrodinger.run_epik(mol2_file_path, mae_file_path, tautomerize=False,
max_structures=100, min_probability=np.exp(-MAX_ENERGY_PENALTY), ph=7.4)
# Convert maestro file to sdf and mol2
output_sdf_filename = output_basepath + '-epik.sdf'
output_mol2_filename = output_basepath + '-epik.mol2'
schrodinger.run_structconvert(mae_file_path, output_sdf_filename)
schrodinger.run_structconvert(mae_file_path, output_mol2_filename)
# Read SDF file.
ifs_sdf = oechem.oemolistream()
ifs_sdf.SetFormat(oechem.OEFormat_SDF)
ifs_sdf.open(output_sdf_filename)
sdf_molecule = oechem.OEGraphMol()
# Read MOL2 file.
ifs_mol2 = oechem.oemolistream()
ifs_mol2.open(output_mol2_filename)
mol2_molecule = oechem.OEMol()
# Assign charges.
charged_molecules = list()
index = 0
while oechem.OEReadMolecule(ifs_sdf, sdf_molecule):
oechem.OEReadMolecule(ifs_mol2, mol2_molecule)
index += 1
print("Charging molecule %d" % (index))
try:
# Charge molecule.
charged_molecule = openeye.get_charges(mol2_molecule, max_confs=800, strictStereo=False, normalize=True, keep_confs=None)
# Assign Tripos types
oechem.OETriposAtomTypeNames(charged_molecule)
oechem.OETriposBondTypeNames(charged_molecule)
# Store tags.
oechem.OECopySDData(charged_molecule, sdf_molecule)
# Store molecule
charged_molecules.append(charged_molecule)
except Exception as e:
print(e)
print("Skipping protomer/tautomer because of failed charging.")
# Clean up
ifs_sdf.close()
ifs_mol2.close()
# Write state penalites.
outfile = open(output_basepath + '-state-penalties.out', 'w')
for (index, charged_molecule) in enumerate(charged_molecules):
# Get Epik data.
epik_Ionization_Penalty = float(oechem.OEGetSDData(charged_molecule, "r_epik_Ionization_Penalty"))
epik_Ionization_Penalty_Charging = float(oechem.OEGetSDData(charged_molecule, "r_epik_Ionization_Penalty_Charging"))
epik_Ionization_Penalty_Neutral = float(oechem.OEGetSDData(charged_molecule, "r_epik_Ionization_Penalty_Neutral"))
epik_State_Penalty = float(oechem.OEGetSDData(charged_molecule, "r_epik_State_Penalty"))
epik_Tot_Q = int(oechem.OEGetSDData(charged_molecule, "i_epik_Tot_Q"))
outfile.write('%16.8f\n' % epik_State_Penalty)
outfile.close()
# Write as PDB
charged_pdb_filename = output_basepath + '-epik-charged.pdb'
ofs = oechem.oemolostream(charged_pdb_filename)
flavor = oechem.OEOFlavor_PDB_CurrentResidues | oechem.OEOFlavor_PDB_ELEMENT | oechem.OEOFlavor_PDB_BONDS | oechem.OEOFlavor_PDB_HETBONDS | oechem.OEOFlavor_PDB_BOTH
ofs.SetFlavor(oechem.OEFormat_PDB, flavor)
for (index, charged_molecule) in enumerate(charged_molecules):
# Fix residue names
for atom in charged_molecule.GetAtoms():
residue = oechem.OEAtomGetResidue(atom)
residue.SetName(residue_name)
oechem.OEAtomSetResidue(atom, residue)
#oechem.OEWritePDBFile(ofs, charged_molecule, flavor)
oechem.OEWriteMolecule(ofs, charged_molecule)
ofs.close()
# Write molecules as mol2.
charged_mol2_filename = output_basepath + '-epik-charged.mol2'
write_mol2_preserving_atomnames(charged_mol2_filename, charged_molecules, residue_name)
#!/usr/bin/env python
"""
Generate ffxml files for ligands in a multi-mole mol2.
"""
import openeye
import openmoltools
mol2_filename = 'Imatinib-epik-charged.mol2'
ffxml_filename = 'Imatinib-epik-charged.ffxml'
# Read mol2 file containing protonation states and extract canonical isomeric SMILES from this.
print("Reading molecules")
from openeye import oechem
ifs = oechem.oemolistream(mol2_filename)
mol = oechem.OEMol()
molecules = list()
while oechem.OEReadMolecule(ifs, mol):
molecules.append(oechem.OEMol(mol))
print("Generating forcefield parameters...")
from openmoltools.forcefield_generators import generateForceFieldFromMolecules
ffxml = generateForceFieldFromMolecules(molecules, ignoreFailures=False, generateUniqueNames=True)
print("Writing forcefield to '%s'..." % ffxml_filename)
outfile = open(ffxml_filename, 'w')
outfile.write(ffxml)
outfile.close()
def _read_mol2(mol2_filename):
mol = oechem.OEMol()
istream = oechem.oemolistream()
istream.open(mol2_filename)
oechem.OEReadMol2File(istream, mol)
return mol
