Example #1
0
 def _load_improper_info(self):
     """ Loads the CHARMM Improper types and array """
     del self.impropers[:]
     del self.improper_types[:]
     for k, eq in zip(self.parm_data['CHARMM_IMPROPER_FORCE_CONSTANT'],
                      self.parm_data['CHARMM_IMPROPER_PHASE']):
         # Previous versions of ParmEd stored improper phases as degrees,
         # whereas it should really be stored in radians. So do a simple
         # heuristic check to see if a conversion is necessary so we support
         # all versions.
         eq = eq * RAD_TO_DEG if abs(eq) <= 2 * pi else eq
         self.improper_types.append(ImproperType(k, eq,
                                                 self.improper_types))
     it = iter(self.parm_data['CHARMM_IMPROPERS'])
     for i, j, k, l, m in zip(it, it, it, it, it):
         self.impropers.append(
             Improper(self.atoms[i - 1], self.atoms[j - 1],
                      self.atoms[k - 1], self.atoms[l - 1],
                      self.improper_types[m - 1]))
     # Make sure that if we have a comment in the CHARMM impropers, we fix it
     # to say the units are in radians
     for i in range(len(self.parm_comments.get('CHARMM_IMPROPER_PHASE',
                                               []))):
         comment = self.parm_comments['CHARMM_IMPROPER_PHASE'][i]
         if 'degrees' in comment:
             self.parm_comments['CHARMM_IMPROPER_PHASE'][i] = \
                     comment.replace('degrees', 'radians')
Example #2
0
 def _compareInputOutputPDBs(self, pdbfile, pdbfile2, reordered=False,
                             altloc_option='all'):
     # Now go through all atoms and compare their attributes
     for a1, a2 in zip(pdbfile.atoms, pdbfile2.atoms):
         if altloc_option in ('first', 'all'):
             self.assertEqual(a1.occupancy, a2.occupancy)
             a1idx = a1.idx
         elif altloc_option == 'occupancy':
             a, occ = a1, a1.occupancy
             for key, oa in iteritems(a1.other_locations):
                 if oa.occupancy > occ:
                     occ = oa.occupancy
                     a = oa
             a1idx = a1.idx
             a1 = a # This is the atom we want to compare with
         self.assertEqual(a1.atomic_number, a2.atomic_number)
         self.assertEqual(a1.name, a2.name)
         self.assertEqual(a1.type, a2.type)
         self.assertEqual(a1.mass, a2.mass)
         self.assertEqual(a1.charge, a2.charge)
         self.assertEqual(a1.bfactor, a2.bfactor)
         self.assertEqual(a1.altloc, a2.altloc)
         self.assertEqual(a1idx, a2.idx)
         if altloc_option == 'all':
             self.assertEqual(set(a1.other_locations.keys()),
                              set(a2.other_locations.keys()))
         self.assertEqual(a1.xx, a2.xx)
         self.assertEqual(a1.xy, a2.xy)
         self.assertEqual(a1.xz, a2.xz)
         if altloc_option != 'all':
             # There should be no alternate locations unless we keep them all
             self.assertEqual(len(a2.other_locations), 0)
         if not reordered:
             self.assertEqual(a1.number, a2.number)
         # Search all alternate locations as well
         for k1, k2 in zip(sorted(a1.other_locations.keys()),
                           sorted(a2.other_locations.keys())):
             self.assertEqual(k1, k2)
             oa1 = a1.other_locations[k1]
             oa2 = a2.other_locations[k2]
             self.assertEqual(oa1.atomic_number, oa2.atomic_number)
             self.assertEqual(oa1.name, oa2.name)
             self.assertEqual(oa1.type, oa2.type)
             self.assertEqual(oa1.mass, oa2.mass)
             self.assertEqual(oa1.charge, oa2.charge)
             self.assertEqual(oa1.occupancy, oa2.occupancy)
             self.assertEqual(oa1.bfactor, oa2.bfactor)
             self.assertEqual(oa1.altloc, oa2.altloc)
             self.assertEqual(oa1.idx, oa2.idx)
             if not reordered:
                 self.assertEqual(oa1.number, oa2.number)
     # Now compare all residues
     for r1, r2 in zip(pdbfile.residues, pdbfile2.residues):
         self.assertEqual(r1.name, r2.name)
         self.assertEqual(r1.idx, r2.idx)
         self.assertEqual(r1.ter, r2.ter)
         self.assertEqual(len(r1), len(r2))
         self.assertEqual(r1.insertion_code, r2.insertion_code)
         if not reordered:
             self.assertEqual(r1.number, r2.number)
    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)
Example #4
0
 def testAdd(self):
     """ Tests combining AmberParm instances """
     parm1 = readparm.AmberParm(get_fn('phenol.prmtop'))
     parm2 = readparm.AmberParm(get_fn('biphenyl.prmtop'))
     comb = parm1 + parm2
     self.assertEqual(len(comb.atoms), len(parm1.atoms) + len(parm2.atoms))
     for a1, a2 in zip(comb.atoms, parm1.atoms + parm2.atoms):
         self.assertEqual(a1.name, a2.name)
         self.assertEqual(a1.mass, a2.mass)
         self.assertEqual(a1.charge, a2.charge)
         self.assertEqual(a1.radii, a2.radii)
     self.assertEqual(len(comb.residues), len(parm1.residues) + len(parm2.residues))
     for r1, r2 in zip(comb.residues, parm1.residues + parm2.residues):
         self.assertEqual(len(r1), len(r2))
         self.assertEqual(r1.name, r2.name)
         self.assertEqual(r1.chain, r2.chain)
     # In-place now
     parm1 += parm2
     self.assertEqual(len(parm1.atoms), len(comb.atoms))
     for a1, a2 in zip(comb.atoms, parm1.atoms):
         self.assertEqual(a1.name, a2.name)
         self.assertEqual(a1.mass, a2.mass)
         self.assertEqual(a1.charge, a2.charge)
         self.assertEqual(a1.radii, a2.radii)
     self.assertEqual(len(parm1.residues), len(comb.residues))
     for r1, r2 in zip(comb.residues, parm1.residues):
         self.assertEqual(len(r1), len(r2))
         self.assertEqual(r1.name, r2.name)
         self.assertEqual(r1.chain, r2.chain)
Example #5
0
 def testMult(self):
     """ Tests replicating AmberParm instances """
     parm = readparm.AmberParm(get_fn('phenol.prmtop'))
     mult = parm * 5
     self.assertEqual(len(mult.atoms), 5*len(parm.atoms))
     self.assertEqual(len(mult.residues), 5*len(parm.residues))
     for i, a1 in enumerate(mult.atoms):
         a2 = parm[i%len(parm.atoms)]
         self.assertEqual(a1.name, a2.name)
         self.assertEqual(a1.mass, a2.mass)
         self.assertEqual(a1.charge, a2.charge)
         self.assertEqual(a1.radii, a2.radii)
     for i, r1 in enumerate(mult.residues):
         r2 = parm.residues[i%len(parm.residues)]
         self.assertEqual(len(r1), len(r2))
         self.assertEqual(r1.name, r2.name)
         self.assertEqual(r1.chain, r2.chain)
     # In-place now
     parm *= 5
     self.assertEqual(len(parm.atoms), len(mult.atoms))
     for a1, a2 in zip(mult.atoms, parm.atoms):
         self.assertEqual(a1.name, a2.name)
         self.assertEqual(a1.mass, a2.mass)
         self.assertEqual(a1.charge, a2.charge)
         self.assertEqual(a1.radii, a2.radii)
     self.assertEqual(len(parm.residues), len(mult.residues))
     for r1, r2 in zip(mult.residues, parm.residues):
         self.assertEqual(len(r1), len(r2))
         self.assertEqual(r1.name, r2.name)
         self.assertEqual(r1.chain, r2.chain)
Example #6
0
 def _check_rst(self, rst, written=False):
     """ Checks various restart properties """
     self.assertAlmostEqual(rst.time, 30.1)
     self.assertEqual(rst.Conventions, 'AMBERRESTART')
     self.assertEqual(rst.title, 'ACE')
     if written:
         self.assertEqual(rst.application, 'AmberTools')
         self.assertEqual(rst.program, 'ParmEd')
         self.assertEqual(rst.programVersion, __version__)
     else:
         self.assertEqual(rst.application, 'AMBER')
         self.assertEqual(rst.program, 'sander')
         self.assertEqual(rst.programVersion, '11.0')
     self.assertAlmostEqual(rst.cell_lengths[0], 30.2642725)
     self.assertAlmostEqual(rst.cell_lengths[1], 30.2642725)
     self.assertAlmostEqual(rst.cell_lengths[2], 30.2642725)
     self.assertAlmostEqual(rst.cell_angles[0], 109.471219)
     self.assertAlmostEqual(rst.cell_angles[1], 109.471219)
     self.assertAlmostEqual(rst.cell_angles[2], 109.471219)
     self.assertTrue(
         all([
             round(x - y, 7) == 0
             for x, y in zip(rst.cell_lengths, rst.box[:3])
         ]))
     self.assertTrue(
         all([
             round(x - y, 7) == 0
             for x, y in zip(rst.cell_angles, rst.box[3:])
         ]))
Example #7
0
 def testMoleculeCombine(self):
     """ Tests selective molecule combination in Gromacs topology files """
     warnings.filterwarnings('ignore', category=GromacsWarning)
     parm = load_file(os.path.join(get_fn('12.DPPC'), 'topol3.top'))
     fname = get_fn('combined.top', written=True)
     # Make sure that combining non-adjacent molecules fails
     self.assertRaises(ValueError, lambda:
             parm.write(fname, combine=[[1, 3]]))
     self.assertRaises(ValueError, lambda:
             parm.write(fname, combine='joey'))
     self.assertRaises(ValueError, lambda:
             parm.write(fname, combine=[1, 2, 3]))
     self.assertRaises(TypeError, lambda:
             parm.write(fname, combine=1))
     parm.write(fname, combine=[[3, 4], [126, 127, 128, 129, 130]])
     with open(fname, 'r') as f:
         for line in f:
             if line.startswith('[ molecules ]'):
                 break
         molecule_list = []
         for line in f:
             if line[0] == ';': continue
             words = line.split()
             molecule_list.append((words[0], int(words[1])))
     parm2 = load_file(fname)
     self.assertEqual(molecule_list, [('DPPC', 3), ('system1', 1),
                      ('SOL', 121), ('system2', 1), ('SOL', 121)])
     self.assertEqual(len(parm2.atoms), len(parm.atoms))
     self.assertEqual(len(parm2.residues), len(parm2.residues))
     for a1, a2 in zip(parm.atoms, parm2.atoms):
         self._equal_atoms(a1, a2)
     for r1, r2 in zip(parm.residues, parm2.residues):
         self.assertEqual(len(r1), len(r2))
         for a1, a2 in zip(r1, r2):
             self._equal_atoms(a1, a2)
