def write_header(self):
"""
Confusingly this initializes writer as well because
"""
outfile = open(self.out_filepath, 'w')
self.outfile = outfile
cpdb = app.PDBFile(self.pdb_str)
PDBFile.writeHeader(cpdb.topology, self.outfile)
self.topology = cpdb.topology
self.frame_idx = 0
def report(self, simulation, state):
"""Generate a report.
Parameters:
- simulation (Simulation) The Simulation to generate a report for
- state (State) The current state of the simulation
"""
if self._nextModel == 0:
PDBFile.writeHeader(simulation.topology, self._out)
self._topology = simulation.topology
self._nextModel += 1
PDBFile.writeModel(simulation.topology, state.getPositions(), self._out, self._nextModel)
self._nextModel += 1
def report(self, simulation, state):
"""Generate a report.
Parameters:
- simulation (Simulation) The Simulation to generate a report for
- state (State) The current state of the simulation
"""
if self._nextModel == 0:
PDBFile.writeHeader(simulation.topology, self._out)
self._topology = simulation.topology
self._nextModel += 1
PDBFile.writeModel(simulation.topology, state.getPositions(),
self._out, self._nextModel)
self._nextModel += 1
def report(self, simulation, state):
"""Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
state : State
The current state of the simulation
"""
if self._nextModel == 0:
PDBFile.writeHeader(simulation.topology, self._out)
self._topology = simulation.topology
self._nextModel += 1
PDBFile.writeModel(simulation.topology, state.getPositions(), self._out, self._nextModel)
self._nextModel += 1
if hasattr(self._out, 'flush') and callable(self._out.flush):
self._out.flush()
def report(self, simulation, _):
"""Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
_ : State
The current state of the simulation
"""
state = simulation.context.getState(getPositions=True, enforcePeriodicBox=self._enforcePeriodicBox)
if self._nextModel == 0:
PDBFile.writeHeader(simulation.topology, self._out)
self._topology = simulation.topology
self._nextModel += 1
PDBFile.writeModel(simulation.topology, state.getPositions(), self._out, self._nextModel)
self._nextModel += 1
if hasattr(self._out, 'flush') and callable(self._out.flush):
self._out.flush()
def report(self, simulation, state):
"""Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
state : State
The current state of the simulation
"""
if self._nextModel == 0:
PDBFile.writeHeader(simulation.topology, self._out)
self._topology = simulation.topology
self._nextModel += 1
PDBFile.writeModel(simulation.topology, state.getPositions(),
self._out, self._nextModel)
self._nextModel += 1
if hasattr(self._out, 'flush') and callable(self._out.flush):
self._out.flush()
def report(self, simulation, _):
"""Generate a report.
Parameters
----------
simulation : Simulation
The Simulation to generate a report for
_ : State
The current state of the simulation
"""
state = simulation.context.getState(
getPositions=True, enforcePeriodicBox=self._enforcePeriodicBox)
if self._nextModel == 0:
PDBFile.writeHeader(simulation.topology, self._out)
self._topology = simulation.topology
self._nextModel += 1
PDBFile.writeModel(simulation.topology, state.getPositions(),
self._out, self._nextModel)
self._nextModel += 1
if hasattr(self._out, 'flush') and callable(self._out.flush):
self._out.flush()
nsteps = 5 # number of timesteps per iteration
niterations = 500 # number of iterations
mctrials = 10 # number of Monte Carlo trials per iteration
nsalt = 0 # current number of salt pairs
tol = 1e-6 # constraint tolerance
# Determine number of molecules
nmolecules = 0
for residue in topology.residues():
nmolecules += 1
print('system originally has %d water molecules' % nmolecules)
# Open PDB file for writing.
from simtk.openmm.app import PDBFile
pdbfile = open('output.pdb', 'w')
PDBFile.writeHeader(topology, file=pdbfile)
PDBFile.writeModel(topology, positions, file=pdbfile, modelIndex=0)
# Simulate
for iteration in range(niterations):
print('iteration %5d / %5d' % (iteration, niterations))
# Create a simulation
from openmmtools.integrators import VelocityVerletIntegrator
integrator = VelocityVerletIntegrator(timestep)
integrator.setConstraintTolerance(tol)
context = openmm.Context(system, integrator)
context.setPositions(positions)
# Propagate dynamics at constant counterion number.
print('propagating dynamics for %d steps...' % nsteps)
def prep_system(box_width):
# if model not in supported_models:
# raise Exception("Specified water model '%s' is not in list of supported models: %s" % (model, str(supported_models)))
# Load forcefield for solvent model and ions.
# force_fields = ['tip3p.xml']
# if ionic_strength != 0.0*unit.molar:
# force_fields.append('amber99sb.xml') # For the ions.
ff = app.ForceField('tip3p.xml')
# Create empty topology and coordinates.
top = app.Topology()
pos = unit.Quantity((), unit.angstroms)
# Create new Modeller instance.
m = app.Modeller(top, pos)
boxSize = Vec3(box_width, box_width, box_width) * unit.nanometers
# boxSize = unit.Quantity(numpy.ones([3]) * box_edge / box_edge.unit, box_edge.unit)
m.addSolvent(ff, boxSize=boxSize, model='tip3p')
system = ff.createSystem(m.getTopology(),
nonbondedMethod=app.NoCutoff,
constraints=None,
rigidWater=False)
positions = m.getPositions()
positions = unit.Quantity(np.array(positions / positions.unit),
positions.unit)
# pdb_str = io.StringIO()
fname = "debug.pdb"
fhandle = open(fname, "w")
PDBFile.writeHeader(m.getTopology(), fhandle)
PDBFile.writeModel(m.getTopology(), positions, fhandle, 0)
PDBFile.writeFooter(m.getTopology(), fhandle)
return system, positions, np.eye(3) * box_width, fname
assert 0
# , positiveIon=positive_ion,
# negativeIon=negative_ion, ionicStrength=ionic_strength)
# Get new topology and coordinates.
newtop = m.getTopology()
newpos = m.getPositions()
# Convert positions to numpy.
positions = unit.Quantity(numpy.array(newpos / newpos.unit), newpos.unit)
# Create OpenMM System.
system = ff.createSystem(newtop,
nonbondedMethod=nonbondedMethod,
nonbondedCutoff=cutoff,
constraints=None,
rigidWater=constrained,
removeCMMotion=False)
# Set switching function and dispersion correction.
forces = {
system.getForce(index).__class__.__name__: system.getForce(index)
for index in range(system.getNumForces())
}
forces['NonbondedForce'].setUseSwitchingFunction(False)
if switch_width is not None:
forces['NonbondedForce'].setUseSwitchingFunction(True)
forces['NonbondedForce'].setSwitchingDistance(cutoff - switch_width)
forces['NonbondedForce'].setUseDispersionCorrection(dispersion_correction)
forces['NonbondedForce'].setEwaldErrorTolerance(ewaldErrorTolerance)
n_atoms = system.getNumParticles()
self.ndof = 3 * n_atoms - (constrained * n_atoms)
self.topology = m.getTopology()
self.system = system
self.positions = positions
def run_simulation(mol_name, mol, smirnoff_params, pdb, inference):
omm_forcefield = app.ForceField('amber99sb.xml', 'tip3p.xml')
system = omm_forcefield.createSystem(
pdb.topology,
nonbondedMethod=app.NoCutoff,
constraints=None,
rigidWater=False)
coords = []
for x,y,z in pdb.positions:
coords.append([to_md_units(x),to_md_units(y),to_md_units(z)])
coords = np.array(coords)
host_conf = coords
host_potentials, (host_params, host_param_groups), host_masses = serialize.deserialize_system(system)
smirnoff = ForceField("test_forcefields/smirnoff99Frosst.offxml")
# CAREFUL THIS SHOULD BE THE SINGLE SET OF CONSISTENT FORCEFIELDS
am1 = True
if am1:
guest_potentials, smirnoff_params, smirnoff_param_groups, guest_conf, guest_masses = forcefield.parameterize(mol, smirnoff, am1)
else:
guest_potentials, _, smirnoff_param_groups, guest_conf, guest_masses = forcefield.parameterize(mol, smirnoff, am1)
# guest_conf = rescale_and_center(guest_conf, scale_factor=3.0)
combined_potentials, combined_params, combined_param_groups, combined_conf, combined_masses = forcefield.combiner(
host_potentials, guest_potentials,
host_params, smirnoff_params,
host_param_groups, smirnoff_param_groups,
host_conf, guest_conf,
host_masses, guest_masses)
num_host_atoms = host_conf.shape[0]
def filter_groups(param_groups, groups):
roll = np.zeros_like(param_groups)
for g in groups:
roll = np.logical_or(roll, param_groups == g)
return roll
# host_dp_idxs = np.argwhere(filter_groups(host_param_groups, [7])).reshape(-1)
# guest_dp_idxs = np.argwhere(filter_groups(smirnoff_param_groups, [7])).reshape(-1)
# 1. host bond lengths
# 7. host charges
# 8. host vdw sigma
# 9. host vdw epsilon
# 17. charge
combined_dp_idxs = np.argwhere(filter_groups(combined_param_groups, [17])).reshape(-1)
if inference:
combined_dp_idxs = []
outfile = open("frames/"+mol_name+".pdb", "w")
combined_pdb = Chem.CombineMols(Chem.MolFromPDBFile(pdb.filepath, removeHs=False), mol)
combined_pdb_str = StringIO(Chem.MolToPDBBlock(combined_pdb))
cpdb = app.PDBFile(combined_pdb_str)
PDBFile.writeHeader(cpdb.topology, outfile)
def write_fn(x, frame_idx):
PDBFile.writeModel(cpdb.topology, x, outfile, frame_idx)
dG, dG_grads, all_xis = minimize(
mol_name,
num_host_atoms,
combined_potentials,
combined_params,
combined_conf,
combined_masses,
combined_dp_idxs,
writer_fn=write_fn
)
PDBFile.writeFooter(cpdb.topology, outfile)
outfile.flush()
# print("CDPI", combined_dp_idxs)
# (ytz): we need to offset this by number of host params to compute the indices
# of the original ligand parameters.
if not inference:
ligand_dp_idxs = combined_dp_idxs - len(host_params)
else:
ligand_dp_idxs = None
return dG, dG_grads, ligand_dp_idxs
def integrate(self, topology_proposal, initial_positions, direction='insert', platform=None):
"""
Performs NCMC switching to either delete or insert atoms according to the provided `topology_proposal`.
For `delete`, the system is first modified from fully interacting to alchemically modified, and then NCMC switching is used to eliminate atoms.
For `insert`, the system begins with eliminated atoms in an alchemically noninteracting form and NCMC switching is used to turn atoms on, followed by making system real.
The contribution of transforming the real system to/from an alchemical system is included.
Parameters
----------
topology_proposal : TopologyProposal
Contains old/new Topology and System objects and atom mappings.
initial_positions : simtk.unit.Quantity with dimension [natoms, 3] with units of distance.
Positions of the atoms at the beginning of the NCMC switching.
direction : str, optional, default='insert'
Direction of alchemical switching:
'insert' causes lambda to switch from 0 to 1 over nsteps steps of integration
'delete' causes lambda to switch from 1 to 0 over nsteps steps of integration
platform : simtk.openmm.Platform, optional, default=None
If not None, this platform is used for integration.
Returns
-------
final_positions : simtk.unit.Quantity of dimensions [nparticles,3] with units compatible with angstroms
The final positions after `nsteps` steps of alchemical switching
logP : float
The log acceptance probability of the switch
potential : simtk.unit.Quantity with units compatible with kilocalories_per_mole
For `delete`, the potential energy of the final (alchemically eliminated) conformation.
For `insert`, the potential energy of the initial (alchemically eliminated) conformation.
"""
if direction not in ['insert', 'delete']:
raise Exception("'direction' must be one of ['insert', 'delete']; was '%s' instead" % direction)
if (self.nsteps == 0):
# Special case of instantaneous insertion/deletion.
logP = 0.0
final_positions = copy.deepcopy(initial_positions)
from perses.tests.utils import compute_potential
if direction == 'delete':
potential = self.beta * compute_potential(topology_proposal.old_system, initial_positions, platform=self.platform)
elif direction == 'insert':
potential = self.beta * compute_potential(topology_proposal.new_system, initial_positions, platform=self.platform)
return [final_positions, logP, potential]
# Create alchemical system.
[unmodified_system, alchemical_system] = self.make_alchemical_system(topology_proposal, direction=direction)
# DEBUG: Compute initial potential of unmodified system and alchemical system to make sure finite.
from perses.tests.utils import compute_potential
#print(compute_potential(unmodified_system, initial_positions, platform=self.platform))
#print(compute_potential(alchemical_system, initial_positions, platform=self.platform))
# Select subset of switching functions based on which alchemical parameters are present in the system.
available_parameters = self._getAvailableParameters(alchemical_system)
functions = { parameter_name : self.functions[parameter_name] for parameter_name in self.functions if (parameter_name in available_parameters) }
# Create an NCMC velocity Verlet integrator.
integrator = NCMCAlchemicalIntegrator(self.temperature, alchemical_system, functions, nsteps=self.nsteps, timestep=self.timestep, direction=direction)
# Set the constraint tolerance if specified.
if self.constraint_tolerance is not None:
integrator.setConstraintTolerance(self.constraint_tolerance)
# Create a context on the specified platform.
if self.platform is not None:
context = openmm.Context(alchemical_system, integrator, self.platform)
else:
context = openmm.Context(alchemical_system, integrator)
context.setPositions(initial_positions)
context.applyConstraints(integrator.getConstraintTolerance())
# Set velocities to temperature and apply velocity constraints.
context.setVelocitiesToTemperature(self.temperature)
context.applyVelocityConstraints(integrator.getConstraintTolerance())
# Set initial context parameters.
if direction == 'insert':
for parameter_name in available_parameters:
context.setParameter(parameter_name, 0)
elif direction == 'delete':
for parameter_name in available_parameters:
context.setParameter(parameter_name, 1)
# Compute initial potential of alchemical state.
initial_potential = self.beta * context.getState(getEnergy=True).getPotentialEnergy()
if np.isnan(initial_potential):
raise NaNException("Initial potential of 'insert' operation is NaN (unmodified potential was %.3f kT, alchemical potential was %.3f kT before changing lambda)" % (unmodified_potential, alchemical_potential))
from perses.tests.utils import compute_potential_components
#print("initial potential before '%s' : %f kT" % (direction, initial_potential))
#print("initial potential components: %s" % str(compute_potential_components(context))) # DEBUG
# Take a single integrator step since all switching steps are unrolled in NCMCAlchemicalIntegrator.
try:
# Write PDB file if requested.
if self.write_pdb_interval:
if direction == 'insert':
topology = topology_proposal.new_topology
indices = topology_proposal.unique_new_atoms
else:
topology = topology_proposal.old_topology
indices = topology_proposal.unique_old_atoms
# Write atom indices that are changing
import pickle
filename = 'ncmc-%s-%d-atomindices.pkl' % (direction, self.nattempted)
outfile = open(filename, 'wb')
pickle.dump(indices, outfile)
outfile.close()
from simtk.openmm.app import PDBFile
filename = 'ncmc-%s-%d.pdb' % (direction, self.nattempted)
outfile = open(filename, 'w')
PDBFile.writeHeader(topology, file=outfile)
modelIndex = 0
PDBFile.writeModel(topology, context.getState(getPositions=True).getPositions(asNumpy=True), file=outfile, modelIndex=modelIndex)
try:
for step in range(self.nsteps):
integrator.step(1)
if (step+1)%self.write_pdb_interval == 0:
modelIndex += 1
PDBFile.writeModel(topology, context.getState(getPositions=True).getPositions(asNumpy=True), file=outfile, modelIndex=modelIndex)
except ValueError as e:
# System is exploding and coordinates won't fit in PDB ATOM fields
print(e)
PDBFile.writeFooter(topology, file=outfile)
outfile.close()
else:
integrator.step(self.nsteps)
except Exception as e:
# Trap NaNs as a special exception (allowing us to reject later, if desired)
if str(e) == "Particle coordinate is nan":
raise NaNException(str(e))
else:
raise e
# Set final context parameters.
if direction == 'insert':
for parameter_name in available_parameters:
context.setParameter(parameter_name, 1)
elif direction == 'delete':
for parameter_name in available_parameters:
context.setParameter(parameter_name, 0)
# Compute final potential of alchemical state.
final_potential = self.beta * context.getState(getEnergy=True).getPotentialEnergy()
if np.isnan(final_potential):
raise NaNException("Final potential of 'delete' operation is NaN")
#print("final potential before '%s' : %f kT" % (direction, final_potential))
#print("final potential components: %s" % str(compute_potential_components(context))) # DEBUG
#print('')
# Store final positions and log acceptance probability.
final_positions = context.getState(getPositions=True).getPositions(asNumpy=True)
logP_NCMC = integrator.getLogAcceptanceProbability(context)
# DEBUG
logging.debug("NCMC logP %+10.1f | initial_total_energy %+10.1f kT | final_total_energy %+10.1f kT." % (logP_NCMC, integrator.getGlobalVariableByName('initial_total_energy'), integrator.getGlobalVariableByName('final_total_energy')))
# Clean up NCMC switching integrator.
del context, integrator
# Compute contribution from transforming real system to/from alchemical system.
logP_alchemical_correction = self._computeAlchemicalCorrection(unmodified_system, alchemical_system, initial_positions, final_positions, direction=direction)
# Compute total logP
logP = logP_NCMC + logP_alchemical_correction
# Clean up alchemical system.
del alchemical_system
# Select whether to return initial or final potential.
if direction == 'insert':
potential = initial_potential
elif direction == 'delete':
potential = final_potential
# Keep track of statistics.
self.nattempted += 1
# Return
return [final_positions, logP, potential]
def __init__(self, objs, out_filepath):
"""
This class writes frames out in the PDBFormat. It supports both OpenMM topology
formats and RDKit ROMol types. The molecules are ordered sequentially by the order
in which they are in objs
Usage:
```
topol = app.PDBFile("1dfr.pdb").topology
mol_a = Chem.MolFromMolBlock("...")
mol_b = Chem.MolFromMolBlock("...")
writer = PDBWriter([topol, mol_a, mol_b], out.pdb) # writer header
writer.write_frame(coords) # coords must be in units of angstroms
writer.close() # writes footer
```
Parameters
----------
obj: list of either Chem.Mol or app.Topoolgy types
Molecules of interest
out_filepath: str
Where we write out the PDBFile to
"""
assert len(objs) > 0
rd_mols = []
# super jank
for obj in objs:
if isinstance(obj, app.Topology):
with tempfile.NamedTemporaryFile(mode='w') as fp:
# write
PDBFile.writeHeader(obj, fp)
PDBFile.writeModel(obj, np.zeros((obj.getNumAtoms(), 3)),
fp, 0)
PDBFile.writeFooter(obj, fp)
fp.flush()
# read
rd_mols.append(Chem.MolFromPDBFile(fp.name,
removeHs=False))
if isinstance(obj, Chem.Mol):
rd_mols.append(obj)
combined_mol = rd_mols[0]
for mol in rd_mols[1:]:
combined_mol = Chem.CombineMols(combined_mol, mol)
with tempfile.NamedTemporaryFile(mode='w') as fp:
# write
Chem.MolToPDBFile(combined_mol, fp.name)
fp.flush()
# read
combined_pdb = app.PDBFile(fp.name)
self.topology = combined_pdb.topology
self.out_handle = open(out_filepath, "w")
PDBFile.writeHeader(self.topology, self.out_handle)
self.topology = self.topology
self.frame_idx = 0
nsteps = 5 # number of timesteps per iteration
niterations = 500 # number of iterations
mctrials = 10 # number of Monte Carlo trials per iteration
nsalt = 0 # current number of salt pairs
tol = 1e-6 # constraint tolerance
# Determine number of molecules
nmolecules = 0
for residue in topology.residues():
nmolecules += 1
print('system originally has %d water molecules' % nmolecules)
# Open PDB file for writing.
from simtk.openmm.app import PDBFile
pdbfile = open('output.pdb', 'w')
PDBFile.writeHeader(topology, file=pdbfile)
PDBFile.writeModel(topology, positions, file=pdbfile, modelIndex=0)
# Simulate
for iteration in range(niterations):
print('iteration %5d / %5d' % (iteration, niterations))
# Create a simulation
from openmmtools.integrators import VelocityVerletIntegrator
integrator = VelocityVerletIntegrator(timestep)
integrator.setConstraintTolerance(tol)
context = openmm.Context(system, integrator)
context.setPositions(positions)
# Propagate dynamics at constant counterion number.
print('propagating dynamics for %d steps...' % nsteps)