def alchemical_factory_check(reference_system, positions, receptor_atoms, ligand_atoms, platform_name=None, annihilateElectrostatics=True, annihilateSterics=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
positions - the positions 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
"""
# Create a factory to produce alchemical intermediates.
logger.info("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
logger.info("AbsoluteAlchemicalFactory initialization took %.3f s" % elapsed_time)
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
delta = 0.001
delta = 1.0e-6
compareSystemEnergies(positions, [reference_system, factory.createPerturbedSystem(AlchemicalState(0, 1-delta, 1, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics))], ['reference', 'partially discharged'], platform=platform)
compareSystemEnergies(positions, [factory.createPerturbedSystem(AlchemicalState(0, delta, 1, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics)), factory.createPerturbedSystem(AlchemicalState(0, 0.0, 1, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics))], ['partially charged', 'discharged'], platform=platform)
compareSystemEnergies(positions, [factory.createPerturbedSystem(AlchemicalState(0, 0, 1, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics)), factory.createPerturbedSystem(AlchemicalState(0, 0, 1-delta, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics))], ['discharged', 'partially decoupled'], platform=platform)
compareSystemEnergies(positions, [factory.createPerturbedSystem(AlchemicalState(0, 0, delta, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics)), factory.createPerturbedSystem(AlchemicalState(0, 0, 0, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics))], ['partially coupled', 'decoupled'], platform=platform)
return
def lambda_trace(reference_system, positions, receptor_atoms, ligand_atoms, platform_name=None, annihilateElectrostatics=True, annihilateSterics=False, nsteps=50):
"""
Compute potential energy as a function of lambda.
"""
# Create a factory to produce alchemical intermediates.
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=ligand_atoms)
platform = None
if platform_name:
# Get platform.
platform = openmm.Platform.getPlatformByName(platform_name)
delta = 1.0 / nsteps
def compute_potential(system, positions, platform=None):
timestep = 1.0 * units.femtoseconds
integrator = openmm.VerletIntegrator(timestep)
if platform:
context = openmm.Context(system, integrator, platform)
else:
context = openmm.Context(system, integrator)
context.setPositions(positions)
state = context.getState(getEnergy=True)
potential = state.getPotentialEnergy()
del integrator, context
return potential
# discharging
outfile = open('discharging-trace.out', 'w')
for i in range(nsteps+1):
lambda_value = 1.0-i*delta
alchemical_system = factory.createPerturbedSystem(AlchemicalState(0, lambda_value, 1, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics))
potential = compute_potential(alchemical_system, positions, platform)
line = '%12.6f %24.6f' % (lambda_value, potential / units.kilocalories_per_mole)
outfile.write(line + '\n')
logger.info(line)
outfile.close()
# decoupling
outfile = open('decoupling-trace.out', 'w')
for i in range(nsteps+1):
lambda_value = 1.0-i*delta
alchemical_system = factory.createPerturbedSystem(AlchemicalState(0, 0, lambda_value, 1, annihilateElectrostatics=annihilateElectrostatics, annihilateSterics=annihilateSterics))
potential = compute_potential(alchemical_system, positions, platform)
line = '%12.6f %24.6f' % (lambda_value, potential / units.kilocalories_per_mole)
outfile.write(line + '\n')
logger.info(line)
outfile.close()
return
def overlap_check():
"""
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.
logger.info("Creating Lennard-Jones cluster system...")
#[reference_system, positions] = testsystems.LennardJonesFluid()
#receptor_atoms = [0]
#ligand_atoms = [1]
system_container = testsystems.LysozymeImplicit()
(reference_system, positions) = system_container.system, system_container.positions
receptor_atoms = range(0,2603) # T4 lysozyme L99A
ligand_atoms = range(2603,2621) # p-xylene
unit = positions.unit
positions = units.Quantity(np.array(positions / 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.
logger.info("Creating alchemically-modified state...")
alchemical_system = factory.createPerturbedSystem(alchemical_state)
# Compare energies.
timestep = 1.0 * units.femtosecond
logger.info("Computing reference energies...")
integrator = openmm.VerletIntegrator(timestep)
context = openmm.Context(reference_system, integrator)
context.setPositions(positions)
state = context.getState(getEnergy=True)
reference_potential = state.getPotentialEnergy()
del state, context, integrator
logger.info(reference_potential)
logger.info("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 = positions[a,:] - positions[b,:]
for k in range(3):
positions[ligand_atoms,k] += delta[k]
for i in range(30):
r = dr * i
positions[ligand_atoms,0] += dr
context.setPositions(positions)
state = context.getState(getEnergy=True)
alchemical_potential = state.getPotentialEnergy()
logger.info("%8.3f A : %f " % (r / units.angstroms, alchemical_potential / units.kilocalories_per_mole))
del state, context, integrator
return
def alchemical_factory_check(reference_system,
positions,
receptor_atoms,
ligand_atoms,
platform_name=None,
annihilate_electrostatics=True,
annihilate_sterics=False,
precision=None):
"""
Compare energies of reference system and fully-interacting alchemically modified system.
ARGUMENTS
reference_system (simtk.openmm.System) - the reference System object to compare with
positions - the positions 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
precision : str, optional, default=None
Precision model, or default if not specified. ('single', 'double', 'mixed')
"""
# Create a factory to produce alchemical intermediates.
logger.info("Creating alchemical factory...")
initial_time = time.time()
factory = AbsoluteAlchemicalFactory(
reference_system,
ligand_atoms=ligand_atoms,
annihilate_electrostatics=annihilate_electrostatics,
annihilate_sterics=annihilate_sterics)
final_time = time.time()
elapsed_time = final_time - initial_time
logger.info("AbsoluteAlchemicalFactory initialization took %.3f s" %
elapsed_time)
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
alchemical_system = factory.createPerturbedSystem(
AlchemicalState(0, 1, 1, 1))
# Serialize for debugging.
with open('system.xml', 'w') as outfile:
outfile.write(alchemical_system.__getstate__())
compareSystemEnergies(positions, [reference_system, alchemical_system],
['reference', 'alchemical'],
platform=platform,
precision=precision)
return
def notest_LennardJonesPair(box_width_nsigma=6.0):
"""
Compute binding free energy of two Lennard-Jones particles and compare to numerical result.
Parameters
----------
box_width_nsigma : float, optional, default=6.0
Box width is set to this multiple of Lennard-Jones sigma.
"""
NSIGMA_MAX = 6.0 # number of standard errors tolerated for success
# Create Lennard-Jones pair.
thermodynamic_state = ThermodynamicState(temperature=300.0*unit.kelvin)
kT = kB * thermodynamic_state.temperature
sigma = 3.5 * unit.angstroms
epsilon = 6.0 * kT
test = testsystems.LennardJonesPair(sigma=sigma, epsilon=epsilon)
system, positions = test.system, test.positions
binding_free_energy = test.get_binding_free_energy(thermodynamic_state)
# Create temporary directory for testing.
import tempfile
store_dir = tempfile.mkdtemp()
# Initialize YANK object.
options = dict()
options['number_of_iterations'] = 10
options['platform'] = openmm.Platform.getPlatformByName("Reference") # use Reference platform for speed
options['mc_rotation'] = False
options['mc_displacement'] = True
options['mc_displacement_sigma'] = 1.0 * unit.nanometer
options['timestep'] = 2 * unit.femtoseconds
options['nsteps_per_iteration'] = 50
# Override receptor mass to keep it stationary.
#system.setParticleMass(0, 0)
# Override box vectors.
box_edge = 6*sigma
a = unit.Quantity((box_edge, 0 * unit.angstrom, 0 * unit.angstrom))
b = unit.Quantity((0 * unit.angstrom, box_edge, 0 * unit.angstrom))
c = unit.Quantity((0 * unit.angstrom, 0 * unit.angstrom, box_edge))
system.setDefaultPeriodicBoxVectors(a, b, c)
# Override positions
positions[0,:] = box_edge/2
positions[1,:] = box_edge/4
phase = 'complex-explicit'
# Alchemical protocol.
from yank.alchemy import AlchemicalState
alchemical_states = list()
lambda_values = [0.0, 0.25, 0.50, 0.75, 1.0]
for lambda_value in lambda_values:
alchemical_state = AlchemicalState()
alchemical_state['lambda_electrostatics'] = lambda_value
alchemical_state['lambda_sterics'] = lambda_value
alchemical_states.append(alchemical_state)
protocols = dict()
protocols[phase] = alchemical_states
# Create phases.
alchemical_phase = AlchemicalPhase(phase, system, test.topology, positions,
{'complex-explicit': {'ligand': [1]}},
alchemical_states)
# Create new simulation.
yank = Yank(store_dir, **options)
yank.create(thermodynamic_state, alchemical_phase)
# Run the simulation.
yank.run()
# Analyze the data.
results = yank.analyze()
standard_state_correction = results[phase]['standard_state_correction']
Delta_f = results[phase]['Delta_f_ij'][0,1] - standard_state_correction
dDelta_f = results[phase]['dDelta_f_ij'][0,1]
nsigma = abs(binding_free_energy/kT - Delta_f) / dDelta_f
# Check results against analytical results.
# TODO: Incorporate standard state correction
output = "\n"
output += "Analytical binding free energy : %10.5f +- %10.5f kT\n" % (binding_free_energy / kT, 0)
output += "Computed binding free energy (with standard state correction) : %10.5f +- %10.5f kT (nsigma = %3.1f)\n" % (Delta_f, dDelta_f, nsigma)
output += "Computed binding free energy (without standard state correction): %10.5f +- %10.5f kT (nsigma = %3.1f)\n" % (Delta_f + standard_state_correction, dDelta_f, nsigma)
output += "Standard state correction alone : %10.5f kT\n" % (standard_state_correction)
print(output)
#if (nsigma > NSIGMA_MAX):
# output += "\n"
# output += "Computed binding free energy differs from true binding free energy.\n"
# raise Exception(output)
return [Delta_f, dDelta_f]
def benchmark(reference_system, positions, receptor_atoms, ligand_atoms, platform_name=None, annihilateElectrostatics=True, annihilateSterics=False, nsteps=500):
"""
Benchmark performance relative to unmodified system.
ARGUMENTS
reference_system (simtk.openmm.System) - the reference System object to compare with
positions - the positions 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
"""
# Create a factory to produce alchemical intermediates.
logger.info("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
logger.info("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.annihilateSterics = annihilateSterics
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
# Create the perturbed system.
logger.info("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
logger.info("Computing reference energies...")
reference_integrator = openmm.VerletIntegrator(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()
logger.info("Computing alchemical energies...")
alchemical_integrator = openmm.VerletIntegrator(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()
delta = alchemical_potential - reference_potential
# Make sure all kernels are compiled.
reference_integrator.step(1)
alchemical_integrator.step(1)
# Time simulations.
logger.info("Simulating reference system...")
initial_time = time.time()
reference_integrator.step(nsteps)
reference_state = reference_context.getState(getEnergy=True)
reference_potential = reference_state.getPotentialEnergy()
final_time = time.time()
reference_time = final_time - initial_time
logger.info("Simulating alchemical system...")
initial_time = time.time()
alchemical_integrator.step(nsteps)
alchemical_state = alchemical_context.getState(getEnergy=True)
alchemical_potential = alchemical_state.getPotentialEnergy()
final_time = time.time()
alchemical_time = final_time - initial_time
logger.info("TIMINGS")
logger.info("reference system : %12.3f s for %8d steps (%12.3f ms/step)" % (reference_time, nsteps, reference_time/nsteps*1000))
logger.info("alchemical system : %12.3f s for %8d steps (%12.3f ms/step)" % (alchemical_time, nsteps, alchemical_time/nsteps*1000))
logger.info("alchemical simulation is %12.3f x slower than unperturbed system" % (alchemical_time / reference_time))
return delta
def overlap_check(reference_system, positions, receptor_atoms, ligand_atoms, platform_name=None, annihilate_electrostatics=True, annihilate_sterics=False, precision=None, nsteps=50, nsamples=200):
"""
Test overlap between reference system and alchemical system by running a short simulation.
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.
receptor_atoms : list of int
The list of receptor atoms.
ligand_atoms : list of int
The list of ligand atoms to alchemically modify.
platform_name : str, optional, default=None
The name of the platform to use for benchmarking.
annihilate_electrostatics : bool, optional, default=True
If True, electrostatics will be annihilated; if False, decoupled.
annihilate_sterics : bool, optional, default=False
If True, sterics will be annihilated; if False, decoupled.
nsteps : int, optional, default=50
Number of molecular dynamics steps between samples.
nsamples : int, optional, default=100
Number of samples to collect.
"""
# Create a fully-interacting alchemical state.
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=ligand_atoms)
alchemical_state = AlchemicalState()
alchemical_system = factory.createPerturbedSystem(alchemical_state)
temperature = 300.0 * units.kelvin
collision_rate = 5.0 / units.picoseconds
timestep = 2.0 * units.femtoseconds
kT = (kB * temperature)
# Select platform.
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
# Create integrators.
reference_integrator = openmm.LangevinIntegrator(temperature, collision_rate, timestep)
alchemical_integrator = openmm.VerletIntegrator(timestep)
# Create contexts.
if platform:
reference_context = openmm.Context(reference_system, reference_integrator, platform)
alchemical_context = openmm.Context(alchemical_system, alchemical_integrator, platform)
else:
reference_context = openmm.Context(reference_system, reference_integrator)
alchemical_context = openmm.Context(alchemical_system, alchemical_integrator)
# Collect simulation data.
reference_context.setPositions(positions)
du_n = np.zeros([nsamples], np.float64) # du_n[n] is the
for sample in range(nsamples):
# Run dynamics.
reference_integrator.step(nsteps)
# Get reference energies.
reference_state = reference_context.getState(getEnergy=True, getPositions=True)
reference_potential = reference_state.getPotentialEnergy()
# Get alchemical energies.
alchemical_context.setPositions(reference_state.getPositions())
alchemical_state = alchemical_context.getState(getEnergy=True)
alchemical_potential = alchemical_state.getPotentialEnergy()
du_n[sample] = (alchemical_potential - reference_potential) / kT
# Clean up.
del reference_context, alchemical_context
# Discard data to equilibration and subsample.
from pymbar import timeseries
[t0, g, Neff] = timeseries.detectEquilibration(du_n)
indices = timeseries.subsampleCorrelatedData(du_n, g=g)
du_n = du_n[indices]
# Compute statistics.
from pymbar import EXP
[DeltaF, dDeltaF] = EXP(du_n)
# Raise an exception if the error is larger than 3kT.
MAX_DEVIATION = 3.0 # kT
if (dDeltaF > MAX_DEVIATION):
report = "DeltaF = %12.3f +- %12.3f kT (%5d samples, g = %6.1f)" % (DeltaF, dDeltaF, Neff, g)
raise Exception(report)
return
def benchmark(reference_system, positions, receptor_atoms, ligand_atoms, platform_name=None, annihilate_electrostatics=True, annihilate_sterics=False, nsteps=500, timestep=1.0*units.femtoseconds):
"""
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.
receptor_atoms : list of int
The list of receptor atoms.
ligand_atoms : list of int
The list of ligand atoms to alchemically modify.
platform_name : str, optional, default=None
The name of the platform to use for benchmarking.
annihilate_electrostatics : bool, optional, default=True
If True, electrostatics will be annihilated; if False, decoupled.
annihilate_sterics : bool, optional, default=False
If True, sterics will be annihilated; if False, decoupled.
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.
"""
# Create a factory to produce alchemical intermediates.
logger.info("Creating alchemical factory...")
initial_time = time.time()
factory = AbsoluteAlchemicalFactory(reference_system, ligand_atoms=ligand_atoms, annihilate_electrostatics=annihilate_electrostatics, annihilate_sterics=annihilate_sterics)
final_time = time.time()
elapsed_time = final_time - initial_time
logger.info("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_coulomb=lambda_value, lambda_sterics=lambda_value, lambda_torsions=lambda_value)
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
# Create the perturbed system.
logger.info("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.
logger.info("Computing reference energies...")
reference_integrator = openmm.VerletIntegrator(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()
logger.info("Computing alchemical energies...")
alchemical_integrator = openmm.VerletIntegrator(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()
delta = alchemical_potential - reference_potential
# Make sure all kernels are compiled.
reference_integrator.step(1)
alchemical_integrator.step(1)
# Time simulations.
logger.info("Simulating reference system...")
initial_time = time.time()
reference_integrator.step(nsteps)
reference_state = reference_context.getState(getEnergy=True)
reference_potential = reference_state.getPotentialEnergy()
final_time = time.time()
reference_time = final_time - initial_time
logger.info("Simulating alchemical system...")
initial_time = time.time()
alchemical_integrator.step(nsteps)
alchemical_state = alchemical_context.getState(getEnergy=True)
alchemical_potential = alchemical_state.getPotentialEnergy()
final_time = time.time()
alchemical_time = final_time - initial_time
logger.info("TIMINGS")
logger.info("reference system : %12.3f s for %8d steps (%12.3f ms/step)" % (reference_time, nsteps, reference_time/nsteps*1000))
logger.info("alchemical system : %12.3f s for %8d steps (%12.3f ms/step)" % (alchemical_time, nsteps, alchemical_time/nsteps*1000))
logger.info("alchemical simulation is %12.3f x slower than unperturbed system" % (alchemical_time / reference_time))
return delta
def lambda_trace(reference_system,
positions,
receptor_atoms,
ligand_atoms,
platform_name=None,
precision=None,
annihilate_electrostatics=True,
annihilate_sterics=False,
nsteps=100):
"""
Compute potential energy as a function of lambda.
"""
# Create a factory to produce alchemical intermediates.
factory = AbsoluteAlchemicalFactory(
reference_system,
ligand_atoms=ligand_atoms,
annihilate_electrostatics=annihilate_electrostatics,
annihilate_sterics=annihilate_sterics)
platform = None
if platform_name:
# Get platform.
platform = openmm.Platform.getPlatformByName(platform_name)
if precision:
if platform_name == 'CUDA':
platform.setDefaultPropertyValue('CudaPrecision', precision)
elif platform_name == 'OpenCL':
platform.setDefaultPropertyValue('OpenCLPrecision', precision)
# Take equally-sized steps.
delta = 1.0 / nsteps
def compute_potential(system, positions, platform=None):
timestep = 1.0 * units.femtoseconds
integrator = openmm.VerletIntegrator(timestep)
if platform:
context = openmm.Context(system, integrator, platform)
else:
context = openmm.Context(system, integrator)
context.setPositions(positions)
state = context.getState(getEnergy=True)
potential = state.getPotentialEnergy()
del integrator, context
return potential
# Compute unmodified energy.
u_original = compute_potential(reference_system, positions, platform)
# Scan through lambda values.
lambda_i = np.zeros([nsteps + 1], np.float64) # lambda values for u_i
u_i = units.Quantity(np.zeros([nsteps + 1],
np.float64), units.kilocalories_per_mole
) # u_i[i] is the potential energy for lambda_i[i]
for i in range(nsteps + 1):
lambda_value = 1.0 - i * delta # compute lambda value for this step
alchemical_system = factory.createPerturbedSystem(
AlchemicalState(0, lambda_value, lambda_value, lambda_value))
lambda_i[i] = lambda_value
u_i[i] = compute_potential(alchemical_system, positions, platform)
print "%12.9f %24.8f kcal/mol" % (lambda_i[i],
u_i[i] / units.kilocalories_per_mole)
# Write figure as PDF.
import pylab
from matplotlib.backends.backend_pdf import PdfPages
import matplotlib.pyplot as plt
with PdfPages('lambda-trace.pdf') as pdf:
fig = plt.figure(figsize=(10, 5))
ax = fig.add_subplot(111)
plt.plot(1,
u_original / units.kilocalories_per_mole,
'ro',
label='unmodified')
plt.plot(lambda_i,
u_i / units.kilocalories_per_mole,
'k.',
label='alchemical')
plt.title('T4 lysozyme L99A + p-xylene : AMBER96 + OBC GBSA')
plt.ylabel('potential (kcal/mol)')
plt.xlabel('lambda')
ax.legend()
rstyle(ax)
pdf.savefig() # saves the current figure into a pdf page
plt.close()
return
def overlap_check(reference_system,
positions,
receptor_atoms,
ligand_atoms,
platform_name=None,
annihilate_electrostatics=True,
annihilate_sterics=False,
precision=None,
nsteps=50,
nsamples=200):
"""
Test overlap between reference system and alchemical system by running a short simulation.
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.
receptor_atoms : list of int
The list of receptor atoms.
ligand_atoms : list of int
The list of ligand atoms to alchemically modify.
platform_name : str, optional, default=None
The name of the platform to use for benchmarking.
annihilate_electrostatics : bool, optional, default=True
If True, electrostatics will be annihilated; if False, decoupled.
annihilate_sterics : bool, optional, default=False
If True, sterics will be annihilated; if False, decoupled.
nsteps : int, optional, default=50
Number of molecular dynamics steps between samples.
nsamples : int, optional, default=100
Number of samples to collect.
"""
# Create a fully-interacting alchemical state.
factory = AbsoluteAlchemicalFactory(reference_system,
ligand_atoms=ligand_atoms)
alchemical_state = AlchemicalState(0.00, 1.00, 1.00, 1.0)
alchemical_system = factory.createPerturbedSystem(alchemical_state)
temperature = 300.0 * units.kelvin
collision_rate = 5.0 / units.picoseconds
timestep = 2.0 * units.femtoseconds
kT = (kB * temperature)
# Select platform.
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
# Create integrators.
reference_integrator = openmm.LangevinIntegrator(temperature,
collision_rate, timestep)
alchemical_integrator = openmm.VerletIntegrator(timestep)
# Create contexts.
if platform:
reference_context = openmm.Context(reference_system,
reference_integrator, platform)
alchemical_context = openmm.Context(alchemical_system,
alchemical_integrator, platform)
else:
reference_context = openmm.Context(reference_system,
reference_integrator)
alchemical_context = openmm.Context(alchemical_system,
alchemical_integrator)
# Collect simulation data.
reference_context.setPositions(positions)
du_n = np.zeros([nsamples], np.float64) # du_n[n] is the
for sample in range(nsamples):
# Run dynamics.
reference_integrator.step(nsteps)
# Get reference energies.
reference_state = reference_context.getState(getEnergy=True,
getPositions=True)
reference_potential = reference_state.getPotentialEnergy()
# Get alchemical energies.
alchemical_context.setPositions(reference_state.getPositions())
alchemical_state = alchemical_context.getState(getEnergy=True)
alchemical_potential = alchemical_state.getPotentialEnergy()
du_n[sample] = (alchemical_potential - reference_potential) / kT
# Clean up.
del reference_context, alchemical_context
# Discard data to equilibration and subsample.
from pymbar import timeseries
[t0, g, Neff] = timeseries.detectEquilibration(du_n)
indices = timeseries.subsampleCorrelatedData(du_n, g=g)
du_n = du_n[indices]
# Compute statistics.
from pymbar import EXP
[DeltaF, dDeltaF] = EXP(du_n)
# Raise an exception if the error is larger than 3kT.
MAX_DEVIATION = 3.0 # kT
if (dDeltaF > MAX_DEVIATION):
report = "DeltaF = %12.3f +- %12.3f kT (%5d samples, g = %6.1f)" % (
DeltaF, dDeltaF, Neff, g)
raise Exception(report)
return
def benchmark(reference_system,
positions,
receptor_atoms,
ligand_atoms,
platform_name=None,
annihilate_electrostatics=True,
annihilate_sterics=False,
nsteps=500,
timestep=1.0 * units.femtoseconds):
"""
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.
receptor_atoms : list of int
The list of receptor atoms.
ligand_atoms : list of int
The list of ligand atoms to alchemically modify.
platform_name : str, optional, default=None
The name of the platform to use for benchmarking.
annihilate_electrostatics : bool, optional, default=True
If True, electrostatics will be annihilated; if False, decoupled.
annihilate_sterics : bool, optional, default=False
If True, sterics will be annihilated; if False, decoupled.
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.
"""
# Create a factory to produce alchemical intermediates.
logger.info("Creating alchemical factory...")
initial_time = time.time()
factory = AbsoluteAlchemicalFactory(
reference_system,
ligand_atoms=ligand_atoms,
annihilate_electrostatics=annihilate_electrostatics,
annihilate_sterics=annihilate_sterics)
final_time = time.time()
elapsed_time = final_time - initial_time
logger.info("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)
platform = None
if platform_name:
platform = openmm.Platform.getPlatformByName(platform_name)
# Create the perturbed system.
logger.info("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.
logger.info("Computing reference energies...")
reference_integrator = openmm.VerletIntegrator(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()
logger.info("Computing alchemical energies...")
alchemical_integrator = openmm.VerletIntegrator(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()
delta = alchemical_potential - reference_potential
# Make sure all kernels are compiled.
reference_integrator.step(1)
alchemical_integrator.step(1)
# Time simulations.
logger.info("Simulating reference system...")
initial_time = time.time()
reference_integrator.step(nsteps)
reference_state = reference_context.getState(getEnergy=True)
reference_potential = reference_state.getPotentialEnergy()
final_time = time.time()
reference_time = final_time - initial_time
logger.info("Simulating alchemical system...")
initial_time = time.time()
alchemical_integrator.step(nsteps)
alchemical_state = alchemical_context.getState(getEnergy=True)
alchemical_potential = alchemical_state.getPotentialEnergy()
final_time = time.time()
alchemical_time = final_time - initial_time
logger.info("TIMINGS")
logger.info(
"reference system : %12.3f s for %8d steps (%12.3f ms/step)" %
(reference_time, nsteps, reference_time / nsteps * 1000))
logger.info(
"alchemical system : %12.3f s for %8d steps (%12.3f ms/step)" %
(alchemical_time, nsteps, alchemical_time / nsteps * 1000))
logger.info(
"alchemical simulation is %12.3f x slower than unperturbed system" %
(alchemical_time / reference_time))
return delta