Example #8
0
 def chk_valence(val1, val2):
     self.assertIs(type(val1[0]), type(val2[0]))
     self.assertEqual(len(val1), len(val2))
     attrs = [attr for attr in dir(val1[0]) if attr.startswith('atom')]
     for v1, v2 in zip(val1, val2):
         at1 = [getattr(v1, attr) for attr in attrs]
         at2 = [getattr(v2, attr) for attr in attrs]
         self.assertIsNot(v1, v2)
         for a1, a2 in zip(at1, at2):
             cmp_atoms(a1, a2)
Example #9
0
 def _load_urey_brad_info(self):
     """ Loads the Urey-Bradley types and array """
     del self.urey_bradleys[:]
     del self.urey_bradley_types[:]
     for k, req in zip(
         self.parm_data["CHARMM_UREY_BRADLEY_FORCE_CONSTANT"], self.parm_data["CHARMM_UREY_BRADLEY_EQUIL_VALUE"]
     ):
         self.urey_bradley_types.append(BondType(k, req, self.urey_bradley_types))
     it = iter(self.parm_data["CHARMM_UREY_BRADLEY"])
     for i, j, k in zip(it, it, it):
         self.urey_bradleys.append(UreyBradley(self.atoms[i - 1], self.atoms[j - 1], self.urey_bradley_types[k - 1]))
Example #10
0
 def testCoordinates(self):
     """ Tests coordinate handling in Structure """
     s = create_random_structure(parametrized=False)
     self.assertIs(s.coordinates, None)
     natom = len(s.atoms)
     # Make sure coordinates will be generated from Atom.xx, xy, xz if not
     # otherwise generated
     xyz = np.random.random((natom, 3))
     for a, x in zip(s.atoms, xyz):
         a.xx, a.xy, a.xz = x
     self.assertEqual(s.coordinates.shape, (natom, 3))
     np.testing.assert_equal(s.coordinates, xyz[:,:])
     self.assertIs(s._coordinates, None)
     # Now set multiple frames
     xyz = np.random.random((5, natom, 3)).tolist()
     s.coordinates = xyz
     self.assertIsInstance(s.coordinates, np.ndarray)
     self.assertEqual(s.coordinates.shape, (natom, 3))
     for a, x in zip(s.atoms, xyz[0]):
         self.assertEqual(a.xx, x[0])
         self.assertEqual(a.xy, x[1])
         self.assertEqual(a.xz, x[2])
     np.testing.assert_equal(s.get_coordinates('all'), xyz)
     for i in range(5):
         np.testing.assert_equal(s.get_coordinates(i), xyz[i])
     # Now try setting with units
     xyz = u.Quantity(np.random.random((3, natom, 3)), u.nanometers)
     s.coordinates = xyz
     self.assertIsInstance(s.coordinates, np.ndarray)
     self.assertEqual(s.coordinates.shape, (natom, 3))
     for a, x in zip(s.atoms, xyz[0]._value):
         self.assertEqual(a.xx, x[0]*10)
         self.assertEqual(a.xy, x[1]*10)
         self.assertEqual(a.xz, x[2]*10)
     # Now check setting None
     s.coordinates = None
     for a in s.atoms:
         self.assertFalse(hasattr(a, 'xx'))
         self.assertFalse(hasattr(a, 'xy'))
         self.assertFalse(hasattr(a, 'xz'))
     self.assertIs(s.coordinates, None)
     # Now check setting flattened arrays
     s.coordinates = np.random.random((natom, 3))
     self.assertEqual(s.coordinates.shape, (natom, 3))
     s.coordinates = np.random.random(natom*3)
     self.assertEqual(s.coordinates.shape, (natom, 3))
     s.coordinates = np.random.random(natom*3*10)
     self.assertEqual(s.coordinates.shape, (natom, 3))
     # Now check other iterables
     old_crds = s.coordinates
     s.coordinates = (random.random() for i in range(3*len(s.atoms)))
     self.assertEqual(s.coordinates.shape, (natom, 3))
     diff = (old_crds - s.coordinates).ravel()**2
     self.assertGreater(diff.sum(), 0.01)
Example #11
0
    def testSimpleSlice(self):
        """ Tests simple slicing of AmberParm """
        parm1 = readparm.AmberParm(get_fn("trx.prmtop"))
        parm2 = readparm.AmberParm(get_fn("trx.prmtop"))
        parm2.strip("!@CA,C,O,N,HA,H")
        selection = parm1["@CA,C,O,N,HA,H"]
        self.assertIs(type(parm1), readparm.AmberParm)
        self.assertIs(type(parm2), readparm.AmberParm)
        self.assertIs(type(selection), readparm.AmberParm)
        self.assertEqual(len(parm2.atoms), len(selection.atoms))
        self.assertEqual(len(parm2.residues), len(selection.residues))
        self.assertLess(len(parm2.atoms), len(parm1.atoms))

        def cmp_atoms(a1, a2):
            self.assertEqual(a1.name, a2.name)
            self.assertEqual(a1.type, a2.type)
            self.assertEqual(a1.charge, a2.charge)
            self.assertEqual(a1.tree, a2.tree)
            self.assertEqual(a1.radii, a2.radii)
            self.assertEqual(a1.screen, a2.screen)
            self.assertEqual(a1.join, a2.join)
            self.assertEqual(a1.mass, a2.mass)
            self.assertEqual(a1.atomic_number, a2.atomic_number)
            self.assertEqual(a1.residue.name, a2.residue.name)
            self.assertEqual(a1.residue.idx, a2.residue.idx)
            self.assertEqual(a1.nb_idx, a2.nb_idx)

        for a1, a2 in zip(parm2.atoms, selection.atoms):
            cmp_atoms(a1, a2)
        # Now check valence terms
        self.assertEqual(len(parm2.bonds), len(selection.bonds))
        self.assertEqual(len(parm2.angles), len(selection.angles))
        self.assertEqual(len(parm2.dihedrals), len(selection.dihedrals))
        self.assertGreater(len(parm2.bonds), 0)
        self.assertGreater(len(parm2.angles), 0)
        self.assertGreater(len(parm2.dihedrals), 0)
        for b1, b2 in zip(parm2.bonds, selection.bonds):
            cmp_atoms(b1.atom1, b2.atom1)
            cmp_atoms(b1.atom2, b2.atom2)
            self.assertEqual(b1.type, b2.type)
        for a1, a2 in zip(parm2.angles, selection.angles):
            cmp_atoms(a1.atom1, a2.atom1)
            cmp_atoms(a1.atom2, a2.atom2)
            cmp_atoms(a1.atom3, a2.atom3)
            self.assertEqual(a1.type, a2.type)
        for d1, d2 in zip(parm2.dihedrals, selection.dihedrals):
            cmp_atoms(d1.atom1, d2.atom1)
            cmp_atoms(d1.atom2, d2.atom2)
            cmp_atoms(d1.atom3, d2.atom3)
            cmp_atoms(d1.atom4, d2.atom4)
            self.assertEqual(d1.ignore_end, d2.ignore_end)
            self.assertEqual(d1.improper, d2.improper)
            self.assertEqual(d1.type, d2.type)
Example #12
0
 def testMoleculeOrdering(self):
     """ Tests non-contiguous atoms in Gromacs topology file writes """
     warnings.filterwarnings('ignore', category=GromacsWarning)
     parm = load_file(os.path.join(get_fn('12.DPPC'), 'topol3.top'))
     parm.write(get_fn('topol3.top', written=True))
     parm2 = load_file(get_fn('topol3.top', written=True))
     self.assertEqual(len(parm.atoms), len(parm2.atoms))
     self.assertEqual(len(parm.residues), len(parm2.residues))
     for r1, r2 in zip(parm.residues, parm2.residues):
         self.assertEqual(r1.name, r2.name)
         for a1, a2 in zip(r1.atoms, r2.atoms):
             self.assertEqual(a1.name, a2.name)
             self.assertEqual(a1.type, a2.type)
Example #13
0
 def check_aniso(pdbfile):
     aniso1 = [2066, 1204, 1269, 44, 126, 191]
     aniso2 = [2090, 1182, 921, 46, 64, 60]
     aniso3 = [3057, 3932, 5304, 126, -937, -661]
     self.assertEqual(len(aniso1), len(pdbfile.atoms[0].anisou))
     for x, y in zip(aniso1, pdbfile.atoms[0].anisou):
         self.assertEqual(x/10000, y)
     self.assertEqual(len(aniso2), len(pdbfile.atoms[1].anisou))
     for x, y in zip(aniso2, pdbfile.atoms[1].anisou):
         self.assertEqual(x/10000, y)
     self.assertEqual(len(aniso3), len(pdbfile.atoms[-1].anisou))
     for x, y in zip(aniso3, pdbfile.atoms[-1].anisou):
         self.assertEqual(x/10000, y)
Example #14
0
 def _load_urey_brad_info(self):
     """ Loads the Urey-Bradley types and array """
     del self.urey_bradleys[:]
     del self.urey_bradley_types[:]
     for k, req in zip(self.parm_data['CHARMM_UREY_BRADLEY_FORCE_CONSTANT'],
                       self.parm_data['CHARMM_UREY_BRADLEY_EQUIL_VALUE']):
         self.urey_bradley_types.append(
             BondType(k, req, self.urey_bradley_types))
     it = iter(self.parm_data['CHARMM_UREY_BRADLEY'])
     for i, j, k in zip(it, it, it):
         self.urey_bradleys.append(
             UreyBradley(self.atoms[i - 1], self.atoms[j - 1],
                         self.urey_bradley_types[k - 1]))
