def test_gas_energy_conf_2(self):
""" Compare Amber and OpenMM gas phase energies and forces (topology 2) """
parm = AmberParm(get_fn('hydrogen-peroxide_T0_2.prmtop'), get_fn('hydrogen-peroxide_T0_2.rst7'))
self.assertEqual(parm.combining_rule, 'lorentz')
system = parm.createSystem() # Default, no cutoff
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(parm.positions)
energies = energy_decomposition(parm, sim.context)
#BOND = 0.0319 ANGLE = 2.1690 DIHED = -2.7931
#VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000
#1-4 VDW = 0.0000 1-4 EEL = 0.0000 RESTRAINT = 0.0000
# Compare OpenMM energies with the Amber energies (above)
self.assertAlmostEqual(energies['bond'], 0.0319, places=4)
self.assertAlmostEqual(energies['angle'], 2.1690, places=4)
self.assertAlmostEqual(energies['dihedral'],-2.7931, places=4)
self.assertRelativeEqual(energies['nonbonded'], 0.0, places=3)
# Now test the forces to make sure that they are computed correctly in
# the presence of extra points
pstate = sim.context.getState(getForces=True)
pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole/u.nanometer)
# gmx forces:
# f[ 0]={ 3.14357e+02, -5.90363e+02, 2.11410e+02}
# f[ 1]={-3.14357e+02, 5.90363e+02, 2.11410e+02}
# f[ 2]={ 2.70641e+02, 5.90363e+02, -2.11410e+02}
# f[ 3]={-2.70641e+02, -5.90363e+02, -2.11410e+02}
gf = [ ( 3.14357e+02, -5.90363e+02, 2.11410e+02),
(-3.14357e+02, 5.90363e+02, 2.11410e+02),
( 2.70641e+02, 5.90363e+02, -2.11410e+02),
(-2.70641e+02, -5.90363e+02, -2.11410e+02)]
for p, s in zip(pf, gf):
for x1, x2 in zip(p, s):
self.assertAlmostEqual(x1, x2, places=3)
def main():
prmtop_filename = '<topology>'
crd_filename = '<coordinate>'
prmtop = AmberParm(prmtop_filename, crd_filename)
system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=10*unit.angstrom,
constraints=app.HBonds, switchDistance=8*unit.angstrom)
temperature = 300 * unit.kelvin
pressure = 1 * unit.atmosphere
collision_rate = 5 / unit.picosecond
timestep = 2 * unit.femtosecond
integrator = openmm.LangevinIntegrator(temperature, collision_rate, timestep)
barostat = openmm.MonteCarloBarostat(temperature, pressure)
system.addForce(barostat)
system.setDefaultPeriodicBoxVectors(*prmtop.box_vectors)
simulation = app.Simulation(prmtop.topology, system, integrator)
simulation.context.setPositions(prmtop.positions)
simulation.context.setVelocitiesToTemperature(temperature)
print('System contains {} atoms.'.format(system.getNumParticles()))
print('Using platform "{}".'.format(simulation.context.getPlatform().getName()))
print('Minimizing energy to avoid clashes.')
simulation.minimizeEnergy(maxIterations=100)
print('Initial potential energy is {}'.format(simulation.context.getState(getEnergy=True).getPotentialEnergy()))
# Warm up the integrator to compile kernels, etc
print('Warming up integrator to trigger kernel compilation...')
simulation.step(10)
# Time integration
print('Benchmarking...')
nsteps = <numsteps>
initial_time = time.time()
integrator.step(nsteps)
final_time = time.time()
elapsed_time = (final_time - initial_time) * unit.seconds
simulated_time = nsteps * timestep
performance = (simulated_time / elapsed_time)
print('Completed {} steps in {}.'.format(nsteps, elapsed_time))
print('Performance is {} ns/day'.format(performance / (unit.nanoseconds/unit.day)))
print('Final potential energy is {}'.format(simulation.context.getState(getEnergy=True).getPotentialEnergy()))
def test_gas_energy_conf_4(self):
""" Compare Amber and OpenMM gas phase energies and forces (topology 4) """
parm = AmberParm(get_fn('ethanol_T0.prmtop'),
get_fn('ethanol_T0.rst7'))
self.assertEqual(parm.combining_rule, 'geometric')
system = parm.createSystem() # Default, no cutoff
integrator = mm.VerletIntegrator(1.0 * u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(parm.positions)
energies = energy_decomposition(parm, sim.context)
#BOND = 0.0239 ANGLE = 0.0298 DIHED = 0.0093
#VDWAALS = 0.0000 EEL = 6.7526 HBOND = 0.0000
#1-4 VDW = 0.0492 1-4 EEL = -6.0430 RESTRAINT = 0.0000
# Compare OpenMM energies with the Amber energies (above)
self.assertAlmostEqual(energies['bond'], 0.0239, places=4)
self.assertAlmostEqual(energies['angle'], 0.0298, places=4)
self.assertAlmostEqual(energies['dihedral'], 0.0093, places=4)
self.assertRelativeEqual(energies['nonbonded'],
0.0000 + 6.7526 + 0.0492 - 6.0430,
places=3)
# Now test the forces to make sure that they are computed correctly in
# the presence of extra points
pstate = sim.context.getState(getForces=True)
pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole /
u.nanometer)
# gmx forces:
# f[ 0]={ 1.73101e+02, 5.67250e+01, -4.02950e+01}
# f[ 1]={-8.13704e+00, -1.79612e+01, 9.88537e+01}
# f[ 2]={-2.83120e+01, 6.23352e+00, -5.47393e+00}
# f[ 3]={-1.03312e+01, -1.00966e+01, -5.12129e+00}
# f[ 4]={-1.69636e+02, 3.34850e+01, -1.73612e+02}
# f[ 5]={ 4.19932e+00, -2.58283e+00, 1.29999e+02}
# f[ 6]={ 3.02865e+01, -6.68331e+00, -2.99153e+01}
# f[ 7]={ 1.00113e+02, -5.22480e+01, 4.80526e+01}
# f[ 8]={-9.12828e+01, -6.87157e+00, -2.24877e+01}
gf = [(1.73101e+02, 5.67250e+01, -4.02950e+01),
(-8.13704e+00, -1.79612e+01, 9.88537e+01),
(-2.83120e+01, 6.23352e+00, -5.47393e+00),
(-1.03312e+01, -1.00966e+01, -5.12129e+00),
(-1.69636e+02, 3.34850e+01, -1.73612e+02),
(4.19932e+00, -2.58283e+00, 1.29999e+02),
(3.02865e+01, -6.68331e+00, -2.99153e+01),
(1.00113e+02, -5.22480e+01, 4.80526e+01),
(-9.12828e+01, -6.87157e+00, -2.24877e+01)]
for p, s in zip(pf, gf):
for x1, x2 in zip(p, s):
self.assertAlmostEqual(x1, x2, places=3)
def test_gas_energy_conf_4(self):
""" Compare Amber and OpenMM gas phase energies and forces (topology 4) """
parm = AmberParm(get_fn('ethanol_T0.prmtop'), get_fn('ethanol_T0.rst7'))
self.assertEqual(parm.combining_rule, 'geometric')
system = parm.createSystem() # Default, no cutoff
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(parm.positions)
energies = energy_decomposition(parm, sim.context)
#BOND = 0.0239 ANGLE = 0.0298 DIHED = 0.0093
#VDWAALS = 0.0000 EEL = 6.7526 HBOND = 0.0000
#1-4 VDW = 0.0492 1-4 EEL = -6.0430 RESTRAINT = 0.0000
# Compare OpenMM energies with the Amber energies (above)
self.assertAlmostEqual(energies['bond'], 0.0239, places=4)
self.assertAlmostEqual(energies['angle'], 0.0298, places=4)
self.assertAlmostEqual(energies['dihedral'], 0.0093, places=4)
self.assertRelativeEqual(energies['nonbonded'], 0.0000+6.7526+0.0492-6.0430, places=3)
# Now test the forces to make sure that they are computed correctly in
# the presence of extra points
pstate = sim.context.getState(getForces=True)
pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole/u.nanometer)
# gmx forces:
# f[ 0]={ 1.73101e+02, 5.67250e+01, -4.02950e+01}
# f[ 1]={-8.13704e+00, -1.79612e+01, 9.88537e+01}
# f[ 2]={-2.83120e+01, 6.23352e+00, -5.47393e+00}
# f[ 3]={-1.03312e+01, -1.00966e+01, -5.12129e+00}
# f[ 4]={-1.69636e+02, 3.34850e+01, -1.73612e+02}
# f[ 5]={ 4.19932e+00, -2.58283e+00, 1.29999e+02}
# f[ 6]={ 3.02865e+01, -6.68331e+00, -2.99153e+01}
# f[ 7]={ 1.00113e+02, -5.22480e+01, 4.80526e+01}
# f[ 8]={-9.12828e+01, -6.87157e+00, -2.24877e+01}
gf = [ ( 1.73101e+02, 5.67250e+01, -4.02950e+01),
(-8.13704e+00, -1.79612e+01, 9.88537e+01),
(-2.83120e+01, 6.23352e+00, -5.47393e+00),
(-1.03312e+01, -1.00966e+01, -5.12129e+00),
(-1.69636e+02, 3.34850e+01, -1.73612e+02),
( 4.19932e+00, -2.58283e+00, 1.29999e+02),
( 3.02865e+01, -6.68331e+00, -2.99153e+01),
( 1.00113e+02, -5.22480e+01, 4.80526e+01),
(-9.12828e+01, -6.87157e+00, -2.24877e+01)]
for p, s in zip(pf, gf):
for x1, x2 in zip(p, s):
self.assertAlmostEqual(x1, x2, places=3)
def oemol_to_openmm_system_amber(oemol, molecule_name):
"""
Create an openmm system out of an oemol
Returns
-------
system : openmm.System object
the system from the molecule
positions : [n,3] np.array of floats
"""
_ , tripos_mol2_filename = openmoltools.openeye.molecule_to_mol2(oemol, tripos_mol2_filename=molecule_name + '.tripos.mol2', conformer=0, residue_name='MOL')
gaff_mol2, frcmod = openmoltools.amber.run_antechamber(molecule_name, tripos_mol2_filename)
prmtop_file, inpcrd_file = openmoltools.amber.run_tleap(molecule_name, gaff_mol2, frcmod)
from parmed.amber import AmberParm
prmtop = AmberParm(prmtop_file)
system = prmtop.createSystem(implicitSolvent=None, removeCMMotion=False)
crd = app.AmberInpcrdFile(inpcrd_file)
return system, crd.getPositions(asNumpy=True), prmtop.topology
def oemol_to_openmm_system_amber(oemol, molecule_name):
"""
Create an openmm system out of an oemol
Returns
-------
system : openmm.System object
the system from the molecule
positions : [n,3] np.array of floats
"""
_ , tripos_mol2_filename = openmoltools.openeye.molecule_to_mol2(oemol, tripos_mol2_filename=molecule_name + '.tripos.mol2', conformer=0, residue_name='MOL')
gaff_mol2, frcmod = openmoltools.amber.run_antechamber(molecule_name, tripos_mol2_filename)
prmtop_file, inpcrd_file = openmoltools.amber.run_tleap(molecule_name, gaff_mol2, frcmod)
from parmed.amber import AmberParm
prmtop = AmberParm(prmtop_file)
system = prmtop.createSystem(implicitSolvent=None, removeCMMotion=False)
crd = app.AmberInpcrdFile(inpcrd_file)
return system, crd.getPositions(asNumpy=True), prmtop.topology
def test_gas_energy_conf_3(self):
""" Compare Amber and OpenMM gas phase energies and forces (topology 3) """
parm = AmberParm(get_fn('methanol_T0.prmtop'),
get_fn('methanol_T0.rst7'))
self.assertEqual(parm.combining_rule, 'geometric')
system = parm.createSystem() # Default, no cutoff
integrator = mm.VerletIntegrator(1.0 * u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(parm.positions)
energies = energy_decomposition(parm, sim.context)
#BOND = 0.0224 ANGLE = 0.0469 DIHED = 0.0039
#VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000
#1-4 VDW = 0.0000 1-4 EEL = 3.3789 RESTRAINT = 0.0000
# Compare OpenMM energies with the Amber energies (above)
self.assertAlmostEqual(energies['bond'], 0.0224, places=4)
self.assertAlmostEqual(energies['angle'], 0.0469, places=4)
self.assertAlmostEqual(energies['dihedral'], 0.0039, places=4)
self.assertRelativeEqual(energies['nonbonded'], 3.3789, places=3)
# Now test the forces to make sure that they are computed correctly in
# the presence of extra points
pstate = sim.context.getState(getForces=True)
pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole /
u.nanometer)
# gmx forces:
# f[ 0]={ 2.19935e+01, 8.60143e+01, 1.77895e+02}
# f[ 1]={ 5.25347e+01, 3.46119e+01, -9.73738e+01}
# f[ 2]={ 1.76138e+01, -7.13778e+01, -1.08807e+00}
# f[ 3]={-3.74994e+01, -5.39602e+01, -6.75679e+01}
# f[ 4]={-8.35142e+01, -7.86616e+01, -1.60611e+02}
# f[ 5]={ 2.88716e+01, 8.33735e+01, 1.48746e+02}
gf = [(2.19935e+01, 8.60143e+01, 1.77895e+02),
(5.25347e+01, 3.46119e+01, -9.73738e+01),
(1.76138e+01, -7.13778e+01, -1.08807e+00),
(-3.74994e+01, -5.39602e+01, -6.75679e+01),
(-8.35142e+01, -7.86616e+01, -1.60611e+02),
(2.88716e+01, 8.33735e+01, 1.48746e+02)]
for p, s in zip(pf, gf):
for x1, x2 in zip(p, s):
self.assertAlmostEqual(x1, x2, places=3)
def test_gas_energy_conf_3(self):
""" Compare Amber and OpenMM gas phase energies and forces (topology 3) """
parm = AmberParm(get_fn('methanol_T0.prmtop'), get_fn('methanol_T0.rst7'))
self.assertEqual(parm.combining_rule, 'geometric')
system = parm.createSystem() # Default, no cutoff
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(parm.positions)
energies = energy_decomposition(parm, sim.context)
#BOND = 0.0224 ANGLE = 0.0469 DIHED = 0.0039
#VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000
#1-4 VDW = 0.0000 1-4 EEL = 3.3789 RESTRAINT = 0.0000
# Compare OpenMM energies with the Amber energies (above)
self.assertAlmostEqual(energies['bond'], 0.0224, places=4)
self.assertAlmostEqual(energies['angle'], 0.0469, places=4)
self.assertAlmostEqual(energies['dihedral'], 0.0039, places=4)
self.assertRelativeEqual(energies['nonbonded'], 3.3789, places=3)
# Now test the forces to make sure that they are computed correctly in
# the presence of extra points
pstate = sim.context.getState(getForces=True)
pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole/u.nanometer)
# gmx forces:
# f[ 0]={ 2.19935e+01, 8.60143e+01, 1.77895e+02}
# f[ 1]={ 5.25347e+01, 3.46119e+01, -9.73738e+01}
# f[ 2]={ 1.76138e+01, -7.13778e+01, -1.08807e+00}
# f[ 3]={-3.74994e+01, -5.39602e+01, -6.75679e+01}
# f[ 4]={-8.35142e+01, -7.86616e+01, -1.60611e+02}
# f[ 5]={ 2.88716e+01, 8.33735e+01, 1.48746e+02}
gf = [ ( 2.19935e+01, 8.60143e+01, 1.77895e+02),
( 5.25347e+01, 3.46119e+01, -9.73738e+01),
( 1.76138e+01, -7.13778e+01, -1.08807e+00),
(-3.74994e+01, -5.39602e+01, -6.75679e+01),
(-8.35142e+01, -7.86616e+01, -1.60611e+02),
( 2.88716e+01, 8.33735e+01, 1.48746e+02)]
for p, s in zip(pf, gf):
for x1, x2 in zip(p, s):
self.assertAlmostEqual(x1, x2, places=3)
def test_gas_energy_conf_2(self):
""" Compare Amber and OpenMM gas phase energies and forces (topology 2) """
parm = AmberParm(get_fn('hydrogen-peroxide_T0_2.prmtop'),
get_fn('hydrogen-peroxide_T0_2.rst7'))
self.assertEqual(parm.combining_rule, 'lorentz')
system = parm.createSystem() # Default, no cutoff
integrator = mm.VerletIntegrator(1.0 * u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(parm.positions)
energies = energy_decomposition(parm, sim.context)
#BOND = 0.0319 ANGLE = 2.1690 DIHED = -2.7931
#VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000
#1-4 VDW = 0.0000 1-4 EEL = 0.0000 RESTRAINT = 0.0000
# Compare OpenMM energies with the Amber energies (above)
self.assertAlmostEqual(energies['bond'], 0.0319, places=4)
self.assertAlmostEqual(energies['angle'], 2.1690, places=4)
self.assertAlmostEqual(energies['dihedral'], -2.7931, places=4)
self.assertRelativeEqual(energies['nonbonded'], 0.0, places=3)
# Now test the forces to make sure that they are computed correctly in
# the presence of extra points
pstate = sim.context.getState(getForces=True)
pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole /
u.nanometer)
# gmx forces:
# f[ 0]={ 3.14357e+02, -5.90363e+02, 2.11410e+02}
# f[ 1]={-3.14357e+02, 5.90363e+02, 2.11410e+02}
# f[ 2]={ 2.70641e+02, 5.90363e+02, -2.11410e+02}
# f[ 3]={-2.70641e+02, -5.90363e+02, -2.11410e+02}
gf = [(3.14357e+02, -5.90363e+02, 2.11410e+02),
(-3.14357e+02, 5.90363e+02, 2.11410e+02),
(2.70641e+02, 5.90363e+02, -2.11410e+02),
(-2.70641e+02, -5.90363e+02, -2.11410e+02)]
for p, s in zip(pf, gf):
for x1, x2 in zip(p, s):
self.assertAlmostEqual(x1, x2, places=3)
def get_rmsd(initparas):
global idxs, mcresids2, atompairs
#Modify the C4 terms in the prmtop file
for i in range(0, len(idxs)):
prmtop.parm_data['LENNARD_JONES_CCOEF'][idxs[i]] = initparas[i]
#Overwrite the prmtop file
prmtop.write_parm('OptC4.top')
#Perform the OpenMM optimization
#Use AmberParm function to transfer the topology and
#coordinate file to the object OpenMM can use
Ambermol = AmberParm('OptC4.top', options.cfile)
# Create the OpenMM system
print('Creating OpenMM System')
if options.simupha == 'gas':
system = Ambermol.createSystem(nonbondedMethod=app.NoCutoff)
elif options.simupha == 'liquid':
system = Ambermol.createSystem(
nonbondedMethod=app.PME,
nonbondedCutoff=8.0 * u.angstroms,
constraints=app.HBonds,
)
#Add restraints
force = mm.CustomExternalForce("k*((x-x0)^2+(y-y0)^2+(z-z0)^2)")
force.addGlobalParameter("k", 200.0)
force.addPerParticleParameter("x0")
force.addPerParticleParameter("y0")
force.addPerParticleParameter("z0")
#for i in range(0, len(Ambermol.atoms)):
for i, atom_crd in enumerate(Ambermol.positions):
#if (Ambermol.atoms[i].residue.number+1 not in mcresids2) and \
if (i+1 not in mcresids2) and \
(Ambermol.atoms[i].residue.name not in ['WAT', 'HOH']) and \
(Ambermol.atoms[i].name in ['CA', 'C', 'N']):
force.addParticle(i, atom_crd.value_in_unit(u.nanometers))
system.addForce(force)
# Create the integrator to do Langevin dynamics
# Temperature of heat bath, Friction coefficient, Time step
integrator = mm.LangevinIntegrator(
300 * u.kelvin,
1.0 / u.picoseconds,
1.0 * u.femtoseconds,
)
# Define the platform to use; CUDA, OpenCL, CPU, or Reference. Or do not
# specify the platform to use the default (fastest) platform
# Create the Simulation object
if options.platf == 'ref':
platform = mm.Platform.getPlatformByName('Reference')
sim = app.Simulation(Ambermol.topology, system, integrator, platform)
elif options.platf == 'cpu':
platform = mm.Platform.getPlatformByName('CPU')
sim = app.Simulation(Ambermol.topology, system, integrator, platform)
elif options.platf == 'cuda':
platform = mm.Platform.getPlatformByName('CUDA')
prop = dict(CudaPrecision=options.presn)
sim = app.Simulation(Ambermol.topology, system, integrator, platform,
prop)
elif options.platf == 'opencl':
platform = mm.Platform.getPlatformByName('OpenCL')
prop = dict(OpenCLPrecision=options.presn)
sim = app.Simulation(Ambermol.topology, system, integrator, platform,
prop)
# Set the particle positions
sim.context.setPositions(Ambermol.positions)
# Output the rst file
restrt = RestartReporter(options.rfile, 100, write_velocities=False)
sim.reporters.append(restrt)
# Minimize the energy
print('Minimizing energy ' + str(options.maxsteps) + ' steps.')
sim.minimizeEnergy(maxIterations=options.maxsteps)
# Overwrite the final file
state = sim.context.getState(getPositions=True, enforcePeriodicBox=True)
restrt.report(sim, state)
val_aft_min = []
crds_aft_min = read_rstf(options.rfile)
for i in atompairs:
if len(i) == 2:
crd1 = crds_aft_min[i[0] - 1]
crd2 = crds_aft_min[i[1] - 1]
bond = calc_bond(crd1, crd2)
val_aft_min.append(('bond', bond))
elif len(i) == 3:
crd1 = crds_aft_min[i[0] - 1]
crd2 = crds_aft_min[i[1] - 1]
crd3 = crds_aft_min[i[2] - 1]
angle = calc_angle(crd1, crd2, crd3)
val_aft_min.append(('angle', angle))
elif len(i) == 4:
crd1 = crds_aft_min[i[0] - 1]
crd2 = crds_aft_min[i[1] - 1]
crd3 = crds_aft_min[i[2] - 1]
crd4 = crds_aft_min[i[3] - 1]
dih = calc_dih(crd1, crd2, crd3, crd4)
val_aft_min.append(('dih', dih))
valdiffs = []
for i in range(0, len(atompairs)):
if val_bf_min[i][0] == 'bond':
valdiff = abs(val_aft_min[i][1] - val_bf_min[i][1]) * 1.0 / 100.0
elif val_bf_min[i][0] == 'angle':
valdiff = abs(val_aft_min[i][1] - val_bf_min[i][1]) * 1.0 / 2.0
elif val_bf_min[i][0] == 'dih':
valdiff = abs(val_aft_min[i][1] - val_bf_min[i][1])
if (360.0 - valdiff < valdiff):
valdiff = 360.0 - valdiff
valdiffs.append(valdiff)
fnldiff = numpy.sum(valdiffs)
print(fnldiff)
return fnldiff
class TestStateDataReporter(FileIOTestCase):
def setUp(self):
super().setUp()
self.amber_gas = AmberParm(self.get_fn('ash.parm7'),
self.get_fn('ash.rst7'))
def test_state_data_reporter(self):
""" Test StateDataReporter with various options """
system = self.amber_gas.createSystem()
integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds,
1.0 * u.femtoseconds)
sim = app.Simulation(self.amber_gas.topology,
system,
integrator,
platform=CPU)
sim.context.setPositions(self.amber_gas.positions)
f = open(self.get_fn('akma5.dat', written=True), 'w')
sim.reporters.extend([
StateDataReporter(self.get_fn('akma1.dat', written=True), 10),
StateDataReporter(self.get_fn('akma2.dat', written=True),
10,
time=False,
potentialEnergy=False,
kineticEnergy=False,
totalEnergy=False,
temperature=False),
StateDataReporter(self.get_fn('akma3.dat', written=True),
10,
volume=True,
density=True),
StateDataReporter(self.get_fn('akma4.dat', written=True),
10,
separator='\t'),
StateDataReporter(self.get_fn('units.dat', written=True),
10,
volume=True,
density=True,
energyUnit=u.kilojoules_per_mole,
volumeUnit=u.nanometers**3),
StateDataReporter(f, 10)
])
sim.step(500)
f.close()
# Now open all of the reporters and check that the information in there
# is what we expect it to be
akma1 = open(self.get_fn('akma1.dat', written=True), 'r')
akma2 = open(self.get_fn('akma2.dat', written=True), 'r')
akma3 = open(self.get_fn('akma3.dat', written=True), 'r')
akma4 = open(self.get_fn('akma4.dat', written=True), 'r')
akma5 = open(self.get_fn('akma5.dat', written=True), 'r')
units = open(self.get_fn('units.dat', written=True), 'r')
# AKMA 1 first
header = akma1.readline().strip()[1:].split(',')
self.assertEqual(len(header), 6)
for i, label in enumerate(
('Step', 'Time', 'Potential Energy', 'Kinetic Energy',
'Total Energy', 'Temperature')):
self.assertTrue(label in header[i])
for i, line in enumerate(akma1):
words = line.replace('\n', '').split(',')
self.assertEqual(i * 10 + 10, int(words[0])) # step
akma1.close()
# AKMA 2
header = akma2.readline().strip()[1:].split(',')
self.assertEqual(len(header), 1)
self.assertTrue('Step' in header[0])
for i, line in enumerate(akma2):
self.assertEqual(int(line.replace('\n', '').split(',')[0]),
10 * i + 10)
akma2.close()
# AKMA 3 -- save energies so we can compare to the file with different
# units
header = akma3.readline().strip()[1:].split(',')
self.assertEqual(len(header), 8)
for i, label in enumerate(
('Step', 'Time', 'Potential Energy', 'Kinetic Energy',
'Total Energy', 'Temperature', 'Box Volume', 'Density')):
self.assertTrue(label in header[i])
akma_energies = [[0.0 for i in range(8)] for j in range(50)]
for i, line in enumerate(akma3):
words = line.replace('\n', '').split(',')
akma_energies[i][0] = int(words[0])
for j in range(1, 8):
akma_energies[i][j] = float(words[j])
akma3.close()
# AKMA 4 -- tab delimiter
header = akma4.readline().strip()[1:].split('\t')
self.assertEqual(len(header), 6)
for i, label in enumerate(
('Step', 'Time', 'Potential Energy', 'Kinetic Energy',
'Total Energy', 'Temperature')):
self.assertTrue(label in header[i])
for i, line in enumerate(akma4):
words = line.replace('\n', '').split('\t')
self.assertEqual(i * 10 + 10, int(words[0])) # step
akma4.close()
# AKMA 5 -- write to open file handle
header = akma5.readline().strip()[1:].split(',')
self.assertEqual(len(header), 6)
for i, label in enumerate(
('Step', 'Time', 'Potential Energy', 'Kinetic Energy',
'Total Energy', 'Temperature')):
self.assertTrue(label in header[i])
for i, line in enumerate(akma5):
words = line.replace('\n', '').split(',')
self.assertEqual(i * 10 + 10, int(words[0])) # step
akma5.close()
# UNITS -- compare other units
ene = u.kilojoule_per_mole.conversion_factor_to(u.kilocalorie_per_mole)
volume = u.nanometers.conversion_factor_to(u.angstroms)**3
conversions = [1, 1, ene, ene, ene, 1, volume, 1]
headers = units.readline().strip()[1:].split(',')
self.assertEqual(len(headers), 8)
for i, line in enumerate(units):
words = line.replace('\n', '').split(',')
self.assertEqual(int(words[0]), akma_energies[i][0])
for j in range(1, 8):
self.assertAlmostEqual(float(words[j]) * conversions[j],
akma_energies[i][j],
places=5)
units.close()
def test_progress_reporter(self):
""" Test ProgressReporter with various options """
self.assertRaises(ValueError,
lambda: ProgressReporter(sys.stdout, 1, 5))
system = self.amber_gas.createSystem()
integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds,
1.0 * u.femtoseconds)
sim = app.Simulation(self.amber_gas.topology,
system,
integrator,
platform=CPU)
sim.context.setPositions(self.amber_gas.positions)
sim.reporters.append(
ProgressReporter(self.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(self._temporary_directory.name)), 1)
text = open(self.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)
class TestTrajRestartReporter(FileIOTestCase):
def setUp(self):
super().setUp()
self.amber_gas = AmberParm(self.get_fn('ash.parm7'),
self.get_fn('ash.rst7'))
def test_reporters(self):
""" Test NetCDF and ASCII restart and trajectory reporters (no PBC) """
with self.assertRaises(ValueError):
NetCDFReporter(self.get_fn('blah', written=True), 1, crds=False)
with self.assertRaises(ValueError):
MdcrdReporter(self.get_fn('blah', written=True), 1, crds=False)
with self.assertRaises(ValueError):
MdcrdReporter(self.get_fn('blah', written=True),
1,
crds=True,
vels=True)
system = self.amber_gas.createSystem()
integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds,
1.0 * u.femtoseconds)
sim = app.Simulation(self.amber_gas.topology,
system,
integrator,
platform=CPU)
sim.context.setPositions(self.amber_gas.positions)
sim.reporters.extend([
NetCDFReporter(self.get_fn('traj1.nc', written=True), 10),
NetCDFReporter(self.get_fn('traj2.nc', written=True),
10,
vels=True),
NetCDFReporter(self.get_fn('traj3.nc', written=True),
10,
frcs=True),
NetCDFReporter(self.get_fn('traj4.nc', written=True),
10,
vels=True,
frcs=True),
NetCDFReporter(self.get_fn('traj5.nc', written=True),
10,
crds=False,
vels=True),
NetCDFReporter(self.get_fn('traj6.nc', written=True),
10,
crds=False,
frcs=True),
NetCDFReporter(self.get_fn('traj7.nc', written=True),
10,
crds=False,
vels=True,
frcs=True),
MdcrdReporter(self.get_fn('traj1.mdcrd', written=True), 10),
MdcrdReporter(self.get_fn('traj2.mdcrd', written=True),
10,
crds=False,
vels=True),
MdcrdReporter(self.get_fn('traj3.mdcrd', written=True),
10,
crds=False,
frcs=True),
RestartReporter(self.get_fn('restart.ncrst', written=True),
10,
write_multiple=True,
netcdf=True),
RestartReporter(self.get_fn('restart.rst7', written=True), 10),
])
sim.step(500)
for reporter in sim.reporters:
reporter.finalize()
self.assertEqual(len(os.listdir(self._temporary_directory.name)), 61)
ntraj = [
NetCDFTraj.open_old(self.get_fn('traj1.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj2.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj3.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj4.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj5.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj6.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj7.nc', written=True))
]
atraj = [
AmberMdcrd(self.get_fn('traj1.mdcrd', written=True),
self.amber_gas.ptr('natom'),
hasbox=False,
mode='r'),
AmberMdcrd(self.get_fn('traj2.mdcrd', written=True),
self.amber_gas.ptr('natom'),
hasbox=False,
mode='r'),
AmberMdcrd(self.get_fn('traj3.mdcrd', written=True),
self.amber_gas.ptr('natom'),
hasbox=False,
mode='r'),
]
for traj in ntraj:
self.assertEqual(traj.frame, 50)
self.assertEqual(traj.Conventions, 'AMBER')
self.assertEqual(traj.ConventionVersion, '1.0')
self.assertEqual(traj.application, 'AmberTools')
self.assertEqual(traj.program, 'ParmEd')
self.assertFalse(traj.hasbox)
self.assertTrue(ntraj[0].hascrds)
self.assertFalse(ntraj[0].hasvels)
self.assertFalse(ntraj[0].hasfrcs)
self.assertTrue(ntraj[1].hascrds)
self.assertTrue(ntraj[1].hasvels)
self.assertFalse(ntraj[1].hasfrcs)
self.assertTrue(ntraj[2].hascrds)
self.assertFalse(ntraj[2].hasvels)
self.assertTrue(ntraj[2].hasfrcs)
self.assertTrue(ntraj[3].hascrds)
self.assertTrue(ntraj[3].hasvels)
self.assertTrue(ntraj[3].hasfrcs)
self.assertFalse(ntraj[4].hascrds)
self.assertTrue(ntraj[4].hasvels)
self.assertFalse(ntraj[4].hasfrcs)
self.assertFalse(ntraj[5].hascrds)
self.assertFalse(ntraj[5].hasvels)
self.assertTrue(ntraj[5].hasfrcs)
self.assertFalse(ntraj[6].hascrds)
self.assertTrue(ntraj[6].hasvels)
self.assertTrue(ntraj[6].hasfrcs)
for i in (0, 2, 3, 4, 5, 6):
ntraj[i].close() # still need the 2nd
for traj in atraj:
traj.close()
# Now test the NetCDF restart files
fn = self.get_fn('restart.ncrst.%d', written=True)
for i, j in enumerate(range(10, 501, 10)):
ncrst = NetCDFRestart.open_old(fn % j)
self.assertEqual(ncrst.coordinates.shape, (1, 25, 3))
self.assertEqual(ncrst.velocities.shape, (1, 25, 3))
np.testing.assert_allclose(ncrst.coordinates[0],
ntraj[1].coordinates[i])
np.testing.assert_allclose(ncrst.velocities[0],
ntraj[1].velocities[i],
rtol=1e-6)
# Now test the ASCII restart file
f = AmberAsciiRestart(self.get_fn('restart.rst7', written=True), 'r')
# Compare to ncrst and make sure it's the same data
np.testing.assert_allclose(ncrst.coordinates, f.coordinates, atol=1e-3)
np.testing.assert_allclose(ncrst.velocities, f.velocities, rtol=1e-3)
# Make sure the EnergyMinimizerReporter does not fail
f = StringIO()
rep = EnergyMinimizerReporter(f)
rep.report(sim, frame=10)
rep.finalize()
@unittest.skipUnless(HAS_GROMACS, 'Cannot test without GROMACS')
def test_reporters_pbc(self):
""" Test NetCDF and ASCII restart and trajectory reporters (w/ PBC) """
systemsolv = load_file(self.get_fn('ildn.solv.top'),
xyz=self.get_fn('ildn.solv.gro'))
system = systemsolv.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=8 * u.angstroms)
integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds,
1.0 * u.femtoseconds)
sim = app.Simulation(systemsolv.topology, system, integrator, CPU)
sim.context.setPositions(systemsolv.positions)
sim.reporters.extend([
NetCDFReporter(self.get_fn('traj.nc', written=True),
1,
vels=True,
frcs=True),
MdcrdReporter(self.get_fn('traj.mdcrd', written=True), 1),
RestartReporter(self.get_fn('restart.ncrst', written=True),
1,
netcdf=True),
RestartReporter(self.get_fn('restart.rst7', written=True), 1),
StateDataReporter(self.get_fn('state.o', written=True),
1,
volume=True,
density=True,
systemMass=1)
])
sim.step(5)
for reporter in sim.reporters:
reporter.finalize()
ntraj = NetCDFTraj.open_old(self.get_fn('traj.nc', written=True))
atraj = AmberMdcrd(self.get_fn('traj.mdcrd', written=True),
len(systemsolv.atoms),
True,
mode='r')
nrst = NetCDFRestart.open_old(
self.get_fn('restart.ncrst', written=True))
arst = AmberAsciiRestart(self.get_fn('restart.rst7', written=True),
'r')
self.assertEqual(ntraj.frame, 5)
self.assertEqual(atraj.frame, 5)
self.assertTrue(ntraj.hasvels)
self.assertTrue(ntraj.hasfrcs)
for i in range(ntraj.frame):
for x1, x2 in zip(ntraj.box[i], atraj.box[i]):
self.assertAlmostEqual(x1, x2, places=3)
self.assertEqual(len(nrst.box), 6)
self.assertEqual(len(arst.box), 6)
# Make sure the EnergyMinimizerReporter does not fail
f = StringIO()
rep = EnergyMinimizerReporter(f, volume=True)
rep.report(sim)
rep.finalize()
def test_private_functions(self):
""" Tests private helper functions for OMM reporters """
self.assertEqual(_format_time(7200), (2, 'hr.'))
self.assertEqual(_format_time(3600), (60, 'min.'))
self.assertEqual(_format_time(40), (40, 'sec.'))
def main():
prmtop_filename = '/lustre/atlas/scratch/farkaspall/chm126/inspire-data/nilotinib/e255k/build/e255k-complex.top'
crd_filename = '/lustre/atlas/scratch/farkaspall/chm126/inspire-data/nilotinib/e255k/build/e255k-complex.inpcrd'
prmtop = AmberParm(prmtop_filename, crd_filename)
system = prmtop.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=10 * unit.angstrom,
constraints=app.HBonds,
switchDistance=8 * unit.angstrom)
temperature = 300 * unit.kelvin
pressure = 1 * unit.atmosphere
collision_rate = 5 / unit.picosecond
timestep = 2 * unit.femtosecond
integrator = openmm.LangevinIntegrator(temperature, collision_rate,
timestep)
barostat = openmm.MonteCarloBarostat(temperature, pressure)
system.addForce(barostat)
restrain = True
if restrain:
restrained_atoms = mdtraj.Topology.from_openmm(
prmtop.topology).select("protein and not type H").tolist()
K = 4.0 * unit.kilocalorie / (unit.angstrom**2 * unit.mole)
energy_expression = '(K/2)*periodicdistance(x, y, z, x0, y0, z0)^2'
restraint_force = openmm.CustomExternalForce(energy_expression)
restraint_force.addGlobalParameter('K', K)
restraint_force.addPerParticleParameter('x0')
restraint_force.addPerParticleParameter('y0')
restraint_force.addPerParticleParameter('z0')
for index in restrained_atoms:
parameters = prmtop.positions[index].value_in_unit_system(
unit.md_unit_system)
restraint_force.addParticle(index, parameters)
system.addForce(restraint_force)
system.setDefaultPeriodicBoxVectors(*prmtop.box_vectors)
simulation = app.Simulation(prmtop.topology, system, integrator)
simulation.context.setPositions(prmtop.positions)
simulation.context.setVelocitiesToTemperature(temperature)
print('System contains {} atoms.'.format(system.getNumParticles()))
print('Using platform "{}".'.format(
simulation.context.getPlatform().getName()))
print('Minimizing energy to avoid clashes.')
simulation.minimizeEnergy(maxIterations=100)
print('Initial potential energy is {}'.format(
simulation.context.getState(getEnergy=True).getPotentialEnergy()))
# Warm up the integrator to compile kernels, etc
print('Warming up integrator to trigger kernel compilation...')
simulation.step(10)
# Time integration
print('Time: {}'.format(time.strftime('%H:%M:%S')))
print('Benchmarking...')
nsteps = 20000
initial_time = time.time()
integrator.step(nsteps)
final_time = time.time()
elapsed_time = (final_time - initial_time) * unit.seconds
simulated_time = nsteps * timestep
performance = (simulated_time / elapsed_time)
print('Time: {}'.format(time.strftime('%H:%M:%S')))
print('Completed {} steps in {}.'.format(nsteps, elapsed_time))
print('Performance is {} ns/day'.format(performance /
(unit.nanoseconds / unit.day)))
print('Final potential energy is {}'.format(
simulation.context.getState(getEnergy=True).getPotentialEnergy()))
