def analyze_logZ():
from openmmtools.multistate import SAMSSampler, MultiStateReporter, MultiStateSamplerAnalyzer
iteration = 250000
reporter = MultiStateReporter('traj.nc', open_mode='r',checkpoint_interval=1)
analyzer = MultiStateSamplerAnalyzer(reporter)
Deltaf_ij, dDeltaf_ij = analyzer.get_free_energy()
print(Deltaf_ij)
print(dDeltaf_ij)
return
def _load_data(self):
""" Calculate relative free energy details from the simulation by performing MBAR on the vacuum and solvent legs of the simualtion.
Parameters
----------
Returns
-------
None
"""
from pymbar import MBAR
from perses.analysis import utils
import os
from openmmtools.multistate import MultiStateReporter, MultiStateSamplerAnalyzer
from simtk import unit
# find the output files
output = [
x for x in os.listdir(self.directory)
if x[-3:] == '.nc' and 'checkpoint' not in x
]
for out in output:
if 'vacuum' in out:
vacuum_reporter = MultiStateReporter(f'{self.directory}/{out}')
vacuum_analyzer = MultiStateSamplerAnalyzer(vacuum_reporter)
f_ij, df_ij = vacuum_analyzer.get_free_energy()
f = f_ij[0, -1] * vacuum_analyzer.kT
self._vacdg = f.in_units_of(unit.kilocalories_per_mole)
df = df_ij[0, -1] * vacuum_analyzer.kT
self._vacddg = df.in_units_of(unit.kilocalories_per_mole)
self._vacf_ij = f_ij
self._vacdf_ij = df_ij
elif 'solvent' in out:
solvent_reporter = MultiStateReporter(
f'{self.directory}/{out}')
solvent_analyzer = MultiStateSamplerAnalyzer(solvent_reporter)
f_ij, df_ij = solvent_analyzer.get_free_energy()
f = f_ij[0, -1] * solvent_analyzer.kT
self._soldg = f.in_units_of(unit.kilocalories_per_mole)
df = df_ij[0, -1] * solvent_analyzer.kT
self._solddg = df.in_units_of(unit.kilocalories_per_mole)
self._solf_ij = f_ij
self._soldf_ij = df_ij
elif 'complex' in out:
complex_reporter = MultiStateReporter(
f'{self.directory}/{out}')
complex_analyzer = MultiStateSamplerAnalyzer(complex_reporter)
f_ij, df_ij = complex_analyzer.get_free_energy()
f = f_ij[0, -1] * complex_analyzer.kT
self._comdg = f.in_units_of(unit.kilocalories_per_mole)
df = df_ij[0, -1] * complex_analyzer.kT
self._comddg = df.in_units_of(unit.kilocalories_per_mole)
self._comf_ij = f_ij
self._comdf_ij = df_ij
return
def load_data(self):
""" Calculate relative free energy details from the simulation by performing MBAR on the vacuum and solvent legs of the simualtion.
Parameters
----------
Returns
-------
None
"""
from pymbar import timeseries
from pymbar import MBAR
from perses.analysis import utils
import os
from openmmtools.multistate import MultiStateReporter, MultiStateSamplerAnalyzer
# find the output files
output = [x for x in os.listdir(self.directory) if x[-3:] == '.nc' and 'checkpoint' not in x]
for out in output:
if 'vacuum' in out:
vacuum_reporter = MultiStateReporter(f'{self.directory}/{out}')
vacuum_analyzer = MultiStateSamplerAnalyzer(vacuum_reporter)
f_ij, df_ij = vacuum_analyzer.get_free_energy()
self.vacdg = f_ij[1, -2]
self.vacddg = df_ij[1, -2] ** 2
self.vacf_ij = f_ij
self.vacdf_ij = df_ij
elif'solvent' in out:
solvent_reporter = MultiStateReporter(f'{self.directory}/{out}')
solvent_analyzer = MultiStateSamplerAnalyzer(solvent_reporter)
f_ij, df_ij = solvent_analyzer.get_free_energy()
self.soldg = f_ij[1, -2]
self.solddg = df_ij[1, -2] ** 2
self.solf_ij = f_ij
self.soldf_ij = df_ij
elif 'complex' in out:
complex_reporter = MultiStateReporter(f'{self.directory}/{out}')
complex_analyzer = MultiStateSamplerAnalyzer(complex_reporter)
f_ij, df_ij = complex_analyzer.get_free_energy()
self.comdg = f_ij[1, -2]
self.comddg = df_ij[1, -2] ** 2
self.comf_ij = f_ij
self.comdf_ij = df_ij
return
def historic_fes(self,stepsize=100):
from pymbar import timeseries
from pymbar import MBAR
from perses.analysis import utils
import os
from openmmtools.multistate import MultiStateReporter, MultiStateSamplerAnalyzer
# find the output files
output = [x for x in os.listdir(self.directory) if x[-3:] == '.nc' and 'checkpoint' not in x]
for out in output:
if 'vacuum' in out:
vacuum_reporter = MultiStateReporter(f'{self.directory}/{out}')
ncfile = utils.open_netcdf(f'{self.directory}/{out}')
n_iterations = ncfile.variables['last_iteration'][0]
for step in range(stepsize, n_iterations, stepsize):
vacuum_analyzer = MultiStateSamplerAnalyzer(vacuum_reporter,max_n_iterations=step)
f_ij, df_ij = vacuum_analyzer.get_free_energy()
self.vacdg_history.append(f_ij[1, -2])
self.vacddg_history.append(df_ij[1,-2])
self.vacdg_history_es.append(f_ij[0, -1])
self.vacddg_history_es.append(df_ij[0,-1])
if 'solvent' in out:
solvent_reporter = MultiStateReporter(f'{self.directory}/{out}')
ncfile = utils.open_netcdf(f'{self.directory}/{out}')
n_iterations = ncfile.variables['last_iteration'][0]
for step in range(stepsize, n_iterations, stepsize):
solvent_analyzer = MultiStateSamplerAnalyzer(solvent_reporter,max_n_iterations=step)
f_ij, df_ij = solvent_analyzer.get_free_energy()
self.soldg_history.append(f_ij[1, -2])
self.solddg_history.append(df_ij[1,-2])
self.soldg_history_es.append(f_ij[0, -1])
self.solddg_history_es.append(df_ij[0,-1])
if 'complex' in out:
complex_reporter = MultiStateReporter(f'{self.directory}/{out}')
ncfile = utils.open_netcdf(f'{self.directory}/{out}')
n_iterations = ncfile.variables['last_iteration'][0]
for step in range(stepsize, n_iterations, stepsize):
complex_analyzer = MultiStateSamplerAnalyzer(complex_reporter,max_n_iterations=step)
f_ij, df_ij = complex_analyzer.get_free_energy()
self.comdg_history.append(f_ij[1, -2])
self.comddg_history.append(df_ij[1,-2])
self.comdg_history_es.append(f_ij[0, -1])
self.comddg_history_es.append(df_ij[0,-1])
return
def historic_fes(self, stepsize=100):
""" Function that performs mbar at intervals of the simulation
by postprocessing. Can be slow if stepsize is small
Parameters
----------
stepsize : int, optional, default=100
number of iterations at which to run MBAR
Returns
-------
None
"""
from perses.analysis import utils
from simtk import unit
import os
from openmmtools.multistate import MultiStateReporter, MultiStateSamplerAnalyzer
# find the output files
output = [
x for x in os.listdir(self.directory)
if x[-3:] == '.nc' and 'checkpoint' not in x
]
for out in output:
if 'vacuum' in out:
vacuum_reporter = MultiStateReporter(f'{self.directory}/{out}')
ncfile = utils.open_netcdf(f'{self.directory}/{out}')
n_iterations = ncfile.variables['last_iteration'][0]
for step in range(stepsize, n_iterations, stepsize):
vacuum_analyzer = MultiStateSamplerAnalyzer(
vacuum_reporter, max_n_iterations=step)
f_ij, df_ij = vacuum_analyzer.get_free_energy()
f = f_ij[0, -1] * vacuum_analyzer.kT
self._vacdg_history.append(
f.in_units_of(unit.kilocalories_per_mole))
df = df_ij[0, -1] * vacuum_analyzer.kT
self._vacddg_history.append(
df.in_units_of(unit.kilocalories_per_mole))
if 'solvent' in out:
solvent_reporter = MultiStateReporter(
f'{self.directory}/{out}')
ncfile = utils.open_netcdf(f'{self.directory}/{out}')
n_iterations = ncfile.variables['last_iteration'][0]
for step in range(stepsize, n_iterations, stepsize):
solvent_analyzer = MultiStateSamplerAnalyzer(
solvent_reporter, max_n_iterations=step)
f_ij, df_ij = solvent_analyzer.get_free_energy()
f = f_ij[0, -1] * solvent_analyzer.kT
self._soldg_history.append(
f.in_units_of(unit.kilocalories_per_mole))
df = df_ij[0, -1] * solvent_analyzer.kT
self._solddg_history.append(
df.in_units_of(unit.kilocalories_per_mole))
if 'complex' in out:
complex_reporter = MultiStateReporter(
f'{self.directory}/{out}')
ncfile = utils.open_netcdf(f'{self.directory}/{out}')
n_iterations = ncfile.variables['last_iteration'][0]
for step in range(stepsize, n_iterations, stepsize):
complex_analyzer = MultiStateSamplerAnalyzer(
complex_reporter, max_n_iterations=step)
f_ij, df_ij = complex_analyzer.get_free_energy()
f = f_ij[0, -1] * complex_analyzer.kT
self._comdg_history.append(
f.in_units_of(unit.kilocalories_per_mole))
df = df_ij[0, -1] * complex_analyzer.kT
self._comddg_history.append(
df.in_units_of(unit.kilocalories_per_mole))
return