reference_system.addForce(barostat)
# Identify ligand indices by residue name
print('Identifying ligand atoms to be alchemically modified...')
reference = md.load(pdb_filename)
alchemical_atoms = reference.topology.select(ligand_dsl_selection) # these atoms will be alchemically softened
alchemical_atoms = [ int(index) for index in alchemical_atoms ] # recode as Python int
print("MDTraj DSL selection '%s' identified %d atoms" % (ligand_dsl_selection, len(alchemical_atoms)))
# Create alchemically-modified system using fused softcore electrostatics and sterics
print('Creating alchemically modified system...')
print('lambda schedule: %s' % str(alchemical_lambdas))
from alchemy import AbsoluteAlchemicalFactory
from sams import ThermodynamicState
thermodynamic_states = list()
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=alchemical_atoms, annihilate_electrostatics=True, annihilate_sterics=False)
system = factory.createPerturbedSystem()
for alchemical_lambda in alchemical_lambdas:
parameters = {'lambda_sterics' : alchemical_lambda, 'lambda_electrostatics' : alchemical_lambda}
thermodynamic_states.append( ThermodynamicState(system=system, temperature=temperature, pressure=pressure, parameters=parameters) )
# Select platform automatically; use mixed precision
integrator = openmm.VerletIntegrator(timestep)
context = openmm.Context(system, integrator)
platform = context.getPlatform()
del context
platform.setPropertyDefaultValue('Precision', 'mixed')
if platform.getName() == 'OpenCL':
# GTX-1080 workaround
platform.setPropertyDefaultValue('OpenCLDisablePmeStream', 'true')
for vdw_lambda in vdw_lambdas:
alchemical_states.append(
AlchemicalState(coulomb_lambda=0.0,
vdw_lambda=vdw_lambda,
annihilate_coulomb=True,
annihilate_vdw=True))
# Create alchemical states where we turn on charges with full Lennard-Jones.
for coulomb_lambda in coulomb_lambdas:
alchemical_states.append(
AlchemicalState(coulomb_lambda=coulomb_lambda,
vdw_lambda=1.0,
annihilate_coulomb=True,
annihilate_vdw=True))
alchemical_factory = AbsoluteAlchemicalFactory(
reference_system, alchemical_atoms=alchemical_atoms)
systems = alchemical_factory.createPerturbedSystems(
alchemical_states
) # systems[istate] will be the System object corresponding to alchemical intermediate state index 'istate'
nstates = len(systems)
#==============================================================================
# Run simulation.
#==============================================================================
# Initialize NetCDF file to store data.
import netCDF4 as netcdf
ncfile = netcdf.Dataset(filename, 'w', version='NETCDF4')
ncfile.createDimension('iteration', 0) # unlimited number of iterations
ncfile.createDimension('state', nstates) # number of replicas
ncfile.createDimension(
def _create_phase(self,
phase,
reference_system,
positions,
atom_indices,
thermodynamic_state,
protocols=None,
options=None,
mpicomm=None):
"""
Create a repex object for a specified phase.
Parameters
----------
phase : str
The phase being initialized (one of ['complex', 'solvent', 'vacuum'])
reference_system : simtk.openmm.System
The reference system object from which alchemical intermediates are to be construcfted.
positions : list of simtk.unit.Qunatity objects containing (natoms x 3) positions (as np or lists)
The list of positions to be used to seed replicas in a round-robin way.
atom_indices : dict
atom_indices[phase][component] is the set of atom indices associated with component, where component is ['ligand', 'receptor']
thermodynamic_state : ThermodynamicState
Thermodynamic state from which reference temperature and pressure are to be taken.
protocols : dict of list of AlchemicalState, optional, default=None
If specified, the alchemical protocol protocols[phase] will be used for phase 'phase' instead of the default.
options : dict of str, optional, default=None
If specified, these options will override default repex simulation options.
"""
# Make sure positions argument is a list of coordinate snapshots.
if hasattr(positions, 'unit'):
# Wrap in list.
positions = [positions]
# Check the dimensions of positions.
for index in range(len(positions)):
# Make sure it is recast as a np array.
positions[index] = unit.Quantity(
np.array(positions[index] / positions[index].unit),
positions[index].unit)
[natoms, ndim] = (positions[index] / positions[index].unit).shape
if natoms != reference_system.getNumParticles():
raise Exception(
"positions argument must be a list of simtk.unit.Quantity of (natoms,3) lists or np array with units compatible with nanometers."
)
# Create metadata storage.
metadata = dict()
# Make a deep copy of the reference system so we don't accidentally modify it.
reference_system = copy.deepcopy(reference_system)
# TODO: Use more general approach to determine whether system is periodic.
is_periodic = self._is_periodic(reference_system)
# Make sure pressure is None if not periodic.
if not is_periodic: thermodynamic_state.pressure = None
# Compute standard state corrections for complex phase.
metadata['standard_state_correction'] = 0.0
# TODO: Do we need to include a standard state correction for other phases in periodic boxes?
if phase == 'complex-implicit':
# Impose restraints for complex system in implicit solvent to keep ligand from drifting too far away from receptor.
if self.verbose: print "Creating receptor-ligand restraints..."
reference_positions = positions[0]
if self.restraint_type == 'harmonic':
restraints = HarmonicReceptorLigandRestraint(
thermodynamic_state, reference_system, reference_positions,
atom_indices['receptor'], atom_indices['ligand'])
elif self.restraint_type == 'flat-bottom':
restraints = FlatBottomReceptorLigandRestraint(
thermodynamic_state, reference_system, reference_positions,
atom_indices['receptor'], atom_indices['ligand'])
else:
raise Exception("restraint_type of '%s' is not supported." %
self.restraint_type)
force = restraints.getRestraintForce(
) # Get Force object incorporating restraints
reference_system.addForce(force)
metadata[
'standard_state_correction'] = restraints.getStandardStateCorrection(
) # standard state correction in kT
elif phase == 'complex-explicit':
# For periodic systems, we do not use a restraint, but must add a standard state correction for the box volume.
# TODO: What if the box volume fluctuates during the simulation?
box_vectors = reference_system.getDefaultPeriodicBoxVectors()
box_volume = thermodynamic_state._volume(box_vectors)
STANDARD_STATE_VOLUME = 1660.53928 * unit.angstrom**3
metadata['standard_state_correction'] = np.log(
STANDARD_STATE_VOLUME / box_volume) # TODO: Check sign.
# Use default alchemical protocols if not specified.
if not protocols:
protocols = self.default_protocols
# Create alchemically-modified states using alchemical factory.
if self.verbose: print "Creating alchemically-modified states..."
factory = AbsoluteAlchemicalFactory(
reference_system, ligand_atoms=atom_indices['ligand'])
systems = factory.createPerturbedSystems(protocols[phase])
# Randomize ligand position if requested, but only for implicit solvent systems.
if self.randomize_ligand and (phase == 'complex-implicit'):
if self.verbose:
print "Randomizing ligand positions and excluding overlapping configurations..."
randomized_positions = list()
nstates = len(systems)
for state_index in range(nstates):
positions_index = np.random.randint(0, len(positions))
current_positions = positions[positions_index]
new_positions = ModifiedHamiltonianExchange.randomize_ligand_position(
current_positions, atom_indices['receptor'],
atom_indices['ligand'],
self.randomize_ligand_sigma_multiplier *
restraints.getReceptorRadiusOfGyration(),
self.randomize_ligand_close_cutoff)
randomized_positions.append(new_positions)
positions = randomized_positions
# Identify whether any atoms will be displaced via MC.
mc_atoms = list()
if 'ligand' in atom_indices:
mc_atoms = atom_indices['ligand']
# Combine simulation options with defaults.
options = dict(self.default_options.items() + options.items())
# Set up simulation.
# TODO: Support MPI initialization?
if self.verbose: print "Creating replica exchange object..."
store_filename = os.path.join(self._store_directory, phase + '.nc')
self._store_filenames[phase] = store_filename
simulation = ModifiedHamiltonianExchange(store_filename,
mpicomm=mpicomm)
simulation.create(thermodynamic_state,
systems,
positions,
displacement_sigma=self.mc_displacement_sigma,
mc_atoms=mc_atoms,
options=options,
metadata=metadata)
simulation.verbose = self.verbose
# Initialize simulation.
# TODO: Use the right scheme for initializing the simulation without running.
#if self.verbose: print "Initializing simulation..."
#simulation.run(0)
# TODO: Process user-supplied options.
# Clean up simulation.
del simulation
return
def _create_phase(self, thermodynamic_state, alchemical_phase):
"""
Create a repex object for a specified phase.
Parameters
----------
thermodynamic_state : ThermodynamicState (System need not be defined)
Thermodynamic state from which reference temperature and pressure are to be taken.
alchemical_phase : AlchemicalPhase
The alchemical phase to be created.
"""
# We add default repex options only on creation, on resume repex will pick them from the store file
repex_parameters = {
'number_of_equilibration_iterations': 0,
'number_of_iterations': 100,
'timestep': 2.0 * unit.femtoseconds,
'collision_rate': 5.0 / unit.picoseconds,
'minimize': False,
'show_mixing_statistics':
True, # this causes slowdown with iteration and should not be used for production
'displacement_sigma': 1.0 * unit.
nanometers # attempt to displace ligand by this stddev will be made each iteration
}
repex_parameters.update(self._repex_parameters)
# Convenience variables
positions = alchemical_phase.positions
reference_system = copy.deepcopy(alchemical_phase.reference_system)
atom_indices = alchemical_phase.atom_indices
alchemical_states = alchemical_phase.protocol
# If temperature and pressure are specified, make sure MonteCarloBarostat is attached.
if thermodynamic_state.temperature and thermodynamic_state.pressure:
forces = {
reference_system.getForce(index).__class__.__name__:
reference_system.getForce(index)
for index in range(reference_system.getNumForces())
}
if 'MonteCarloAnisotropicBarostat' in forces:
raise Exception(
'MonteCarloAnisotropicBarostat is unsupported.')
if 'MonteCarloBarostat' in forces:
logger.debug(
'MonteCarloBarostat found: Setting default temperature and pressure.'
)
barostat = forces['MonteCarloBarostat']
# Set temperature and pressure.
try:
barostat.setDefaultTemperature(
thermodynamic_state.temperature)
except AttributeError: # versions previous to OpenMM7.1
barostat.setTemperature(thermodynamic_state.temperature)
barostat.setDefaultPressure(state.pressure)
else:
# Create barostat and add it to the system if it doesn't have one already.
logger.debug('MonteCarloBarostat not found: Creating one.')
barostat = openmm.MonteCarloBarostat(
thermodynamic_state.pressure,
thermodynamic_state.temperature)
reference_system.addForce(barostat)
# Check the dimensions of positions.
for index in range(len(positions)):
n_atoms, _ = (positions[index] / positions[index].unit).shape
if n_atoms != reference_system.getNumParticles():
err_msg = "Phase {}: number of atoms in positions {} and and " \
"reference system differ ({} and {} respectively)"
err_msg.format(alchemical_phase.name, index, n_atoms,
reference_system.getNumParticles())
logger.error(err_msg)
raise RuntimeError(err_msg)
# Inizialize metadata storage.
metadata = dict()
# Store a serialized copy of the reference system.
metadata['reference_system'] = openmm.XmlSerializer.serialize(
reference_system)
metadata['topology'] = utils.serialize_topology(
alchemical_phase.reference_topology)
# TODO: Use more general approach to determine whether system is periodic.
is_periodic = self._is_periodic(reference_system)
is_complex_explicit = len(atom_indices['receptor']) > 0 and is_periodic
is_complex_implicit = len(
atom_indices['receptor']) > 0 and not is_periodic
# Make sure pressure is None if not periodic.
if not is_periodic: thermodynamic_state.pressure = None
# Create a copy of the system for which the fully-interacting energy is to be computed.
# For explicit solvent calculations, an enlarged cutoff is used to account for the anisotropic dispersion correction.
fully_interacting_system = copy.deepcopy(reference_system)
if is_periodic:
# Expand cutoff to maximum allowed
# TODO: Should we warn if cutoff can't be extended enough?
# TODO: Should we extend to some minimum cutoff rather than the maximum allowed?
box_vectors = fully_interacting_system.getDefaultPeriodicBoxVectors(
)
max_allowed_cutoff = 0.499 * max([
max(vector) for vector in box_vectors
]) # TODO: Correct this for non-rectangular boxes
logger.debug(
'Setting cutoff for fully interacting system to maximum allowed (%s)'
% str(max_allowed_cutoff))
for force_index in range(fully_interacting_system.getNumForces()):
force = fully_interacting_system.getForce(force_index)
if hasattr(force, 'setCutoffDistance'):
force.setCutoffDistance(max_allowed_cutoff)
if hasattr(force, 'setCutoff'):
force.setCutoff(max_allowed_cutoff)
# Construct thermodynamic state
fully_interacting_state = copy.deepcopy(thermodynamic_state)
fully_interacting_state.system = fully_interacting_system
# Compute standard state corrections for complex phase.
metadata['standard_state_correction'] = 0.0
# TODO: Do we need to include a standard state correction for other phases in periodic boxes?
if is_complex_implicit:
# Impose restraints for complex system in implicit solvent to keep ligand from drifting too far away from receptor.
logger.debug("Creating receptor-ligand restraints...")
reference_positions = positions[0]
if self._restraint_type == 'harmonic':
restraints = HarmonicReceptorLigandRestraint(
thermodynamic_state, reference_system, reference_positions,
atom_indices['receptor'], atom_indices['ligand'])
elif self._restraint_type == 'flat-bottom':
restraints = FlatBottomReceptorLigandRestraint(
thermodynamic_state, reference_system, reference_positions,
atom_indices['receptor'], atom_indices['ligand'])
else:
raise Exception("restraint_type of '%s' is not supported." %
self._restraint_type)
force = restraints.getRestraintForce(
) # Get Force object incorporating restraints
reference_system.addForce(force)
metadata[
'standard_state_correction'] = restraints.getStandardStateCorrection(
) # standard state correction in kT
elif is_complex_explicit:
# For periodic systems, we do not use a restraint, but must add a standard state correction for the box volume.
# TODO: What if the box volume fluctuates during the simulation?
box_vectors = reference_system.getDefaultPeriodicBoxVectors()
box_volume = thermodynamic_state._volume(box_vectors)
STANDARD_STATE_VOLUME = 1660.53928 * unit.angstrom**3
metadata['standard_state_correction'] = -np.log(
STANDARD_STATE_VOLUME / box_volume)
# Create alchemically-modified states using alchemical factory.
logger.debug("Creating alchemically-modified states...")
try:
alchemical_indices = atom_indices[
'ligand_counterions'] + atom_indices['ligand']
except KeyError:
alchemical_indices = atom_indices['ligand']
factory = AbsoluteAlchemicalFactory(reference_system,
ligand_atoms=alchemical_indices,
**self._alchemy_parameters)
alchemical_system = factory.alchemically_modified_system
thermodynamic_state.system = alchemical_system
# Check systems for finite energies.
# TODO: Refactor this into another function.
finite_energy_check = False
if finite_energy_check:
logger.debug(
"Checking energies are finite for all alchemical systems.")
integrator = openmm.VerletIntegrator(1.0 * unit.femtosecond)
context = openmm.Context(alchemical_system, integrator)
context.setPositions(positions[0])
for alchemical_state in alchemical_states:
AbsoluteAlchemicalFactory.perturbContext(
context, alchemical_state)
potential = context.getState(
getEnergy=True).getPotentialEnergy()
if np.isnan(potential / unit.kilocalories_per_mole):
raise Exception("Energy for system %d is NaN." % index)
del context, integrator
logger.debug("All energies are finite.")
# Randomize ligand position if requested, but only for implicit solvent systems.
if self._randomize_ligand and is_complex_implicit:
logger.debug(
"Randomizing ligand positions and excluding overlapping configurations..."
)
randomized_positions = list()
nstates = len(alchemical_states)
for state_index in range(nstates):
positions_index = np.random.randint(0, len(positions))
current_positions = positions[positions_index]
new_positions = ModifiedHamiltonianExchange.randomize_ligand_position(
current_positions, atom_indices['receptor'],
atom_indices['ligand'],
self._randomize_ligand_sigma_multiplier *
restraints.getReceptorRadiusOfGyration(),
self._randomize_ligand_close_cutoff)
randomized_positions.append(new_positions)
positions = randomized_positions
if self._randomize_ligand and is_complex_explicit:
logger.warning(
"Ligand randomization requested, but will not be performed for explicit solvent simulations."
)
# Identify whether any atoms will be displaced via MC, unless option is turned off.
mc_atoms = None
if self._mc_displacement_sigma:
mc_atoms = list()
if 'ligand' in atom_indices:
mc_atoms = atom_indices['ligand']
# Set up simulation.
# TODO: Support MPI initialization?
logger.debug("Creating replica exchange object...")
store_filename = os.path.join(self._store_directory,
alchemical_phase.name + '.nc')
self._store_filenames[alchemical_phase.name] = store_filename
simulation = ModifiedHamiltonianExchange(store_filename)
simulation.create(thermodynamic_state,
alchemical_states,
positions,
displacement_sigma=self._mc_displacement_sigma,
mc_atoms=mc_atoms,
options=repex_parameters,
metadata=metadata,
fully_interacting_state=fully_interacting_state)
# Initialize simulation.
# TODO: Use the right scheme for initializing the simulation without running.
#logger.debug("Initializing simulation...")
#simulation.run(0)
# Clean up simulation.
del simulation
# Add to list of phases that have been set up.
self._phases.append(alchemical_phase.name)
return
def test_ncmc_alchemical_integrator_stability_molecules():
"""
Test NCMCAlchemicalIntegrator
"""
molecule_names = ['pentane', 'biphenyl', 'imatinib']
if os.environ.get("TRAVIS", None) == 'true':
molecule_names = ['pentane']
for molecule_name in molecule_names:
from perses.tests.utils import createSystemFromIUPAC
[molecule, system, positions,
topology] = createSystemFromIUPAC(molecule_name)
# Eliminate half of the molecule
# TODO: Use a more rigorous scheme to make sure we are really cutting the molecule in half and not just eliminating hydrogens or something.
alchemical_atoms = [
index for index in range(int(system.getNumParticles() / 2))
]
# Create an alchemically-modified system.
from alchemy import AbsoluteAlchemicalFactory
alchemical_factory = AbsoluteAlchemicalFactory(
system,
ligand_atoms=alchemical_atoms,
annihilate_electrostatics=True,
annihilate_sterics=True)
# Return the alchemically-modified system in fully-interacting form.
alchemical_system = alchemical_factory.createPerturbedSystem()
# Create an NCMC switching integrator.
from perses.annihilation.ncmc_switching import NCMCVVAlchemicalIntegrator
temperature = 300.0 * unit.kelvin
functions = {
'lambda_sterics': 'lambda',
'lambda_electrostatics': 'lambda^0.5',
'lambda_torsions': 'lambda',
'lambda_angles': 'lambda^2'
}
ncmc_integrator = NCMCVVAlchemicalIntegrator(temperature,
alchemical_system,
functions,
direction='delete',
nsteps=10,
timestep=1.0 *
unit.femtoseconds)
# Create a Context
context = openmm.Context(alchemical_system, ncmc_integrator)
context.setPositions(positions)
# Run the integrator
ncmc_integrator.step(1)
# Check positions are finite
positions = context.getState(getPositions=True).getPositions(
asNumpy=True)
if np.isnan(np.any(positions / positions.unit)):
raise Exception('NCMCAlchemicalIntegrator gave NaN positions')
if np.isnan(ncmc_integrator.getLogAcceptanceProbability(context)):
raise Exception(
'NCMCAlchemicalIntegrator gave NaN logAcceptanceProbability')
del context, ncmc_integrator
def benchmark(reference_system,
positions,
platform_name=None,
nsteps=500,
timestep=1.0 * unit.femtoseconds,
factory_args=None):
"""
Benchmark performance of alchemically modified system relative to original system.
Parameters
----------
reference_system : simtk.openmm.System
The reference System object to compare with
positions : simtk.unit.Quantity with units compatible with nanometers
The positions to assess energetics for.
platform_name : str, optional, default=None
The name of the platform to use for benchmarking.
nsteps : int, optional, default=500
Number of molecular dynamics steps to use for benchmarking.
timestep : simtk.unit.Quantity with units compatible with femtoseconds, optional, default=1*femtoseconds
Timestep to use for benchmarking.
factory_args : dict(), optional, default=None
Arguments passed to AbsoluteAlchemicalFactory.
"""
from alchemy import AbsoluteAlchemicalFactory, AlchemicalState
# Create a factory to produce alchemical intermediates.
print("Creating alchemical factory...")
initial_time = time.time()
factory = AbsoluteAlchemicalFactory(reference_system, **factory_args)
final_time = time.time()
elapsed_time = final_time - initial_time
print("AbsoluteAlchemicalFactory initialization took %.3f s" %
elapsed_time)
# Create an alchemically-perturbed state corresponding to nearly fully-interacting.
# NOTE: We use a lambda slightly smaller than 1.0 because the AlchemicalFactory does not use Custom*Force softcore versions if lambda = 1.0 identically.
lambda_value = 1.0 - 1.0e-6
alchemical_state = AlchemicalState(lambda_electrostatics=lambda_value,
lambda_sterics=lambda_value,
lambda_torsions=lambda_value)
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
temperature = 300. * unit.kelvin
collision_rate = 90. / unit.picoseconds
# Create the perturbed system.
print("Creating alchemically-modified state...")
initial_time = time.time()
alchemical_system = factory.createPerturbedSystem(alchemical_state)
final_time = time.time()
elapsed_time = final_time - initial_time
# Compare energies.
print("Computing reference energies...")
reference_integrator = openmm.LangevinIntegrator(temperature,
collision_rate, timestep)
if platform:
reference_context = openmm.Context(reference_system,
reference_integrator, platform)
else:
reference_context = openmm.Context(reference_system,
reference_integrator)
reference_context.setPositions(positions)
reference_state = reference_context.getState(getEnergy=True)
reference_potential = reference_state.getPotentialEnergy()
print(reference_potential)
print("Computing alchemical energies...")
alchemical_integrator = openmm.LangevinIntegrator(temperature,
collision_rate, timestep)
if platform:
alchemical_context = openmm.Context(alchemical_system,
alchemical_integrator, platform)
else:
alchemical_context = openmm.Context(alchemical_system,
alchemical_integrator)
alchemical_context.setPositions(positions)
alchemical_state = alchemical_context.getState(getEnergy=True)
alchemical_potential = alchemical_state.getPotentialEnergy()
print(reference_potential)
# Make sure all kernels are compiled.
reference_integrator.step(2)
alchemical_integrator.step(2)
# Time simulations.
print("Simulating reference system...")
initial_time = time.time()
reference_integrator.step(nsteps)
reference_state = reference_context.getState()
#reference_state = reference_context.getState(getEnergy=True)
#reference_potential = reference_state.getPotentialEnergy()
final_time = time.time()
reference_time = final_time - initial_time
print("Simulating alchemical system...")
initial_time = time.time()
alchemical_integrator.step(nsteps)
reference_state = alchemical_context.getState()
#alchemical_state = alchemical_context.getState(getEnergy=True)
#alchemical_potential = alchemical_state.getPotentialEnergy()
final_time = time.time()
alchemical_time = final_time - initial_time
seconds_per_day = (1. * unit.day) / (1. * unit.seconds)
print("TIMINGS")
print(
"reference system : %12.3f s for %8d steps (%12.3f ms/step; %12.3f ns/day)"
% (reference_time, nsteps, reference_time / nsteps * 1000, nsteps *
timestep * (seconds_per_day / reference_time) / unit.nanoseconds))
print(
"alchemical system : %12.3f s for %8d steps (%12.3f ms/step; %12.3f ns/day)"
% (alchemical_time, nsteps, alchemical_time / nsteps * 1000, nsteps *
timestep * (seconds_per_day / alchemical_time) / unit.nanoseconds))
print("alchemical simulation is %12.3f x slower than unperturbed system" %
(alchemical_time / reference_time))
def _create_phase(self, phase, reference_system, positions, atom_indices, thermodynamic_state, protocols=None):
"""
Create a repex object for a specified phase.
Parameters
----------
phase : str
The phase being initialized (one of ['complex', 'solvent', 'vacuum'])
reference_system : simtk.openmm.System
The reference system object from which alchemical intermediates are to be construcfted.
positions : list of simtk.unit.Qunatity objects containing (natoms x 3) positions (as np or lists)
The list of positions to be used to seed replicas in a round-robin way.
atom_indices : dict
atom_indices[phase][component] is the set of atom indices associated with component, where component
is ['ligand', 'receptor', 'complex', 'solvent', 'ligand_counterions']
thermodynamic_state : ThermodynamicState
Thermodynamic state from which reference temperature and pressure are to be taken.
protocols : dict of list of AlchemicalState, optional, default=None
If specified, the alchemical protocol protocols[phase] will be used for phase 'phase' instead of the default.
"""
# We add default repex options only on creation, on resume repex will pick them from the store file
repex_parameters = {
'number_of_equilibration_iterations': 0,
'number_of_iterations': 100,
'timestep': 2.0 * unit.femtoseconds,
'collision_rate': 5.0 / unit.picoseconds,
'minimize': False,
'show_mixing_statistics': True, # this causes slowdown with iteration and should not be used for production
'displacement_sigma': 1.0 * unit.nanometers # attempt to displace ligand by this stddev will be made each iteration
}
repex_parameters.update(self._repex_parameters)
# Make sure positions argument is a list of coordinate snapshots.
if hasattr(positions, 'unit'):
# Wrap in list.
positions = [positions]
# Check the dimensions of positions.
for index in range(len(positions)):
# Make sure it is recast as a np array.
positions[index] = unit.Quantity(np.array(positions[index] / positions[index].unit), positions[index].unit)
[natoms, ndim] = (positions[index] / positions[index].unit).shape
if natoms != reference_system.getNumParticles():
raise Exception("positions argument must be a list of simtk.unit.Quantity of (natoms,3) lists or np array with units compatible with nanometers.")
# Create metadata storage.
metadata = dict()
# Make a deep copy of the reference system so we don't accidentally modify it.
reference_system = copy.deepcopy(reference_system)
# TODO: Use more general approach to determine whether system is periodic.
is_periodic = self._is_periodic(reference_system)
# Make sure pressure is None if not periodic.
if not is_periodic: thermodynamic_state.pressure = None
# Compute standard state corrections for complex phase.
metadata['standard_state_correction'] = 0.0
# TODO: Do we need to include a standard state correction for other phases in periodic boxes?
if phase == 'complex-implicit':
# Impose restraints for complex system in implicit solvent to keep ligand from drifting too far away from receptor.
logger.debug("Creating receptor-ligand restraints...")
reference_positions = positions[0]
if self._restraint_type == 'harmonic':
restraints = HarmonicReceptorLigandRestraint(thermodynamic_state, reference_system, reference_positions, atom_indices['receptor'], atom_indices['ligand'])
elif self._restraint_type == 'flat-bottom':
restraints = FlatBottomReceptorLigandRestraint(thermodynamic_state, reference_system, reference_positions, atom_indices['receptor'], atom_indices['ligand'])
else:
raise Exception("restraint_type of '%s' is not supported." % self._restraint_type)
force = restraints.getRestraintForce() # Get Force object incorporating restraints
reference_system.addForce(force)
metadata['standard_state_correction'] = restraints.getStandardStateCorrection() # standard state correction in kT
elif phase == 'complex-explicit':
# For periodic systems, we do not use a restraint, but must add a standard state correction for the box volume.
# TODO: What if the box volume fluctuates during the simulation?
box_vectors = reference_system.getDefaultPeriodicBoxVectors()
box_volume = thermodynamic_state._volume(box_vectors)
STANDARD_STATE_VOLUME = 1660.53928 * unit.angstrom**3
metadata['standard_state_correction'] = - np.log(STANDARD_STATE_VOLUME / box_volume)
# Use default alchemical protocols if not specified.
if not protocols:
protocols = self.default_protocols
# Create alchemically-modified states using alchemical factory.
logger.debug("Creating alchemically-modified states...")
try:
alchemical_indices = atom_indices['ligand_counterions'] + atom_indices['ligand']
except KeyError:
alchemical_indices = atom_indices['ligand']
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=alchemical_indices,
**self._alchemy_parameters)
alchemical_states = protocols[phase]
alchemical_system = factory.alchemically_modified_system
thermodynamic_state.system = alchemical_system
# Check systems for finite energies.
# TODO: Refactor this into another function.
finite_energy_check = False
if finite_energy_check:
logger.debug("Checking energies are finite for all alchemical systems.")
integrator = openmm.VerletIntegrator(1.0 * unit.femtosecond)
context = openmm.Context(alchemical_system, integrator)
context.setPositions(positions[0])
for alchemical_state in alchemical_states:
AbsoluteAlchemicalFactory.perturbContext(context, alchemical_state)
potential = context.getState(getEnergy=True).getPotentialEnergy()
if np.isnan(potential / unit.kilocalories_per_mole):
raise Exception("Energy for system %d is NaN." % index)
del context, integrator
logger.debug("All energies are finite.")
# Randomize ligand position if requested, but only for implicit solvent systems.
if self._randomize_ligand and (phase == 'complex-implicit'):
logger.debug("Randomizing ligand positions and excluding overlapping configurations...")
randomized_positions = list()
nstates = len(alchemical_states)
for state_index in range(nstates):
positions_index = np.random.randint(0, len(positions))
current_positions = positions[positions_index]
new_positions = ModifiedHamiltonianExchange.randomize_ligand_position(current_positions,
atom_indices['receptor'], atom_indices['ligand'],
self._randomize_ligand_sigma_multiplier * restraints.getReceptorRadiusOfGyration(),
self._randomize_ligand_close_cutoff)
randomized_positions.append(new_positions)
positions = randomized_positions
if self._randomize_ligand and (phase == 'complex-explicit'):
logger.warning("Ligand randomization requested, but will not be performed for explicit solvent simulations.")
# Identify whether any atoms will be displaced via MC, unless option is turned off.
mc_atoms = None
if self._mc_displacement_sigma:
mc_atoms = list()
if 'ligand' in atom_indices:
mc_atoms = atom_indices['ligand']
# Set up simulation.
# TODO: Support MPI initialization?
logger.debug("Creating replica exchange object...")
store_filename = os.path.join(self._store_directory, phase + '.nc')
self._store_filenames[phase] = store_filename
simulation = ModifiedHamiltonianExchange(store_filename)
simulation.create(thermodynamic_state, alchemical_states, positions,
displacement_sigma=self._mc_displacement_sigma, mc_atoms=mc_atoms,
options=repex_parameters, metadata=metadata)
# Initialize simulation.
# TODO: Use the right scheme for initializing the simulation without running.
#logger.debug("Initializing simulation...")
#simulation.run(0)
# Clean up simulation.
del simulation
# Add to list of phases that have been set up.
self._phases.append(phase)
return
# DEBUG
outfile = open('nacl-solvated.pdb', 'w')
app.PDBFile.writeFile(topology, positions, file=outfile)
outfile.close()
#
# Create alchemical intermediates.
#
print "Creating alchemical intermediates..."
# Create a factory to produce alchemical intermediates.
ligand_atoms = range(0, 2) # NaCl
from alchemy import AbsoluteAlchemicalFactory
factory = AbsoluteAlchemicalFactory(reference_system,
ligand_atoms=ligand_atoms)
# Get the default protocol for 'denihilating' in complex in explicit solvent.
protocol = factory.defaultComplexProtocolImplicit()
# Create the perturbed systems using this protocol.
systems = factory.createPerturbedSystems(protocol, verbose=True)
#
# Set up replica exchange simulation.
#
print "Setting up replica-exchange simulation..."
# Create reference state.
from thermodynamics import ThermodynamicState
reference_state = ThermodynamicState(reference_system,
temperature=temperature,
def _create_phase(self, thermodynamic_state, alchemical_phase, restraint_type):
"""
Create a repex object for a specified phase.
Parameters
----------
thermodynamic_state : ThermodynamicState (System need not be defined)
Thermodynamic state from which reference temperature and pressure are to be taken.
alchemical_phase : AlchemicalPhase
The alchemical phase to be created.
restraint_type : str or None
Restraint type to add between protein and ligand. Supported
types are 'FlatBottom' and 'Harmonic'. The second one is
available only in implicit solvent.
"""
# We add default repex options only on creation, on resume repex will pick them from the store file
repex_parameters = {
'number_of_equilibration_iterations': 0,
'number_of_iterations': 100,
'timestep': 2.0 * unit.femtoseconds,
'collision_rate': 5.0 / unit.picoseconds,
'minimize': False,
'show_mixing_statistics': True, # this causes slowdown with iteration and should not be used for production
'displacement_sigma': 1.0 * unit.nanometers # attempt to displace ligand by this stddev will be made each iteration
}
repex_parameters.update(self._repex_parameters)
# Convenience variables
positions = alchemical_phase.positions
reference_system = copy.deepcopy(alchemical_phase.reference_system)
atom_indices = alchemical_phase.atom_indices
alchemical_states = alchemical_phase.protocol
# Check the dimensions of positions.
for index in range(len(positions)):
n_atoms, _ = (positions[index] / positions[index].unit).shape
if n_atoms != reference_system.getNumParticles():
err_msg = "Phase {}: number of atoms in positions {} and and " \
"reference system differ ({} and {} respectively)"
err_msg.format(alchemical_phase.name, index, n_atoms,
reference_system.getNumParticles())
logger.error(err_msg)
raise RuntimeError(err_msg)
# Inizialize metadata storage.
metadata = dict()
# TODO: Use more general approach to determine whether system is periodic.
is_periodic = reference_system.usesPeriodicBoundaryConditions()
is_complex = len(atom_indices['receptor']) > 0
is_complex_explicit = is_complex and is_periodic
is_complex_implicit = is_complex and not is_periodic
# Make sure pressure is None if not periodic.
if not is_periodic:
thermodynamic_state.pressure = None
# If temperature and pressure are specified, make sure MonteCarloBarostat is attached.
elif thermodynamic_state.temperature and thermodynamic_state.pressure:
forces = { reference_system.getForce(index).__class__.__name__ : reference_system.getForce(index) for index in range(reference_system.getNumForces()) }
if 'MonteCarloAnisotropicBarostat' in forces:
raise Exception('MonteCarloAnisotropicBarostat is unsupported.')
if 'MonteCarloBarostat' in forces:
logger.debug('MonteCarloBarostat found: Setting default temperature and pressure.')
barostat = forces['MonteCarloBarostat']
# Set temperature and pressure.
try:
barostat.setDefaultTemperature(thermodynamic_state.temperature)
except AttributeError: # versions previous to OpenMM7.1
barostat.setTemperature(thermodynamic_state.temperature)
barostat.setDefaultPressure(thermodynamic_state.pressure)
else:
# Create barostat and add it to the system if it doesn't have one already.
logger.debug('MonteCarloBarostat not found: Creating one.')
barostat = openmm.MonteCarloBarostat(thermodynamic_state.pressure, thermodynamic_state.temperature)
reference_system.addForce(barostat)
# Store a serialized copy of the reference system.
metadata['reference_system'] = openmm.XmlSerializer.serialize(reference_system)
metadata['topology'] = utils.serialize_topology(alchemical_phase.reference_topology)
# For explicit solvent calculations, we create a copy of the system for
# which the fully-interacting energy is to be computed. An enlarged cutoff
# is used to account for the anisotropic dispersion correction. This must
# be done BEFORE adding the restraint to reference_system.
# We dont care about restraint in decoupled state (although we will set to 0) since we will
# account for that by hand.
# Helper function for expanded cutoff
def expand_cutoff(passed_system, max_allowed_cutoff = 16 * unit.angstroms):
# Determine minimum box side dimension
box_vectors = passed_system.getDefaultPeriodicBoxVectors()
min_box_dimension = min([max(vector) for vector in box_vectors])
# Expand cutoff to minimize artifact and verify that box is big enough.
# If we use a barostat we leave more room for volume fluctuations or
# we risk fatal errors. If we don't use a barostat, OpenMM will raise
# the appropriate exception on context creation.
max_switching_distance = max_allowed_cutoff - (1 * unit.angstrom)
# TODO: Make max_allowed_cutoff an option
if thermodynamic_state.pressure and min_box_dimension < 2.25 * max_allowed_cutoff:
raise RuntimeError('Barostated box sides must be at least 36 Angstroms '
'to correct for missing dispersion interactions')
logger.debug('Setting cutoff for fully interacting system to maximum '
'allowed {}'.format(str(max_allowed_cutoff)))
# Expanded cutoff system if needed
# We don't want to reduce the cutoff if its already large
for force in passed_system.getForces():
try:
if force.getCutoffDistance() < max_allowed_cutoff:
force.setCutoffDistance(max_allowed_cutoff)
# Set switch distance
# We don't need to check if we are using a switch since there is a setting for that.
force.setSwitchingDistance(max_switching_distance)
except Exception:
pass
try:
if force.getCutoff() < max_allowed_cutoff:
force.setCutoff(max_allowed_cutoff)
except Exception:
pass
# Set the fully-interacting expanded cutoff state here
if not is_periodic:
fully_interacting_expanded_state = None
else:
# Create the fully interacting system
fully_interacting_expanded_system = copy.deepcopy(reference_system)
# Expand Cutoff
expand_cutoff(fully_interacting_expanded_system)
# Construct thermodynamic states
fully_interacting_expanded_state = copy.deepcopy(thermodynamic_state)
fully_interacting_expanded_state.system = fully_interacting_expanded_system
# Compute standard state corrections for complex phase.
metadata['standard_state_correction'] = 0.0
# TODO: Do we need to include a standard state correction for other phases in periodic boxes?
if is_complex and restraint_type is not None:
logger.debug("Creating receptor-ligand restraints...")
reference_positions = positions[0]
restraints = create_restraints(restraint_type, alchemical_phase.reference_topology,
thermodynamic_state, reference_system, reference_positions,
atom_indices['receptor'], atom_indices['ligand'])
force = restraints.get_restraint_force() # Get Force object incorporating restraints.
reference_system.addForce(force)
metadata['standard_state_correction'] = restraints.get_standard_state_correction() # in kT
elif is_complex_explicit:
# For periodic systems, we must still add a standard state
# correction for the box volume.
# TODO: What if the box volume fluctuates during the simulation?
box_vectors = reference_system.getDefaultPeriodicBoxVectors()
box_volume = thermodynamic_state._volume(box_vectors)
metadata['standard_state_correction'] = - np.log(V0 / box_volume)
elif is_complex_implicit:
# For implicit solvent/vacuum complex systems, we require a restraint
# to keep the ligand from drifting too far away from receptor.
raise ValueError('A receptor-ligand system in implicit solvent or '
'vacuum requires a restraint.')
# Create alchemically-modified states using alchemical factory.
logger.debug("Creating alchemically-modified states...")
try:
alchemical_indices = atom_indices['ligand_counterions'] + atom_indices['ligand']
except KeyError:
alchemical_indices = atom_indices['ligand']
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=alchemical_indices,
**self._alchemy_parameters)
alchemical_system = factory.alchemically_modified_system
thermodynamic_state.system = alchemical_system
# Create the expanded cutoff decoupled state
if fully_interacting_expanded_state is None:
noninteracting_expanded_state = None
else:
# Create the system for noninteracting
expanded_factory = AbsoluteAlchemicalFactory(fully_interacting_expanded_state.system,
ligand_atoms=alchemical_indices,
**self._alchemy_parameters)
noninteracting_expanded_system = expanded_factory.alchemically_modified_system
# Set all USED alchemical interactions to the decoupled state
alchemical_state = alchemical_states[-1]
AbsoluteAlchemicalFactory.perturbSystem(noninteracting_expanded_system, alchemical_state)
# Construct thermodynamic states
noninteracting_expanded_state = copy.deepcopy(thermodynamic_state)
noninteracting_expanded_state.system = noninteracting_expanded_system
# Check systems for finite energies.
# TODO: Refactor this into another function.
finite_energy_check = False
if finite_energy_check:
logger.debug("Checking energies are finite for all alchemical systems.")
integrator = openmm.VerletIntegrator(1.0 * unit.femtosecond)
context = openmm.Context(alchemical_system, integrator)
context.setPositions(positions[0])
for index, alchemical_state in enumerate(alchemical_states):
AbsoluteAlchemicalFactory.perturbContext(context, alchemical_state)
potential = context.getState(getEnergy=True).getPotentialEnergy()
if np.isnan(potential / unit.kilocalories_per_mole):
raise Exception("Energy for system %d is NaN." % index)
del context, integrator
logger.debug("All energies are finite.")
# Randomize ligand position if requested, but only for implicit solvent systems.
if self._randomize_ligand and is_complex_implicit:
logger.debug("Randomizing ligand positions and excluding overlapping configurations...")
randomized_positions = list()
nstates = len(alchemical_states)
for state_index in range(nstates):
positions_index = np.random.randint(0, len(positions))
current_positions = positions[positions_index]
new_positions = ModifiedHamiltonianExchange.randomize_ligand_position(current_positions,
atom_indices['receptor'], atom_indices['ligand'],
self._randomize_ligand_sigma_multiplier * restraints.getReceptorRadiusOfGyration(),
self._randomize_ligand_close_cutoff)
randomized_positions.append(new_positions)
positions = randomized_positions
if self._randomize_ligand and is_complex_explicit:
logger.warning("Ligand randomization requested, but will not be performed for explicit solvent simulations.")
# Identify whether any atoms will be displaced via MC, unless option is turned off.
mc_atoms = None
if self._mc_displacement_sigma:
mc_atoms = list()
if 'ligand' in atom_indices:
mc_atoms = atom_indices['ligand']
# Set up simulation.
# TODO: Support MPI initialization?
logger.debug("Creating replica exchange object...")
store_filename = os.path.join(self._store_directory, alchemical_phase.name + '.nc')
self._store_filenames[alchemical_phase.name] = store_filename
simulation = ModifiedHamiltonianExchange(store_filename, platform=self._platform)
simulation.create(thermodynamic_state, alchemical_states, positions,
displacement_sigma=self._mc_displacement_sigma, mc_atoms=mc_atoms,
options=repex_parameters, metadata=metadata,
fully_interacting_expanded_state = fully_interacting_expanded_state,
noninteracting_expanded_state = noninteracting_expanded_state)
# Initialize simulation.
# TODO: Use the right scheme for initializing the simulation without running.
#logger.debug("Initializing simulation...")
#simulation.run(0)
# Clean up simulation.
del simulation
# Add to list of phases that have been set up.
self._phases.append(alchemical_phase.name)
self._phases.sort() # sorting ensures all MPI processes run the same phase
return
def testAlchemicalFactory(reference_system, coordinates, receptor_atoms, ligand_atoms, platform_name='Reference', annihilateElectrostatics=True, annihilateLennardJones=False):
"""
Compare energies of reference system and fully-interacting alchemically modified system.
ARGUMENTS
reference_system (simtk.openmm.System) - the reference System object to compare with
coordinates - the coordinates to assess energetics for
receptor_atoms (list of int) - the list of receptor atoms
ligand_atoms (list of int) - the list of ligand atoms to alchemically modify
"""
import simtk.unit as units
import simtk.openmm as openmm
import time
# Create a factory to produce alchemical intermediates.
print "Creating alchemical factory..."
initial_time = time.time()
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=ligand_atoms)
final_time = time.time()
elapsed_time = final_time - initial_time
print "AbsoluteAlchemicalFactory initialization took %.3f s" % elapsed_time
# Create an alchemically-perturbed state corresponding to nearly fully-interacting.
# NOTE: We use a lambda slightly smaller than 1.0 because the AlchemicalFactory does not use Custom*Force softcore versions if lambda = 1.0 identically.
lambda_value = 1.0 - 1.0e-6
alchemical_state = AlchemicalState(0.00, lambda_value, lambda_value, lambda_value)
alchemical_state.annihilateElectrostatics = annihilateElectrostatics
alchemical_state.annihilateLennardJones = annihilateLennardJones
#platform_name = 'Reference' # DEBUG
platform = openmm.Platform.getPlatformByName(platform_name)
# Create the perturbed system.
print "Creating alchemically-modified state..."
initial_time = time.time()
alchemical_system = factory.createPerturbedSystem(alchemical_state)
final_time = time.time()
elapsed_time = final_time - initial_time
# Compare energies.
timestep = 1.0 * units.femtosecond
print "Computing reference energies..."
reference_integrator = openmm.VerletIntegrator(timestep)
reference_context = openmm.Context(reference_system, reference_integrator, platform)
reference_context.setPositions(coordinates)
reference_state = reference_context.getState(getEnergy=True)
reference_potential = reference_state.getPotentialEnergy()
print "Computing alchemical energies..."
alchemical_integrator = openmm.VerletIntegrator(timestep)
alchemical_context = openmm.Context(alchemical_system, alchemical_integrator, platform)
alchemical_context.setPositions(coordinates)
alchemical_state = alchemical_context.getState(getEnergy=True)
alchemical_potential = alchemical_state.getPotentialEnergy()
delta = alchemical_potential - reference_potential
print "reference system : %24.8f kcal/mol" % (reference_potential / units.kilocalories_per_mole)
print "alchemically modified : %24.8f kcal/mol" % (alchemical_potential / units.kilocalories_per_mole)
print "ERROR : %24.8f kcal/mol" % ((alchemical_potential - reference_potential) / units.kilocalories_per_mole)
print "elapsed alchemical time %.3f s" % elapsed_time
return delta
def test_overlap():
"""
BUGS TO REPORT:
* Even if epsilon = 0, energy of two overlapping atoms is 'nan'.
* Periodicity in 'nan' if dr = 0.1 even in nonperiodic system
"""
# Create a reference system.
import testsystems
print "Creating Lennard-Jones cluster system..."
#[reference_system, coordinates] = testsystems.LennardJonesFluid()
#receptor_atoms = [0]
#ligand_atoms = [1]
[reference_system, coordinates] = testsystems.LysozymeImplicit()
receptor_atoms = range(0,2603) # T4 lysozyme L99A
ligand_atoms = range(2603,2621) # p-xylene
import simtk.unit as units
unit = coordinates.unit
coordinates = units.Quantity(numpy.array(coordinates / unit), unit)
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=ligand_atoms)
alchemical_state = AlchemicalState(0.00, 0.00, 0.00, 1.0)
# Create the perturbed system.
print "Creating alchemically-modified state..."
alchemical_system = factory.createPerturbedSystem(alchemical_state)
# Compare energies.
import simtk.unit as units
import simtk.openmm as openmm
timestep = 1.0 * units.femtosecond
print "Computing reference energies..."
integrator = openmm.VerletIntegrator(timestep)
context = openmm.Context(reference_system, integrator)
context.setPositions(coordinates)
state = context.getState(getEnergy=True)
reference_potential = state.getPotentialEnergy()
del state, context, integrator
print reference_potential
print "Computing alchemical energies..."
integrator = openmm.VerletIntegrator(timestep)
context = openmm.Context(alchemical_system, integrator)
dr = 0.1 * units.angstroms # TODO: Why does 0.1 cause periodic 'nan's?
a = receptor_atoms[-1]
b = ligand_atoms[-1]
delta = coordinates[a,:] - coordinates[b,:]
for k in range(3):
coordinates[ligand_atoms,k] += delta[k]
for i in range(30):
r = dr * i
coordinates[ligand_atoms,0] += dr
context.setPositions(coordinates)
state = context.getState(getEnergy=True)
alchemical_potential = state.getPotentialEnergy()
print "%8.3f A : %f " % (r / units.angstroms, alchemical_potential / units.kilocalories_per_mole)
del state, context, integrator
return
def __init__(self, alchemical_protocol='two-phase', nlambda=50, **kwargs):
"""
Create an alchemical free energy calculation SAMS test system from the provided system.
Parameters
----------
alchemical_protocol : str, optional, default='two-phase'
Alchemical protocol scheme to use. ['two-phase', 'fused']
nlambda : int, optional, default=50
Number of alchemical states.
"""
super(AlchemicalSAMSTestSystem, self).__init__(**kwargs)
self.description = 'Alchemical SAMS test system'
self.alchemical_protocol = alchemical_protocol
if not (hasattr(self, 'topology') and hasattr(self, 'system')
and hasattr(self, 'positions')
and hasattr(self, 'alchemical_atoms')):
raise Exception(
"%s: 'topology', 'system', 'positions', and 'alchemical_atoms' properties must be defined!"
% self.__class__.__name__)
if not hasattr(self, 'temperature'):
self.temperature = 300 * unit.kelvin
if not hasattr(self, 'temperature'):
self.temperature = 300 * unit.kelvin
if not hasattr(self, 'pressure'):
self.pressure = None
# Add a MonteCarloBarostat if system does not have one
has_barostat = False
for force in self.system.getForces():
if force.__class__.__name__ in [
'MonteCarloBarostat', 'MonteCarloAnisotropicBarostat'
]:
has_barostat = True
if (self.pressure is not None) and (not has_barostat):
barostat = openmm.MonteCarloBarostat(self.pressure,
self.temperature)
self.system.addForce(barostat)
# Create alchemically-modified system and populate thermodynamic states.
from alchemy import AbsoluteAlchemicalFactory
from sams import ThermodynamicState
self.thermodynamic_states = list()
if alchemical_protocol == 'fused':
factory = AbsoluteAlchemicalFactory(
self.system,
ligand_atoms=self.alchemical_atoms,
annihilate_electrostatics=True,
annihilate_sterics=False)
self.system = factory.createPerturbedSystem()
from sams import ThermodynamicState
alchemical_lambdas = np.linspace(1.0, 0.0, nlambda)
for alchemical_lambda in alchemical_lambdas:
parameters = {
'lambda_sterics': alchemical_lambda,
'lambda_electrostatics': alchemical_lambda
}
self.thermodynamic_states.append(
ThermodynamicState(system=self.system,
temperature=self.temperature,
pressure=self.pressure,
parameters=parameters))
elif alchemical_protocol == 'two-phase':
factory = AbsoluteAlchemicalFactory(
self.system,
ligand_atoms=self.alchemical_atoms,
annihilate_electrostatics=True,
annihilate_sterics=False,
softcore_beta=0.0) # turn off softcore electrostatics
self.system = factory.createPerturbedSystem()
nelec = int(nlambda / 2.0)
nvdw = nlambda - nelec
for state in range(nelec + 1):
parameters = {
'lambda_sterics': 1.0,
'lambda_electrostatics':
(1.0 - float(state) / float(nelec))
}
self.thermodynamic_states.append(
ThermodynamicState(system=self.system,
temperature=self.temperature,
pressure=self.pressure,
parameters=parameters))
for state in range(1, nvdw + 1):
parameters = {
'lambda_sterics': (1.0 - float(state) / float(nvdw)),
'lambda_electrostatics': 0.0
}
self.thermodynamic_states.append(
ThermodynamicState(system=self.system,
temperature=self.temperature,
pressure=self.pressure,
parameters=parameters))
else:
raise Exception(
"'alchemical_protocol' must be one of ['two-phase', 'fused']; scheme '%s' unknown."
% alchemical_protocol)
# Create SAMS samplers
print('Setting up samplers...')
from sams.samplers import SamplerState, MCMCSampler, ExpandedEnsembleSampler, SAMSSampler
thermodynamic_state_index = 0 # initial thermodynamic state index
thermodynamic_state = self.thermodynamic_states[
thermodynamic_state_index]
sampler_state = SamplerState(positions=self.positions)
self.mcmc_sampler = MCMCSampler(
sampler_state=sampler_state,
thermodynamic_state=thermodynamic_state,
ncfile=self.ncfile)
self.mcmc_sampler.timestep = 2.0 * unit.femtoseconds
self.mcmc_sampler.nsteps = 500
#self.mcmc_sampler.pdbfile = open('output.pdb', 'w')
self.mcmc_sampler.topology = self.topology
self.mcmc_sampler.verbose = True
self.exen_sampler = ExpandedEnsembleSampler(self.mcmc_sampler,
self.thermodynamic_states)
self.exen_sampler.verbose = True
self.sams_sampler = SAMSSampler(self.exen_sampler)
self.sams_sampler.verbose = True
# DEBUG: Write PDB of initial frame
from simtk.openmm.app import PDBFile
outfile = open('initial.pdb', 'w')
PDBFile.writeFile(self.topology, self.positions, outfile)
outfile.close()
def __init__(self, **kwargs):
super(LoopSoftening, self).__init__(**kwargs)
self.description = 'Alchemical Loop Softening script'
padding = 9.0*unit.angstrom
explicit_solvent_model = 'tip3p'
setup_path = 'data/mtor'
# Create topology, positions, and system.
from pkg_resources import resource_filename
gaff_xml_filename = resource_filename('sams', 'data/gaff.xml')
system_generators = dict()
ffxmls = [gaff_xml_filename, 'amber99sbildn.xml', 'tip3p.xml']
forcefield_kwargs={ 'nonbondedMethod' : app.CutoffPeriodic, 'nonbondedCutoff' : 9.0 * unit.angstrom, 'implicitSolvent' : None, 'constraints' : app.HBonds, 'rigidWater' : True }
# Load topologies and positions for all components
print('Creating mTOR test system...')
forcefield = app.ForceField(*ffxmls)
from simtk.openmm.app import PDBFile, Modeller
pdb_filename = resource_filename('sams', os.path.join(setup_path, 'mtor_pdbfixer_apo.pdb'))
pdbfile = PDBFile(pdb_filename)
modeller = app.Modeller(pdbfile.topology, pdbfile.positions)
print('Adding solvent...')
modeller.addSolvent(forcefield, model=explicit_solvent_model, padding=padding)
self.topology = modeller.getTopology()
self.positions = modeller.getPositions()
print('Creating system...')
self.system = forcefield.createSystem(self.topology, **forcefield_kwargs)
# DEBUG: Write PDB
outfile = open('initial.pdb', 'w')
PDBFile.writeFile(self.topology, self.positions, outfile)
outfile.close()
# Atom Selection using MDtraj
res_pairs = [[403, 483], [1052, 1109]]
t = md.load(pdb_filename)
alchemical_atoms = []
for x in res_pairs:
start = min(t.top.select('residue %s' % min(x)))
end = max(t.top.select('residue %s' % max(x))) + 1
alchemical_atoms.append(list(range(start, end)))
#print(alchemical_atoms)
# Add a MonteCarloBarostat
#temperature = 300 * unit.kelvin # will be replaced as thermodynamic state is updated
#pressure = 1.0 * unit.atmospheres
#barostat = openmm.MonteCarloBarostat(pressure, temperature)
#self.system.addForce(barostat)
# Create thermodynamic states.
print('Creating alchemically-modified system...')
temperature = 300 * unit.kelvin
pressure = 1.0 * unit.atmospheres
alchemical_atoms = range(0,69) # Abl:imatinib
from alchemy import AbsoluteAlchemicalFactory
factory = AbsoluteAlchemicalFactory(self.system, ligand_atoms=alchemical_atoms, annihilate_electrostatics=True, annihilate_sterics=False, softcore_beta=0.0) # turn off softcore electrostatics
self.system = factory.createPerturbedSystem()
print('Setting up alchemical intermediates...')
from sams import ThermodynamicState
self.thermodynamic_states = list()
for state in range(251):
parameters = {'lambda_sterics' : 1.0, 'lambda_electrostatics' : (1.0 - float(state)/250.0) }
self.thermodynamic_states.append( ThermodynamicState(system=self.system, temperature=temperature, parameters=parameters) )
for state in range(1,251):
parameters = {'lambda_sterics' : (1.0 - float(state)/250.0), 'lambda_electrostatics' : 0.0 }
self.thermodynamic_states.append( ThermodynamicState(system=self.system, temperature=temperature, parameters=parameters) )
# Create SAMS samplers
print('Setting up samplers...')
from sams.samplers import SamplerState, MCMCSampler, ExpandedEnsembleSampler, SAMSSampler
thermodynamic_state_index = 0 # initial thermodynamic state index
thermodynamic_state = self.thermodynamic_states[thermodynamic_state_index]
sampler_state = SamplerState(positions=self.positions)
self.mcmc_sampler = MCMCSampler(sampler_state=sampler_state, thermodynamic_state=thermodynamic_state, ncfile=self.ncfile)
self.mcmc_sampler.pdbfile = open('output.pdb', 'w')
self.mcmc_sampler.topology = self.topology
self.mcmc_sampler.verbose = True
self.exen_sampler = ExpandedEnsembleSampler(self.mcmc_sampler, self.thermodynamic_states)
self.exen_sampler.verbose = True
self.sams_sampler = SAMSSampler(self.exen_sampler)
self.sams_sampler.verbose = True
