def test_gb1_energy(self): # HCT (uses mbondi radii internally)
""" Compare OpenMM and CHARMM GB (igb=1) energies """
parm = charmm_gas
system = parm.createSystem(param22, implicitSolvent=app.HCT)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.3351, places=3)
self.assertAlmostEqual(energies['angle'], 14.1158, places=3)
self.assertAlmostEqual(energies['urey_bradley'], 0.3669, places=3)
self.assertAlmostEqual(energies['dihedral'], 14.2773, places=3)
self.assertAlmostEqual(energies['improper'], 0.3344, places=3)
self.assertAlmostEqual(energies['cmap'], -0.5239, places=3)
self.assertRelativeEqual(energies['nonbonded'], -102.1598379, places=5)
system = parm.createSystem(param22, implicitSolvent=app.HCT,
implicitSolventSaltConc=1.0*u.molar)
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.3351, places=3)
self.assertAlmostEqual(energies['angle'], 14.1158, places=3)
self.assertAlmostEqual(energies['urey_bradley'], 0.3669, places=3)
self.assertAlmostEqual(energies['dihedral'], 14.2773, places=3)
self.assertAlmostEqual(energies['improper'], 0.3344, places=3)
self.assertAlmostEqual(energies['cmap'], -0.5239, places=3)
self.assertRelativeEqual(energies['nonbonded'], -102.5012873, places=5)
def testGB1Energy(self): # HCT (uses mbondi radii internally)
""" Compare OpenMM and CHARMM GB (igb=1) energies """
parm = charmm_gas
system = parm.createSystem(param22, implicitSolvent=app.HCT)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.3351, places=3)
self.assertAlmostEqual(energies['angle'], 14.1158, places=3)
self.assertAlmostEqual(energies['urey_bradley'], 0.3669, places=3)
self.assertAlmostEqual(energies['dihedral'], 14.2773, places=3)
self.assertAlmostEqual(energies['improper'], 0.3344, places=3)
self.assertAlmostEqual(energies['cmap'], -0.5239, places=3)
self.assertRelativeEqual(energies['nonbonded'], -102.1598379, places=5)
system = parm.createSystem(param22, implicitSolvent=app.HCT,
implicitSolventSaltConc=1.0*u.molar)
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.3351, places=3)
self.assertAlmostEqual(energies['angle'], 14.1158, places=3)
self.assertAlmostEqual(energies['urey_bradley'], 0.3669, places=3)
self.assertAlmostEqual(energies['dihedral'], 14.2773, places=3)
self.assertAlmostEqual(energies['improper'], 0.3344, places=3)
self.assertAlmostEqual(energies['cmap'], -0.5239, places=3)
self.assertRelativeEqual(energies['nonbonded'], -102.5012873, places=5)
def test_round_trip(self):
""" Test ParmEd -> OpenMM round trip with Gromacs system """
# Use DPPC to get RB-torsions tested. Also check that it initially fails
# with the CustomNonbondedForce
top = load_file(os.path.join(get_fn('12.DPPC'), 'topol.top'),
xyz=os.path.join(get_fn('12.DPPC'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
system = top.createSystem()
def bad_system():
return openmm.load_topology(top.topology, system).createSystem()
self.assertTrue(
openmm.load_topology(top.topology, system).unknown_functional)
self.assertRaises(ParmedError, bad_system)
for i in range(len(system.getForces())):
if isinstance(system.getForce(i), mm.CustomNonbondedForce):
system.removeForce(i)
break
system2 = openmm.load_topology(top.topology, system).createSystem()
con1 = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
con2 = mm.Context(system2, mm.VerletIntegrator(0.001), CPU)
con1.setPositions(top.positions)
con2.setPositions(top.positions)
ene1 = energy_decomposition(top, con1)
ene2 = energy_decomposition(top, con2)
self.assertAlmostEqual(ene1['bond'], ene2['bond'])
self.assertAlmostEqual(ene1['angle'], ene2['angle'])
self.assertAlmostEqual(ene1['dihedral'], ene2['dihedral'])
self.assertAlmostEqual(ene1['improper'], ene2['improper'])
self.assertAlmostEqual(ene1['rb_torsion'], ene2['rb_torsion'])
self.assertAlmostEqual(ene1['nonbonded'], ene2['nonbonded'])
def test_round_trip(self):
""" Test ParmEd -> OpenMM round trip with Gromacs system """
# Use DPPC to get RB-torsions tested. Also check that it initially fails
# with the CustomNonbondedForce
warnings.filterwarnings('ignore', category=GromacsWarning)
top = load_file(os.path.join(get_fn('12.DPPC'), 'topol.top'),
xyz=os.path.join(get_fn('12.DPPC'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
system = top.createSystem()
def bad_system():
return openmm.load_topology(top.topology, system).createSystem()
warnings.filterwarnings('ignore', category=OpenMMWarning)
self.assertTrue(
openmm.load_topology(top.topology, system).unknown_functional
)
self.assertRaises(ParmedError, bad_system)
for i in range(len(system.getForces())):
if isinstance(system.getForce(i), mm.CustomNonbondedForce):
system.removeForce(i)
break
system2 = openmm.load_topology(top.topology, system).createSystem()
con1 = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
con2 = mm.Context(system2, mm.VerletIntegrator(0.001), CPU)
con1.setPositions(top.positions)
con2.setPositions(top.positions)
ene1 = energy_decomposition(top, con1)
ene2 = energy_decomposition(top, con2)
self.assertAlmostEqual(ene1['bond'], ene2['bond'])
self.assertAlmostEqual(ene1['angle'], ene2['angle'])
self.assertAlmostEqual(ene1['dihedral'], ene2['dihedral'])
self.assertAlmostEqual(ene1['improper'], ene2['improper'])
self.assertAlmostEqual(ene1['rb_torsion'], ene2['rb_torsion'])
self.assertAlmostEqual(ene1['nonbonded'], ene2['nonbonded'])
def test_jac(self):
""" Tests the JAC benchmark Gromacs system nrg and force (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('07.DHFR-Liquid-NoPBC'),
'topol.top'),
xyz=os.path.join(get_fn('07.DHFR-Liquid-NoPBC'),
'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 35.142565, places=3)
self.assertAlmostEqual(energies['angle'], 3735.514669, places=3)
self.assertAlmostEqual(energies['dihedral'], 7277.741635, delta=0.002)
self.assertRelativeEqual(energies['nonbonded'],
-288718.981405,
places=4)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('07.DHFR-Liquid-NoPBC'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole / u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.5)
def test_dppc(self):
""" Tests non-standard Gromacs force fields and nonbonded exceptions """
# We know what we're doing
warnings.filterwarnings('ignore', category=GromacsWarning)
top = load_file(os.path.join(get_fn('12.DPPC'), 'topol.top'),
xyz=os.path.join(get_fn('12.DPPC'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers.
self.assertAlmostEqual(energies['bond'], 0)
self.assertAlmostEqual(energies['angle'], 1405.7354199, places=4)
self.assertAlmostEqual(energies['dihedral'], 236.932663255, places=4)
self.assertAlmostEqual(energies['improper'], 33.201541811, places=4)
self.assertAlmostEqual(energies['rb_torsion'], 428.0550599, places=4)
self.assertRelativeEqual(energies['nonbonded'], -16432.8092955, places=4)
gmxfrc = get_forces_from_xvg(os.path.join(get_fn('12.DPPC'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole/u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 5)
def test_small_double_peptide(self):
""" Test interacting peptides Gromacs system nrg and frc (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('03.AlaGlu'), 'topol.top'),
xyz=os.path.join(get_fn('03.AlaGlu'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 1.5307999, places=4)
self.assertAlmostEqual(energies['angle'], 6.5804488, places=4)
self.assertAlmostEqual(energies['dihedral'], 80.379714, places=4)
self.assertAlmostEqual(energies['nonbonded'], -275.142487, places=3)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('03.AlaGlu'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole / u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.05)
def test_jac_pme(self):
""" Tests the JAC benchmark Gromacs system nrg and force (PME) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('09.DHFR-PME'), 'topol.top'),
xyz=os.path.join(get_fn('09.DHFR-PME'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem(nonbondedMethod=app.PME,
constraints=app.HBonds,
nonbondedCutoff=0.9*u.nanometers,
ewaldErrorTolerance=1.0e-5)
context = mm.Context(system, mm.VerletIntegrator(0.001), Reference)
context.setPositions(top.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 1628.54739, places=3)
self.assertAlmostEqual(energies['angle'], 3604.58751, places=3)
self.assertAlmostEqual(energies['dihedral'], 6490.00844, delta=0.002)
self.assertRelativeEqual(energies['nonbonded'], 23616.457584, delta=0.002)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('09.DHFR-PME'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole/u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 5)
def test_jac(self):
""" Tests the JAC benchmark Gromacs system nrg and force (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('07.DHFR-Liquid-NoPBC'), 'topol.top'),
xyz=os.path.join(get_fn('07.DHFR-Liquid-NoPBC'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 35.142565, places=3)
self.assertAlmostEqual(energies['angle'], 3735.514669, places=3)
self.assertAlmostEqual(energies['dihedral'], 7277.741635, delta=0.002)
self.assertRelativeEqual(energies['nonbonded'], -288718.981405, places=4)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('07.DHFR-Liquid-NoPBC'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole/u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.5)
def test_small_double_peptide(self):
""" Test interacting peptides Gromacs system nrg and frc (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('03.AlaGlu'), 'topol.top'),
xyz=os.path.join(get_fn('03.AlaGlu'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 1.5307999, places=4)
self.assertAlmostEqual(energies['angle'], 6.5804488, places=4)
self.assertAlmostEqual(energies['dihedral'], 80.379714, places=4)
self.assertAlmostEqual(energies['nonbonded'], -275.142487, places=3)
gmxfrc = get_forces_from_xvg(os.path.join(get_fn('03.AlaGlu'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole/u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.05)
def test_dispersion_correction(self):
""" Compare OpenMM and CHARMM PME energies w/out vdW correction """
parm = charmm_nbfix
system = parm.createSystem(
param36,
nonbondedMethod=app.PME,
nonbondedCutoff=8 * u.angstroms,
)
self.assertEqual(parm.combining_rule, 'lorentz')
for force in system.getForces():
if isinstance(force, mm.NonbondedForce):
force.setUseDispersionCorrection(False)
elif isinstance(force, mm.CustomNonbondedForce):
force.setUseLongRangeCorrection(False)
integrator = mm.VerletIntegrator(1.0 * u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_nbfix_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.1324212, places=4)
self.assertAlmostEqual(energies['angle'], 1.06880188, places=4)
self.assertAlmostEqual(energies['urey_bradley'], 0.06142407, places=4)
self.assertAlmostEqual(energies['dihedral'], 7.81143025, places=4)
self.assertAlmostEqual(energies['improper'], 0, places=4)
self.assertAlmostEqual(energies['cmap'], 0.126790, places=4)
self.assertRelativeEqual(energies['nonbonded'],
6584.01821319,
places=4)
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 test_jac_pme(self):
""" Tests the JAC benchmark Gromacs system nrg and force (PME) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('09.DHFR-PME'), 'topol.top'),
xyz=os.path.join(get_fn('09.DHFR-PME'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem(nonbondedMethod=app.PME,
constraints=app.HBonds,
nonbondedCutoff=0.9 * u.nanometers,
ewaldErrorTolerance=1.0e-5)
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 1628.54739, places=3)
self.assertAlmostEqual(energies['angle'], 3604.58751, places=3)
self.assertAlmostEqual(energies['dihedral'], 6490.00844, delta=0.002)
self.assertRelativeEqual(energies['nonbonded'],
23616.457584,
delta=0.002)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('09.DHFR-PME'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole / u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 5)
def test_pme_switch(self):
""" Tests the DHFR Gromacs system nrg and force (PME w/ switch) """
# Load the top and gro files
top = load_file(get_fn('ildn.solv.top'), xyz=get_fn('ildn.solv.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem(nonbondedMethod=app.PME,
constraints=app.HBonds,
flexibleConstraints=True,
nonbondedCutoff=0.9 * u.nanometers,
ewaldErrorTolerance=1.0e-5,
switchDistance=0.7 * u.nanometers)
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 399.925189, places=4)
self.assertAlmostEqual(energies['angle'], 36.18562, places=4)
self.assertAlmostEqual(energies['dihedral'], 101.92265, places=4)
self.assertRelativeEqual(energies['nonbonded'], -18587.09715, places=4)
def test_dppc(self):
""" Tests non-standard Gromacs force fields and nonbonded exceptions """
# We know what we're doing
top = load_file(os.path.join(get_fn('12.DPPC'), 'topol.top'),
xyz=os.path.join(get_fn('12.DPPC'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers.
self.assertAlmostEqual(energies['bond'], 0)
self.assertAlmostEqual(energies['angle'], 1405.7354199, places=4)
self.assertAlmostEqual(energies['dihedral'], 236.932663255, places=4)
self.assertAlmostEqual(energies['improper'], 33.201541811, places=4)
self.assertAlmostEqual(energies['rb_torsion'], 428.0550599, places=4)
self.assertRelativeEqual(energies['nonbonded'],
-16432.8092955,
places=4)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('12.DPPC'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole / u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 5)
def test_very_small(self):
""" Test very small Gromacs system nrg and frc (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('02.6water'), 'topol.top'),
xyz=os.path.join(get_fn('02.6water'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# create the system and context, then calculate the energy decomposition
system = top.createSystem(constraints=app.HBonds,
rigidWater=True,
flexibleConstraints=True)
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 0, places=4)
self.assertAlmostEqual(energies['nonbonded'], -108.277803, places=3)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('02.6water'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole / u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.05)
def test_opls(self):
""" Tests geometric combining rules with OPLS/AA in Gromacs topology """
top = load_file(os.path.join(get_fn('05.OPLS'), 'topol.top'),
xyz=os.path.join(get_fn('05.OPLS'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'geometric')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Compare with Gromacs energies
self.assertAlmostEqual(energies['bond'], 332.178260935, places=4)
self.assertAlmostEqual(energies['angle'], 29.2231806883, places=4)
self.assertAlmostEqual(energies['dihedral'], 0.0057758656, places=4)
self.assertAlmostEqual(energies['rb_torsion'], 55.603030624, places=4)
self.assertRelativeEqual(energies['nonbonded'],
327.954397827,
places=4)
# Now make sure it can be set with PME
system = top.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=8 * u.angstroms)
n = 0
for force in system.getForces():
if isinstance(force, mm.NonbondedForce):
self.assertAlmostEqualQuantities(force.getCutoffDistance(),
8 * u.angstroms)
self.assertEqual(force.getNonbondedMethod(), force.PME)
n += 1
elif isinstance(force, mm.CustomNonbondedForce):
self.assertAlmostEqualQuantities(force.getCutoffDistance(),
8 * u.angstroms)
self.assertEqual(force.getNonbondedMethod(),
force.CutoffPeriodic)
n += 1
self.assertEqual(n, 2)
# Now try with non-periodic cutoff
system = top.createSystem(nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=16 * u.angstroms,
switchDistance=14 * u.angstroms)
n = 0
for force in system.getForces():
if isinstance(force, mm.NonbondedForce) or isinstance(
force, mm.CustomNonbondedForce):
self.assertAlmostEqualQuantities(force.getCutoffDistance(),
16 * u.angstroms)
self.assertEqual(force.getNonbondedMethod(),
force.CutoffNonPeriodic)
self.assertTrue(force.getUseSwitchingFunction())
self.assertAlmostEqualQuantities(force.getSwitchingDistance(),
14 * u.angstroms)
n += 1
self.assertEqual(n, 2)
def test_round_trip(self):
""" Test ParmEd -> OpenMM round trip with CHARMM gas phase """
parm = charmm_gas
system = parm.createSystem(param22)
self.assertEqual(parm.combining_rule, 'lorentz')
system2 = openmm.load_topology(parm.topology, system).createSystem()
con1 = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
con2 = mm.Context(system2, mm.VerletIntegrator(0.001), CPU)
con1.setPositions(charmm_gas_crds.positions)
con2.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, con1)
energies2 = energy_decomposition(parm, con2)
self.assertAlmostEqual(energies['bond'], energies2['bond'])
self.assertAlmostEqual(energies['angle'], energies2['angle'])
self.assertAlmostEqual(energies['urey_bradley'], energies2['urey_bradley'])
self.assertAlmostEqual(energies['dihedral'], energies2['dihedral'])
self.assertAlmostEqual(energies['improper'], energies2['improper'])
self.assertAlmostEqual(energies['cmap'], energies2['cmap'])
self.assertRelativeEqual(energies['nonbonded'], energies2['nonbonded'])
def testRoundTrip(self):
""" Test ParmEd -> OpenMM round trip with CHARMM gas phase """
parm = charmm_gas
system = parm.createSystem(param22)
self.assertEqual(parm.combining_rule, 'lorentz')
system2 = openmm.load_topology(parm.topology, system).createSystem()
con1 = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
con2 = mm.Context(system2, mm.VerletIntegrator(0.001), CPU)
con1.setPositions(charmm_gas_crds.positions)
con2.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, con1)
energies2 = energy_decomposition(parm, con2)
self.assertAlmostEqual(energies['bond'], energies2['bond'])
self.assertAlmostEqual(energies['angle'], energies2['angle'])
self.assertAlmostEqual(energies['urey_bradley'], energies2['urey_bradley'])
self.assertAlmostEqual(energies['dihedral'], energies2['dihedral'])
self.assertAlmostEqual(energies['improper'], energies2['improper'])
self.assertAlmostEqual(energies['cmap'], energies2['cmap'])
self.assertRelativeEqual(energies['nonbonded'], energies2['nonbonded'])
def test_opls(self):
""" Tests geometric combining rules with OPLS/AA in Gromacs topology """
top = load_file(os.path.join(get_fn('05.OPLS'), 'topol.top'),
xyz=os.path.join(get_fn('05.OPLS'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'geometric')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Gromacs energies
self.assertAlmostEqual(energies['bond'], 332.178260935, places=4)
self.assertAlmostEqual(energies['angle'], 29.2231806883, places=4)
self.assertAlmostEqual(energies['dihedral'], 0.0057758656, places=4)
self.assertAlmostEqual(energies['rb_torsion'], 55.603030624, places=4)
self.assertRelativeEqual(energies['nonbonded'], 327.954397827, places=4)
# Now make sure it can be set with PME
system = top.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=8*u.angstroms)
n = 0
for force in system.getForces():
if isinstance(force, mm.NonbondedForce):
self.assertAlmostEqualQuantities(force.getCutoffDistance(),
8*u.angstroms)
self.assertEqual(force.getNonbondedMethod(), force.PME)
n += 1
elif isinstance(force, mm.CustomNonbondedForce):
self.assertAlmostEqualQuantities(force.getCutoffDistance(),
8*u.angstroms)
self.assertEqual(force.getNonbondedMethod(), force.CutoffPeriodic)
n += 1
self.assertEqual(n, 2)
# Now try with non-periodic cutoff
system = top.createSystem(nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=16*u.angstroms,
switchDistance=14*u.angstroms)
n = 0
for force in system.getForces():
if isinstance(force, mm.NonbondedForce) or isinstance(force,
mm.CustomNonbondedForce):
self.assertAlmostEqualQuantities(force.getCutoffDistance(),
16*u.angstroms)
self.assertEqual(force.getNonbondedMethod(), force.CutoffNonPeriodic)
self.assertTrue(force.getUseSwitchingFunction())
self.assertAlmostEqualQuantities(force.getSwitchingDistance(),
14*u.angstroms)
n += 1
self.assertEqual(n, 2)
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 testGasEnergy(self):
""" Compare OpenMM and CHARMM gas phase energies """
parm = charmm_gas
system = parm.createSystem(param22)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.3351, places=4)
self.assertAlmostEqual(energies['angle'], 14.1158, places=4)
self.assertAlmostEqual(energies['urey_bradley'], 0.3669, places=4)
self.assertAlmostEqual(energies['dihedral'], 14.2773, places=4)
self.assertAlmostEqual(energies['improper'], 0.3344, places=4)
self.assertAlmostEqual(energies['cmap'], -0.5239, places=4)
self.assertRelativeEqual(energies['nonbonded'], 9.2210, places=4)
def test_gas_energy(self):
""" Compare OpenMM and CHARMM gas phase energies """
parm = charmm_gas
system = parm.createSystem(param22)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.3351, places=4)
self.assertAlmostEqual(energies['angle'], 14.1158, places=4)
self.assertAlmostEqual(energies['urey_bradley'], 0.3669, places=4)
self.assertAlmostEqual(energies['dihedral'], 14.2773, places=4)
self.assertAlmostEqual(energies['improper'], 0.3344, places=4)
self.assertAlmostEqual(energies['cmap'], -0.5239, places=4)
self.assertRelativeEqual(energies['nonbonded'], 9.2210, places=4)
def testPME(self):
""" Compare OpenMM and CHARMM PME energies """
parm = charmm_solv
system = parm.createSystem(param22, nonbondedMethod=app.PME,
nonbondedCutoff=8*u.angstrom)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=Reference)
sim.context.setPositions(charmm_solv_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertRelativeEqual(energies['bond'], 8578.9872739, places=5)
self.assertRelativeEqual(energies['angle'], 5018.3206306, places=5)
self.assertRelativeEqual(energies['urey_bradley'], 29.6489539, places=5)
self.assertRelativeEqual(energies['dihedral'], 740.9486106, places=5)
self.assertRelativeEqual(energies['improper'], 14.2418054, places=5)
self.assertRelativeEqual(energies['cmap'], -216.1422183, places=5)
self.assertRelativeEqual(energies['nonbonded'], -242262.368372, places=5)
def test_nbfix(self):
""" Test PME energies of systems with NBFIX modifications """
parm = charmm_nbfix
system = parm.createSystem(param36, nonbondedMethod=app.PME,
nonbondedCutoff=8*u.angstroms)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=Reference)
sim.context.setPositions(charmm_nbfix_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.1324212, places=4)
self.assertAlmostEqual(energies['angle'], 1.06880188, places=4)
self.assertAlmostEqual(energies['urey_bradley'], 0.06142407, places=4)
self.assertAlmostEqual(energies['dihedral'], 7.81143025, places=4)
self.assertAlmostEqual(energies['improper'], 0, places=4)
self.assertAlmostEqual(energies['cmap'], 0.126790, places=4)
self.assertRelativeEqual(energies['nonbonded'], 6514.283116, places=4)
def testNBFIX(self):
""" Test PME energies of systems with NBFIX modifications """
parm = charmm_nbfix
system = parm.createSystem(param36, nonbondedMethod=app.PME,
nonbondedCutoff=8*u.angstroms)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=Reference)
sim.context.setPositions(charmm_nbfix_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.1324212, places=4)
self.assertAlmostEqual(energies['angle'], 1.06880188, places=4)
self.assertAlmostEqual(energies['urey_bradley'], 0.06142407, places=4)
self.assertAlmostEqual(energies['dihedral'], 7.81143025, places=4)
self.assertAlmostEqual(energies['improper'], 0, places=4)
self.assertAlmostEqual(energies['cmap'], 0.126790, places=4)
self.assertRelativeEqual(energies['nonbonded'], 6514.283116, places=4)
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 testOPLS(self):
""" Tests geometric combining rules with OPLS/AA in Gromacs topology """
top = load_file(os.path.join(get_fn('05.OPLS'), 'topol.top'),
xyz=os.path.join(get_fn('05.OPLS'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'geometric')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Gromacs energies
self.assertAlmostEqual(energies['bond'], 332.178260935, places=4)
self.assertAlmostEqual(energies['angle'], 29.2231806883, places=4)
self.assertAlmostEqual(energies['dihedral'], 0.0057758656, places=4)
self.assertAlmostEqual(energies['rb_torsion'], 55.603030624, places=4)
self.assertRelativeEqual(energies['nonbonded'], 327.954397827, places=4)
def testDispersionCorrection(self):
""" Compare OpenMM and CHARMM PME energies w/out vdW correction """
parm = charmm_solv
system = parm.createSystem(param22, nonbondedMethod=app.PME,
nonbondedCutoff=8*u.angstroms,)
self.assertEqual(parm.combining_rule, 'lorentz')
for force in system.getForces():
if isinstance(force, mm.NonbondedForce):
force.setUseDispersionCorrection(False)
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=Reference)
sim.context.setPositions(charmm_solv_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertRelativeEqual(energies['bond'], 8578.9872739, places=5)
self.assertRelativeEqual(energies['angle'], 5018.3206306, places=5)
self.assertRelativeEqual(energies['urey_bradley'], 29.6489539, places=5)
self.assertRelativeEqual(energies['dihedral'], 740.9486106, places=5)
self.assertRelativeEqual(energies['improper'], 14.2418054, places=5)
self.assertRelativeEqual(energies['cmap'], -216.1422183, places=5)
self.assertRelativeEqual(energies['nonbonded'], -240681.958902, places=5)
def testTiny(self):
""" Test tiny Gromacs system nrg and frc (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('01.1water'), 'topol.top'))
gro = load_file(os.path.join(get_fn('01.1water'), 'conf.gro'))
# create the system and context, then calculate the energy decomposition
system = top.createSystem(constraints=app.HBonds, rigidWater=True)
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(gro.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Make sure they match Lee-Ping's answers (both energies and forces)
self.assertAlmostEqual(energies['bond'], 1.63805, places=4)
self.assertAlmostEqual(energies['angle'], 0.014803, places=4)
gmxfrc = get_forces_from_xvg(os.path.join(get_fn('01.1water'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole/u.nanometer)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.01)
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 testDispersionCorrection(self):
""" Compare OpenMM and CHARMM PME energies w/out vdW correction """
parm = charmm_nbfix
system = parm.createSystem(param36, nonbondedMethod=app.PME,
nonbondedCutoff=8*u.angstroms,)
self.assertEqual(parm.combining_rule, 'lorentz')
for force in system.getForces():
if isinstance(force, mm.NonbondedForce):
force.setUseDispersionCorrection(False)
elif isinstance(force, mm.CustomNonbondedForce):
force.setUseLongRangeCorrection(False)
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=Reference)
sim.context.setPositions(charmm_nbfix_crds.positions)
energies = energy_decomposition(parm, sim.context)
self.assertAlmostEqual(energies['bond'], 1.1324212, places=4)
self.assertAlmostEqual(energies['angle'], 1.06880188, places=4)
self.assertAlmostEqual(energies['urey_bradley'], 0.06142407, places=4)
self.assertAlmostEqual(energies['dihedral'], 7.81143025, places=4)
self.assertAlmostEqual(energies['improper'], 0, places=4)
self.assertAlmostEqual(energies['cmap'], 0.126790, places=4)
self.assertRelativeEqual(energies['nonbonded'], 6584.01821319, places=4)
def testSmallPeptide(self):
""" Test alanine dipeptide Gromacs system nrg and frc (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('04.Ala'), 'topol.top'))
gro = load_file(os.path.join(get_fn('04.Ala'), 'conf.gro'))
# create the system and context, then calculate the energy decomposition
system = top.createSystem()
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(gro.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 116.61637407, places=3)
self.assertAlmostEqual(energies['angle'], 3.00686419356, places=4)
self.assertAlmostEqual(energies['dihedral'], 46.2010926096, places=4)
self.assertAlmostEqual(energies['nonbonded'], -103.924745659, places=3)
gmxfrc = get_forces_from_xvg(os.path.join(get_fn('04.Ala'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole/u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.05)
def testVerySmall(self):
""" Test very small Gromacs system nrg and frc (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('02.6water'), 'topol.top'))
gro = load_file(os.path.join(get_fn('02.6water'), 'conf.gro'))
# create the system and context, then calculate the energy decomposition
system = top.createSystem(constraints=app.HBonds, rigidWater=True,
flexibleConstraints=True)
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(gro.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 0, places=4)
self.assertAlmostEqual(energies['nonbonded'], -108.277803, places=3)
gmxfrc = get_forces_from_xvg(os.path.join(get_fn('02.6water'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole/u.nanometer)
zero_ep_frc(ommfrc, top)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.05)
def test_pme_switch(self):
""" Tests the DHFR Gromacs system nrg and force (PME w/ switch) """
# Load the top and gro files
top = load_file(get_fn('ildn.solv.top'), xyz=get_fn('ildn.solv.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# Create the system and context, then calculate the energy decomposition
system = top.createSystem(nonbondedMethod=app.PME,
constraints=app.HBonds,
flexibleConstraints=True,
nonbondedCutoff=0.9*u.nanometers,
ewaldErrorTolerance=1.0e-5,
switchDistance=0.7*u.nanometers)
context = mm.Context(system, mm.VerletIntegrator(0.001), Reference)
context.setPositions(top.positions)
energies = energy_decomposition(top, context, nrg=u.kilojoules_per_mole)
# Compare with Lee-Ping's answers. Make sure we zero-out forces for
# virtual sites, since OMM doesn't do this and Gromacs does.
self.assertAlmostEqual(energies['bond'], 399.925189, places=4)
self.assertAlmostEqual(energies['angle'], 36.18562, places=4)
self.assertAlmostEqual(energies['dihedral'], 101.92265, places=4)
self.assertRelativeEqual(energies['nonbonded'], -18587.09715, places=4)
def test_tiny(self):
""" Test tiny Gromacs system nrg and frc (no PBC) """
# Load the top and gro files
top = load_file(os.path.join(get_fn('01.1water'), 'topol.top'),
xyz=os.path.join(get_fn('01.1water'), 'conf.gro'))
self.assertEqual(top.combining_rule, 'lorentz')
# create the system and context, then calculate the energy decomposition
system = top.createSystem(constraints=app.HBonds, rigidWater=True)
context = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
context.setPositions(top.positions)
energies = energy_decomposition(top,
context,
nrg=u.kilojoules_per_mole)
# Make sure they match Lee-Ping's answers (both energies and forces)
self.assertAlmostEqual(energies['bond'], 1.63805, places=4)
self.assertAlmostEqual(energies['angle'], 0.014803, places=4)
gmxfrc = get_forces_from_xvg(
os.path.join(get_fn('01.1water'), 'force.xvg'))
ommfrc = context.getState(getForces=True).getForces().value_in_unit(
u.kilojoules_per_mole / u.nanometer)
max_diff = get_max_diff(gmxfrc, ommfrc)
self.assertLess(max_diff, 0.01)
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 energy_decomposition(parm, context):
from parmed.openmm.utils import energy_decomposition
ret = defaultdict(float)
for key, val in energy_decomposition(parm, context).items():
ret[key] = val
return ret
def energy_decomposition(parm, context):
from parmed.openmm.utils import energy_decomposition
ret = defaultdict(float)
for key, val in energy_decomposition(parm, context).items():
ret[key] = val
return ret
