def test_energy_complicated(self):
""" Check equal energies for Gmx -> Amber conversion of complex FF """
top = load_file(self.get_fn(os.path.join('12.DPPC', 'topol2.top')))
gro = load_file(self.get_fn(os.path.join('12.DPPC', 'conf.gro')))
parm = amber.AmberParm.from_structure(top)
parm.write_parm(self.get_fn('dppc.parm7', written=True))
parm = load_file(self.get_fn('dppc.parm7', written=True))
sysg = top.createSystem()
sysa = parm.createSystem()
cong = mm.Context(sysg, mm.VerletIntegrator(0.001), CPU)
cona = mm.Context(sysa, mm.VerletIntegrator(0.001), CPU)
cong.setPositions(gro.positions)
cona.setPositions(gro.positions)
self.check_energies(top, cong, parm, cona)
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 test_rb_torsion_conversion3(self):
""" Check equal energies for Gromacs -> Amber conversion of Amber FF """
top = get_fn('2PPN_bulk.top')
gro = get_fn('2PPN_bulk.gro')
top = load_file(top, xyz=gro)
parm = amber.AmberParm.from_structure(top)
parm.save(get_fn('2PPN_bulk.prmtop', written=True))
parm.save(get_fn('2PPN_bulk.rst7', written=True))
sysg = top.createSystem()
sysa = parm.createSystem()
cong = mm.Context(sysg, mm.VerletIntegrator(0.001), CPU)
cona = mm.Context(sysa, mm.VerletIntegrator(0.001), CPU)
cong.setPositions(top.positions)
cona.setPositions(top.positions)
self.check_energies(top, cong, parm, cona)
def test_rb_torsion_conversion2(self):
""" Check equal energies for Gromacs -> Amber conversion of Amber FF """
top = self.get_fn(os.path.join('05.OPLS', 'topol.top'))
gro = self.get_fn(os.path.join('05.OPLS', 'conf.gro'))
top = load_file(top, xyz=gro)
parm = amber.AmberParm.from_structure(top)
parm.save(self.get_fn('05opls.prmtop', written=True))
parm.save(self.get_fn('05opls.rst7', written=True))
sysg = top.createSystem()
sysa = parm.createSystem()
cong = mm.Context(sysg, mm.VerletIntegrator(0.001), CPU)
cona = mm.Context(sysa, mm.VerletIntegrator(0.001), CPU)
cong.setPositions(top.positions)
cona.setPositions(top.positions)
self.check_energies(top, cong, parm, cona)
def test_chamber_energies(self):
""" Tests converting Gromacs to Chamber parm calculated energies """
# Now let's modify an exception parameter so that it needs type
# expansion, and ensure that it is handled correctly
top = load_file(get_fn('1aki.charmm27.solv.top'),
xyz=get_fn('1aki.charmm27.solv.gro'))
gsystem = top.createSystem(nonbondedCutoff=8 * u.angstroms,
nonbondedMethod=app.PME)
gcon = mm.Context(gsystem, mm.VerletIntegrator(1 * u.femtosecond), CPU)
gcon.setPositions(top.positions)
eg = gcon.getState(getEnergy=True).getPotentialEnergy()
eg = eg.value_in_unit(u.kilocalories_per_mole)
# Convert to chamber now
parm = amber.ChamberParm.from_structure(top)
asystem = parm.createSystem(nonbondedCutoff=8 * u.angstroms,
nonbondedMethod=app.PME)
acon = mm.Context(asystem, mm.VerletIntegrator(1 * u.femtosecond), CPU)
acon.setPositions(top.positions)
ea = acon.getState(getEnergy=True).getPotentialEnergy()
ea = ea.value_in_unit(u.kilocalories_per_mole)
self.assertLess(abs(eg - ea), 1e-2)
def test_write_xml_parameters_methanol_ions_energy(self):
""" Test writing XML parameter files from Charmm parameter files, reading them back into OpenMM ForceField, and computing energy of methanol and NaCl """
params = openmm.OpenMMParameterSet.from_parameterset(
pmd.charmm.CharmmParameterSet(
get_fn('par_all36_cgenff.prm'), get_fn('top_all36_cgenff.rtf'),
get_fn('toppar_water_ions.str'
)) # WARNING: contains duplicate water templates
)
del params.residues[
'TP3M'] # Delete to avoid duplicate water template topologies
ffxml_filename = get_fn('charmm_conv.xml', written=True)
params.write(
ffxml_filename,
provenance=dict(
OriginalFile=
'par_all36_cgenff.prm, top_all36_cgenff.rtf, toppar_water_ions.str',
Reference='MacKerrell'))
forcefield = app.ForceField(ffxml_filename)
# Parameterize methanol and ions in vacuum
pdbfile = app.PDBFile(get_fn('methanol_ions.pdb'))
system = forcefield.createSystem(pdbfile.topology,
nonbondedMethod=app.NoCutoff)
integrator = mm.VerletIntegrator(1.0 * u.femtoseconds)
context = mm.Context(system, integrator, CPU)
context.setPositions(pdbfile.positions)
ffxml_potential = context.getState(
getEnergy=True).getPotentialEnergy() / u.kilocalories_per_mole
del context, integrator
# Compute energy via ParmEd reader
psf = CharmmPsfFile(get_fn('methanol_ions.psf'))
system = psf.createSystem(params)
integrator = mm.VerletIntegrator(1.0 * u.femtoseconds)
context = mm.Context(system, integrator, CPU)
context.setPositions(pdbfile.positions)
parmed_potential = context.getState(
getEnergy=True).getPotentialEnergy() / u.kilocalories_per_mole
del context, integrator
# Ensure potentials are almost equal
self.assertAlmostEqual(ffxml_potential, parmed_potential)
def test_load_topology_use_atom_id_as_typename(self):
""" Tests loading an OpenMM Topology and using Atom.id to name types """
ommparm = load_file(get_fn('ash.parm7'), get_fn('ash.rst7'))
parm = load_file(get_fn('ash.parm7'), get_fn('ash.rst7'))
system = ommparm.createSystem(implicitSolvent=app.OBC1)
for pmd_atom, omm_atom in zip(parm.atoms, ommparm.topology.atoms()):
omm_atom.id = pmd_atom.type
structure = openmm.load_topology(ommparm.topology, system,
xyz=parm.positions)
self.assertEqual(len(parm.atoms), len(structure.atoms))
self.assertEqual([a.type for a in parm.atoms],
[a.type for a in structure.atoms])
self.assertEqual(len(parm.residues), len(structure.residues))
self.assertEqual(len(parm.bonds), len(structure.bonds))
con1 = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
con2 = mm.Context(system, mm.VerletIntegrator(0.001), CPU)
con1.setPositions(parm.positions)
con2.setPositions(structure.positions)
self.check_energies(parm, con1, structure, con2)
def test_unconvertable_rb_torsion(self):
""" Check equal energies for Gromacs -> Amber conversion of Amber FF """
top = get_fn(os.path.join('gmxtops', 'unconvertable_rb_torsion.top'))
gro = get_fn(os.path.join('gmxtops', 'rb_torsions.gro'))
top = load_file(top, xyz=gro)
# 4 types are defined but parmed adds entries to the dict for each
# ordering of the bondingtypes and one dihedral is symmetric
assert len(top.parameterset.rb_torsion_types) == 7
parm = amber.AmberParm.from_structure(top)
parm.save(get_fn('rb_torsions.prmtop', written=True))
parm.save(get_fn('rb_torsions.rst7', written=True))
sysg = top.createSystem()
sysa = parm.createSystem()
cong = mm.Context(sysg, mm.VerletIntegrator(0.001), CPU)
cona = mm.Context(sysa, mm.VerletIntegrator(0.001), CPU)
cong.setPositions(top.positions)
cona.setPositions(top.positions)
self.check_energies(top, cong, parm, cona)
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)
