class BenchmarkCube(SourceCube):
title = "OpenMM BenchmarkCube"
description = """
Cube that performs a benchmark of OpenMM on all of the different
platforms that are available and outputs the byte string
resulting from the benchmarks line by line to its success port
"""
tags = [["OpenMM", "Benchmarking"]]
success = BinaryOutputPort("success")
cutoff = parameter.DecimalParameter("cutoff", default=0.9)
seconds = parameter.IntegerParameter("seconds", default=60)
polarization = parameter.StringParameter(
"polarization",
default="mutual",
choices=["direct", "extrapolated", "mutual"])
amoeba_target_epsilon = parameter.DecimalParameter(
"amoeba_target_epsilon",
default=1e-5,
title="Amoeba Mutual Induced Target Epsilon")
use_heavy_hydrogens = parameter.BooleanParameter(
"use_heavy_hydrogens", default=False, title="Use Heavy Hydrogens")
precision = parameter.StringParameter(
"precision", default="single", choices=["single", "mixed", "double"])
def __iter__(self):
stream = StringIO()
stream.write("Benchmarking Results:\n")
run_platform_benchmarks(self.args, stream=stream)
stream.flush()
stream.seek(0)
output = stream.readline()
while len(output):
self.log.info(output)
yield output.encode("utf-8")
output = stream.readline()
class OpenMMminimizeCube(ParallelOEMolComputeCube):
title = 'Minimization Cube'
version = "0.0.0"
classification = [["Simulation", "OpenMM", "Minimization"]]
tags = ['OpenMM', 'Parallel Cube']
description = """
Minimize the protein:ligand complex.
This cube will take in the streamed complex.oeb.gz file containing
the solvated protein:ligand complex and minimize it.
Input parameters:
steps (integer): the number of steps of minimization to apply. If 0
the minimization will proceed until convergence is reached
"""
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {
"default": 1
}, # 1 molecule at a time
"item_timeout": {
"default": 43200
}, # Default 12 hour limit (units are seconds)
"item_count": {
"default": 1
} # 1 molecule at a time
}
steps = parameter.IntegerParameter(
'steps',
default=0,
help_text="""Number of minimization steps.
If 0 the minimization will continue
until convergence""")
restraints = parameter.StringParameter(
'restraints',
default='',
help_text="""Mask selection to apply restraints. Possible keywords are:
ligand, protein, water, ions, ca_protein, cofactors.
The selection can be refined by using logical tokens:
not, noh, and, or, diff, around""")
restraintWt = parameter.DecimalParameter(
'restraintWt',
default=5.0,
help_text="Restraint weight for xyz atom restraints in kcal/(mol A^2)")
freeze = parameter.StringParameter(
'freeze',
default='',
help_text="""Mask selection to freeze atoms along the MD
simulation. Possible keywords are: ligand, protein, water,
ions, ca_protein, cofactors. The selection can be refined by
using logical tokens: not, noh, and, or, diff, around""")
temperature = parameter.DecimalParameter('temperature',
default=300,
help_text="Temperature (Kelvin)")
nonbondedMethod = parameter.StringParameter(
'nonbondedMethod',
default='PME',
choices=[
'NoCutoff', 'CutoffNonPeriodic', 'CutoffPeriodic', 'PME', 'Ewald'
],
help_text="NoCutoff, CutoffNonPeriodic, CutoffPeriodic, PME, or Ewald")
nonbondedCutoff = parameter.DecimalParameter(
'nonbondedCutoff',
default=10,
help_text="""The non-bonded cutoff in angstroms.
This is ignored if the non-bonded method is NoCutoff.""")
constraints = parameter.StringParameter(
'constraints',
default='HBonds',
choices=['None', 'HBonds', 'HAngles', 'AllBonds'],
help_text="""None, HBonds, HAngles, or AllBonds
Which type of constraints to add to the system (e.g., SHAKE).
None means no bonds are constrained.
HBonds means bonds with hydrogen are constrained""")
outfname = parameter.StringParameter(
'outfname',
default='min',
help_text='Filename suffix for output simulation files')
center = parameter.BooleanParameter(
'center',
default=False,
description='Center the system to the OpenMM unit cell')
verbose = parameter.BooleanParameter(
'verbose', default=True, description='Increase log file verbosity')
platform = parameter.StringParameter(
'platform',
default='Auto',
choices=['Auto', 'Reference', 'CPU', 'CUDA', 'OpenCL'],
help_text='Select which platform to use to run the simulation')
cuda_opencl_precision = parameter.StringParameter(
'cuda_opencl_precision',
default='single',
choices=['single', 'mixed', 'double'],
help_text='Select the CUDA or OpenCL precision')
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
self.opt['SimType'] = 'min'
return
def process(self, mol, port):
try:
# The copy of the dictionary option as local variable
# is necessary to avoid filename collisions due to
# the parallel cube processes
opt = dict(self.opt)
# Update cube simulation parameters with the eventually molecule SD tags
new_args = {
dp.GetTag(): dp.GetValue()
for dp in oechem.OEGetSDDataPairs(mol)
if dp.GetTag() in ["temperature"]
}
if new_args:
for k in new_args:
try:
new_args[k] = float(new_args[k])
except:
pass
self.log.info(
"Updating parameters for molecule: {}\n{}".format(
mol.GetTitle(), new_args))
opt.update(new_args)
if utils.PackageOEMol.checkTags(mol, ['Structure']):
gd = utils.PackageOEMol.unpack(mol)
opt['outfname'] = '{}-{}'.format(gd['IDTag'],
self.opt['outfname'])
mdData = utils.MDData(mol)
opt['molecule'] = mol
self.log.info('MINIMIZING System: %s' % gd['IDTag'])
simtools.simulation(mdData, **opt)
packedmol = mdData.packMDData(mol)
self.success.emit(packedmol)
except Exception as e:
# Attach error message to the molecule that failed
self.log.error(traceback.format_exc())
mol.SetData('error', str(e))
# Return failed mol
self.failure.emit(mol)
return
class SolvationCube(ParallelOEMolComputeCube):
title = "Solvation Cube Packmol"
version = "0.0.0"
classification = [["Preparation", "OEChem"]]
tags = ['OEChem', 'PackMol']
description = """
This cube solvate the molecular system
Input:
-------
oechem.OEMCMol - Streamed-in of the molecular system
Output:
-------
oechem.OEMCMol - Emits the solvated system
"""
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {
"default": 1
}, # 1 molecule at a time
"item_timeout": {
"default": 3600
}, # Default 1 hour limit (units are seconds)
"item_count": {
"default": 1
} # 1 molecule at a time
}
density = parameter.DecimalParameter('density',
default=1.0,
help_text="Solution density in g/ml")
padding_distance = parameter.DecimalParameter(
'padding_distance',
default=10.0,
help_text=
"The padding distance between the solute and the box edge in A")
distance_between_atoms = parameter.DecimalParameter(
'distance_between_atoms',
default=2.0,
help_text="The minimum distance between atoms in A")
solvents = parameter.StringParameter(
'solvents',
required=True,
default='[H]O[H]',
help_text=
'Select solvents. The solvents are specified as comma separated smiles strings'
'e.g. [H]O[H], C(Cl)(Cl)Cl, CS(=O)C')
molar_fractions = parameter.StringParameter(
'molar_fractions',
default='1.0',
help_text=
"Molar fractions of each solvent components. The molar fractions are specified"
"as comma separated molar fractions strings e.g. 0.5,0.2,0.3")
geometry = parameter.StringParameter(
'geometry',
default='box',
choices=['box', 'sphere'],
help_text=
"Geometry selection: box or sphere. Sphere cannot be used as periodic system "
"along with MD simulation")
close_solvent = parameter.BooleanParameter(
'close_solvent',
default=False,
help_text=
"If Checked/True solvent molecules will be placed very close to the solute"
)
salt = parameter.StringParameter(
'salt',
default='[Na+], [Cl-]',
help_text='Salt type. The salt is specified as list of smiles strings. '
'Each smiles string is the salt component dissociated in the '
'solution e.g. Na+, Cl-')
salt_concentration = parameter.DecimalParameter(
'salt_concentration',
default=0.0,
help_text="Salt concentration in millimolar")
neutralize_solute = parameter.BooleanParameter(
'neutralize_solute',
default=True,
help_text=
'Neutralize the solute by adding Na+ and Cl- counter-ions based on'
'the solute formal charge')
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
def process(self, solute, port):
try:
opt = dict(self.opt)
# Update cube simulation parameters with the eventually molecule SD tags
new_args = {
dp.GetTag(): dp.GetValue()
for dp in oechem.OEGetSDDataPairs(solute)
if dp.GetTag() in ["solvents", "molar_fractions", "density"]
}
if new_args:
for k in new_args:
if k == 'molar_fractions':
continue
try:
new_args[k] = float(new_args[k])
except:
pass
self.log.info(
"Updating parameters for molecule: {}\n{}".format(
solute.GetTitle(), new_args))
opt.update(new_args)
# Solvate the system
sol_system = oesolvate(solute, **opt)
self.log.info("Solvated System atom number {}".format(
sol_system.NumAtoms()))
sol_system.SetTitle(solute.GetTitle())
self.success.emit(sol_system)
except Exception as e:
# Attach error message to the molecule that failed
self.log.error(traceback.format_exc())
solute.SetData('error', str(e))
# Return failed mol
self.failure.emit(solute)
return
class ComplexPrep(OEMolComputeCube):
title = "Complex Preparation Cube"
version = "0.0.0"
classification = [["Complex Preparation", "OEChem", "Complex preparation"]]
tags = ['OEChem']
description = """
This cube assembles the complex made of the solvated system and the
ligands. If a ligand presents multiple conformers, then each conformer
is bonded to the protein to form the solvated complex. For example if a
ligand has 3 conformers then 3 complexes are generated.
Input:
-------
oechem.OEMCMol - Streamed-in of the solvated system and the ligands
Output:
-------
oechem.OEMCMol - Emits the complex molecule
"""
remove_explicit_solvent = parameter.BooleanParameter(
'remove_explicit_solvent',
default=False,
description=
'If True/Checked removes water and ion molecules from the system')
system_port = MoleculeInputPort("system_port")
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
self.wait_on('system_port')
self.count = 0
self.check_system = False
def process(self, mol, port):
try:
if port == 'system_port':
# Remove from solution water and ions
if self.opt['remove_explicit_solvent']:
mol = oeommutils.strip_water_ions(mol)
self.system = mol
self.check_system = True
return
if self.check_system:
num_conf = 0
try:
lig_id = mol.GetData("IDTag")
name = 'p' + self.system.GetTitle() + '_' + lig_id
except:
name = 'p' + self.system.GetTitle() + '_l' + mol.GetTitle(
)[0:12] + '_' + str(self.count)
for conf in mol.GetConfs():
conf_mol = oechem.OEMol(conf)
complx = self.system.CreateCopy()
oechem.OEAddMols(complx, conf_mol)
# Split the complex in components
protein, ligand, water, excipients = oeommutils.split(
complx)
# If the protein does not contain any atom emit a failure
if not protein.NumAtoms(
): # Error: protein molecule is empty
oechem.OEThrow.Fatal(
"The protein molecule does not contains atoms")
# If the ligand does not contain any atom emit a failure
if not ligand.NumAtoms(
): # Error: ligand molecule is empty
oechem.OEThrow.Fatal(
"The Ligand molecule does not contains atoms")
# Check if the ligand is inside the binding site. Cutoff distance 3A
if not oeommutils.check_shell(ligand, protein, 3):
oechem.OEThrow.Fatal(
"The ligand is probably outside the protein binding site"
)
# Removing possible clashes between the ligand and water or excipients
if water.NumAtoms():
water_del = oeommutils.delete_shell(ligand,
water,
1.5,
in_out='in')
if excipients.NumAtoms():
excipient_del = oeommutils.delete_shell(ligand,
excipients,
1.5,
in_out='in')
# Reassemble the complex
new_complex = protein.CreateCopy()
oechem.OEAddMols(new_complex, ligand)
if excipients.NumAtoms():
oechem.OEAddMols(new_complex, excipient_del)
if water.NumAtoms():
oechem.OEAddMols(new_complex, water_del)
name_c = name
if mol.GetMaxConfIdx() > 1:
name_c = name + '_c' + str(num_conf)
new_complex.SetData(oechem.OEGetTag('IDTag'), name_c)
new_complex.SetTitle(name_c)
num_conf += 1
self.success.emit(new_complex)
self.count += 1
except Exception as e:
# Attach error message to the molecule that failed
self.log.error(traceback.format_exc())
mol.SetData('error', str(e))
# Return failed mol
self.failure.emit(mol)
return
class HydrationCube(ParallelOEMolComputeCube):
title = "Solvation Cube"
version = "0.0.0"
classification = [["Complex Preparation", "OEChem", "Complex preparation"]]
tags = ['OEChem', 'OpenMM', 'PDBFixer']
description = """
This cube solvate the molecular system
Input:
-------
oechem.OEMCMol - Streamed-in of the molecular system
Output:
-------
oechem.OEMCMol - Emits the solvated system
"""
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {
"default": 1
}, # 1 molecule at a time
"item_timeout": {
"default": 3600
}, # Default 1 hour limit (units are seconds)
"item_count": {
"default": 1
} # 1 molecule at a time
}
solvent_padding = parameter.DecimalParameter(
'solvent_padding',
default=10.0,
help_text="Padding around protein for solvent box (angstroms)")
salt_concentration = parameter.DecimalParameter(
'salt_concentration',
default=50.0,
help_text="Salt concentration (millimolar)")
ref_structure = parameter.BooleanParameter(
'ref_structure',
default=True,
help_text=
"If Checked/True the molecule before solvation is attached to the solvated one"
)
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
def process(self, system, port):
try:
# Solvate the system
sol_system = utils.hydrate(system, self.opt)
sol_system.SetTitle(system.GetTitle())
# Attached the original system to the solvated one
if self.opt['ref_structure']:
sol_system.SetData(oechem.OEGetTag("RefStructure"), system)
self.success.emit(sol_system)
except Exception as e:
# Attach error message to the molecule that failed
self.log.error(traceback.format_exc())
system.SetData('error', str(e))
# Return failed mol
self.failure.emit(system)
return
class GenerateTorsionalConfs(Cube):
"""
Generate conformers by rotating the primary torsion.
"""
cube_type = constants.CUBE_COMPUTE
num_points = parameter.IntegerParameter(
'num_points',
title='Number of torsional conformers to generate.',
default=24,
min_value=1,
max_value=36,
description="""The number of evenly spaced torsion angles to sample
when generating torsional conformers.""")
split_confs = parameter.BooleanParameter(
'split_confs',
title='Emit each conformer separately',
default=True,
description=
"""Whether conformers should be emitted separately or as part of a single molecule."""
)
best_conf = parameter.BooleanParameter(
'best_conf',
title='For each torsion select single best conformer',
default=True,
description=
"""Whether single best conformer should be emitted for each dihedral angle."""
)
def begin(self):
self.torsion_library = torsion_library
def process(self, mol, port):
fragmentLabel = mol.GetTitle()+'_' +\
'_'.join(get_sd_data(mol, 'TORSION_ATOMS_ParentMol').split())
torsion_tag = 'TORSION_ATOMS_FRAGMENT'
torsion_atoms_in_fragment = get_sd_data(mol, torsion_tag).split()
dihedral_atom_indices = [int(x) - 1 for x in torsion_atoms_in_fragment]
print(fragmentLabel, torsion_atoms_in_fragment, dihedral_atom_indices)
try:
dih, _ = get_dihedral(mol, dihedral_atom_indices)
if self.args.best_conf:
torsional_conformers = get_best_conf(mol, dih,
self.args.num_points)
else:
torsional_conformers = gen_torsional_confs(
mol, dih, self.args.num_points, include_input=False)
if self.args.split_confs:
for pose in split_confs(torsional_conformers):
self.success.emit(pose)
else:
self.success.emit(torsional_conformers)
self.log.info(
'%d torsional conformers generated for fragment %s.' %
(torsional_conformers.NumConfs(), fragmentLabel))
except Exception as e:
self.log.error(
"Could not generate conformers for fragment %s: %s" %
(fragmentLabel, e))
self.failure.emit(mol)
class YankHydrationCube(ParallelOEMolComputeCube):
title = "YankHydrationCube"
description = """
Compute the hydration free energy of a small molecule with YANK.
This cube uses the YANK alchemical free energy code to compute the
transfer free energy of one or more small molecules from gas phase
to TIP3P solvent.
See http://getyank.org for more information about YANK.
"""
classification = ["Alchemical free energy calculations"]
tags = [tag for lists in classification for tag in lists]
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {
"default": 1
}, # 1 molecule at a time
"item_timeout": {
"default": 3600
}, # Default 1 hour limit (units are seconds)
"item_count": {
"default": 1
} # 1 molecule at a time
}
#Define Custom Ports to handle oeb.gz files
intake = CustomMoleculeInputPort('intake')
success = CustomMoleculeOutputPort('success')
failure = CustomMoleculeOutputPort('failure')
# These can override YAML parameters
nsteps_per_iteration = parameter.IntegerParameter(
'nsteps_per_iteration',
default=500,
help_text="Number of steps per iteration")
timestep = parameter.DecimalParameter('timestep',
default=2.0,
help_text="Timestep (fs)")
simulation_time = parameter.DecimalParameter(
'simulation_time',
default=0.100,
help_text="Simulation time (ns/replica)")
temperature = parameter.DecimalParameter('temperature',
default=300.0,
help_text="Temperature (Kelvin)")
pressure = parameter.DecimalParameter('pressure',
default=1.0,
help_text="Pressure (atm)")
solvent = parameter.StringParameter(
'solvent',
default='gbsa',
choices=['gbsa', 'tip3p'],
help_text="Solvent choice: one of ['gbsa', 'tip3p']")
verbose = parameter.BooleanParameter(
'verbose',
default=False,
help_text="Print verbose YANK logging output")
def construct_yaml(self, **kwargs):
# Make substitutions to YAML here.
# TODO: Can we override YAML parameters without having to do string substitutions?
options = {
'timestep':
self.args.timestep,
'nsteps_per_iteration':
self.args.nsteps_per_iteration,
'number_of_iterations':
int(
np.ceil(self.args.simulation_time * unit.nanoseconds /
(self.args.nsteps_per_iteration * self.args.timestep *
unit.femtoseconds))),
'temperature':
self.args.temperature,
'pressure':
self.args.pressure,
'solvent':
self.args.solvent,
'verbose':
'yes' if self.args.verbose else 'no',
}
for parameter in kwargs.keys():
options[parameter] = kwargs[parameter]
return hydration_yaml_template % options
def begin(self):
# TODO: Is there another idiom to use to check valid input?
if self.args.solvent not in ['gbsa', 'tip3p']:
raise Exception("solvent must be one of ['gbsa', 'tip3p']")
# Compute kT
kB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA # Boltzmann constant
self.kT = kB * (self.args.temperature * unit.kelvin)
def process(self, mol, port):
kT_in_kcal_per_mole = self.kT.value_in_unit(unit.kilocalories_per_mole)
# Retrieve data about which molecule we are processing
title = mol.GetTitle()
with TemporaryDirectory() as output_directory:
try:
# Print out which molecule we are processing
self.log.info('Processing {} in directory {}.'.format(
title, output_directory))
# Check that molecule is charged.
if not molecule_is_charged(mol):
raise Exception(
'Molecule %s has no charges; input molecules must be charged.'
% mol.GetTitle())
# Write the specified molecule out to a mol2 file without changing its name.
mol2_filename = os.path.join(output_directory, 'input.mol2')
ofs = oechem.oemolostream(mol2_filename)
oechem.OEWriteMol2File(ofs, mol)
# Undo oechem fuckery with naming mol2 substructures `<0>`
from YankCubes.utils import unfuck_oechem_mol2_file
unfuck_oechem_mol2_file(mol2_filename)
# Run YANK on the specified molecule.
from yank.yamlbuild import YamlBuilder
yaml = self.construct_yaml(output_directory=output_directory)
yaml_builder = YamlBuilder(yaml)
yaml_builder.build_experiments()
self.log.info(
'Ran Yank experiments for molecule {}.'.format(title))
# Analyze the hydration free energy.
from yank.analyze import estimate_free_energies
(Deltaf_ij_solvent,
dDeltaf_ij_solvent) = estimate_free_energies(
netcdf.Dataset(
output_directory + '/experiments/solvent1.nc', 'r'))
(Deltaf_ij_vacuum, dDeltaf_ij_vacuum) = estimate_free_energies(
netcdf.Dataset(
output_directory + '/experiments/solvent2.nc', 'r'))
DeltaG_hydration = Deltaf_ij_vacuum[0,
-1] - Deltaf_ij_solvent[0,
-1]
dDeltaG_hydration = np.sqrt(Deltaf_ij_vacuum[0, -1]**2 +
Deltaf_ij_solvent[0, -1]**2)
# Add result to original molecule
oechem.OESetSDData(mol, 'DeltaG_yank_hydration',
str(DeltaG_hydration * kT_in_kcal_per_mole))
oechem.OESetSDData(
mol, 'dDeltaG_yank_hydration',
str(dDeltaG_hydration * kT_in_kcal_per_mole))
self.log.info(
'Analyzed and stored hydration free energy for molecule {}.'
.format(title))
# Emit molecule to success port.
self.success.emit(mol)
except Exception as e:
self.log.info(
'Exception encountered when processing molecule {}.'.
format(title))
# Attach error message to the molecule that failed
# TODO: If there is an error in the leap setup log,
# we should capture that and attach it to the failed molecule.
self.log.error(traceback.format_exc())
mol.SetData('error', str(e))
# Return failed molecule
self.failure.emit(mol)
class YankBindingCube(ParallelOEMolComputeCube):
title = "YankBindingCube"
description = """
Compute thebinding free energy of a small molecule with YANK.
This cube uses the YANK alchemical free energy code to compute the binding
free energy of one or more small molecules using harmonic restraints.
See http://getyank.org for more information about YANK.
"""
classification = ["Alchemical free energy calculations"]
tags = [tag for lists in classification for tag in lists]
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {
"default": 1
}, # 1 molecule at a time
"item_timeout": {
"default": 3600
}, # Default 1 hour limit (units are seconds)
"item_count": {
"default": 1
} # 1 molecule at a time
}
#Define Custom Ports to handle oeb.gz files
intake = CustomMoleculeInputPort('intake')
success = CustomMoleculeOutputPort('success')
failure = CustomMoleculeOutputPort('failure')
# Receptor specification
receptor = parameter.DataSetInputParameter(
'receptor', required=True, help_text='Receptor structure file')
# These can override YAML parameters
nsteps_per_iteration = parameter.IntegerParameter(
'nsteps_per_iteration',
default=500,
help_text="Number of steps per iteration")
timestep = parameter.DecimalParameter('timestep',
default=2.0,
help_text="Timestep (fs)")
simulation_time = parameter.DecimalParameter(
'simulation_time',
default=0.100,
help_text="Simulation time (ns/replica)")
temperature = parameter.DecimalParameter('temperature',
default=300.0,
help_text="Temperature (Kelvin)")
pressure = parameter.DecimalParameter('pressure',
default=1.0,
help_text="Pressure (atm)")
solvent = parameter.StringParameter(
'solvent',
default='gbsa',
choices=['gbsa', 'pme', 'rf'],
help_text="Solvent choice ['gbsa', 'pme', 'rf']")
minimize = parameter.BooleanParameter(
'minimize',
default=True,
help_text="Minimize initial structures for stability")
randomize_ligand = parameter.BooleanParameter(
'randomize_ligand',
default=False,
help_text="Randomize initial ligand position (implicit only)")
verbose = parameter.BooleanParameter(
'verbose',
default=False,
help_text="Print verbose YANK logging output")
def construct_yaml(self, **kwargs):
# Make substitutions to YAML here.
# TODO: Can we override YAML parameters without having to do string substitutions?
options = {
'timestep':
self.args.timestep,
'nsteps_per_iteration':
self.args.nsteps_per_iteration,
'number_of_iterations':
int(
np.ceil(self.args.simulation_time * unit.nanoseconds /
(self.args.nsteps_per_iteration * self.args.timestep *
unit.femtoseconds))),
'temperature':
self.args.temperature,
'pressure':
self.args.pressure,
'solvent':
self.args.solvent,
'minimize':
'yes' if self.args.minimize else 'no',
'verbose':
'yes' if self.args.verbose else 'no',
'randomize_ligand':
'yes' if self.args.randomize_ligand else 'no',
}
for parameter in kwargs.keys():
options[parameter] = kwargs[parameter]
return binding_yaml_template % options
def begin(self):
# TODO: Is there another idiom to use to check valid input?
if self.args.solvent not in ['gbsa', 'pme', 'rf']:
raise Exception("solvent must be one of ['gbsa', 'pme', 'rf']")
# Compute kT
kB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA # Boltzmann constant
self.kT = kB * (self.args.temperature * unit.kelvin)
# Load receptor
self.receptor = oechem.OEMol()
receptor_filename = download_dataset_to_file(self.args.receptor)
with oechem.oemolistream(receptor_filename) as ifs:
if not oechem.OEReadMolecule(ifs, self.receptor):
raise RuntimeError("Error reading receptor")
def process(self, mol, port):
kT_in_kcal_per_mole = self.kT.value_in_unit(unit.kilocalories_per_mole)
# Retrieve data about which molecule we are processing
title = mol.GetTitle()
with TemporaryDirectory() as output_directory:
try:
# Print out which molecule we are processing
self.log.info('Processing {} in {}.'.format(
title, output_directory))
# Check that molecule is charged.
if not molecule_is_charged(mol):
raise Exception(
'Molecule %s has no charges; input molecules must be charged.'
% mol.GetTitle())
# Write the receptor.
pdbfilename = os.path.join(output_directory, 'receptor.pdb')
with oechem.oemolostream(pdbfilename) as ofs:
res = oechem.OEWriteConstMolecule(ofs, self.receptor)
if res != oechem.OEWriteMolReturnCode_Success:
raise RuntimeError(
"Error writing receptor: {}".format(res))
# Write the specified molecule out to a mol2 file without changing its name.
mol2_filename = os.path.join(output_directory, 'input.mol2')
ofs = oechem.oemolostream(mol2_filename)
oechem.OEWriteMol2File(ofs, mol)
# Undo oechem fuckery with naming mol2 substructures `<0>`
from YankCubes.utils import unfuck_oechem_mol2_file
unfuck_oechem_mol2_file(mol2_filename)
# Run YANK on the specified molecule.
from yank.yamlbuild import YamlBuilder
yaml = self.construct_yaml(output_directory=output_directory)
yaml_builder = YamlBuilder(yaml)
yaml_builder.build_experiments()
self.log.info(
'Ran Yank experiments for molecule {}.'.format(title))
# Analyze the binding free energy
# TODO: Use yank.analyze API for this
from YankCubes.analysis import analyze
store_directory = os.path.join(output_directory, 'experiments')
[DeltaG_binding, dDeltaG_binding] = analyze(store_directory)
"""
# Extract trajectory (DEBUG)
from yank.analyze import extract_trajectory
trajectory_filename = 'trajectory.pdb'
store_filename = os.path.join(store_directory, 'complex.pdb')
extract_trajectory(trajectory_filename, store_filename, state_index=0, keep_solvent=False,
discard_equilibration=True, image_molecules=True)
ifs = oechem.oemolistream(trajectory_filename)
ifs.SetConfTest(oechem.OEAbsCanonicalConfTest()) # load multi-conformer molecule
mol = oechem.OEMol()
for mol in ifs.GetOEMols():
print (mol.GetTitle(), "has", mol.NumConfs(), "conformers")
ifs.close()
os.remove(trajectory_filename)
"""
# Attach binding free energy estimates to molecule
oechem.OESetSDData(mol, 'DeltaG_yank_binding',
str(DeltaG_binding * kT_in_kcal_per_mole))
oechem.OESetSDData(mol, 'dDeltaG_yank_binding',
str(dDeltaG_binding * kT_in_kcal_per_mole))
self.log.info(
'Analyzed and stored binding free energy for molecule {}.'.
format(title))
# Emit molecule to success port.
self.success.emit(mol)
except Exception as e:
self.log.info(
'Exception encountered when processing molecule {}.'.
format(title))
# Attach error message to the molecule that failed
# TODO: If there is an error in the leap setup log,
# we should capture that and attach it to the failed molecule.
self.log.error(traceback.format_exc())
mol.SetData('error', str(e))
# Return failed molecule
self.failure.emit(mol)
class LigandReader(SourceCube):
title = "LigandReader Cube"
version = "0.0.0"
classification = [["Ligand Reader Cube", "OEChem", "Reader Cube"]]
tags = ['OEChem']
description = """
Ligand Reader Cube
Input:
-------
oechem.OEMCMol or - Streamed-in of Ligands
The input file can be an .oeb, .oeb.gz, .pdb or a .mol2 file
Output:
-------
oechem.OEMCMol - Emits the Ligands
"""
success = MoleculeOutputPort("success")
data_in = parameter.DataSetInputParameter(
"data_in",
help_text="Ligand to read in",
required=True,
description="The Ligand to read in")
limit = parameter.IntegerParameter(
"limit",
required=False)
download_format = parameter.StringParameter(
"download_format",
choices=[".oeb.gz", ".oeb", ".pdb", ".mol2", ".smi"],
required=False,
default=".oeb.gz")
prefix = parameter.StringParameter(
'prefix',
default='',
help_text='An SD tag used as prefix string')
suffix = parameter.StringParameter(
'suffix',
default='',
help_text='An SD tag used as suffix string')
type = parameter.StringParameter(
'type',
default='LIG',
required=True,
help_text='The ligand reside name')
IDTag = parameter.BooleanParameter(
'IDTag',
default=True,
required=False,
help_text='If True/Checked ligands are enumerated by sequentially integers.'
'A SD tag containing part of the ligand name and an integer is used '
'to create a unique IDTag which is attached to the ligand')
def begin(self):
self.opt = vars(self.args)
def __iter__(self):
max_idx = self.args.limit
if max_idx is not None:
max_idx = int(max_idx)
count = 0
self.config = config_from_env()
in_orion = self.config is not None
if not in_orion:
with oechem.oemolistream(str(self.args.data_in)) as ifs:
for mol in ifs.GetOEMols():
mol.SetData(oechem.OEGetTag('prefix'), self.opt['prefix'])
mol.SetData(oechem.OEGetTag('suffix'), self.opt['suffix'])
for at in mol.GetAtoms():
residue = oechem.OEAtomGetResidue(at)
residue.SetName(self.opt['type'])
oechem.OEAtomSetResidue(at, residue)
if self.opt['IDTag']:
mol.SetData(oechem.OEGetTag('IDTag'), 'l' + mol.GetTitle()[0:12] + '_' + str(count))
yield mol
count += 1
if max_idx is not None and count == max_idx:
break
else:
stream = StreamingDataset(self.args.data_in,
input_format=self.args.download_format)
for mol in stream:
mol.SetData(oechem.OEGetTag('prefix'), self.opt['prefix'])
mol.SetData(oechem.OEGetTag('suffix'), self.opt['suffix'])
for at in mol.GetAtoms():
residue = oechem.OEAtomGetResidue(at)
residue.SetName(self.opt['type'])
oechem.OEAtomSetResidue(at, residue)
if self.opt['IDTag']:
mol.SetData(oechem.OEGetTag('IDTag'), 'l' + mol.GetTitle()[0:12] + '_'+str(count))
yield mol
count += 1
if max_idx is not None and count == max_idx:
break
class YankBindingFECube(ParallelOEMolComputeCube):
version = "0.0.0"
title = "YankSolvationFECube"
description = """
Compute the hydration free energy of a small molecule with YANK.
This cube uses the YANK alchemical free energy code to compute the
transfer free energy of one or more small molecules from gas phase
to the selected solvent.
See http://getyank.org for more information about YANK.
"""
classification = ["Alchemical free energy calculations"]
tags = [tag for lists in classification for tag in lists]
# The intake port is re-defined as batch port
intake = BatchMoleculeInputPort("intake")
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {"default": 1}, # 1 molecule at a time
"item_timeout": {"default": 43200}, # Default 12 hour limit (units are seconds)
"item_count": {"default": 1} # 1 molecule at a time
}
temperature = parameter.DecimalParameter(
'temperature',
default=300.0,
help_text="Temperature (Kelvin)")
pressure = parameter.DecimalParameter(
'pressure',
default=1.0,
help_text="Pressure (atm)")
minimize = parameter.BooleanParameter(
'minimize',
default=False,
help_text="Minimize input system")
iterations = parameter.IntegerParameter(
'iterations',
default=1000,
help_text="Number of iterations")
nsteps_per_iteration = parameter.IntegerParameter(
'nsteps_per_iteration',
default=500,
help_text="Number of steps per iteration")
timestep = parameter.DecimalParameter(
'timestep',
default=2.0,
help_text="Timestep (fs)")
nonbondedCutoff = parameter.DecimalParameter(
'nonbondedCutoff',
default=10.0,
help_text="The non-bonded cutoff in angstroms")
restraints = parameter.StringParameter(
'restraints',
default='Harmonic',
choices=['FlatBottom', 'Harmonic', 'Boresch'],
help_text='Select the restraint types')
ligand_resname = parameter.StringParameter(
'ligand_resname',
default='LIG',
help_text='The decoupling ligand residue name')
verbose = parameter.BooleanParameter(
'verbose',
default=True,
help_text="Print verbose YANK logging output")
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
def process(self, solvated_system, port):
try:
opt = dict(self.opt)
# Extract the solvated ligand and the solvated complex
solvated_ligand = solvated_system[0]
solvated_complex = solvated_system[1]
# Update cube simulation parameters with the eventually molecule SD tags
new_args = {dp.GetTag(): dp.GetValue() for dp in oechem.OEGetSDDataPairs(solvated_ligand) if dp.GetTag() in
["temperature", "pressure"]}
if new_args:
for k in new_args:
try:
new_args[k] = float(new_args[k])
except:
pass
self.log.info("Updating parameters for molecule: {}\n{}".format(solvated_ligand.GetTitle(), new_args))
opt.update(new_args)
# Extract the MD data
mdData_ligand = data_utils.MDData(solvated_ligand)
solvated_ligand_structure = mdData_ligand.structure
mdData_complex = data_utils.MDData(solvated_complex)
solvated_complex_structure = mdData_complex.structure
# Create the solvated OpenMM systems
solvated_complex_omm_sys = solvated_complex_structure.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=opt['nonbondedCutoff'] * unit.angstroms,
constraints=app.HBonds,
removeCMMotion=False)
solvated_ligand_omm_sys = solvated_ligand_structure.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=opt['nonbondedCutoff'] * unit.angstroms,
constraints=app.HBonds,
removeCMMotion=False)
# Write out all the required files and set-run the Yank experiment
with TemporaryDirectory() as output_directory:
opt['Logger'].info("Output Directory {}".format(output_directory))
solvated_complex_structure_fn = os.path.join(output_directory, "complex.pdb")
solvated_complex_structure.save(solvated_complex_structure_fn, overwrite=True)
solvated_ligand_structure_fn = os.path.join(output_directory, "solvent.pdb")
solvated_ligand_structure.save(solvated_ligand_structure_fn, overwrite=True)
solvated_complex_omm_serialized = XmlSerializer.serialize(solvated_complex_omm_sys)
solvated_complex_omm_serialized_fn = os.path.join(output_directory, "complex.xml")
solvated_complex_f = open(solvated_complex_omm_serialized_fn, 'w')
solvated_complex_f.write(solvated_complex_omm_serialized)
solvated_complex_f.close()
solvated_ligand_omm_serialized = XmlSerializer.serialize(solvated_ligand_omm_sys)
solvated_ligand_omm_serialized_fn = os.path.join(output_directory, "solvent.xml")
solvated_ligand_f = open(solvated_ligand_omm_serialized_fn, 'w')
solvated_ligand_f.write(solvated_ligand_omm_serialized)
solvated_ligand_f.close()
# Build the Yank Experiment
yaml_builder = ExperimentBuilder(yank_binding_template.format(
verbose='yes' if opt['verbose'] else 'no',
minimize='yes' if opt['minimize'] else 'no',
output_directory=output_directory,
timestep=opt['timestep'],
nsteps_per_iteration=opt['nsteps_per_iteration'],
number_iterations=opt['iterations'],
temperature=opt['temperature'],
pressure=opt['pressure'],
complex_pdb_fn=solvated_complex_structure_fn,
complex_xml_fn=solvated_complex_omm_serialized_fn,
solvent_pdb_fn=solvated_ligand_structure_fn,
solvent_xml_fn=solvated_ligand_omm_serialized_fn,
restraints=opt['restraints'],
ligand_resname=opt['ligand_resname']))
# Run Yank
yaml_builder.run_experiments()
exp_dir = os.path.join(output_directory, "experiments")
DeltaG_binding, dDeltaG_binding, DeltaH, dDeltaH = yankutils.analyze_directory(exp_dir)
protein, ligand, water, excipients = oeommutils.split(solvated_ligand,
ligand_res_name=opt['ligand_resname'])
# Add result to the extracted ligand in kcal/mol
oechem.OESetSDData(ligand, 'DG_yank_binding', str(DeltaG_binding))
oechem.OESetSDData(ligand, 'dG_yank_binding', str(dDeltaG_binding))
self.success.emit(ligand)
except Exception as e:
# Attach an error message to the molecule that failed
self.log.error(traceback.format_exc())
solvated_system[1].SetData('error', str(e))
# Return failed mol
self.failure.emit(solvated_system[1])
return
class YankSolvationFECube(ParallelOEMolComputeCube):
version = "0.0.0"
title = "YankSolvationFECube"
description = """
Compute the hydration free energy of a small molecule with YANK.
This cube uses the YANK alchemical free energy code to compute the
transfer free energy of one or more small molecules from gas phase
to the selected solvent.
See http://getyank.org for more information about YANK.
"""
classification = ["Alchemical free energy calculations"]
tags = [tag for lists in classification for tag in lists]
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {"default": 1}, # 1 molecule at a time
"item_timeout": {"default": 43200}, # Default 12 hour limit (units are seconds)
"item_count": {"default": 1} # 1 molecule at a time
}
temperature = parameter.DecimalParameter(
'temperature',
default=300.0,
help_text="Temperature (Kelvin)")
pressure = parameter.DecimalParameter(
'pressure',
default=1.0,
help_text="Pressure (atm)")
minimize = parameter.BooleanParameter(
'minimize',
default=False,
help_text="Minimize input system")
iterations = parameter.IntegerParameter(
'iterations',
default=1000,
help_text="Number of iterations")
nsteps_per_iteration = parameter.IntegerParameter(
'nsteps_per_iteration',
default=500,
help_text="Number of steps per iteration")
timestep = parameter.DecimalParameter(
'timestep',
default=2.0,
help_text="Timestep (fs)")
nonbondedCutoff = parameter.DecimalParameter(
'nonbondedCutoff',
default=10.0,
help_text="The non-bonded cutoff in angstroms")
verbose = parameter.BooleanParameter(
'verbose',
default=False,
help_text="Print verbose YANK logging output")
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
def process(self, solvated_system, port):
try:
# The copy of the dictionary option as local variable
# is necessary to avoid filename collisions due to
# the parallel cube processes
opt = dict(self.opt)
# Split the complex in components
protein, solute, water, excipients = oeommutils.split(solvated_system, ligand_res_name='LIG')
# Update cube simulation parameters with the eventually molecule SD tags
new_args = {dp.GetTag(): dp.GetValue() for dp in oechem.OEGetSDDataPairs(solute) if dp.GetTag() in
["temperature", "pressure"]}
if new_args:
for k in new_args:
try:
new_args[k] = float(new_args[k])
except:
pass
self.log.info("Updating parameters for molecule: {}\n{}".format(solute.GetTitle(), new_args))
opt.update(new_args)
# Extract the MD data
mdData = data_utils.MDData(solvated_system)
solvated_structure = mdData.structure
# Extract the ligand parmed structure
solute_structure = solvated_structure.split()[0][0]
solute_structure.box = None
# Set the ligand title
solute.SetTitle(solvated_system.GetTitle())
# Create the solvated and vacuum system
solvated_omm_sys = solvated_structure.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=opt['nonbondedCutoff'] * unit.angstroms,
constraints=app.HBonds,
removeCMMotion=False)
solute_omm_sys = solute_structure.createSystem(nonbondedMethod=app.NoCutoff,
constraints=app.HBonds,
removeCMMotion=False)
# This is a note from:
# https://github.com/MobleyLab/SMIRNOFF_paper_code/blob/e5012c8fdc4570ca0ec750f7ab81dd7102e813b9/scripts/create_input_files.py#L114
# Fix switching function.
for force in solvated_omm_sys.getForces():
if isinstance(force, openmm.NonbondedForce):
force.setUseSwitchingFunction(True)
force.setSwitchingDistance((opt['nonbondedCutoff'] - 1.0) * unit.angstrom)
# Write out all the required files and set-run the Yank experiment
with TemporaryDirectory() as output_directory:
opt['Logger'].info("Output Directory {}".format(output_directory))
solvated_structure_fn = os.path.join(output_directory, "solvated.pdb")
solvated_structure.save(solvated_structure_fn, overwrite=True)
solute_structure_fn = os.path.join(output_directory, "solute.pdb")
solute_structure.save(solute_structure_fn, overwrite=True)
solvated_omm_sys_serialized = XmlSerializer.serialize(solvated_omm_sys)
solvated_omm_sys_serialized_fn = os.path.join(output_directory, "solvated.xml")
solvated_f = open(solvated_omm_sys_serialized_fn, 'w')
solvated_f.write(solvated_omm_sys_serialized)
solvated_f.close()
solute_omm_sys_serialized = XmlSerializer.serialize(solute_omm_sys)
solute_omm_sys_serialized_fn = os.path.join(output_directory, "solute.xml")
solute_f = open(solute_omm_sys_serialized_fn, 'w')
solute_f.write(solute_omm_sys_serialized)
solute_f.close()
# Build the Yank Experiment
yaml_builder = ExperimentBuilder(yank_solvation_template.format(
verbose='yes' if opt['verbose'] else 'no',
minimize='yes' if opt['minimize'] else 'no',
output_directory=output_directory,
timestep=opt['timestep'],
nsteps_per_iteration=opt['nsteps_per_iteration'],
number_iterations=opt['iterations'],
temperature=opt['temperature'],
pressure=opt['pressure'],
solvated_pdb_fn=solvated_structure_fn,
solvated_xml_fn=solvated_omm_sys_serialized_fn,
solute_pdb_fn=solute_structure_fn,
solute_xml_fn=solute_omm_sys_serialized_fn))
# Run Yank
yaml_builder.run_experiments()
exp_dir = os.path.join(output_directory, "experiments")
# Calculate solvation free energy, solvation Enthalpy and their errors
DeltaG_solvation, dDeltaG_solvation, DeltaH, dDeltaH = yankutils.analyze_directory(exp_dir)
# # Add result to the original molecule in kcal/mol
oechem.OESetSDData(solute, 'DG_yank_solv', str(DeltaG_solvation))
oechem.OESetSDData(solute, 'dG_yank_solv', str(dDeltaG_solvation))
# Emit the ligand
self.success.emit(solute)
except Exception as e:
# Attach an error message to the molecule that failed
self.log.error(traceback.format_exc())
solvated_system.SetData('error', str(e))
# Return failed mol
self.failure.emit(solvated_system)
return
class OpenMMnptCube(ParallelOEMolComputeCube):
title = 'NPT Cube'
version = "0.0.0"
classification = [["Simulation", "OpenMM", "NPT"]]
tags = ['OpenMM', 'Parallel Cube']
description = """NPT simulation of the protein:ligand complex.
This cube will take in the streamed complex.oeb.gz file containing
the solvated protein:ligand complex and will perform a MD simulation at
constant temperature and pressure.
Input parameters:
----------------
picosec (decimal): Number of picoseconds to perform the complex simulation.
temperature (decimal): target temperature
pressure (decimal): target pressure
"""
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {
"default": 1
}, # 1 molecule at a time
"item_timeout": {
"default": 43200
}, # Default 12 hour limit (units are seconds)
"item_count": {
"default": 1
} # 1 molecule at a time
}
temperature = parameter.DecimalParameter('temperature',
default=300.0,
help_text="Temperature (Kelvin)")
pressure = parameter.DecimalParameter('pressure',
default=1.0,
help_text="Pressure (atm)")
time = parameter.DecimalParameter(
'time', default=10.0, help_text="NPT simulation time in picoseconds")
restraints = parameter.StringParameter(
'restraints',
default='',
help_text=""""Mask selection to apply restraints. Possible keywords are:
ligand, protein, water, ions, ca_protein, cofactors.
Operational tokens are: and, not, noh""")
restraintWt = parameter.DecimalParameter(
'restraintWt',
default=2.0,
help_text="Restraint weight for xyz atom restraints in kcal/(mol ang^2)"
)
nonbondedMethod = parameter.StringParameter(
'nonbondedMethod',
default='PME',
choices=[
'NoCutoff', 'CutoffNonPeriodic', 'CutoffPeriodic', 'PME', 'Ewald'
],
help_text="NoCutoff, CutoffNonPeriodic, CutoffPeriodic, PME, or Ewald."
)
nonbondedCutoff = parameter.DecimalParameter(
'nonbondedCutoff',
default=10,
help_text="""The non-bonded cutoff in angstroms.
This is ignored if non-bonded method is NoCutoff""")
constraints = parameter.StringParameter(
'constraints',
default='HBonds',
choices=['None', 'HBonds', 'HAngles', 'AllBonds'],
help_text="""None, HBonds, HAngles, or AllBonds
Which type of constraints to add to the system (e.g., SHAKE).
None means no bonds are constrained.
HBonds means bonds with hydrogen are constrained""")
trajectory_filetype = parameter.StringParameter(
'trajectory_filetype',
default='DCD',
choices=['DCD', 'NetCDF', 'HDF5'],
help_text="NetCDF, DCD, HDF5. File type to write trajectory files")
trajectory_interval = parameter.IntegerParameter(
'trajectory_interval',
default=0,
help_text="Step interval for trajectory snapshots. If 0 the trajectory"
"file will not be generated")
reporter_interval = parameter.IntegerParameter(
'reporter_interval',
default=0,
help_text="Step interval for reporting data. If 0 the reporter file"
"will not be generated")
outfname = parameter.StringParameter(
'outfname',
default='npt',
help_text=
'Filename suffix for output simulation files. Formatted: <title>-<outfname>'
)
tarxz = parameter.BooleanParameter(
'tarxz',
default=False,
description='Create a tar.xz file of the attached data')
center = parameter.BooleanParameter(
'center',
default=True,
description='Center the system to the OpenMM unit cell')
verbose = parameter.BooleanParameter(
'verbose', default=True, description='Increase log file verbosity.')
platform = parameter.StringParameter(
'platform',
default='Auto',
choices=['Auto', 'Reference', 'CPU', 'CUDA', 'OpenCL'],
help_text='Select which platform to use to run the simulation')
cuda_opencl_precision = parameter.StringParameter(
'cuda_opencl_precision',
default='single',
choices=['single', 'mixed', 'double'],
help_text='Select the CUDA or OpenCL precision')
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
self.opt['SimType'] = 'npt'
return
def process(self, mol, port):
try:
# The copy of the dictionary option as local variable
# is necessary to avoid filename collisions due to
# the parallel cube processes
opt = dict(self.opt)
if utils.PackageOEMol.checkTags(mol, ['Structure']):
gd = utils.PackageOEMol.unpack(mol)
opt['outfname'] = '{}-{}'.format(gd['IDTag'],
self.opt['outfname'])
mdData = utils.MDData(mol)
opt['molecule'] = mol
self.log.info('START NPT SIMULATION %s' % gd['IDTag'])
simtools.simulation(mdData, **opt)
packedmol = mdData.packMDData(mol)
self.success.emit(packedmol)
except Exception as e:
# Attach error message to the molecule that failed
self.log.error(traceback.format_exc())
mol.SetData('error', str(e))
# Return failed mol
self.failure.emit(mol)
return
class LigChargeCube(ParallelOEMolComputeCube):
title = "Ligand Charge Cube"
version = "0.0.0"
classification = [["Ligand Preparation", "OEChem", "Ligand preparation"]]
tags = ['OEChem', 'Quacpac']
description = """
This cube charges the Ligand by using the ELF10 charge method
Input:
-------
oechem.OEMCMol - Streamed-in of the ligand molecules
Output:
-------
oechem.OEMCMol - Emits the charged ligands
"""
# Override defaults for some parameters
parameter_overrides = {
"prefetch_count": {"default": 1}, # 1 molecule at a time
"item_timeout": {"default": 3600}, # Default 1 hour limit (units are seconds)
"item_count": {"default": 1} # 1 molecule at a time
}
max_conformers = parameter.IntegerParameter(
'max_conformers',
default=800,
help_text="Max number of ligand conformers")
charge_ligands = parameter.BooleanParameter(
'charge_ligands',
default=True,
description='Flag used to set if charge the ligands or not')
def begin(self):
self.opt = vars(self.args)
self.opt['Logger'] = self.log
def process(self, ligand, port):
try:
# Ligand sanitation
ligand = oeommutils.sanitizeOEMolecule(ligand)
# Charge the ligand
if self.opt['charge_ligands']:
self.log.info("ELF10 Charges applied to the ligand")
charged_ligand = ff_utils.assignELF10charges(ligand,
self.opt['max_conformers'],
strictStereo=False)
# If the ligand has been charged then transfer the computed
# charges to the starting ligand
map_charges = {at.GetIdx(): at.GetPartialCharge() for at in charged_ligand.GetAtoms()}
for at in ligand.GetAtoms():
at.SetPartialCharge(map_charges[at.GetIdx()])
self.success.emit(ligand)
except Exception as e:
# Attach error message to the molecule that failed
self.log.error(traceback.format_exc())
ligand.SetData('error', str(e))
# Return failed mol
self.failure.emit(ligand)
return
