def _openmm_init(fname_prmtop, platformName=None):
prmtop = app.AmberPrmtopFile(fname_prmtop)
system = prmtop.createSystem(nonbondedMethod=app.NoCutoff,
constraints=app.HBonds,
implicitSolvent=None)
time_step = 1.0 # fs
integrator = omm.LangevinIntegrator(300.0 * unit.kelvin,
1.0 / unit.picoseconds,
time_step * unit.femtoseconds)
platform = omm.Platform.getPlatformByName('Reference')
properties = {}
if platformName == 'OpenCL':
platform = omm.Platform.getPlatformByName('OpenCL')
properties = {'OpenCLPrecision': 'mixed'}
if platformName == 'CUDA':
platform = omm.Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed'}
simulation = app.Simulation(prmtop.topology, system, integrator, platform,
properties)
charge_list = prmtop._prmtop.getCharges()
natom = prmtop._prmtop.getNumAtoms()
nonbond = np.array(prmtop._prmtop.getNonbondTerms())
return simulation, natom, charge_list, nonbond
def NPT1(system, coordinates, velocities, prmtop):
# Select Integrator
integrator = mm.LangevinIntegrator(TEMPERATURE, NPT_FRICTION,
NPT1_TIME_STEP)
# Set Barostat
system.addForce(
mm.MonteCarloBarostat(PRESSURE, TEMPERATURE, BAROSTAT_FREQUENCY))
# Set Simulation
simulation = app.Simulation(prmtop.topology, system, integrator)
# Set Position and velocities
simulation.context.setPositions(coordinates)
simulation.context.setVelocities(velocities)
print('First NPT equilibration...\n')
simulation.step(NPT1_STEPS)
# Get and return coordinates, velocities and box vectors
state = simulation.context.getState(getPositions=True,
getVelocities=True,
getEnergy=True)
coords = state.getPositions()
velocities = state.getVelocities()
box = state.getPeriodicBoxVectors()
# Save a PDB to use as input for yank and future splitting
#positions = state.getPositions()
#PDBFile.writeFile( simulation.topology, positions, open( pdbfile, 'w' ) )
return coords, velocities, box
def create_sim(self):
self.system = self.top.createSystem(nonbondedMethod=app.NoCutoff,
constraints=None)
self.integrator = openmm.VerletIntegrator(0.001 * unit.picoseconds)
self.simulation = app.Simulation(self.top.topology, self.system,
self.integrator)
self.simulation.context.setPositions(self.trj.openmm_positions(0))
def _create_torsion_sim(
periodicity: int = 2, phase=0 * omm_angle_unit, k=10.0 * omm_energy_unit
) -> app.Simulation:
"""Create a 4-particle OpenMM Simulation containing only a PeriodicTorsionForce"""
system = mm.System()
# add 4 particles of unit mass
for _ in range(4):
system.addParticle(1)
# add torsion force to system
force = mm.PeriodicTorsionForce()
force.addTorsion(0, 1, 2, 3, periodicity, phase, k)
system.addForce(force)
# create openmm Simulation, which requires a Topology and Integrator
topology = app.Topology()
chain = topology.addChain()
residue = topology.addResidue("torsion", chain)
for name in ["a", "b", "c", "d"]:
topology.addAtom(name, "C", residue)
integrator = mm.VerletIntegrator(1.0)
sim = app.Simulation(topology, system, integrator)
return sim
def minimization():
# Load OpenMM System
file = open(xml_filename, 'r')
serialized_system = file.read()
system = XmlSerializer.deserialize(serialized_system)
# Select Integrator
integrator = mm.LangevinIntegrator(TEMPERATURE, MIN_FRICTION,
MIN_TIME_STEP)
# Set Simulation
simulation = app.Simulation(pdb.topology, system, integrator, MIN_PLATFORM)
# Set Position
simulation.context.setPositions(pdb.positions)
state = simulation.context.getState(getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy before minimization is NaN")
# Minimization
print('Minimizing...\n')
simulation.minimizeEnergy(tolerance=MIN_TOLERANCE, maxIterations=MIN_STEPS)
state = simulation.context.getState(getPositions=True, getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy after minimization is NaN")
coords = state.getPositions()
return coords
def equilibrate(self):
if os.path.exists(self.equil_pdb_filename):
return
prmtop = app.AmberPrmtopFile(self.prmtop_filename)
inpcrd = app.AmberInpcrdFile(self.inpcrd_filename)
system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=CUTOFF, constraints=app.HBonds)
integrator = mm.LangevinIntegrator(self.temperature, EQUIL_FRICTION, EQUIL_TIMESTEP)
system.addForce(mm.MonteCarloBarostat(PRESSURE, self.temperature, BAROSTAT_FREQUENCY))
simulation = app.Simulation(prmtop.topology, system, integrator)
simulation.context.setPositions(inpcrd.positions)
state = simulation.context.getState(getEnergy=True)
print(state.getPotentialEnergy())
print('Minimizing.')
simulation.minimizeEnergy()
state = simulation.context.getState(getEnergy=True)
print(state.getPotentialEnergy())
simulation.context.setVelocitiesToTemperature(self.temperature)
print('Equilibrating.')
simulation.reporters.append(app.DCDReporter(self.equil_dcd_filename, OUTPUT_FREQUENCY_EQUIL))
simulation.step(N_EQUIL_STEPS)
# Re-write a better PDB with correct box sizes.
traj = md.load(self.equil_dcd_filename, top=self.prmtop_filename)[-1]
traj.save(self.equil_pdb_filename)
def MinimizedEnergy(filepath):
prmtop = app.AmberPrmtopFile(f'{filepath}.prmtop')
inpcrd = app.AmberInpcrdFile(f'{filepath}.inpcrd')
system = prmtop.createSystem(implicitSolvent=app.GBn2,
nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=1.0*unit.nanometers,
constraints=app.HBonds,
rigidWater=True,
ewaldErrorTolerance=0.0005)
integrator = mm.LangevinIntegrator(300*unit.kelvin,
1.0/unit.picoseconds,
2.0*unit.femtoseconds)
integrator.setConstraintTolerance(0.00001)
# TODO: This should just recognize whatever the computer is capable of, not force CUDA.
platform = mm.Platform.getPlatformByName('CUDA')
# TODO: I am not sure if mixed precision is necessary. It dramatically changes the results.
properties = {'CudaPrecision': 'mixed'}
simulation = app.Simulation(prmtop.topology, system, integrator, platform)
simulation.context.setPositions(inpcrd.positions)
simulation.minimizeEnergy()
energy = simulation.context.getState(getEnergy=True).getPotentialEnergy().value_in_unit(unit.kilojoule/unit.mole)
return energy
def calculate_eng(self, oe_mol):
# Extract starting MD data from OEMol
mdData = utils.MDData(oe_mol)
topology = mdData.topology
positions = mdData.positions
structure = mdData.structure
box = mdData.box
# OpenMM system
system = structure.createSystem(nonbondedMethod=eval("app.%s" % self.cube.args.nonbondedMethod),
nonbondedCutoff=self.cube.args.nonbondedCutoff * unit.angstroms,
constraints=eval("app.%s" % self.cube.args.constraints))
# OpenMM Integrator
integrator = openmm.LangevinIntegrator(self.cube.args.temperature * unit.kelvin,
1.0 / unit.picoseconds, 0.002 * unit.picoseconds)
# Set Simulation
simulation = app.Simulation(topology, system, integrator)
# Set Positions
simulation.context.setPositions(positions)
# Set Box dimensions
simulation.context.setPeriodicBoxVectors(box[0], box[1], box[2])
# Collect the OpenMM state energy info
state = simulation.context.getState(getEnergy=True)
# Potential Energy
peng = state.getPotentialEnergy()
return peng
def _initialize_simulation(self):
"""
"""
self._system = self._forcefield.createSystem(
self.topology.to_openmm(),
nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=1.0 * unit.nanometers,
constraints=app.HBonds,
rigidWater=True,
ewaldErrorTolerance=0.0005)
self._integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2.0 * unit.femtoseconds)
self._integrator.setConstraintTolerance(0.00001)
mm.Platform.getPlatformByName(self._platform)
self._simulation = app.Simulation(self.topology.to_openmm(),
self._system, self._integrator)
#self._platform)
# self._properties)
self._simulation.context.setPositions(self.positions)
self._simulation.minimizeEnergy()
self._simulation.context.setVelocitiesToTemperature(300 * unit.kelvin)
return
def test_membraneModeller():
# pdb file containing a solvated single lipid molecule
pdb = PDBFile('solvated-lipid.pdb')
modeller = Modeller(pdb.topology,pdb.positions)
modeller.modifyTopology()
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
modeller.addHydrogens(forcefield=forcefield)
system = forcefield.createSystem(modeller.topology,
nonbondedMethod=app.PME,
rigidWater=True,
nonbondedCutoff=1*unit.nanometer)
integrator = mm.VerletIntegrator(0.5*unit.femtoseconds)
platform = mm.Platform.getPlatformByName('Reference')
simulation = app.Simulation(modeller.topology, system, integrator, platform)
simulation.context.setPositions(modeller.positions)
simulation.context.setVelocitiesToTemperature(300*unit.kelvin)
# Minimize the system after adding hydrogens
tolerance = 0.1*unit.kilojoules_per_mole/unit.angstroms
simulation.minimizeEnergy(tolerance=tolerance,maxIterations=200)
simulation.reporters.append(app.StateDataReporter('relax-hydrogens.log',
1000,
step=True,
potentialEnergy=True))
simulation.step(1000)
def simulation(self):
if self._simulation is None:
platform = self.platform
try:
sim = self._simulation = app.Simulation(self.handler.topology, self.system,
self.integrator, *platform)
except Exception as e:
template = '{}. Try with: {}.'
if 'Illegal property name' in str(e):
msg = template.format(e, ', '.join(platform[0].getPropertyNames()))
raise ValueError(msg)
elif 'There is no registered Platform' in str(e):
msg = template.format(e, ', '.join(available_platforms()))
raise ValueError(msg)
raise e
# Box vectors
box = self.box if self.box is not None else self.handler.box
if box is not None:
sim.context.setPeriodicBoxVectors(*box)
# Positions
pos = self.positions if self.positions is not None else self.handler.positions
if pos is None:
raise ValueError('Positions must be set to start a simulation.')
sim.context.setPositions(pos)
# Velocities
vel = self.velocities if self.velocities is not None else self.handler.velocities
if vel is not None:
sim.context.setVelocities(vel)
else:
sim.context.setVelocitiesToTemperature(self.temperature*u.kelvin)
return self._simulation
def minimizeOpenMM(Topology, System, Positions):
"""
Minimize molecule with specified topology, system, and positions
using OpenMM. Return the positions of the optimized moelcule.
Parameters
----------
Topology
System
Positions
Returns
-------
boolean True if the function successfully completed, False otherwise
"""
# need to create integrator but don't think it's used
integrator = mm.LangevinIntegrator(
300.0 * u.kelvin,
1.0 / u.picosecond,
2.0 * u.femtosecond)
simulation = app.Simulation(Topology, System, integrator)
simulation.context.setPositions(Positions)
#simulation.minimizeEnergy()
simulation.minimizeEnergy(tolerance=5.0E-9, maxIterations=1500)
Topology.positions = simulation.context.getState(getPositions=True).getPositions()
return Topology.positions
def configure_amber_explicit(
pdb_file: str,
top_file: str,
dt_ps: float,
temperature_kelvin: float,
heat_bath_friction_coef: float,
platform: simtk.openmm.Platform,
platform_properties: dict,
) -> Tuple[simtk.openmm.app.Simulation, parmed.Structure]:
# Configure system
top = parmed.load_file(top_file, xyz=pdb_file)
system = top.createSystem(
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
)
# Congfigure integrator
integrator = omm.LangevinIntegrator(
temperature_kelvin * u.kelvin,
heat_bath_friction_coef / u.picosecond,
dt_ps * u.picosecond,
)
system.addForce(omm.MonteCarloBarostat(1 * u.bar, temperature_kelvin * u.kelvin))
sim = app.Simulation(
top.topology, system, integrator, platform, platform_properties
)
# Return simulation and handle to coordinates
return sim, top
def minimizeOpenMM(Topology, System, Positions):
"""
Minimize molecule with specified topology, system, and positions
using OpenMM. Return the positions of the optimized moelcule.
Parameters
----------
Topology: OpenMM topology
System: OpenMM system
Positions: OpenMM positions
Returns
-------
concat_coords: list of positions ready to add to an OEMol
"""
# need to create integrator but don't think it's used
integrator = mm.LangevinIntegrator(
300.0 * u.kelvin,
1.0 / u.picosecond,
2.0 * u.femtosecond)
simulation = app.Simulation(Topology, System, integrator)
simulation.context.setPositions(Positions)
simulation.minimizeEnergy(tolerance=5.0E-9, maxIterations=1500)
positions = simulation.context.getState(getPositions=True).getPositions(asNumpy=True)
positions = positions/u.angstroms
coordlist = list()
for atom_coords in positions:
coordlist += [i for i in atom_coords]
return coordlist
def run_raw_protocol(self):
integrator = mm.LangevinIntegrator(50 * u.kelvin,
self._FRICTION_COEFFICIENT,
self._TIMESTEP)
simulation = app.Simulation(self.topology, self.system, integrator)
def _calc_energy(self, coords):
"""
Given some coords, it calculates periodic torsion contribution
to the energy, according to OpenMM.
Parameters
----------
coords : a simtk.unit.Quantity object
The coordinates of a certain conformation of the molecule
Returns
-------
omm_energy : a simtk.unit.Quantity
The dihedral energy from OpenMM
"""
from simtk.openmm import app, LangevinIntegrator, unit
omm_idx_to_force = {}
for idx, force in enumerate(self.omm_system.getForces()):
force.setForceGroup(idx)
omm_idx_to_force[str(type(force).__name__)] = idx
omm_integrator = LangevinIntegrator(300 * unit.kelvin,
1 / unit.picosecond,
0.002 * unit.picoseconds)
omm_simulation = app.Simulation(self.omm_top, self.omm_system,
omm_integrator)
omm_simulation.context.setPositions(coords)
omm_energy = omm_simulation.context.getState(
getEnergy=True, groups={omm_idx_to_force['PeriodicTorsionForce']
}).getPotentialEnergy()
return omm_energy
def simulation(self):
"""
Build a new OpenMM simulation if not yet defined and return it
Notes
-----
self.topology must be defined previously!
Use self.chimera_molecule_to_openmm_topology to set it.
"""
if self._simulation is None:
system = self.forcefield.createSystem(
self.topology,
nonbondedMethod=openmm_app.CutoffNonPeriodic,
nonbondedCutoff=1.0 * unit.nanometers,
rigidWater=True,
constraints=None)
integrator = openmm.VerletIntegrator(0.001)
if self.platform is not None:
platform = openmm.Platform.getPlatformByName(self.platform),
else:
platform = ()
self._simulation = openmm_app.Simulation(self.topology, system,
integrator, *platform)
return self._simulation
def __init__(self, n_waters=None, topology=None, n_procs=1):
if hasattr(topology, 'to_openmm'):
self._top = topology.to_openmm()
else:
self._top = topology
if n_waters is None:
self.n_waters = n_waters
else:
self.n_waters = int(n_waters)
self.n_procs = np.int(n_procs)
forcefield = app.ForceField('iamoeba.xml')
self._top.setUnitCellDimensions([10, 10, 10])
system = forcefield.createSystem(self._top,
nonbondedMethod=app.PME,
polarization='direct')
self._amoeba_force = [
f for f in system.getForces()
if isinstance(f, mm.openmm.AmoebaMultipoleForce)
][0]
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2.0 * unit.femtoseconds)
platform = mm.Platform.getPlatformByName('CPU')
self._sim = app.Simulation(self._top, system, integrator, platform)
self._context = self._sim.context
def production(self):
if os.path.exists(self.production_dcd_filename) and os.path.exists(self.production_data_filename):
return
prmtop = app.AmberPrmtopFile(self.prmtop_filename)
pdb = app.PDBFile(self.equil_pdb_filename)
system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=CUTOFF, constraints=app.HBonds)
integrator = mm.LangevinIntegrator(self.temperature, FRICTION, TIMESTEP)
system.addForce(mm.MonteCarloBarostat(PRESSURE, self.temperature, BAROSTAT_FREQUENCY))
simulation = app.Simulation(prmtop.topology, system, integrator)
simulation.context.setPositions(pdb.positions)
simulation.context.setPeriodicBoxVectors(*pdb.topology.getPeriodicBoxVectors())
simulation.context.setVelocitiesToTemperature(self.temperature)
print('Production.')
simulation.reporters.append(app.DCDReporter(self.production_dcd_filename, OUTPUT_FREQUENCY))
simulation.reporters.append(app.StateDataReporter(self.production_data_filename, OUTPUT_DATA_FREQUENCY, step=True, potentialEnergy=True, temperature=True, density=True))
converged = False
while not converged:
simulation.step(N_STEPS)
d = pd.read_csv(self.production_data_filename, names=["step", "U", "Temperature", "Density"], skiprows=1)
density_ts = np.array(d.Density)
[t0, g, Neff] = ts.detectEquilibration(density_ts, nskip=1000)
density_ts = density_ts[t0:]
density_mean_stderr = density_ts.std() / np.sqrt(Neff)
if density_mean_stderr < STD_ERROR_TOLERANCE:
converged = True
def __setstate__(self, state):
from simtk.openmm import app
if 'sim_args' in state:
assert 'sim' not in state
args = state.pop('sim_args')
state['sim'] = app.Simulation(*args)
self.__dict__.update(state)
def test_water256_periodic(self):
nonbondedMethod = app.PME
expected_energy = -2270.88890
pdb = app.PDBFile("pdb_files/water256_integration_test.pdb")
forcefield = app.ForceField("../mbpol.xml")
nonbondedCutoff = 0.9 * unit.nanometer
if (nonbondedMethod == app.PME):
boxDimension = 19.3996888399961804 / 10.
boxsize = [boxDimension, boxDimension, boxDimension]
pdb.topology.setUnitCellDimensions(boxsize)
system = forcefield.createSystem(pdb.topology,
nonbondedMethod=nonbondedMethod,
nonbondedCutoff=nonbondedCutoff)
integrator = mm.LangevinIntegrator(0.0, 0.1, 0.01)
platform = mm.Platform.getPlatformByName('Reference')
simulation = app.Simulation(pdb.topology, system, integrator, platform)
simulation.context.setPositions(pdb.positions)
simulation.context.computeVirtualSites()
state = simulation.context.getState(getForces=True,
getEnergy=True,
getPositions=True)
potential_energy = state.getPotentialEnergy()
potential_energy.in_units_of(unit.kilocalorie_per_mole)
self.assertTrue(
abs(
potential_energy.in_units_of(unit.kilocalorie_per_mole)._value
- expected_energy) < 20)
def testProgressReporter(self):
""" Test ProgressReporter with various options """
system = amber_gas.createSystem()
integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds,
1.0 * u.femtoseconds)
sim = app.Simulation(amber_gas.topology, system, integrator)
sim.context.setPositions(amber_gas.positions)
sim.reporters.append(
ProgressReporter(get_fn('progress_reporter.dat', written=True),
10,
500,
step=True,
time=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
volume=True,
density=True,
systemMass=None))
sim.step(500)
self.assertEqual(len(os.listdir(get_fn('writes'))), 1)
text = open(get_fn('progress_reporter.dat', written=True), 'r').read()
self.assertTrue('Estimated time to completion' in text)
self.assertTrue('Total Energy' in text)
self.assertTrue('Potential Energy' in text)
self.assertTrue('Kinetic Energy' in text)
self.assertTrue('Temperature' in text)
def OMMsimulation(self):
from simtk.openmm import app
if not hasattr(self, '_simulation'):
self._simulation = app.Simulation(self.modeller.topology,
self.OMMsystem, self.integrator)
self._simulation.context.setPositions(self.modeller.positions)
return self._simulation
def test_porin_membrane_system():
"""Test the addition of a ligand to a solvated porin"""
# pdb file corresponding to a solvated porin
pdb = PDBFile(
os.path.join(os.path.dirname(__file__),
'../data/porin/solvated-porin.pdb'))
modeller = app.Modeller(pdb.topology, pdb.positions)
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
platform = mm.Platform.getPlatformByName('CPU')
modeller.addHydrogens(forcefield=forcefield)
# rigidWater False is required for ParMed to access water paramters
system_md = forcefield.createSystem(modeller.topology,
nonbondedMethod=app.PME,
rigidWater=False,
nonbondedCutoff=1 * unit.nanometer)
ligand_system = PorinMembraneSystem('comp7',
system_md,
modeller.topology,
modeller.positions,
platform,
tolerance=1 * unit.kilojoule /
unit.mole,
max_iterations=200)
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2 * unit.femtosecond)
simulation = app.Simulation(ligand_system.structure.topology,
ligand_system.system, integrator, platform)
simulation.context.setPositions(ligand_system.structure.positions)
state = simulation.context.getState(getEnergy=True)
pe = state.getPotentialEnergy()._value
assert pe < 0.0
def npt2(system, coordinates, velocities, box, prmtop, pdbfile):
# Select Integrator
integrator = mm.LangevinIntegrator(TEMPERATURE, NPT_FRICTION,
NPT2_TIME_STEP)
# Set Barostat
system.addForce(
mm.MonteCarloBarostat(PRESSURE, TEMPERATURE, BAROSTAT_FREQUENCY))
# Set Simulation
simulation = app.Simulation(prmtop.topology, system, integrator)
# Set Position and velocities
simulation.context.setPositions(coordinates)
if velocities is not None:
simulation.context.setVelocities(velocities)
else: #reset
simulation.context.setVelocitiesToTemperature(TEMPERATURE)
# Set Box
simulation.context.setPeriodicBoxVectors(box[0], box[1], box[2])
print('Second NPT equilibration...\n')
simulation.step(NPT2_STEPS)
state = simulation.context.getState(getPositions=True,
getVelocities=True,
getForces=True,
getEnergy=True,
enforcePeriodicBox=True)
# Save a PDB to use as input for yank and future splitting
positions = state.getPositions()
PDBFile.writeFile(simulation.topology, positions, open(pdbfile, 'w'))
return state
def openmm_system(self):
"""Initialise the OpenMM system we will use to evaluate the energies."""
# Load the initial coords into the system and initialise
pdb = app.PDBFile(self.pdb)
forcefield = app.ForceField(self.xml)
modeller = app.Modeller(pdb.topology, pdb.positions) # set the initial positions from the pdb
self.system = forcefield.createSystem(modeller.topology, nonbondedMethod=app.NoCutoff, constraints=None)
# Check what combination rule we should be using from the xml
xmlstr = open(self.xml).read()
# check if we have opls combination rules if the xml is present
try:
self.combination = ET.fromstring(xmlstr).find('NonbondedForce').attrib['combination']
except AttributeError:
pass
except KeyError:
pass
if self.combination == 'opls':
print('OPLS combination rules found in xml file')
self.opls_lj()
temperature = constants.STP * unit.kelvin
integrator = mm.LangevinIntegrator(temperature, 5 / unit.picoseconds, 0.001 * unit.picoseconds)
self.simulation = app.Simulation(modeller.topology, self.system, integrator)
self.simulation.context.setPositions(modeller.positions)
def __init__(self, config_: Config, old_sampler_state=None):
"""
:param systemLoader:
:param config:
"""
self._times = None
self.config = config_
self.logger = make_message_writer(self.config.verbose, self.__class__.__name__)
if self.config.systemloader.system is None:
self.system = self.config.systemloader.get_system(self.config.parameters.createSystem)
self.topology = self.config.systemloader.topology
positions, velocities = self.config.systemloader.get_positions(), None
else:
self.system = self.config.systemloader.system
self.topology = self.config.systemloader.topology
positions, velocities = self.config.systemloader.get_positions(), None
self.topology = self.config.systemloader.topology
self.explicit = self.config.systemloader.explicit
integrator = integrators.GeodesicBAOABIntegrator(temperature=self.config.parameters.integrator_params['temperature'],
timestep=self.config.parameters.integrator_params['timestep'],
collision_rate=self.config.parameters.integrator_params[
'collision_rate'],
constraint_tolerance=self.config.parameters.integrator_setConstraintTolerance)
self.simulation = app.Simulation(self.topology, self.system, integrator,
self.config.parameters.platform, self.config.parameters.platform_config)
self.simulation.context.setPositions(self.config.systemloader.positions)
self.simulation.minimizeEnergy(self.config.parameters.minMaxIters)
self.simulation.context.setVelocitiesToTemperature(self.config.parameters.integrator_params['temperature'])
def simulate_system(self,
equilibrate=100,
production=100,
dcd_frequency=10):
context, integrator = self.get_context()
# integrator.step(num_steps)
dummy_integrator = mm.VerletIntegrator(1 * u.femtosecond)
simulation = app.Simulation(self.topology, context.getSystem(),
dummy_integrator)
simulation.context = context
simulation.integrator = integrator
simulation.reporters.append(
app.DCDReporter('equilibration.dcd', dcd_frequency))
simulation.step(equilibrate)
simulation.reporters.clear()
simulation.reporters.append(
app.DCDReporter('production.dcd', dcd_frequency))
simulation.step(production)
self.sampler_state.update_from_context(context)
del context
def setup(traj,
mmtop,
temperature,
pressure,
sigma,
epsilon,
nonbondedCutoff=1.4 * u.nanometer):
system = ff.createSystem(mmtop,
nonbondedMethod=app.CutoffPeriodic,
nonbondedCutoff=nonbondedCutoff)
f = system.getForce(0)
set_parms(f, sigma, epsilon)
friction = 1.0 / u.picoseconds
timestep = 3.0 * u.femtoseconds
barostat_frequency = 25
integrator = mm.LangevinIntegrator(temperature, friction, timestep)
system.addForce(
mm.MonteCarloBarostat(pressure, temperature, barostat_frequency))
simulation = app.Simulation(mmtop, system, integrator)
simulation.reporters.append(
app.StateDataReporter(sys.stdout, 100, step=True, density=True))
simulation.context.setPositions(traj.openmm_positions(0))
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(temperature)
simulation.step(10000)
return simulation
def build(self, target_path="", file_name="out"):
build_string = self.build_string
if self.chains:
for chain in self.chains:
self.build_string += chain.structure.init_string
for index, chain in enumerate(self.chains):
if chain.sequence:
self.build_string +="""
CHAIN%s = sequence {%s}
"""%(index, chain.sequence)
else:
raise ValueError("Empty Chain Index: %s"%index)
chain_string = " ".join(["CHAIN%s"%index for index in range(len(self.chains))])
self.build_string +="""
UNION = combine {%s}
saveamberparm UNION %s.prmtop %s.inpcrd
quit
"""%(chain_string, target_path+file_name, target_path+file_name)
infile = open("%s%s.in"%(target_path, file_name),"w")
infile.write(self.build_string)
infile.close()
self.build_string = build_string
#os.remove("%s%s.in"%(target_path, file_name))
result = subprocess.call("tleap -f %s%s.in"%(target_path,file_name),shell=True)
self.prmtop = app.AmberPrmtopFile(target_path+file_name+".prmtop")
self.inpcrd = app.AmberInpcrdFile(target_path+file_name+".inpcrd")
self.topology = self.prmtop.topology
self.positions = self.inpcrd.positions
self.system = self.prmtop.createSystem(nonbondedMethod=app.NoCutoff, constraints=None, implicitSolvent=app.OBC1)
self.integrator = mm.LangevinIntegrator(300.*unit.kelvin, 1./unit.picosecond, 0.002*unit.picoseconds)
self.simulation = app.Simulation(self.topology, self.system, self.integrator)
else:
raise ValueError('Empty Complex! CANNOT build!')