Example #15
0
 def _check4lzt(self, cif):
     pdb = read_PDB(self.lztpdb)
     self.assertEqual(len(cif.atoms), len(pdb.atoms))
     nextra = 0
     for a1, a2 in zip(cif.atoms, pdb.atoms):
         self.assertEqual(a1.name, a2.name)
         self.assertEqual(a1.number + nextra, a2.number)
         self.assertEqual(len(a1.anisou), len(a2.anisou))
         for x, y in zip(a1.anisou, a2.anisou):
             self.assertEqual(x, y)
         self.assertEqual(a1.altloc, a2.altloc)
         self.assertEqual(len(a1.other_locations), len(a2.other_locations))
         self.assertEqual(a1.residue.name, a2.residue.name)
         self.assertEqual(a1.residue.number, a2.residue.number)
         # TER cards consume a serial number in the PDB file, but *not* in a
         # CIF file.
         if a2.residue.ter and a2 is a2.residue.atoms[-1]:
             nextra += 1
     # Check the unit cell info
     self.assertEqual(cif.box[0], 27.240)
     self.assertEqual(cif.box[1], 31.870)
     self.assertEqual(cif.box[2], 34.230)
     self.assertEqual(cif.box[3], 88.520)
     self.assertEqual(cif.box[4], 108.53)
     self.assertEqual(cif.box[5], 111.89)
     # Check the metadata now
     self.assertEqual(cif.experimental, 'X-RAY DIFFRACTION')
     self.assertEqual(cif.authors,
             'Walsh, M.A., Schneider, T., Sieker, L.C., Dauter, Z., '
             'Lamzin, V., Wilson, K.S.')
     self.assertEqual(cif.title,
             'Refinement of triclinic hen egg-white lysozyme at atomic '
             'resolution.; Refinement of Triclinic Lysozyme: I. Fourier '
             'and Least-Squares Methods; Refinement of Triclinic Lysozyme: '
             'II. The Method of Stereochemically Restrained Least Squares')
     self.assertEqual(cif.journal,
             'Acta Crystallogr.,Sect.D; Acta Crystallogr.,Sect.B; '
             'Acta Crystallogr.,Sect.B')
     self.assertEqual(cif.journal_authors,
             'Walsh, M.A., Schneider, T.R., Sieker, L.C., Dauter, Z., '
             'Lamzin, V.S., Wilson, K.S., Hodsdon, J.M., Brown, G.M., '
             'Jensen, L.H., Ramanadham, M.')
     self.assertEqual(cif.year, '1998, 1990, 1990')
     self.assertEqual(cif.page, '522, 54, 63')
     self.assertEqual(cif.keywords, ['HYDROLASE', 'O-GLYCOSYL',
                                     'GLYCOSIDASE'])
     self.assertEqual(cif.volume, '54, 46, 46')
     self.assertEqual(cif.doi, '10.1107/S0907444997013656')
     self.assertEqual(cif.pmid, '9761848')
     self.assertEqual(cif.resolution, 0.95)
Example #16
0
 def _load_improper_info(self):
     """ Loads the CHARMM Improper types and array """
     del self.impropers[:]
     del self.improper_types[:]
     for k, eq in zip(self.parm_data['CHARMM_IMPROPER_FORCE_CONSTANT'],
                      self.parm_data['CHARMM_IMPROPER_PHASE']):
         self.improper_types.append(ImproperType(k, eq,
                                                 self.improper_types))
     it = iter(self.parm_data['CHARMM_IMPROPERS'])
     for i, j, k, l, m in zip(it, it, it, it, it):
         self.impropers.append(
             Improper(self.atoms[i - 1], self.atoms[j - 1],
                      self.atoms[k - 1], self.atoms[l - 1],
                      self.improper_types[m - 1]))
Example #17
0
 def chk_valence(val1, val2):
     self.assertIs(type(val1[0]), type(val2[0]))
     self.assertEqual(len(val1), len(val2))
     attrs = [attr for attr in dir(val1[0]) if attr.startswith('atom')]
     for v1, v2 in zip(val1, val2):
         at1 = [getattr(v1, attr) for attr in attrs]
         at2 = [getattr(v2, attr) for attr in attrs]
         self.assertIsNot(v1, v2)
         for a1, a2 in zip(at1, at2):
             cmp_atoms(a1, a2)
         if hasattr(v1, 'type'):
             self.assertEqual(v1.type, v2.type)
             if not isinstance(v1.type, integer_types):
                 self.assertIsNot(v1.type, v2.type)
    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)
Example #19
0
 def testAnisouRead(self):
     """ Tests that read_PDB properly reads ANISOU records """
     pdbfile = read_PDB(self.pdb)
     aniso1 = [2066, 1204, 1269, 44, 126, 191] # first atom's ANISOU record
     aniso2 = [2090, 1182, 921, 46, 64, 60]    # second atom's ANISOU record
     aniso3 = [3057, 3932, 5304, 126, -937, -661] # last atom's ANISOU
     self.assertEqual(len(aniso1), len(pdbfile.atoms[0].anisou))
     for x, y in zip(aniso1, pdbfile.atoms[0].anisou):
         self.assertEqual(x/10000, y)
     self.assertEqual(len(aniso2), len(pdbfile.atoms[1].anisou))
     for x, y in zip(aniso2, pdbfile.atoms[1].anisou):
         self.assertEqual(x/10000, y)
     self.assertEqual(len(aniso3), len(pdbfile.atoms[-1].anisou))
     for x, y in zip(aniso3, pdbfile.atoms[-1].anisou):
         self.assertEqual(x/10000, y)
Example #20
0
 def _load_improper_info(self):
     """ Loads the CHARMM Improper types and array """
     del self.impropers[:]
     del self.improper_types[:]
     for k, eq in zip(self.parm_data['CHARMM_IMPROPER_FORCE_CONSTANT'],
                      self.parm_data['CHARMM_IMPROPER_PHASE']):
         self.improper_types.append(
                 ImproperType(k, eq, self.improper_types)
         )
     it = iter(self.parm_data['CHARMM_IMPROPERS'])
     for i, j, k, l, m in zip(it, it, it, it, it):
         self.impropers.append(
                 Improper(self.atoms[i-1], self.atoms[j-1], self.atoms[k-1],
                          self.atoms[l-1], self.improper_types[m-1])
         )
Example #21
0
def energy_decomposition_system(structure,
                                system,
                                platform=None,
                                nrg=u.kilocalories_per_mole):
    """
    This function computes the energy contribution for all of the different
    force groups.

    Parameters
    ----------
    structure : Structure
        The Structure with the coordinates for this system
    system : mm.System
        The OpenMM System object to get decomposed energies from
    platform : str
        The platform to use. Options are None (default), 'CPU', 'Reference',
        'CUDA', and 'OpenCL'. None will pick default OpenMM platform for this
        installation and computer
    nrg : energy unit, optional
        The unit to convert all energies into. Default is kcal/mol

    Returns
    -------
    energies : list of tuple
        Each entry is a tuple with the name of the force followed by its
        contribution
    """
    import simtk.openmm as mm
    # First get all of the old force groups so we can restore them
    old_groups = [f.getForceGroup() for f in system.getForces()]
    old_recip_group = []

    def _ene(context, grp):
        st = context.getState(getEnergy=True, groups=1 << grp)
        return (type(system.getForce(grp)).__name__,
                st.getPotentialEnergy().value_in_unit(nrg))

    try:
        for i, f in enumerate(system.getForces()):
            if isinstance(f, mm.NonbondedForce):
                old_recip_group.append(f.getReciprocalSpaceForceGroup())
                f.setReciprocalSpaceForceGroup(i)
            f.setForceGroup(i)
        if platform is None:
            con = mm.Context(system, mm.VerletIntegrator(0.001))
        else:
            con = mm.Context(system, mm.VerletIntegrator(0.001),
                             mm.Platform.getPlatformByName(platform))
        con.setPositions(structure.positions)
        if structure.box is not None:
            con.setPeriodicBoxVectors(*structure.box_vectors)

        return list(map(lambda x: _ene(con, x), range(system.getNumForces())))
    finally:
        idx = 0
        for grp, force in zip(old_groups, system.getForces()):
            if isinstance(force, mm.NonbondedForce):
                force.setReciprocalSpaceForceGroup(old_recip_group[idx])
                idx += 1
            force.setForceGroup(grp)
Example #22
0
 def testXyz(self):
     """ Tests parsing Tinker XYZ files """
     self.assertTrue(tinkerfiles.XyzFile.id_format(get_fn('nma.xyz')))
     self.assertTrue(
         tinkerfiles.XyzFile.id_format(get_fn('2igd_924wat.xyz')))
     xyz = tinkerfiles.XyzFile(get_fn('nma.xyz'))
     np.testing.assert_allclose(xyz.box,
                                [30.735, 30.876, 28.485, 90.0, 90.0, 90.0])
     self.assertEqual(len(xyz.atoms), 2466)
     self.assertEqual(xyz.atoms[0].name, 'C')
     self.assertEqual(xyz.atoms[0].type, '221')
     self.assertEqual(len(xyz.atoms[0].bond_partners), 4)
     self.assertEqual(xyz.atoms[-1].name, 'H')
     self.assertEqual(xyz.atoms[-1].atomic_number, 1)
     self.assertEqual(xyz.atoms[-1].type, '248')
     xyz = pmd.load_file(get_fn('2igd_924wat.xyz'),
                         get_fn('2igd_924wat.pdb'))
     pdb = pmd.load_file(get_fn('2igd_924wat.pdb'))
     self.assertEqual(len(pdb.atoms), len(xyz.atoms))
     self.assertEqual(len(pdb.residues), len(xyz.residues))
     for r1, r2 in zip(pdb.residues, xyz.residues):
         self.assertEqual(len(r1), len(r2))
         self.assertEqual(r1.chain, r2.chain)
         self.assertEqual(r1.name, r2.name)
         self.assertEqual(r1.insertion_code, r2.insertion_code)
Example #23
0
 def testPdbWriteXtal(self):
     """ Test PDB file writing from a Xtal structure """
     pdbfile = read_PDB(self.pdb)
     self._check4lzt(pdbfile)
     output = StringIO()
     pdbfile.write_pdb(output, renumber=False)
     output.seek(0)
     pdbfile2 = read_PDB(output)
     self._check4lzt(pdbfile2, check_meta=False)
     self._compareInputOutputPDBs(pdbfile, pdbfile2)
     output = reset_stringio(output)
     write_PDB(pdbfile, output)
     output.seek(0)
     pdbfile3 = read_PDB(output)
     self._check4lzt(pdbfile3, check_meta=False)
     self._compareInputOutputPDBs(pdbfile, pdbfile3, True)
     # Now check that renumbering is done correctly. 4lzt skips residues 130
     # through 200
     for res1, res2 in zip(pdbfile.residues, pdbfile3.residues):
         if res1.idx < 129:
             self.assertEqual(res1.number, res2.number)
         elif res1.idx < 135:
             self.assertEqual(res1.number, res2.number + 71)
         else:
             # Some residue numbers are skipped in the water numbering
             self.assertGreaterEqual(res1.number, res2.number + 71 + 794)
