def __init__(self, **kwargs):
super(AlanineDipeptideExplicitSimulatedTempering,
self).__init__(**kwargs)
self.description = 'Alanine dipeptide in explicit solvent simulated tempering simulation'
# Create topology, positions, and system.
from openmmtools.testsystems import AlanineDipeptideExplicit
testsystem = AlanineDipeptideExplicit(
nonbondedMethod=app.CutoffPeriodic)
self.topology = testsystem.topology
self.positions = testsystem.positions
self.system = testsystem.system
# DEBUG: Write PDB
from simtk.openmm.app import PDBFile
outfile = open('initial.pdb', 'w')
PDBFile.writeFile(self.topology, self.positions, outfile)
outfile.close()
# Add a MonteCarloBarostat
temperature = 270 * 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.
Tmin = 270 * unit.kelvin
Tmax = 600 * unit.kelvin
ntemps = 256 # number of temperatures
from sams import ThermodynamicState
temperatures = unit.Quantity(
np.logspace(np.log10(Tmin / unit.kelvin),
np.log10(Tmax / unit.kelvin), ntemps), unit.kelvin)
self.thermodynamic_states = [
ThermodynamicState(system=self.system,
temperature=temperature,
pressure=pressure)
for temperature in temperatures
]
# Create SAMS 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.nsteps = 500
self.mcmc_sampler.timestep = 2.0 * unit.femtoseconds
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
def __init__(self, **kwargs):
super(HarmonicOscillatorSimulatedTempering, self).__init__(**kwargs)
self.description = 'Harmonic oscillator simulated tempering simulation'
# Create topology, positions, and system.
from openmmtools.testsystems import HarmonicOscillator
K = 1.0 * unit.kilocalories_per_mole / unit.angstroms**2 # 3D harmonic oscillator spring constant
mass = 39.948 * unit.amu # 3D harmonic oscillator particle mass
period = 2.0 * np.pi * unit.sqrt(
mass / K) # harmonic oscillator period
timestep = 0.01 * period
testsystem = HarmonicOscillator(K=K, mass=mass)
self.topology = testsystem.topology
self.positions = testsystem.positions
self.system = testsystem.system
# Create thermodynamic states.
Tmin = 100 * unit.kelvin
Tmax = 1000 * unit.kelvin
ntemps = 8 # number of temperatures
from sams import ThermodynamicState
temperatures = unit.Quantity(
np.logspace(np.log10(Tmin / unit.kelvin),
np.log10(Tmax / unit.kelvin), ntemps), unit.kelvin)
self.thermodynamic_states = [
ThermodynamicState(system=self.system, temperature=temperature)
for temperature in temperatures
]
# Compute analytical logZ for each thermodynamic state.
self.logZ = np.zeros([ntemps], np.float64)
for (index,
thermodynamic_state) in enumerate(self.thermodynamic_states):
beta = thermodynamic_state.beta
self.logZ[index] = -1.5 * np.log(beta * K * unit.angstrom**2)
self.logZ[:] -= self.logZ[0]
# Create SAMS 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.timestep = timestep
self.mcmc_sampler.collision_rate = 1.0 / (100 * timestep)
self.mcmc_sampler.nsteps = 1000
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,
update_stages='two-stage',
update_method='optimal')
self.sams_sampler.verbose = True
def __init__(self, **kwargs):
super(AlanineDipeptideVacuumSimulatedTempering,
self).__init__(**kwargs)
self.description = 'Alanine dipeptide in vacuum simulated tempering simulation'
# Create topology, positions, and system.
from openmmtools.testsystems import AlanineDipeptideVacuum
testsystem = AlanineDipeptideVacuum()
self.topology = testsystem.topology
self.positions = testsystem.positions
self.system = testsystem.system
# Create thermodynamic states.
Tmin = 270 * unit.kelvin
Tmax = 600 * unit.kelvin
ntemps = 8 # number of temperatures
from sams import ThermodynamicState
temperatures = unit.Quantity(
np.logspace(np.log10(Tmin / unit.kelvin),
np.log10(Tmax / unit.kelvin), ntemps), unit.kelvin)
self.thermodynamic_states = [
ThermodynamicState(system=self.system, temperature=temperature)
for temperature in temperatures
]
# Create SAMS 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.nsteps = 500 # reduce number of steps for testing
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
umbrella_force = openmm.CustomBondForce(energy_function)
umbrella_force.addGlobalParameter('distance_K', 0.0)
umbrella_force.addGlobalParameter('distance_r0', 0.0)
umbrella_force.addBond(*DFG_atoms, [])
distance_K = kT/distance_sigma**2
system.addForce(umbrella_force)
# Create thermodynamic states
thermodynamic_states = list()
# Umbrella off state
parameters = {
'torsion_K' : 0.0, 'torsion_theta0' : 0.0, # umbrella parameters
'distance_K' : 0.0, 'distance_r0' : 0.0, # umbrella parameters
}
thermodynamic_states.append( ThermodynamicState(system=system, temperature=temperature, pressure=pressure, parameters=parameters) )
# Umbrella on state
alchemical_lambda = 0.0
for theta0 in torsion_umbrella_values:
for r0 in distance_umbrella_values:
parameters = {
'torsion_K' : torsion_K.value_in_unit_system(unit.md_unit_system), 'torsion_theta0' : theta0.value_in_unit_system(unit.md_unit_system), # umbrella parameters
'distance_K' : distance_K.value_in_unit_system(unit.md_unit_system), 'distance_r0' : r0.value_in_unit_system(unit.md_unit_system), # umbrella parameters
}
thermodynamic_states.append( ThermodynamicState(system=system, temperature=temperature, pressure=pressure, parameters=parameters) )
# Select platform automatically; use mixed precision
from openmmtools.integrators import LangevinIntegrator
integrator = LangevinIntegrator(temperature=temperature, collision_rate=collision_rate, timestep=timestep)
context = openmm.Context(system, integrator)
umbrella_K = kT / umbrella_sigma**2
system.addForce(umbrella_force)
# Create thermodynamic states
thermodynamic_states = list()
for alchemical_lambda in alchemical_lambdas:
# Umbrella off state
parameters = {
'lambda_sterics': alchemical_lambda,
'lambda_electrostatics': alchemical_lambda, # alchemical parameters
'umbrella_K': 0.0,
'umbrella_r0': 0.0, # umbrella parameters
}
thermodynamic_states.append(
ThermodynamicState(system=system,
temperature=temperature,
pressure=pressure,
parameters=parameters))
# Umbrella on state
for umbrella_distance in umbrella_distances:
parameters = {
'lambda_sterics':
alchemical_lambda,
'lambda_electrostatics':
alchemical_lambda, # alchemical parameters
'umbrella_K':
umbrella_K.value_in_unit_system(unit.md_unit_system),
'umbrella_r0':
umbrella_distance.value_in_unit_system(
unit.md_unit_system), # umbrella parameters
}
thermodynamic_states.append(
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