def run(self, niterations=None, mpicomm=None, options=None):
"""
Run a free energy calculation.
Parameters
----------
niterations : int, optional, default=None
If specified, only this many iterations will be run for each phase.
This is useful for running simulation incrementally, but may incur a good deal of overhead.
mpicomm : MPI communicator, optional, default=None
If an MPI communicator is passed, an MPI simulation will be attempted.
options : dict of str, optional, default=None
If specified, these options will override any other options.
"""
# Make sure we've been properly initialized first.
if not self._initialized:
raise Exception(
"Yank must first be initialized by either resume() or create()."
)
# Handle some logistics necessary for MPI.
if mpicomm:
# Turn off output from non-root nodes:
if not (mpicomm.rank == 0):
self.verbose = False
# Make sure each thread's random number generators have unique seeds.
# TODO: Do we need to store seed in repex object?
seed = np.random.randint(sys.maxint - mpicomm.size) + mpicomm.rank
np.random.seed(seed)
# Run all phases sequentially.
# TODO: Divide up MPI resources among the phases so they can run simultaneously?
for phase in self._phases:
store_filename = self._store_filenames[phase]
# Resume simulation from store file.
simulation = ModifiedHamiltonianExchange(
store_filename=store_filename, mpicomm=mpicomm)
simulation.resume(options=options)
# TODO: We may need to manually update run options here if options=options above does not behave as expected.
simulation.run(niterations_to_run=niterations)
# Clean up to ensure we close files, contexts, etc.
del simulation
return
def run(self, niterations_to_run=None, mpicomm=None, options=None):
"""
Run a free energy calculation.
Parameters
----------
niterations_to_run : int, optional, default=None
If specified, only this many iterations will be run for each phase.
This is useful for running simulation incrementally, but may incur a good deal of overhead.
mpicomm : MPI communicator, optional, default=None
If an MPI communicator is passed, an MPI simulation will be attempted.
options : dict of str, optional, default=None
If specified, these options will override any other options.
"""
# Make sure we've been properly initialized first.
if not self._initialized:
raise Exception("Yank must first be initialized by either resume() or create().")
# Handle some logistics necessary for MPI.
if mpicomm:
# Turn off output from non-root nodes:
if not (mpicomm.rank==0):
self.verbose = False
# Make sure each thread's random number generators have unique seeds.
# TODO: Do we need to store seed in repex object?
seed = np.random.randint(sys.maxint - mpicomm.size) + mpicomm.rank
np.random.seed(seed)
# Run all phases sequentially.
# TODO: Divide up MPI resources among the phases so they can run simultaneously?
for phase in self._phases:
store_filename = self._store_filenames[phase]
# Resume simulation from store file.
simulation = ModifiedHamiltonianExchange(store_filename=store_filename, mpicomm=mpicomm)
simulation.resume(options=options)
# TODO: We may need to manually update run options here if options=options above does not behave as expected.
simulation.run(niterations_to_run=niterations_to_run)
# Clean up to ensure we close files, contexts, etc.
del simulation
return
def run(self, niterations_to_run=None):
"""
Run a free energy calculation.
Parameters
----------
niterations_to_run : int, optional, default=None
If specified, only this many iterations will be run for each phase.
This is useful for running simulation incrementally, but may incur a good deal of overhead.
"""
# Make sure we've been properly initialized first.
if not self._initialized:
raise Exception(
"Yank must first be initialized by either resume() or create()."
)
# Handle some logistics necessary for MPI.
if self._mpicomm is not None:
logger.debug("yank.run starting for MPI...")
# Make sure each thread's random number generators have unique seeds.
# TODO: Do we need to store seed in repex object?
seed = np.random.randint(4294967295 -
self._mpicomm.size) + self._mpicomm.rank
np.random.seed(seed)
# Run all phases sequentially.
# TODO: Divide up MPI resources among the phases so they can run simultaneously?
for phase in self._phases:
store_filename = self._store_filenames[phase]
# Resume simulation from store file.
simulation = ModifiedHamiltonianExchange(
store_filename=store_filename, mpicomm=self._mpicomm)
simulation.resume(options=self._repex_parameters)
# TODO: We may need to manually update run options here if options=options above does not behave as expected.
simulation.run(niterations_to_run=niterations_to_run)
# Clean up to ensure we close files, contexts, etc.
del simulation
return
def run(self, niterations_to_run=None):
"""
Run a free energy calculation.
Parameters
----------
niterations_to_run : int, optional, default=None
If specified, only this many iterations will be run for each phase.
This is useful for running simulation incrementally, but may incur a good deal of overhead.
"""
# Make sure we've been properly initialized first.
if not self._initialized:
raise Exception("Yank must first be initialized by either resume() or create().")
# Handle some logistics necessary for MPI.
if self._mpicomm is not None:
logger.debug("yank.run starting for MPI...")
# Make sure each thread's random number generators have unique seeds.
# TODO: Do we need to store seed in repex object?
seed = np.random.randint(4294967295 - self._mpicomm.size) + self._mpicomm.rank
np.random.seed(seed)
# Run all phases sequentially.
# TODO: Divide up MPI resources among the phases so they can run simultaneously?
for phase in self._phases:
store_filename = self._store_filenames[phase]
# Resume simulation from store file.
simulation = ModifiedHamiltonianExchange(store_filename=store_filename, mpicomm=self._mpicomm)
simulation.resume(options=self._repex_parameters)
# TODO: We may need to manually update run options here if options=options above does not behave as expected.
simulation.run(niterations_to_run=niterations_to_run)
# Clean up to ensure we close files, contexts, etc.
del simulation
return
def analyze(self):
"""
Programmatic interface to retrieve the results of a YANK free energy calculation.
Returns
-------
results : dict
results[phase][component] is the estimate of 'component' of thermodynamic leg 'phase'
'component' can be one of ['DeltaF', 'dDeltaF', 'DeltaH', 'dDeltaH']
DeltaF is the estimated free energy difference
dDeltaF is the statistical uncertainty in DeltaF (one standard error)
DeltaH is the estimated enthalpy difference
dDeltaH is the statistical uncertainty in DeltaH (one standard error)
all quantites are reported in units are kT
If simulation has not been initialized by a call to resume() or create(), None is returned.
"""
if not self._initialized: return None
# TODO: Can we simplify this code by pushing more into analyze.py or repex.py?
import analyze
from pymbar import MBAR, timeseries
import netCDF4 as netcdf
# Storage for results.
results = dict()
logger.debug("Analyzing simulation data...")
# Process each netcdf file in output directory.
for phase in self._phases:
fullpath = self._store_filenames[phase]
# Skip if the file doesn't exist.
if (not os.path.exists(fullpath)): continue
# Read this phase.
simulation = ModifiedHamiltonianExchange(fullpath)
simulation.resume()
# Analyze this phase.
analysis = simulation.analyze()
# Retrieve standard state correction.
analysis['standard_state_correction'] = simulation.metadata[
'standard_state_correction']
# Store results.
results[phase] = analysis
# Clean up.
del simulation
# TODO: Analyze binding or hydration, depending on what phases are present.
# TODO: Include effects of analytical contributions.
phases_available = results.keys()
if set(['solvent', 'vacuum']).issubset(phases_available):
# SOLVATION FREE ENERGY
results['solvation'] = dict()
results['solvation']['Delta_f'] = results['solvent'][
'Delta_f'] + results['vacuum']['Delta_f']
# TODO: Correct in different ways depending on what reference conditions are desired.
results['solvation']['Delta_f'] += results['solvent'][
'standard_state_correction'] + results['vacuum'][
'standard_state_correction']
results['solvation']['dDelta_f'] = np.sqrt(
results['solvent']['dDelta_f']**2 +
results['vacuum']['Delta_f']**2)
if set(['ligand', 'complex']).issubset(phases_available):
# BINDING FREE ENERGY
results['binding'] = dict()
# Compute binding free energy.
results['binding']['Delta_f'] = (
results['solvent']['Delta_f'] +
results['solvent']['standard_state_correction']) - (
results['complex']['Delta_f'] +
results['complex']['standard_state_correction'])
results['binding']['dDelta_f'] = np.sqrt(
results['solvent']['dDelta_f']**2 +
results['complex']['dDelta_f']**2)
return results
def analyze(self):
"""
Programmatic interface to retrieve the results of a YANK free energy calculation.
Returns
-------
results : dict
results[phase][component] is the estimate of 'component' of thermodynamic leg 'phase'
'component' can be one of ['DeltaF', 'dDeltaF', 'DeltaH', 'dDeltaH']
DeltaF is the estimated free energy difference
dDeltaF is the statistical uncertainty in DeltaF (one standard error)
DeltaH is the estimated enthalpy difference
dDeltaH is the statistical uncertainty in DeltaH (one standard error)
all quantites are reported in units are kT
If simulation has not been initialized by a call to resume() or create(), None is returned.
"""
if not self._initialized: return None
# TODO: Can we simplify this code by pushing more into analyze.py or repex.py?
import analyze
from pymbar import MBAR, timeseries
import netCDF4 as netcdf
# Storage for results.
results = dict()
logger.debug("Analyzing simulation data...")
# Process each netcdf file in output directory.
for phase in self._phases:
fullpath = self._store_filenames[phase]
# Skip if the file doesn't exist.
if (not os.path.exists(fullpath)): continue
# Read this phase.
simulation = ModifiedHamiltonianExchange(fullpath)
simulation.resume()
# Analyze this phase.
analysis = simulation.analyze()
# Retrieve standard state correction.
analysis['standard_state_correction'] = simulation.metadata['standard_state_correction']
# Store results.
results[phase] = analysis
# Clean up.
del simulation
# TODO: Analyze binding or hydration, depending on what phases are present.
# TODO: Include effects of analytical contributions.
phases_available = results.keys()
if set(['solvent', 'vacuum']).issubset(phases_available):
# SOLVATION FREE ENERGY
results['solvation'] = dict()
results['solvation']['Delta_f'] = results['solvent']['Delta_f'] + results['vacuum']['Delta_f']
# TODO: Correct in different ways depending on what reference conditions are desired.
results['solvation']['Delta_f'] += results['solvent']['standard_state_correction'] + results['vacuum']['standard_state_correction']
results['solvation']['dDelta_f'] = np.sqrt(results['solvent']['dDelta_f']**2 + results['vacuum']['Delta_f']**2)
if set(['ligand', 'complex']).issubset(phases_available):
# BINDING FREE ENERGY
results['binding'] = dict()
# Compute binding free energy.
results['binding']['Delta_f'] = (results['solvent']['Delta_f'] + results['solvent']['standard_state_correction']) - (results['complex']['Delta_f'] + results['complex']['standard_state_correction'])
results['binding']['dDelta_f'] = np.sqrt(results['solvent']['dDelta_f']**2 + results['complex']['dDelta_f']**2)
return results