Example #24
0
    def _check_written_mdcrds(self, box):
        # Now try to read them and verify the information
        crd = asciicrd.AmberMdcrd(get_fn('testc.mdcrd', written=True),
                                  15, False, 'r')
        self.assertEqual(crd.title, 'Test file')
        self.assertFalse(crd.hasbox)
        for i in range(crd.frame):
            shape = crd.coordinates[i].shape
            refcrd = np.arange(45) + i
            np.testing.assert_equal(crd.coordinates[i], refcrd.reshape(shape))
        for i, array in enumerate(crd.coordinates):
            refcrd = (np.arange(45) + i).reshape(array.shape)
            np.testing.assert_equal(array, refcrd)
        crd.close()

        crd = asciicrd.AmberMdcrd(get_fn('testcb.mdcrd', written=True),
                                  18, True, 'r')
        self.assertEqual(crd.title, 'Test file')
        self.assertTrue(crd.hasbox)
        for i in range(crd.frame):
            refcrd = (np.arange(54) + i).reshape(crd.coordinates[i].shape)
            np.testing.assert_equal(crd.coordinates[i], refcrd)
            np.testing.assert_equal(crd.box[i], box)
        for i, (coords, mybox) in enumerate(zip(crd.coordinates, crd.box)):
            np.testing.assert_equal(coords, (np.arange(54)+i).reshape(coords.shape))
            np.testing.assert_equal(mybox, box)
Example #25
0
def detailed_diff(l1, l2, absolute_error=None, relative_error=None, spacechar=None):
    """
    Check individual fields to make sure numbers are numerically equal if the
    lines differ. Also ignore fields that appear to be a file name, since those
    will be system-dependent
    """
    fdir = os.path.split(get_fn('writes'))[0]
    if spacechar is not None:
        for char in spacechar:
            l1 = l1.replace(char, ' ')
            l2 = l2.replace(char, ' ')
    w1 = l1.split()
    w2 = l2.split()
    if len(w1) != len(w2): return False
    for wx, wy in zip(w1, w2):
        try:
            wx = float(wx)
            wy = float(wy)
        except ValueError:
            if isinstance(wx, float) or (wx != wy and not
                    (wx.startswith(fdir) or wy.startswith(fdir))):
                return False
        else:
            if wx != wy:
                if absolute_error is not None and abs(wx-wy) > absolute_error:
                    return False
                elif relative_error is not None:
                    if wx == 0 or wy == 0 and abs(wx-wy) > relative_error:
                        return False
                    if abs((wx / wy) - 1) > relative_error:
                        return False
                elif absolute_error is None and relative_error is None:
                    return False
    return True
 def test_dihedral_type_list(self):
     """ Tests the DihedralTypeList class """
     dihed_types = TrackedList()
     dihed_types.append(DihedralTypeList(list=dihed_types))
     dihed_types[0].append(DihedralType(5.0, 2, 0.0, 1.2, 2.0))
     dihed_types[0].append(DihedralType(1.0, 3, 180.0, 1.2, 2.0))
     dihed_types[0].append(DihedralType(2.0, 4, 180.0, 1.2, 2.0))
     dihed_types[0].append(DihedralType(10.0, 1, 180.0, 0., 0.))
     self.assertIs(dihed_types[0].list, dihed_types)
     self.assertEqual(len(dihed_types), 1)
     self.assertEqual(dihed_types[0].idx, 0)
     self.assertEqual(len(dihed_types[0]), 4)
     # Now test DihedralTypeList.__copy__
     cp = copy(dihed_types[0])
     self.assertIsNot(cp, dihed_types[0])
     self.assertIs(cp.list, None)
     self.assertEqual(cp.idx, -1)
     self.assertEqual(len(cp), 4)
     i = 0
     for t1, t2 in zip(cp, dihed_types[0]):
         self.assertIsNot(t1, t2)
         self.assertEqual(t1.phi_k, t2.phi_k)
         self.assertEqual(t1.per, t2.per)
         self.assertEqual(t1.phase, t2.phase)
         self.assertEqual(t1.scee, t2.scee)
         self.assertEqual(t1.scnb, t2.scnb)
         i += 1
     self.assertEqual(i, 4)
Example #27
0
 def testReportersPBC(self):
     """ Test NetCDF and ASCII restart and trajectory reporters (w/ PBC) """
     system = amber_solv.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(amber_solv.topology, system, integrator)
     sim.context.setPositions(amber_solv.positions)
     sim.reporters.extend([
             NetCDFReporter(get_fn('traj.nc', written=True), 1,
                            vels=True, frcs=True),
             MdcrdReporter(get_fn('traj.mdcrd', written=True), 1),
             RestartReporter(get_fn('restart.ncrst', written=True), 1,
                             netcdf=True),
             RestartReporter(get_fn('restart.rst7', written=True), 1)
     ])
     sim.step(5)
     for reporter in sim.reporters: reporter.finalize()
     ntraj = NetCDFTraj.open_old(get_fn('traj.nc', written=True))
     atraj = AmberMdcrd(get_fn('traj.mdcrd', written=True),
                        amber_solv.ptr('natom'), True, mode='r')
     nrst = NetCDFRestart.open_old(get_fn('restart.ncrst', written=True))
     arst = AmberAsciiRestart(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)
Example #28
0
 def cmp_valence(val1, val2, typeattrs=None):
     self.assertEqual(len(val1), len(val2))
     for v1, v2 in zip(val1, val2):
         self.assertIs(type(v1), type(v2))
         attrs = [attr for attr in dir(v1) if attr.startswith('atom')]
         atoms1 = [getattr(v1, attr) for attr in attrs]
         atoms2 = [getattr(v2, attr) for attr in attrs]
         for a1, a2 in zip(atoms1, atoms2):
             cmp_atoms(a1, a2)
         # Check the type lists
         if typeattrs is not None:
             for attr in typeattrs:
                 self.assertAlmostEqual(getattr(v1.type, attr),
                                        getattr(v2.type, attr), places=5)
         else:
             self.assertEqual(v1.type, v2.type)
    def test_residue(self):
        """ Tests the Residue object """
        atoms = TrackedList()
        atoms.extend([Atom(list=atoms) for i in range(10)])
        res = Residue('ALA')
        for atom in atoms:
            res.add_atom(atom)
        self.assertEqual(len(res), len(atoms))
        for atom in atoms:
            self.assertIs(atom.residue, res)
        for x, y in zip(atoms, res):
            self.assertIs(x, y)
        for atom in atoms:
            self.assertIn(atom, res)

        # Try deleting all of our atoms
        while len(res):
            lenres = len(res)
            atom = random.choice(atoms)
            is_inside = atom in res
            res.delete_atom(atom)
            self.assertEqual(lenres-len(res), is_inside)
            self.assertIs(atom.residue, None)
        self.assertEqual(len(res), 0)
        for atom in atoms:
            self.assertIs(atom.residue, None)
        self.assertTrue(res.is_empty())
Example #30
0
 def test_xyz(self):
     """ Tests parsing Tinker XYZ files """
     self.assertTrue(tinkerfiles.XyzFile.id_format(get_fn('nma.xyz')))
     self.assertTrue(tinkerfiles.XyzFile.id_format(get_fn('2igd_924wat.xyz')))
     xyz = tinkerfiles.XyzFile(get_fn('nma.xyz'))
     np.testing.assert_allclose(xyz.box, [30.735, 30.876, 28.485, 90.0, 90.0, 90.0])
     self.assertEqual(len(xyz.atoms), 2466)
     self.assertEqual(xyz.atoms[0].name, 'C')
     self.assertEqual(xyz.atoms[0].type, '221')
     self.assertEqual(len(xyz.atoms[0].bond_partners), 4)
     self.assertEqual(xyz.atoms[-1].name, 'H')
     self.assertEqual(xyz.atoms[-1].atomic_number, 1)
     self.assertEqual(xyz.atoms[-1].type, '248')
     xyz = pmd.load_file(get_fn('2igd_924wat.xyz'), get_fn('2igd_924wat.pdb'))
     pdb = pmd.load_file(get_fn('2igd_924wat.pdb'))
     xyz2 = pmd.load_file(get_fn('2igd_924wat.xyz'))
     self.assertEqual(len(pdb.atoms), len(xyz.atoms))
     self.assertEqual(len(pdb.residues), len(xyz.residues))
     for r1, r2 in zip(pdb.residues, xyz.residues):
         self.assertEqual(len(r1), len(r2))
         self.assertEqual(r1.chain, r2.chain)
         self.assertEqual(r1.name, r2.name)
         self.assertEqual(r1.insertion_code, r2.insertion_code)
     # Make sure NA ions are atomic number of sodium
     for atom in xyz.view['NA',:].atoms:
         self.assertEqual(atom.atomic_number, pmd.periodic_table.AtomicNum['Na'])
     # Now make sure that NA ions are atomic number of sodium even if we
     # don't load a PDB file
     for atom in xyz2.view[:,'Na+']:
         self.assertEqual(atom.atomic_number, pmd.periodic_table.AtomicNum['Na'])
Example #31
0
 def _check_rst(self, rst):
     """ Checks various restart properties """
     self.assertAlmostEqual(rst.time, 30.1)
     self.assertEqual(rst.Conventions, "AMBERRESTART")
     self.assertEqual(rst.title, "ACE")
     self.assertEqual(rst.application, "AMBER")
     self.assertEqual(rst.program, "sander")
     self.assertEqual(rst.programVersion, "11.0")
     self.assertAlmostEqual(rst.cell_lengths[0], 30.2642725)
     self.assertAlmostEqual(rst.cell_lengths[1], 30.2642725)
     self.assertAlmostEqual(rst.cell_lengths[2], 30.2642725)
     self.assertAlmostEqual(rst.cell_angles[0], 109.471219)
     self.assertAlmostEqual(rst.cell_angles[1], 109.471219)
     self.assertAlmostEqual(rst.cell_angles[2], 109.471219)
     self.assertTrue(all([round(x - y, 7) == 0 for x, y in zip(rst.cell_lengths, rst.box[:3])]))
     self.assertTrue(all([round(x - y, 7) == 0 for x, y in zip(rst.cell_angles, rst.box[3:])]))
Example #32
0
 def testAnisouWrite(self):
     """ Tests that write_PDB properly writes ANISOU records """
     def check_aniso(pdbfile):
         aniso1 = [2066, 1204, 1269, 44, 126, 191]
         aniso2 = [2090, 1182, 921, 46, 64, 60]
         aniso3 = [3057, 3932, 5304, 126, -937, -661]
         self.assertEqual(len(aniso1), len(pdbfile.atoms[0].anisou))
         for x, y in zip(aniso1, pdbfile.atoms[0].anisou):
             self.assertEqual(x/10000, y)
         self.assertEqual(len(aniso2), len(pdbfile.atoms[1].anisou))
         for x, y in zip(aniso2, pdbfile.atoms[1].anisou):
             self.assertEqual(x/10000, y)
         self.assertEqual(len(aniso3), len(pdbfile.atoms[-1].anisou))
         for x, y in zip(aniso3, pdbfile.atoms[-1].anisou):
             self.assertEqual(x/10000, y)
     pdbfile = read_PDB(self.pdb)
     check_aniso(pdbfile)
     output = StringIO()
     pdbfile.write_pdb(output)
     output.seek(0)
     pdbfile2 = read_PDB(output)
     # Should have no anisou records, since by default they are not written
     for atom in pdbfile2.atoms:
         self.assertIs(atom.anisou, None)
     output = reset_stringio(output)
     pdbfile.write_pdb(output, renumber=False, write_anisou=True)
     output.seek(0)
     # This one should have anisou records
     pdbfile3 = read_PDB(output)
     self._compareInputOutputPDBs(pdbfile, pdbfile3)
     for a1, a2 in zip(pdbfile.atoms, pdbfile3.atoms):
         if has_numpy():
             self.assertEqual(a1.anisou.shape, a2.anisou.shape)
         else:
             self.assertEqual(len(a1.anisou), len(a2.anisou))
         for x, y in zip(a1.anisou, a2.anisou):
             self.assertAlmostEqual(x, y, delta=1e-4)
         self.assertEqual(len(a1.other_locations), len(a2.other_locations))
         for key in sorted(a1.other_locations.keys()):
             oa1 = a1.other_locations[key]
             oa2 = a2.other_locations[key]
             if has_numpy():
                 self.assertEqual(oa1.anisou.shape, oa2.anisou.shape)
             else:
                 self.assertEqual(len(oa1.anisou), len(oa2.anisou))
             for x, y in zip(oa1.anisou, oa2.anisou):
                 self.assertAlmostEqual(x, y, delta=1e-4)
Example #33
0
    def same_atoms(self, atomlist):
        """
        Determine if two dihedrals are assigned to the same sets of atom types

        Parameters
        ----------
        atomlist : list
            4-element list of atom types to compare against this DihedralParam

        Returns
        -------
        bool, bool
            First bool is True if all atoms are the same; False otherwise
            Second bool is True if atoms are in the same order; False otherwise

        Notes
        -----
        If this torsion is an improper, the first atom is fixed and the other 3
        atoms must be the same (but in any order). If this torsion is a proper,
        then the torsions must match in either the forward or reverse
        directions, only.
        """
        if self[0].dihtype == 'improper':
            # For impropers, the third atom is the central atom and the other 3
            # can be in any order
            if self.atype3 != atomlist[2]: return False, False
            if (self.atype1 == atomlist[0] and self.atype2 == atomlist[1] and
                self.atype4 == atomlist[3]):
                return True, True
            # Make sure every atom type is unique so every atom type is added to
            # the set (but we know it is NOT the same order now)
            set1, set2 = set() , set()
            for x, y in zip([atomlist[0], atomlist[1], atomlist[3]],
                            [self.atype1, self.atype2, self.atype4]):
                if x in set1:
                    i = 0
                    while '%s%d%d' % (x, i, i) in set1: i += 1
                    set1.add('%s%d%d' % (x, i, i))
                else:
                    set1.add(x)
                if y in set2:
                    i = 0
                    while '%s%d%d' % (y, i, i) in set2: i += 1
                    set2.add('%s%d%d' % (y, i, i))
                else:
                    set2.add(y)
            return set1 == set2, False
        # If we reached here, this is a proper dihedral
        if self.atype2 == atomlist[1] and self.atype3 == atomlist[2]:
            same = self.atype1 == atomlist[0] and self.atype4 == atomlist[3]
            if not same:
                # Check case when atype2 == atype3 and we're not the same --
                # check for reversed order
                eq = self.atype1 == atomlist[3] and self.atype4 == atomlist[0]
                return eq, False
            return same, same
        if self.atype3 == atomlist[1] and self.atype2 == atomlist[2]:
            return self.atype1==atomlist[3] and self.atype4==atomlist[0], False
        return False, False
Example #34
0
 def cmp_dihedrals(dih1, dih2):
     self.assertEqual(len(dih1), len(dih2))
     for v1, v2 in zip(dih1, dih2):
         self.assertIs(type(v1), type(v2))
         self.assertIs(type(v1.type), type(v2.type))
         atoms1 = [v1.atom1, v1.atom2, v1.atom3, v1.atom4]
         atoms2 = [v2.atom1, v2.atom2, v2.atom3, v2.atom4]
         for a1, a2 in zip(atoms1, atoms2):
             cmp_atoms(a1, a2)
         self.assertEqual(v1.improper, v2.improper)
         self.assertEqual(v1.ignore_end, v2.ignore_end)
         if isinstance(v1, DihedralTypeList):
             self.assertEqual(len(v1.type), len(v2.type))
             for vt1, vt2 in zip(v1.type, v2.type):
                 self.assertAlmostEqual(v1.type.phi_k, v2.type.phi_k, places=5)
                 self.assertAlmostEqual(v1.type.per, v2.type.per, places=5)
                 self.assertAlmostEqual(v1.type.phase, v2.type.phase, places=5)
    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)
Example #36
0
def energy_decomposition_system(structure, system, platform=None,
                                nrg=u.kilocalories_per_mole):
    """
    This function computes the energy contribution for all of the different
    force groups.

    Parameters
    ----------
    structure : Structure
        The Structure with the coordinates for this system
    system : mm.System
        The OpenMM System object to get decomposed energies from
    platform : str
        The platform to use. Options are None (default), 'CPU', 'Reference',
        'CUDA', and 'OpenCL'. None will pick default OpenMM platform for this
        installation and computer
    nrg : energy unit, optional
        The unit to convert all energies into. Default is kcal/mol

    Returns
    -------
    energies : list of tuple
        Each entry is a tuple with the name of the force followed by its
        contribution
    """
    import simtk.openmm as mm
    # First get all of the old force groups so we can restore them
    old_groups = [f.getForceGroup() for f in system.getForces()]
    old_recip_group = []
    def _ene(context, grp):
        st = context.getState(getEnergy=True, groups=1<<grp)
        return (type(system.getForce(grp)).__name__,
                st.getPotentialEnergy().value_in_unit(nrg))

    try:
        for i, f in enumerate(system.getForces()):
            if isinstance(f, mm.NonbondedForce):
                old_recip_group.append(f.getReciprocalSpaceForceGroup())
                f.setReciprocalSpaceForceGroup(i)
            f.setForceGroup(i)
        if platform is None:
            con = mm.Context(system, mm.VerletIntegrator(0.001))
        else:
            con = mm.Context(system, mm.VerletIntegrator(0.001),
                             mm.Platform.getPlatformByName(platform))
        con.setPositions(structure.positions)
        if structure.box is not None:
            con.setPeriodicBoxVectors(*structure.box_vectors)

        return list(map(lambda x: _ene(con, x), range(system.getNumForces())))
    finally:
        idx = 0
        for grp, force in zip(old_groups, system.getForces()):
            if isinstance(force, mm.NonbondedForce):
                force.setReciprocalSpaceForceGroup(old_recip_group[idx])
                idx += 1
            force.setForceGroup(grp)
 def cmp_top_arrays(arr1, arr2):
     self.assertEqual(len(arr1), len(arr2))
     for t1, t2 in zip(arr1, arr2):
         self.assertIs(type(t1), type(t2))
         atoms = [attr for attr in dir(t1) if attr.startswith('atom')]
         for a in atoms:
             self._equal_atoms(getattr(t1, a), getattr(t2, a))
         if hasattr(t1, 'type'):
             self.assertEqual(t1.type, t2.type)
 def cmp_top_arrays(arr1, arr2):
     self.assertEqual(len(arr1), len(arr2))
     for t1, t2 in zip(arr1, arr2):
         self.assertIs(type(t1), type(t2))
         atoms = [attr for attr in dir(t1) if attr.startswith("atom")]
         for a in atoms:
             self._equal_atoms(getattr(t1, a), getattr(t2, a))
         if hasattr(t1, "type"):
             self.assertEqual(t1.type, t2.type)
Example #39
0
def get_max_diff(f1, f2):
    """ Gets the maximum difference between two force vectors """
    maxfrc = None
    assert len(f1) == len(f2), 'vector size mismatch'
    for v1, v2 in zip(f1, f2):
        norm = u.norm(v1 - v2)
        if maxfrc is None:
            maxfrc = norm
        else:
            maxfrc = max(maxfrc, norm)
    return maxfrc
Example #40
0
    def test_dyn(self):
        """ Tests parsing Tinker DYN files """
        dyn = tinkerfiles.DynFile(get_fn('nma.dyn'))
        self.assertEqual(dyn.natom, 2466)
        for attr in ('accelerations', 'old_accelerations', 'box', 'positions',
                     'velocities'):
            self.assertTrue(hasattr(dyn, attr))

        for x, y in zip(dyn.positions[10],
                [-0.1099425448789507, -1.83499212341286, 6.089155631551154]):
            self.assertAlmostEqual(x, y)
Example #41
0
 def __init__(self, fname, seq=None):
     super(XyzFile, self).__init__()
     if isinstance(fname, string_types):
         fxyz = genopen(fname, 'r')
         own_handle_xyz = True
     else:
         fxyz = fname
         own_handle_xyz = False
     if seq is not None:
         seqstruct = load_file(seq)
     # Now parse the file
     try:
         natom = int(fxyz.readline().split()[0])
     except (ValueError, IndexError):
         raise TinkerError('Bad XYZ file format; first line')
     if seq is not None and natom != len(seqstruct.atoms):
         raise ValueError(
             'Sequence file %s # of atoms does not match the # '
             'of atoms in the XYZ file' % seq)
     words = fxyz.readline().split()
     if len(words) == 6 and not XyzFile._check_atom_record(words):
         self.box = [float(w) for w in words]
         words = fxyz.readline().split()
     atom = Atom(atomic_number=AtomicNum[element_by_name(words[1])],
                 name=words[1],
                 type=words[5])
     atom.xx, atom.xy, atom.xz = [float(w) for w in words[2:5]]
     residue = Residue('SYS')
     residue.number = 1
     residue._idx = 0
     if seq is not None:
         residue = seqstruct.residues[0]
     self.add_atom(atom, residue.name, residue.number, residue.chain,
                   residue.insertion_code, residue.segid)
     bond_ids = [[int(w) for w in words[6:]]]
     for i, line in enumerate(fxyz):
         words = line.split()
         atom = Atom(atomic_number=AtomicNum[element_by_name(words[1])],
                     name=words[1],
                     type=words[5])
         atom.xx, atom.xy, atom.xz = [float(w) for w in words[2:5]]
         if seq is not None:
             residue = seqstruct.atoms[i + 1].residue
         self.add_atom(atom, residue.name, residue.number, residue.chain,
                       residue.insertion_code, residue.segid)
         bond_ids.append([int(w) for w in words[6:]])
     # All of the bonds are stored now -- go ahead and make them now
     for atom, bonds in zip(self.atoms, bond_ids):
         i = atom.idx + 1
         for idx in bonds:
             if idx > i:
                 self.bonds.append(Bond(atom, self.atoms[idx - 1]))
     if own_handle_xyz:
         fxyz.close()
    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)
Example #43
0
 def testLoadDataFrameStructureView(self):
     """ Tests the load_dataframe method on StructureView """
     struct = create_random_structure(parametrized=True).view[:10, :]
     charges = [a.charge for a in struct.atoms]
     self.assertTrue(not all(x == 0 for x in charges))
     df = struct.to_dataframe()
     # First zero-out all of the charges
     struct.load_dataframe(dict(charge=[0 for a in struct.atoms]))
     self.assertTrue(all(a.charge == 0 for a in struct.atoms))
     # Now re-load the dataframe to restore the original charges
     struct.load_dataframe(df)
     self.assertTrue(
         all(a.charge == x for a, x in zip(struct.atoms, charges)))
     # Change the first atomic properties of *everything* now to
     # make sure that they all get updated
     df_orig = df.copy()
     df.loc[0, 'number'] = 1
     df.loc[0, 'name'] = 'HAHA'
     df.loc[0, 'type'] = 'FUNY'
     df.loc[0, 'atomic_number'] = 92  # uranium
     df.loc[0, 'charge'] *= 2
     df.loc[0, 'mass'] *= 10
     df.loc[0, 'nb_idx'] = 10
     df.loc[0, 'solvent_radius'] *= 2
     df.loc[0, 'screen'] = 0.5
     df.loc[0, 'occupancy'] = 0.1
     df.loc[0, 'bfactor'] = 0.5
     df.loc[0, 'altloc'] = 'X'
     df.loc[0, 'tree'] = 'BLU'
     df.loc[0, 'join'] = 1.0
     df.loc[0, 'irotat'] = 2.0
     df.loc[0, 'rmin'] *= 2
     df.loc[0, 'epsilon'] /= 2
     struct.load_dataframe(df)
     atom = struct.atoms[0]
     self.assertEqual(atom.number, 1)
     self.assertEqual(atom.name, 'HAHA')
     self.assertEqual(atom.type, 'FUNY')
     self.assertEqual(atom.atomic_number, 92)
     self.assertEqual(atom.charge, charges[0] * 2)
     self.assertEqual(atom.mass, 10 * df_orig.loc[0, 'mass'])
     self.assertEqual(atom.nb_idx, 10)
     self.assertEqual(atom.solvent_radius,
                      2 * df_orig.loc[0, 'solvent_radius'])
     self.assertEqual(atom.screen, 0.5)
     self.assertEqual(atom.occupancy, 0.1)
     self.assertEqual(atom.bfactor, 0.5)
     self.assertEqual(atom.altloc, 'X')
     self.assertEqual(atom.tree, 'BLU')
     self.assertEqual(atom.join, 1.0)
     self.assertEqual(atom.irotat, 2.0)
     self.assertEqual(atom.rmin, 2 * df_orig.loc[0, 'rmin'])
     self.assertEqual(atom.epsilon, df_orig.loc[0, 'epsilon'] / 2)
Example #44
0
 def test_reporters_pbc(self):
     """ Test NetCDF and ASCII restart and trajectory reporters (w/ PBC) """
     systemsolv = load_file(get_fn('ildn.solv.top'),
                            xyz=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,
                          Reference)
     sim.context.setPositions(systemsolv.positions)
     sim.reporters.extend([
         NetCDFReporter(get_fn('traj.nc', written=True),
                        1,
                        vels=True,
                        frcs=True),
         MdcrdReporter(get_fn('traj.mdcrd', written=True), 1),
         RestartReporter(get_fn('restart.ncrst', written=True),
                         1,
                         netcdf=True),
         RestartReporter(get_fn('restart.rst7', written=True), 1),
         StateDataReporter(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(get_fn('traj.nc', written=True))
     atraj = AmberMdcrd(get_fn('traj.mdcrd', written=True),
                        len(systemsolv.atoms),
                        True,
                        mode='r')
     nrst = NetCDFRestart.open_old(get_fn('restart.ncrst', written=True))
     arst = AmberAsciiRestart(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()
Example #45
0
 def assertAlmostEqualQuantities(self, item1, item2, places=6):
     try:
         val1 = item1.value_in_unit(item1.unit)
         val2 = item2.value_in_unit(item1.unit)
     except TypeError:
         raise self.failureException('Incompatible units %s and %s' %
                                     (item1.unit, item2.unit))
     try:
         if len(val1) != len(val2):
             raise self.failureException('collections are different lengths')
         for x, y in zip(val1, val2):
             self.assertAlmostEqual(x, y, places=places)
     except TypeError:
         self.assertAlmostEqual(val1, val2, places=places)
 def test_benzene_cyclohexane(self):
     """ Test converting binary liquid from Amber prmtop to Gromacs top """
     parm = load_file(get_fn('benzene_cyclohexane_10_500.prmtop'),
                      get_fn('benzene_cyclohexane_10_500.inpcrd'))
     top = gromacs.GromacsTopologyFile.from_structure(parm)
     self.assertEqual(top.combining_rule, 'lorentz')
     groname = get_fn('benzene_cyclohexane_10_500.gro', written=True)
     gromacs.GromacsGroFile.write(parm, groname, precision=8)
     gro = gromacs.GromacsGroFile.parse(groname)
     self.assertEqual(len(gro.atoms), len(parm.atoms))
     np.testing.assert_allclose(gro.box, parm.box)
     for a1, a2 in zip(gro.atoms, parm.atoms):
         self.assertEqual(a1.residue.name, a2.residue.name)
         self.assertEqual(a1.residue.idx, a2.residue.idx)
         self.assertEqual(a1.name, a2.name)
         self.assertAlmostEqual(a1.xx, a2.xx)
         self.assertAlmostEqual(a1.xy, a2.xy)
         self.assertAlmostEqual(a1.xz, a2.xz)
     top.write(get_fn('benzene_cyclohexane_10_500.top', written=True))
     saved = GromacsFile(get_saved_fn('benzene_cyclohexane_10_500.top'))
     written = GromacsFile(
         get_fn('benzene_cyclohexane_10_500.top', written=True))
     self.assertTrue(diff_files(saved, written))
     # Check that Gromacs topology is given the correct box information when
     # generated from a Structure
     gromacs.GromacsGroFile.write(top, groname, precision=8)
     gro = gromacs.GromacsGroFile.parse(groname)
     self.assertEqual(len(gro.atoms), len(parm.atoms))
     for a1, a2 in zip(gro.atoms, parm.atoms):
         self.assertEqual(a1.residue.name, a2.residue.name)
         self.assertEqual(a1.residue.idx, a2.residue.idx)
         self.assertEqual(a1.name, a2.name)
         self.assertAlmostEqual(a1.xx, a2.xx)
         self.assertAlmostEqual(a1.xy, a2.xy)
         self.assertAlmostEqual(a1.xz, a2.xz)
     np.testing.assert_allclose(gro.box, parm.box)
     np.testing.assert_allclose(top.box, parm.box)
Example #47
0
 def __str__(self):
     if len(self.amplitude) == 0:
         return ('TorsionAngle %r --- %r --- %r --- %r\n'
                 '   No Terms' %
                 (self.atom1, self.atom2, self.atom3, self.atom4))
     retstr = 'TorsionAngle %r --- %r --- %r --- %r' % (
         self.atom1, self.atom2, self.atom3, self.atom4)
     seq = range(len(self.amplitude))
     for i, amp, phase, per in enumerate(
             zip(seq, self.amplitude, self.phase, self.periodicity)):
         retstr += ('\n   Term %d\n'
                    '   Amplitude = %.4f\n'
                    '       Phase = %.4f\n'
                    ' Periodicity = %.4f' % (i + 1, amp, phase, per))
     return retstr
    def test_residue_serialization(self):
        """ Tests the serialization of Residue """
        struct = utils.create_random_structure(parametrized=True)
        res = struct.residues[0]

        fobj = BytesIO()
        pickle.dump(res, fobj)
        fobj.seek(0)
        unpickled = pickle.load(fobj)

        self.assertEqual(len(res.atoms), len(unpickled.atoms))
        for a1, a2 in zip(res, unpickled):
            self._equal_atoms(a1, a2)
            self.assertIs(a1.residue, res)
            self.assertIs(a2.residue, unpickled)
    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_residue_atom_selection(self):
        """ Tests combined residue,atom slicing/selections """
        sel = pdb1[10:20, :5]  # First five atoms of residues 10-19
        self.assertEqual(len(sel.atoms), 49)  # 1 residue has only 4 atoms
        c = 0
        for res in pdb1.residues[10:20]:
            for i in range(min(len(res), 5)):
                self.assertEqual(sel.atoms[c].name, res[i].name)
                self.assertEqual(sel.atoms[c].xx, res[i].xx)
                self.assertEqual(sel.atoms[c].xy, res[i].xy)
                self.assertEqual(sel.atoms[c].xz, res[i].xz)
                c += 1

        sel = pdb1[[0, 2, 3,
                    5], :2]  # First 2 atoms of residues 0, 2, 3, and 5
        self.assertEqual(len(sel.atoms), 8)
        c = 0
        for i, res in enumerate([0, 2, 3, 5]):
            res = pdb1.residues[res]
            self.assertEqual(sel.atoms[c].name, res[0].name)
            self.assertEqual(sel.atoms[c].xx, res[0].xx)
            self.assertEqual(sel.atoms[c].xy, res[0].xy)
            self.assertEqual(sel.atoms[c].xz, res[0].xz)
            c += 1
            self.assertEqual(sel.atoms[c].name, res[1].name)
            self.assertEqual(sel.atoms[c].xx, res[1].xx)
            self.assertEqual(sel.atoms[c].xy, res[1].xy)
            self.assertEqual(sel.atoms[c].xz, res[1].xz)
            c += 1

        sel = pdb1[8, :]
        self.assertEqual(len(sel.atoms), len(pdb1.residues[8]))
        for a1, a2 in zip(sel.atoms, pdb1.residues[8]):
            self.assertEqual(a1.name, a2.name)
            self.assertEqual(a1.xx, a2.xx)
            self.assertEqual(a1.xy, a2.xy)
            self.assertEqual(a1.xz, a2.xz)

        self.assertIs(pdb1[8, 4], pdb1.residues[8][4])

        sel = pdb1[['ALA', 'GLY'], :]
        for atom in sel.atoms:
            self.assertIn(atom.residue.name, ('ALA', 'GLY'))

        nalagly = sum(r.name in ('ALA', 'GLY') for r in pdb1.residues)
        natom = sum(len(r) for r in pdb1.residues if r.name in ('ALA', 'GLY'))
        self.assertEqual(nalagly, len(sel.residues))
        self.assertEqual(natom, len(sel.atoms))
Example #51
0
 def _load_cmap_info(self):
     """ Loads the CHARMM CMAP types and array """
     if not self.has_cmap: return
     del self.cmaps[:]
     del self.cmap_types[:]
     for i in range(self.pointers['CMAP_TYPES']):
         resolution = self.parm_data['CHARMM_CMAP_RESOLUTION'][i]
         grid = self.parm_data['CHARMM_CMAP_PARAMETER_%02d' % (i + 1)]
         cmts = self.parm_comments['CHARMM_CMAP_PARAMETER_%02d' % (i + 1)]
         self.cmap_types.append(
             CmapType(resolution, grid, cmts, list=self.cmap_types))
     it = iter(self.parm_data['CHARMM_CMAP_INDEX'])
     for i, j, k, l, m, n in zip(it, it, it, it, it, it):
         self.cmaps.append(
             Cmap(self.atoms[i - 1], self.atoms[j - 1], self.atoms[k - 1],
                  self.atoms[l - 1], self.atoms[m - 1],
                  self.cmap_types[n - 1]))
Example #52
0
    def test_simple(self):
        """ Tests converting simple Amber system to CHARMM PSF/parameters """
        parm = load_file(get_fn('trx.prmtop'), get_fn('trx.inpcrd'))
        parm.save(get_fn('amber_to_charmm.psf', written=True))
        params = charmm.CharmmParameterSet.from_structure(parm)
        params.write(str=get_fn('amber_to_charmm.str', written=True))

        self.assertTrue(
                diff_files(get_saved_fn('amber_to_charmm.psf'),
                           get_fn('amber_to_charmm.psf', written=True)
                )
        )
        self.assertTrue(
                diff_files(get_saved_fn('amber_to_charmm.str'),
                           get_fn('amber_to_charmm.str', written=True),
                           absolute_error=1e-5,
                )
        )
        # Check the PSF file
        psf = load_file(get_fn('amber_to_charmm.psf', written=True))
        psf.load_parameters(
                charmm.CharmmParameterSet(get_fn('amber_to_charmm.str',
                                          written=True))
        )
        for a1, a2 in zip(psf.atoms, parm.atoms):
            self.assertEqual(a1.name, a2.name)
            self.assertEqual(a1.atomic_number, a2.atomic_number)
            self.assertEqual(a1.mass, a2.mass)
        self.assertEqual(len(psf.bonds), len(parm.bonds))
        self.assertEqual(len(psf.angles), len(parm.angles))
        # Get number of unique torsions
        nnormal = nimp = 0
        torsfound = set()
        for tor in parm.dihedrals:
            a1, a2, a3, a4 = tor.atom1, tor.atom2, tor.atom3, tor.atom4
            if tor.improper:
                nimp += 1
                continue
            if (a1, a2, a3, a4) in torsfound or (a4, a3, a2, a1) in torsfound:
                continue
            torsfound.add((a1, a2, a3, a4))
            nnormal += 1
        # Make sure that written psf only contains unique torsions.
        self.assertEqual(nnormal+nimp, len(psf.dihedrals))
    def test_residue_atom_selection(self):
        """ Tests combined residue,atom slicing/selections (view) """
        sel = pdb1.view[10:20, :5]  # First five atoms of residues 10-19
        self.assertIsInstance(sel, pmd.structure.StructureView)
        self.assertEqual(len(sel.atoms), 49)  # 1 residue has only 4 atoms
        c = 0
        for res in pdb1.residues[10:20]:
            for i in range(min(len(res), 5)):
                self.assertIs(sel.atoms[c], res[i])
                c += 1

        sel = pdb1.view[[0, 2, 3,
                         5], :2]  # First 2 atoms of residues 0, 2, 3, and 5
        self.assertIsInstance(sel, pmd.structure.StructureView)
        self.assertEqual(len(sel.atoms), 8)
        c = 0
        for i, res in enumerate([0, 2, 3, 5]):
            res = pdb1.residues[res]
            self.assertIs(sel.atoms[c], res[0])
            c += 1
            self.assertIs(sel.atoms[c], res[1])
            c += 1

        sel = pdb1.view[8, :]
        self.assertIsInstance(sel, pmd.structure.StructureView)
        self.assertEqual(len(sel.atoms), len(pdb1.residues[8]))
        for a1, a2 in zip(sel.atoms, pdb1.residues[8]):
            self.assertIs(a1, a2)

        self.assertIs(pdb1[8, 4], pdb1.residues[8][4])

        sel = pdb1.view[['ALA', 'GLY'], :]
        self.assertIsInstance(sel, pmd.structure.StructureView)
        for atom in sel.atoms:
            self.assertIn(atom.residue.name, ('ALA', 'GLY'))
            self.assertIs(atom.list, pdb1.atoms)

        nalagly = sum(r.name in ('ALA', 'GLY') for r in pdb1.residues)
        natom = sum(len(r) for r in pdb1.residues if r.name in ('ALA', 'GLY'))
        self.assertEqual(nalagly, len(sel.residues))
        self.assertEqual(natom, len(sel.atoms))
 def test_simple(self):
     """ Tests converting standard Gromacs system into Amber prmtop """
     top = load_file(get_fn(os.path.join('03.AlaGlu', 'topol.top')))
     self.assertEqual(top.combining_rule, 'lorentz')
     parm = amber.AmberParm.from_structure(top)
     parm.write_parm(get_fn('ala_glu.parm7', written=True))
     parm = load_file(get_fn('ala_glu.parm7', written=True))
     self.assertIsInstance(parm, amber.AmberParm)
     self.assertEqual(len(top.atoms), len(parm.atoms))
     self.assertEqual(len(top.bonds), len(parm.bonds))
     self.assertEqual(len(top.angles), len(parm.angles))
     self.assertEqual(len(top.residues), len(parm.residues))
     for a1, a2 in zip(top.atoms, parm.atoms):
         self.assertEqual(a1.name, a2.name)
         self.assertEqual(a1.type, a2.type)
         self.assertEqual(a1.atomic_number, a2.atomic_number)
         self.assertEqual(a1.residue.name, a2.residue.name)
         self.assertEqual(a1.residue.idx, a2.residue.idx)
         self.assertAlmostEqual(a1.mass, a2.mass)
         self.assertIs(type(a1), type(a2))
         self.assertAlmostEqual(a1.charge, a2.charge)
         self.assertEqual(set([a.idx for a in a1.bond_partners]),
                          set([a.idx for a in a2.bond_partners]))
         self.assertEqual(set([a.idx for a in a1.angle_partners]),
                          set([a.idx for a in a2.angle_partners]))
         self.assertEqual(set([a.idx for a in a1.dihedral_partners]),
                          set([a.idx for a in a2.dihedral_partners]))
     # Make sure that assign_nbidx_from_types compresses maximally. First
     # add a new, equivalent L-J type. Then call assign_nbidx_from_types
     # again, which should recompress
     before_nbidx = [a.nb_idx for a in parm.atoms]
     addLJType(parm, '@1').execute()
     after_nbidx = [a.nb_idx for a in parm.atoms]
     self.assertEqual(before_nbidx[1:], after_nbidx[1:])
     self.assertEqual(after_nbidx[0], max(before_nbidx) + 1)
     parm.atoms.assign_nbidx_from_types()
     # Should recompress
     self.assertEqual(before_nbidx, [a.nb_idx for a in parm.atoms])
 def cmp_type_arrays(arr1, arr2):
     self.assertEqual(len(arr1), len(arr2))
     for x1, x2 in zip(arr1, arr2):
         self.assertEqual(x1, x2)
    def _compare_structures(self, unpickled, structure):

        self.assertEqual(len(unpickled.residues), len(structure.residues))
        for r1, r2 in zip(unpickled.residues, structure.residues):
            self.assertEqual(len(r1), len(r2))
            self.assertEqual(r1.idx, r2.idx)
            for a1, a2 in zip(r1, r2):
                self._equal_atoms(a1, a2)

        def cmp_alists(alist1, alist2):
            self.assertEqual(len(alist1), len(alist2))
            for a1, a2 in zip(alist1, alist2):
                self._equal_atoms(a1, a2)

        for a1, a2 in zip(unpickled, structure):
            self._equal_atoms(a1, a2)
            self.assertEqual(a1.idx, a2.idx)
            self.assertEqual(len(a1.bonds), len(a2.bonds))
            self.assertEqual(len(a1.angles), len(a2.angles))
            self.assertEqual(len(a1.dihedrals), len(a2.dihedrals))
            self.assertEqual(len(a1.impropers), len(a2.impropers))
            cmp_alists(a1.bond_partners, a2.bond_partners)
            cmp_alists(a1.angle_partners, a2.angle_partners)
            cmp_alists(a1.dihedral_partners, a2.dihedral_partners)
            cmp_alists(a1.tortor_partners, a2.tortor_partners)
            cmp_alists(a1.exclusion_partners, a2.exclusion_partners)

        # Check coordinates
        if structure.get_coordinates() is None:
            self.assertIs(unpickled.get_coordinates(), None)
        else:
            np.testing.assert_equal(structure.get_coordinates(),
                                    unpickled.get_coordinates())
        # Check unit cell
        if structure.box is None:
            self.assertIs(unpickled.box, None)
            self.assertIs(unpickled.box_vectors, None)
        else:
            np.testing.assert_equal(structure.box, unpickled.box)
            self.assertEqual(structure.box_vectors, unpickled.box_vectors)

        # Check velocities
        if structure.velocities is None:
            self.assertIs(unpickled.velocities, None)
        else:
            np.testing.assert_equal(structure.velocities, unpickled.velocities)

        # Check nrexcl and combining_rule
        self.assertEqual(structure.nrexcl, unpickled.nrexcl)
        self.assertEqual(structure.combining_rule, unpickled.combining_rule)

        # Make sure all of the type arrays are equivalent
        def cmp_type_arrays(arr1, arr2):
            self.assertEqual(len(arr1), len(arr2))
            for x1, x2 in zip(arr1, arr2):
                self.assertEqual(x1, x2)

        cmp_type_arrays(structure.bond_types, unpickled.bond_types)
        cmp_type_arrays(structure.angle_types, unpickled.angle_types)
        cmp_type_arrays(structure.dihedral_types, unpickled.dihedral_types)
        cmp_type_arrays(structure.improper_types, unpickled.improper_types)
        cmp_type_arrays(structure.urey_bradley_types,
                        unpickled.urey_bradley_types)
        cmp_type_arrays(structure.rb_torsion_types, unpickled.rb_torsion_types)
        cmp_type_arrays(structure.cmap_types, unpickled.cmap_types)
        cmp_type_arrays(structure.trigonal_angle_types,
                        unpickled.trigonal_angle_types)
        cmp_type_arrays(structure.out_of_plane_bend_types,
                        unpickled.out_of_plane_bend_types)
        cmp_type_arrays(structure.stretch_bend_types,
                        unpickled.stretch_bend_types)
        cmp_type_arrays(structure.torsion_torsion_types,
                        unpickled.torsion_torsion_types)
        cmp_type_arrays(structure.pi_torsion_types, unpickled.pi_torsion_types)
        cmp_type_arrays(structure.adjust_types, unpickled.adjust_types)

        # Make sure all of the connectivity arrays are equivalent
        def cmp_top_arrays(arr1, arr2):
            self.assertEqual(len(arr1), len(arr2))
            for t1, t2 in zip(arr1, arr2):
                self.assertIs(type(t1), type(t2))
                atoms = [attr for attr in dir(t1) if attr.startswith('atom')]
                for a in atoms:
                    self._equal_atoms(getattr(t1, a), getattr(t2, a))
                if hasattr(t1, 'type'):
                    self.assertEqual(t1.type, t2.type)

        cmp_top_arrays(structure.bonds, unpickled.bonds)
        cmp_top_arrays(structure.angles, unpickled.angles)
        cmp_top_arrays(structure.dihedrals, unpickled.dihedrals)
        cmp_top_arrays(structure.impropers, unpickled.impropers)
        cmp_top_arrays(structure.urey_bradleys, unpickled.urey_bradleys)
        cmp_top_arrays(structure.rb_torsions, unpickled.rb_torsions)
        cmp_top_arrays(structure.cmaps, unpickled.cmaps)
        cmp_top_arrays(structure.trigonal_angles, unpickled.trigonal_angles)
        cmp_top_arrays(structure.out_of_plane_bends,
                       unpickled.out_of_plane_bends)
        cmp_top_arrays(structure.pi_torsions, unpickled.pi_torsions)
        cmp_top_arrays(structure.stretch_bends, unpickled.stretch_bends)
        cmp_top_arrays(structure.torsion_torsions, unpickled.torsion_torsions)
        cmp_top_arrays(structure.chiral_frames, unpickled.chiral_frames)
        cmp_top_arrays(structure.multipole_frames, unpickled.multipole_frames)
        cmp_top_arrays(structure.adjusts, unpickled.adjusts)
        cmp_top_arrays(structure.groups, unpickled.groups)
Example #57
0
 def __init__(self, psf_name=None):
     """
     Opens and parses a PSF file, then instantiates a CharmmPsfFile
     instance from the data.
     """
     global _resre
     Structure.__init__(self)
     # Bail out if we don't have a filename
     if psf_name is None:
         return
     conv = CharmmPsfFile._convert
     # Open the PSF and read the first line. It must start with "PSF"
     with closing(genopen(psf_name, 'r')) as psf:
         self.name = psf_name
         line = psf.readline()
         if not line.startswith('PSF'):
             raise CharmmError('Unrecognized PSF file. First line is %s' %
                               line.strip())
         # Store the flags
         psf_flags = line.split()[1:]
         # Now get all of the sections and store them in a dict
         psf.readline()
         # Now get all of the sections
         psfsections = _ZeroDict()
         while True:
             try:
                 sec, ptr, data = CharmmPsfFile._parse_psf_section(psf)
             except _FileEOF:
                 break
             psfsections[sec] = (ptr, data)
         # store the title
         self.title = psfsections['NTITLE'][1]
         # Next is the number of atoms
         natom = conv(psfsections['NATOM'][0], int, 'natom')
         # Parse all of the atoms
         for i in range(natom):
             words = psfsections['NATOM'][1][i].split()
             atid = int(words[0])
             if atid != i + 1:
                 raise CharmmError('Nonsequential atoms detected!')
             segid = words[1]
             rematch = _resre.match(words[2])
             if not rematch:
                 raise CharmmError('Could not interpret residue number %s'
                                   %  # pragma: no cover
                                   words[2])
             resid, inscode = rematch.groups()
             resid = conv(resid, int, 'residue number')
             resname = words[3]
             name = words[4]
             attype = words[5]
             # Try to convert the atom type to an integer a la CHARMM
             try:
                 attype = int(attype)
             except ValueError:
                 pass
             charge = conv(words[6], float, 'partial charge')
             mass = conv(words[7], float, 'atomic mass')
             props = words[8:]
             atom = Atom(name=name, type=attype, charge=charge, mass=mass)
             atom.props = props
             self.add_atom(atom,
                           resname,
                           resid,
                           chain=segid,
                           inscode=inscode,
                           segid=segid)
         # Now get the number of bonds
         nbond = conv(psfsections['NBOND'][0], int, 'number of bonds')
         if len(psfsections['NBOND'][1]) != nbond * 2:
             raise CharmmError(
                 'Got %d indexes for %d bonds' %  # pragma: no cover
                 (len(psfsections['NBOND'][1]), nbond))
         it = iter(psfsections['NBOND'][1])
         for i, j in zip(it, it):
             self.bonds.append(Bond(self.atoms[i - 1], self.atoms[j - 1]))
         # Now get the number of angles and the angle list
         ntheta = conv(psfsections['NTHETA'][0], int, 'number of angles')
         if len(psfsections['NTHETA'][1]) != ntheta * 3:
             raise CharmmError(
                 'Got %d indexes for %d angles' %  # pragma: no cover
                 (len(psfsections['NTHETA'][1]), ntheta))
         it = iter(psfsections['NTHETA'][1])
         for i, j, k in zip(it, it, it):
             self.angles.append(
                 Angle(self.atoms[i - 1], self.atoms[j - 1],
                       self.atoms[k - 1]))
             self.angles[-1].funct = 5  # urey-bradley
         # Now get the number of torsions and the torsion list
         nphi = conv(psfsections['NPHI'][0], int, 'number of torsions')
         if len(psfsections['NPHI'][1]) != nphi * 4:
             raise CharmmError(
                 'Got %d indexes for %d torsions' %  # pragma: no cover
                 (len(psfsections['NPHI']), nphi))
         it = iter(psfsections['NPHI'][1])
         for i, j, k, l in zip(it, it, it, it):
             self.dihedrals.append(
                 Dihedral(self.atoms[i - 1], self.atoms[j - 1],
                          self.atoms[k - 1], self.atoms[l - 1]))
         self.dihedrals.split = False
         # Now get the number of improper torsions
         nimphi = conv(psfsections['NIMPHI'][0], int, 'number of impropers')
         if len(psfsections['NIMPHI'][1]) != nimphi * 4:
             raise CharmmError(
                 'Got %d indexes for %d impropers' %  # pragma: no cover
                 (len(psfsections['NIMPHI'][1]), nimphi))
         it = iter(psfsections['NIMPHI'][1])
         for i, j, k, l in zip(it, it, it, it):
             self.impropers.append(
                 Improper(self.atoms[i - 1], self.atoms[j - 1],
                          self.atoms[k - 1], self.atoms[l - 1]))
         # Now handle the donors (what is this used for??)
         ndon = conv(psfsections['NDON'][0], int, 'number of donors')
         if len(psfsections['NDON'][1]) != ndon * 2:
             raise CharmmError(
                 'Got %d indexes for %d donors' %  # pragma: no cover
                 (len(psfsections['NDON'][1]), ndon))
         it = iter(psfsections['NDON'][1])
         for i, j in zip(it, it):
             self.donors.append(
                 AcceptorDonor(self.atoms[i - 1], self.atoms[j - 1]))
         # Now handle the acceptors (what is this used for??)
         nacc = conv(psfsections['NACC'][0], int, 'number of acceptors')
         if len(psfsections['NACC'][1]) != nacc * 2:
             raise CharmmError(
                 'Got %d indexes for %d acceptors' %  # pragma: no cover
                 (len(psfsections['NACC'][1]), nacc))
         it = iter(psfsections['NACC'][1])
         for i, j in zip(it, it):
             self.acceptors.append(
                 AcceptorDonor(self.atoms[i - 1], self.atoms[j - 1]))
         # Now get the group sections
         try:
             ngrp, nst2 = psfsections['NGRP NST2'][0]
         except ValueError:  # pragma: no cover
             raise CharmmError(
                 'Could not unpack GROUP pointers')  # pragma: no cover
         tmp = psfsections['NGRP NST2'][1]
         self.groups.nst2 = nst2
         # Now handle the groups
         if len(psfsections['NGRP NST2'][1]) != ngrp * 3:
             raise CharmmError(
                 'Got %d indexes for %d groups' %  # pragma: no cover
                 (len(tmp), ngrp))
         it = iter(psfsections['NGRP NST2'][1])
         for i, j, k in zip(it, it, it):
             self.groups.append(Group(self.atoms[i], j, k))
         # Assign all of the atoms to molecules recursively
         tmp = psfsections['MOLNT'][1]
         set_molecules(self.atoms)
         molecule_list = [a.marked for a in self.atoms]
         if len(tmp) == len(self.atoms):
             if molecule_list != tmp:
                 warnings.warn(
                     'Detected PSF molecule section that is WRONG. '
                     'Resetting molecularity.', CharmmWarning)
             # We have a CHARMM PSF file; now do NUMLP/NUMLPH sections
             numlp, numlph = psfsections['NUMLP NUMLPH'][0]
             if numlp != 0 or numlph != 0:
                 raise NotImplementedError(
                     'Cannot currently handle PSFs with '
                     'lone pairs defined in the NUMLP/'
                     'NUMLPH section.')
         # Now do the CMAPs
         ncrterm = conv(psfsections['NCRTERM'][0], int,
                        'Number of cross-terms')
         if len(psfsections['NCRTERM'][1]) != ncrterm * 8:
             raise CharmmError('Got %d CMAP indexes for %d cmap terms'
                               %  # pragma: no cover
                               (len(psfsections['NCRTERM']), ncrterm))
         it = iter(psfsections['NCRTERM'][1])
         for i, j, k, l, m, n, o, p in zip(it, it, it, it, it, it, it, it):
             self.cmaps.append(
                 Cmap.extended(self.atoms[i - 1], self.atoms[j - 1],
                               self.atoms[k - 1], self.atoms[l - 1],
                               self.atoms[m - 1], self.atoms[n - 1],
                               self.atoms[o - 1], self.atoms[p - 1]))
         self.unchange()
         self.flags = psf_flags
 def cmp_alists(alist1, alist2):
     self.assertEqual(len(alist1), len(alist2))
     for a1, a2 in zip(alist1, alist2):
         self._equal_atoms(a1, a2)