Example #1
0
    def test_qmmm_advanced_2(self):
        """ 2 qm fragments in qm/mm interface with bond breaking """
        filename = "temp.inp"
        molecule = fileToMol("tests/5ala.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataPE)
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()

        ref_fragments = copy.deepcopy(fragmentation.getFragments()[:])
        self.assertEqual(len(ref_fragments), 5)

        qmmm = QMMM(fragmentation, [2, 3])
        qmfrag, qmcharge = qmmm.pop_qm_fragment()
        new_fragments = copy.deepcopy(fragmentation.getFragments()[:])

        self.assertEqual(len(new_fragments), 5)
        self.assertEqual(len(qmfrag),
                         len(ref_fragments[1]) + len(ref_fragments[2]) +
                         2)  # two atoms added to QM region from two fragments
        self.assertEqual(len(new_fragments[0]),
                         len(ref_fragments[0]) +
                         1)  # one atom added to MM region for one fragment
        self.assertEqual(len(new_fragments[3]),
                         len(ref_fragments[3]) +
                         1)  # one atom added to MM region for one fragment
    def test_2form8wat_2(self):
        filename = "temp.inp"
        otherfile = self.fixtures + "/2form8wat_2.fixture"
        molecule = fileToMol("tests/2form8wat.pdb")
        fragmentation = Fragmentation(molecule, defaults=FragItDataFMO)
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()
        fragmentation.setFMOEFPWatersFromLayer(1)
        directories = {'share': ''}
        gamessfmo = GamessFMO(fragmentation, directories)
        gamessfmo.setCentralFragmentID(1)
        gamessfmo.setBoundariesFromString("3.0")
        gamessfmo.setup()
        gamessfmo.writeFile(filename)
        generated = ReadStringListFromFile(filename)
        fixture = ReadStringListFromFile(otherfile)

        self.assertEqual(len(generated), len(fixture))

        ignoring = False
        for i in range(len(fixture)):
            if "EFRAG" in generated[i] or "EFRAG" in fixture[i]:
                ignoring = True

            if ignoring:
                if "END" in generated[i] or "END" in fixture[i]:
                    ignoring = False

            if not ignoring:
                self.assertEqual(generated[i], fixture[i])

        self.delete_file(filename)
Example #3
0
    def setUp(self):
        self.filename_pdb = "tests/1UAO.pdb"

        # for testing, use OpenBabel functionality directly
        self.molecule = fileToMol(self.filename_pdb)
        self.fragmentation = Fragmentation(self.molecule,
                                           defaults=FragItDataFMO)
 def test_writereadconfiguration_basic(self):
     filename = "temp.cfg"
     self.fragmentation.writeConfigurationToFile(filename)
     otherfrag = Fragmentation(self.molecule)
     otherfrag.readConfigurationFromFile(filename)
     for key in otherfrag.values.keys():
       for key2 in otherfrag.values[key].keys():
         self.assertEqual(self.fragmentation.values[key][key2], otherfrag.values[key][key2])
     self.delete_file(filename)
    def test_2form8wat_2(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/2form8wat_2.fixture"
      molecule = fileToMol("tests/2form8wat.pdb")
      fragmentation = Fragmentation(molecule)
      fragmentation.beginFragmentation()
      fragmentation.doFragmentation()
      fragmentation.finishFragmentation()
      fragmentation.setFMOEFPWatersFromLayer(1)
      directories = {'share':''}
      gamessfmo = GamessFMO(fragmentation, directories)
      gamessfmo.setCentralFragmentID(1)
      gamessfmo.setBoundariesFromString("3.0")
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))

      ignoring = False
      for i in range(len(fixture)):
        if "EFRAG" in generated[i] or "EFRAG" in fixture[i]:
            ignoring = True

        if ignoring:
            if "END" in generated[i] or "END" in fixture[i]:
                ignoring = False

        if not ignoring:
            self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)
Example #6
0
 def test_writereadconfiguration_basic(self):
     filename = "temp.cfg"
     handle = open(filename, 'w')
     self.fragmentation.writeConfigurationToFile(handle)
     handle.close()
     otherfrag = Fragmentation(self.molecule)
     otherfrag.readConfigurationFromFile(filename)
     for key in otherfrag.values.keys():
         for key2 in otherfrag.values[key].keys():
             self.assertEqual(self.fragmentation.values[key][key2],
                              otherfrag.values[key][key2])
     self.delete_file(filename)
Example #7
0
    def test_qmmm_simple_2(self):
        """ 2 qm fragments in qm/mm interface without bond breaking """
        filename = "temp.inp"
        molecule = fileToMol("tests/watercluster4.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataPE)
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()

        ref_fragments = fragmentation.getFragments()
        self.assertEqual(len(ref_fragments), 4)

        qmmm = QMMM(fragmentation, [1, 3])  # extracts fragments 1 and 3
        qmfrag, qmcharge = qmmm.pop_qm_fragment()
        new_fragments = fragmentation.getFragments()

        self.assertEqual(qmfrag, [1, 2, 3, 7, 8, 9])
        self.assertEqual(len(new_fragments), 4)
        self.assertEqual(new_fragments[0], [-1, -1, -1])
        self.assertEqual(new_fragments[2], [-1, -1, -1])
    def test_5ala_1_hop(self):
        filename = "temp.inp"
        otherfile = self.fixtures + "/5ala_1_hop.fixture"
        molecule = fileToMol("tests/5ala.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataFMO)
        fragmentation.setFMOHOPFragmentation()
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()
        directories = {'share': 'share'}
        gamessfmo = GamessFMO(fragmentation, directories)
        gamessfmo.setup()
        gamessfmo.writeFile(filename)
        generated = ReadStringListFromFile(filename)
        fixture = ReadStringListFromFile(otherfile)

        self.assertEqual(len(generated), len(fixture))
        for i in range(len(fixture)):
            self.assertEqual(generated[i], fixture[i])

        self.delete_file(filename)
    def test_5ala_2_afo(self):
        filename = "temp.inp"
        otherfile = self.fixtures + "/5ala_2_afo.fixture"
        molecule = fileToMol("tests/5ala.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataFMO)
        fragmentation.setQMBasis('3-21G:6-31G(d)')
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()
        directories = {'share': 'share'}
        gamessfmo = GamessFMO(fragmentation, directories)
        gamessfmo.setCentralFragmentID(1)
        gamessfmo.setBoundariesFromString("1.0")
        gamessfmo.setup()
        gamessfmo.writeFile(filename)
        generated = ReadStringListFromFile(filename)
        fixture = ReadStringListFromFile(otherfile)

        self.assertEqual(len(generated), len(fixture))
        for i in range(len(fixture)):
            self.assertEqual(generated[i], fixture[i])

        self.delete_file(filename)
Example #10
0
    def test_qmmm_simple_1(self):
        """ 1 qm fragment in qm/mm interface without bond breaking """
        filename = "temp.inp"
        molecule = fileToMol("tests/watercluster4.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataPE)
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()

        ref_fragments = fragmentation.getFragments()
        self.assertEqual(len(ref_fragments), 4)

        qmmm = QMMM(fragmentation,
                    [1])  # extracts first fragment (for user this is #1)
        qmfrag, qmcharge = qmmm.pop_qm_fragment()

        new_fragments = fragmentation.getFragments()

        self.assertEqual(qmfrag, [1, 2, 3])  # extracts first fragment
        self.assertEqual(len(new_fragments),
                         4)  # must leave all fragments intact
        self.assertEqual(new_fragments[0],
                         [-1, -1, -1])  # -1 signals "DO NOT USE"
Example #11
0
    def test_qmmm_advanced_1(self):
        """ 1 qm fragment in qm/mm interface with bond breaking """
        filename = "temp.inp"
        molecule = fileToMol("tests/5ala.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataPE)
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()

        ref_fragments = copy.deepcopy(fragmentation.getFragments()[:])
        self.assertEqual(len(ref_fragments), 5)

        qmmm = QMMM(fragmentation,
                    [1])  # extracts first fragment (for user this is #1)
        qmfrag, qmcharge = qmmm.pop_qm_fragment()
        new_fragments = fragmentation.getFragments()[:]

        self.assertEqual(len(new_fragments), 5)
        self.assertEqual(len(qmfrag),
                         len(ref_fragments[0]) +
                         1)  # one atom added to QM region
        self.assertEqual(len(new_fragments[1]),
                         len(ref_fragments[1]) +
                         1)  # one atom added to MM region
    def test_5ala_1_hop(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/5ala_1_hop.fixture"
      molecule = fileToMol("tests/5ala.xyz")
      fragmentation = Fragmentation(molecule)
      fragmentation.setFMOHOPFragmentation()
      fragmentation.beginFragmentation()
      fragmentation.doFragmentation()
      fragmentation.finishFragmentation()
      directories = {'share':'share'}
      gamessfmo = GamessFMO(fragmentation, directories)
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)
    def test_water_1(self):
        filename = "temp.inp"
        otherfile = self.fixtures + "/water_1.fixture"
        molecule = fileToMol("tests/watercluster4.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataFMO)
        directories = {'share': ''}
        gamessfmo = GamessFMO(fragmentation, directories)
        gamessfmo.setup()
        gamessfmo.writeFile(filename)
        generated = ReadStringListFromFile(filename)
        fixture = ReadStringListFromFile(otherfile)

        self.assertEqual(len(generated), len(fixture))
        for i in range(len(fixture)):
            self.assertEqual(generated[i], fixture[i])

        self.delete_file(filename)
    def test_5ala_2_afo(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/5ala_2_afo.fixture"
      molecule = fileToMol("tests/5ala.xyz")
      fragmentation = Fragmentation(molecule)
      fragmentation.setQMBasis('3-21G:6-31G(d)')
      fragmentation.beginFragmentation()
      fragmentation.doFragmentation()
      fragmentation.finishFragmentation()
      directories = {'share':'share'}
      gamessfmo = GamessFMO(fragmentation, directories)
      gamessfmo.setCentralFragmentID(1)
      gamessfmo.setBoundariesFromString("1.0")
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)
    def test_water_5(self):
        filename = "temp.inp"
        otherfile = self.fixtures + "/water_5.fixture"
        molecule = fileToMol("tests/watercluster4.xyz")
        fragmentation = Fragmentation(molecule, defaults=FragItDataFMO)
        fragmentation.beginFragmentation()
        fragmentation.doFragmentation()
        fragmentation.finishFragmentation()
        directories = {'share': ''}
        gamessfmo = GamessFMO(fragmentation, directories)
        gamessfmo.setCentralFragmentID(1)
        gamessfmo.setBoundariesFromString("1.0")
        gamessfmo.setActiveAtomsDistance(1.0)
        gamessfmo.setBufferMaxDistance(1.0)
        gamessfmo.setup()
        gamessfmo.writeFile(filename)
        generated = ReadStringListFromFile(filename)
        fixture = ReadStringListFromFile(otherfile)

        self.assertEqual(len(generated), len(fixture))
        for i in range(len(fixture)):
            self.assertEqual(generated[i], fixture[i])

        self.delete_file(filename)
    def test_water_5(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/water_5.fixture"
      molecule = fileToMol("tests/watercluster4.xyz")
      fragmentation = Fragmentation(molecule)
      fragmentation.beginFragmentation()
      fragmentation.doFragmentation()
      fragmentation.finishFragmentation()
      directories = {'share':''}
      gamessfmo = GamessFMO(fragmentation, directories)
      gamessfmo.setCentralFragmentID(1)
      gamessfmo.setBoundariesFromString("1.0")
      gamessfmo.setActiveAtomsDistance(1.0)
      gamessfmo.setBufferMaxDistance(1.0)
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)
    def test_5ala_3_hop(self):
      """ Regression test to make sure if only one basis
          set is specified we get the correct input file
          FMO with HOP
      """
      filename = "temp.inp"
      otherfile = self.fixtures + "/5ala_3_hop.fixture"
      molecule = fileToMol("tests/5ala.xyz")
      fragmentation = Fragmentation(molecule)
      fragmentation.setFMOHOPFragmentation()
      fragmentation.setQMBasis('3-21G')
      fragmentation.beginFragmentation()
      fragmentation.doFragmentation()
      fragmentation.finishFragmentation()
      directories = {'share':'share'}
      gamessfmo = GamessFMO(fragmentation, directories)
      gamessfmo.setCentralFragmentID(1)
      gamessfmo.setBoundariesFromString("1.0")
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)
 def setUp(self):
     directories = {'share': ''}
     self.molecule = fileToMol("tests/1UAO.pdb")
     self.fragmentation = Fragmentation(self.molecule)
     self.standardwriter = Standard(self.fragmentation, directories)
Example #19
0
class TestFragmentationModule(unittest.TestCase):
    def setUp(self):
        self.filename_pdb = "tests/1UAO.pdb"

        # for testing, use OpenBabel functionality directly
        self.molecule = fileToMol(self.filename_pdb)
        self.fragmentation = Fragmentation(self.molecule,
                                           defaults=FragItDataFMO)

    def tearDown(self):
        pass

    def delete_file(self, filename):
        try:
            f = open(filename)
        except IOError:
            return
        finally:
            f.close()
            os.remove(filename)

    def test_FragmentationDefaultParameters(self):
        frg = self.fragmentation
        self.assertEqual(frg.mol != None, True)

    def test_FragmentationSetActiveFragments(self):
        self.fragmentation.setActiveFragments([1, 2, 3])
        self.assertEqual(self.fragmentation.active_fragments, [1, 2, 3])

    def test_FragmentationApplySmartProtectPatterns(self):
        self.fragmentation.applySmartProtectPatterns()
        self.assertEqual(self.fragmentation.getExplicitlyProtectedAtoms(),
                         [1, 2, 3, 4, 10])

    def test_FragmentationDetermineFormalCharges(self):
        #self.fragmentation.determineFormalCharges()
        self.assertAlmostEqual(sum(self.fragmentation.formalCharges), -2)

    def test_FragmentationGetProtectedAtoms(self):
        self.assertEqual(self.fragmentation.getExplicitlyProtectedAtoms(), [])

    def test_FragmentationAddProtectedAtomsAfterProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.addExplicitlyProtectedAtoms([44, 55, 67])
        self.assertEqual(self.fragmentation.getExplicitlyProtectedAtoms(),
                         [1, 2, 3, 4, 10, 44, 55, 67])

    def test_FragmentationAddBrokenBond(self):
        pass

    def test_FragmentationIsBondProtected(self):
        bond_pair = (2, 3)
        self.assertEqual(self.fragmentation.isBondProtected(bond_pair), False)
        self.fragmentation.addExplicitlyProtectedAtoms([2])
        self.assertEqual(self.fragmentation.isBondProtected(bond_pair), True)

    def test_FragmentationRealBondBreakerNoProtect(self):
        bond_atoms = (2, 3)
        self.fragmentation.addFragmentationAtomPair(bond_atoms)
        self.assertEqual(self.fragmentation.getExplicitlyBreakAtomPairs(),
                         [(2, 3)])

    def test_FragmentationIsValidExplicitBond(self):
        self.assertRaises(ValueError, self.fragmentation.isValidExplicitBond,
                          (1, 1))
        self.assertRaises(ValueError, self.fragmentation.isValidExplicitBond,
                          (2, 4))

    def test_FragmentationBreakBondsWithNoProtect(self):
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()),
                         9)

    def test_FragmentationBreakBondsExplcitWithNoProtect(self):
        self.fragmentation.addExplicitlyBreakAtomPairs([(111, 112)])
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()),
                         10)

    def test_FragmentationBreakBondsWithProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()),
                         8)

    def test_FragmentationBreakBondsExplcitWithProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.addExplicitlyBreakAtomPairs([(111, 112)])
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()),
                         9)

    def test_FragmentationDetermineFragmentsNoBreaking(self):
        self.assertRaises(ValueError, self.fragmentation.determineFragments)

    def test_FragmentationDetermineFragmentsWithBreaking(self):
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        for fragment, expected_size in zip(
                self.fragmentation.getFragments(),
            [7, 21, 12, 14, 15, 14, 7, 14, 24, 10]):
            self.assertEqual(len(fragment), expected_size)

    def test_FragmentationDetermineFragmentsWithBreakingAndGrouping(self):
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.doFragmentGrouping()
        self.assertEqual(len(self.fragmentation.getFragments()), 5)
        for fragment, expected_size in zip(self.fragmentation.getFragments(),
                                           [28, 26, 29, 21, 34]):
            self.assertEqual(len(fragment), expected_size)

    def test_FragmentationDetermineFragmentsWithBreakingAndGroupingTriple(
            self):
        self.fragmentation.setFragmentGroupCount(3)
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.doFragmentGrouping()
        self.assertEqual(len(self.fragmentation.getFragments()), 4)
        for fragment, expected_size in zip(self.fragmentation.getFragments(),
                                           [40, 43, 45, 10]):
            self.assertEqual(len(fragment), expected_size)

    def test_FragmentationFindFragmentsCastErrors(self):
        self.assertRaises(ValueError,
                          self.fragmentation.getAtomsInSameFragment, 1, 1)
        self.assertRaises(ValueError,
                          self.fragmentation.getAtomsInSameFragment, "")

    def test_FragmentationFindFragmentsNoGrouping(self):
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        res1 = [12, 13, 31, 32]
        res1.extend(range(35, 43))
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(11, 0), [
            3, 4, 10, 11, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
            27, 28, 29, 30
        ])
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(12, 0),
                         res1)

    def test_FragmentationFindFragmentsNoGroupingWithProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        res1 = list(range(1, 12))
        res1.extend(list(range(14, 31)))
        res2 = [12, 13, 31, 32]
        res2.extend(list(range(35, 43)))
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(11, 0),
                         res1)
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(12, 0),
                         res2)

    def test_FragmentationFragmentChargeAfterFragment(self):
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(),
                         [1, 0, -1, 0, -1, 0, 0, 0, 0, -1])

    def test_FragmentationFragmentChargeAfterProtectAndFragment(self):
        self.fragmentation.setProtectedAtoms()
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(),
                         [1, -1, 0, -1, 0, 0, 0, 0, -1])

    def test_FragmentationFragmentChargeAfterFragmentAndGroup(self):
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.doFragmentGrouping()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(),
                         [1, -1, -1, 0, -1])

    def test_FragmentationFragmentChargeAfterProtectFragmentAndGroup(self):
        self.fragmentation.setProtectedAtoms()
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.doFragmentGrouping()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(),
                         [0, -1, 0, 0, -1])

    def test_FragmentationGetOBAtom(self):
        test_atom = self.fragmentation.getOBAtom(1)
        self.assertEqual(type(test_atom), type(openbabel.OBAtom()))

    def test_FragmentationNameFragments(self):
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.nameFragments()
        self.assertEqual(self.fragmentation.getFragmentNames(), [
            'GLY', 'GLY', 'TYR', 'ASP', 'PRO', 'GLU', 'THR', 'GLY', 'THR',
            'TRP'
        ])

    def test_FragmentationNameFragmentsProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.nameFragments()
        self.assertEqual(
            self.fragmentation.getFragmentNames(),
            ['GLY', 'TYR', 'ASP', 'PRO', 'GLU', 'THR', 'GLY', 'THR', 'TRP'])

    def test_FragmentationNameFragmentsGroupByTwo(self):
        self.fragmentation.breakBonds()
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.determineFragments()
        self.fragmentation.doFragmentGrouping()
        self.fragmentation.nameFragments()
        self.assertEqual(self.fragmentation.getFragmentNames(),
                         ['GLY', 'TYR', 'PRO', 'THR', 'THR'])

    def test_writereadconfiguration_basic(self):
        filename = "temp.cfg"
        handle = open(filename, 'w')
        self.fragmentation.writeConfigurationToFile(handle)
        handle.close()
        otherfrag = Fragmentation(self.molecule)
        otherfrag.readConfigurationFromFile(filename)
        for key in otherfrag.values.keys():
            for key2 in otherfrag.values[key].keys():
                self.assertEqual(self.fragmentation.values[key][key2],
                                 otherfrag.values[key][key2])
        self.delete_file(filename)
class TestFragmentationModule(unittest.TestCase):

    def setUp(self):
        self.filename_pdb = "tests/1UAO.pdb"

        # for testing, use OpenBabel functionality directly
        self.molecule = fileToMol(self.filename_pdb)
        self.fragmentation = Fragmentation(self.molecule)

    def tearDown(self):
        pass

    def delete_file(self,filename):
        try:
                f = open(filename)
        except IOError:
                return
        finally:
                f.close()
                os.remove(filename)

    def test_FragmentationDefaultParameters(self):
        frg = self.fragmentation
        self.assertEqual(frg.mol != None, True)

    def test_FragmentationSetActiveFragments(self):
        self.fragmentation.setActiveFragments([1, 2, 3])
        self.assertEqual(self.fragmentation.active_fragments, [1, 2, 3])

    def test_FragmentationApplySmartProtectPatterns(self):
        self.fragmentation.applySmartProtectPatterns()
        self.assertEqual(self.fragmentation.getExplicitlyProtectedAtoms(), [1, 2, 3, 4, 10])

    def test_FragmentationDetermineFormalCharges(self):
        #self.fragmentation.determineFormalCharges()
        self.assertAlmostEqual(sum(self.fragmentation.formalCharges), -2)

    def test_FragmentationGetProtectedAtoms(self):
        self.assertEqual(self.fragmentation.getExplicitlyProtectedAtoms(), [])

    def test_FragmentationAddProtectedAtomsAfterProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.addExplicitlyProtectedAtoms([44, 55, 67])
        self.assertEqual(self.fragmentation.getExplicitlyProtectedAtoms(), [1, 2, 3, 4, 10, 44, 55, 67])

    def test_FragmentationAddBrokenBond(self):
	pass

    def test_FragmentationIsBondProtected(self):
        bond_pair = (2, 3)
        self.assertEqual(self.fragmentation.isBondProtected(bond_pair), False)
        self.fragmentation.addExplicitlyProtectedAtoms([2])
        self.assertEqual(self.fragmentation.isBondProtected(bond_pair), True)

    def test_FragmentationRealBondBreakerNoProtect(self):
        bond_atoms = (2, 3)
        self.fragmentation.realBondBreaker("peptide", bond_atoms)
        self.assertEqual(self.fragmentation.getExplicitlyBreakAtomPairs(), [(2, 3)])

    def test_FragmentationIsValidExplicitBond(self):
        self.assertRaises(ValueError, self.fragmentation.isValidExplicitBond, (1, 1))
        self.assertRaises(ValueError, self.fragmentation.isValidExplicitBond, (2, 4))

    def test_FragmentationBreakBondsWithNoProtect(self):
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()), 9)

    def test_FragmentationBreakBondsExplcitWithNoProtect(self):
        self.fragmentation.addExplicitlyBreakAtomPairs([(111, 112)])
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()), 10)

    def test_FragmentationBreakBondsWithProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()), 8)

    def test_FragmentationBreakBondsExplcitWithProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.addExplicitlyBreakAtomPairs([(111, 112)])
        self.fragmentation.breakBonds()
        self.assertEqual(len(self.fragmentation.getExplicitlyBreakAtomPairs()), 9)

    def test_FragmentationDetermineFragmentsNoBreaking(self):
        self.assertRaises(ValueError, self.fragmentation.determineFragments)

    def test_FragmentationDetermineFragmentsWithBreaking(self):
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.assertEqual(lenOfLists(self.fragmentation.getFragments()), [7, 21, 12, 14, 15, 14, 7, 14, 24, 10])

    def test_FragmentationDetermineFragmentsWithBreakingAndGrouping(self):
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.doFragmentGrouping()
        self.assertEqual(lenOfLists(self.fragmentation.getFragments()), [28, 26, 29, 21, 34])

    def test_FragmentationDetermineFragmentsWithBreakingAndGroupingTriple(self):
        self.fragmentation.setFragmentGroupCount(3)
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.doFragmentGrouping()
        self.assertEqual(lenOfLists(self.fragmentation.getFragments()), [40, 43, 45, 10])

    def test_FragmentationFindFragmentsCastErrors(self):
        self.assertRaises(ValueError, self.fragmentation.getAtomsInSameFragment, 1, 1)
        self.assertRaises(ValueError, self.fragmentation.getAtomsInSameFragment, "")

    def test_FragmentationFindFragmentsNoGrouping(self):
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(11, 0), [3, 4, 10, 11, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30])
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(12, 0), [12, 13, 31, 32] + range(35, 43))

    def test_FragmentationFindFragmentsNoGroupingWithProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(11, 0), range(1, 12)+range(14, 31))
        self.assertEqual(self.fragmentation.getAtomsInSameFragment(12, 0), [12, 13, 31, 32] + range(35, 43))

    def test_FragmentationFragmentChargeAfterFragment(self):
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(), [ 1, 0, -1, 0, -1, 0, 0, 0, 0, -1])

    def test_FragmentationFragmentChargeAfterProtectAndFragment(self):
        self.fragmentation.setProtectedAtoms()
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(), [1, -1, 0, -1, 0, 0, 0, 0, -1])

    def test_FragmentationFragmentChargeAfterFragmentAndGroup(self):
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.doFragmentGrouping()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(), [1, -1, -1, 0, -1])

    def test_FragmentationFragmentChargeAfterProtectFragmentAndGroup(self):
        self.fragmentation.setProtectedAtoms()
        #self.fragmentation.determineFormalCharges()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.doFragmentGrouping()
        self.fragmentation.determineFragmentCharges()
        self.assertEqual(self.fragmentation.getFragmentCharges(), [0, -1, 0, 0, -1])

    def test_FragmentationGetOBAtom(self):
        test_atom = self.fragmentation.getOBAtom(1)
        self.assertEqual(type(test_atom), type(openbabel.OBAtom()))

    def test_FragmentationNameFragments(self):
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.nameFragments()
        self.assertEqual(self.fragmentation.getFragmentNames(), ['GLY', 'GLY', 'TYR', 'ASP', 'PRO', 'GLU', 'THR', 'GLY', 'THR', 'TRP'])

    def test_FragmentationNameFragmentsProtect(self):
        self.fragmentation.setProtectedAtoms()
        self.fragmentation.breakBonds()
        self.fragmentation.determineFragments()
        self.fragmentation.nameFragments()
        self.assertEqual(self.fragmentation.getFragmentNames(), ['GLY', 'TYR', 'ASP', 'PRO', 'GLU', 'THR', 'GLY', 'THR', 'TRP'])

    def test_FragmentationNameFragmentsGroupByTwo(self):
        self.fragmentation.breakBonds()
        self.fragmentation.setFragmentGroupCount(2)
        self.fragmentation.determineFragments()
        self.fragmentation.doFragmentGrouping()
        self.fragmentation.nameFragments()
        self.assertEqual(self.fragmentation.getFragmentNames(), ['GLY', 'TYR', 'PRO', 'THR', 'THR'])

    def test_writereadconfiguration_basic(self):
        filename = "temp.cfg"
        self.fragmentation.writeConfigurationToFile(filename)
        otherfrag = Fragmentation(self.molecule)
        otherfrag.readConfigurationFromFile(filename)
        for key in otherfrag.values.keys():
          for key2 in otherfrag.values[key].keys():
            self.assertEqual(self.fragmentation.values[key][key2], otherfrag.values[key][key2])
        self.delete_file(filename)
 def setUp(self):
   self.molecule = fileToMol("tests/watercluster4.xyz")
   self.fragmentation = Fragmentation(self.molecule)
   self.fixtures = 'tests/gamess-fmo-fixtures'
Example #22
0
    def test_qmmm_advanced_3(self):
        """ 1 qm fragment + cov bound in qm/mm interface with bond breaking """
        filename = "temp.inp"
        m1 = fileToMol("tests/5ala.xyz")
        frag1 = Fragmentation(m1, defaults=FragItDataPE)
        frag1.beginFragmentation()
        frag1.doFragmentation()
        frag1.finishFragmentation()
        qm1 = QMMM(frag1, [2, 3, 4])
        qmf1, qmq1 = qm1.pop_qm_fragment()

        m2 = fileToMol("tests/5ala.xyz")
        frag2 = Fragmentation(m2, defaults=FragItDataPE)
        frag2.values['qmmm']['includecovalent'] = True
        frag2.beginFragmentation()
        frag2.doFragmentation()
        frag2.finishFragmentation()
        qm2 = QMMM(frag2, [3])
        qmf2, qmq2 = qm2.pop_qm_fragment()

        # must produce identical results
        self.assertEqual(len(qmf1), len(qmf2))
        self.assertEqual(frag1.getFragments(), frag2.getFragments())
    def setUp(self):
        self.filename_pdb = "tests/1UAO.pdb"

        # for testing, use OpenBabel functionality directly
        self.molecule = fileToMol(self.filename_pdb)
        self.fragmentation = Fragmentation(self.molecule)
class TestGamessFMOOutputModule(unittest.TestCase):

    def setUp(self):
      self.molecule = fileToMol("tests/watercluster4.xyz")
      self.fragmentation = Fragmentation(self.molecule)
      self.fixtures = 'tests/gamess-fmo-fixtures'

    def delete_file(self,filename):
        try:
                f = open(filename)
        except IOError:
                return
        finally:
                f.close()
                os.remove(filename)

    def test_water_1(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/water_1.fixture"
      gamessfmo = GamessFMO(self.fragmentation)
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)

    def test_water_2(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/water_2.fixture"
      self.fragmentation.beginFragmentation()
      self.fragmentation.doFragmentation()
      self.fragmentation.finishFragmentation()
      gamessfmo = GamessFMO(self.fragmentation)
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)

    def test_water_3(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/water_3.fixture"
      self.fragmentation.beginFragmentation()
      self.fragmentation.doFragmentation()
      self.fragmentation.finishFragmentation()
      gamessfmo = GamessFMO(self.fragmentation)
      gamessfmo.setCentralFragmentID(1)
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)

    def test_water_4(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/water_4.fixture"
      self.fragmentation.beginFragmentation()
      self.fragmentation.doFragmentation()
      self.fragmentation.finishFragmentation()
      gamessfmo = GamessFMO(self.fragmentation)
      gamessfmo.setCentralFragmentID(1)
      gamessfmo.setBoundariesFromString("1.0")
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)

    def test_water_5(self):
      filename = "temp.inp"
      otherfile = self.fixtures + "/water_5.fixture"
      self.fragmentation.beginFragmentation()
      self.fragmentation.doFragmentation()
      self.fragmentation.finishFragmentation()
      gamessfmo = GamessFMO(self.fragmentation)
      gamessfmo.setCentralFragmentID(1)
      gamessfmo.setBoundariesFromString("1.0")
      gamessfmo.setActiveAtomsDistance(1.0)
      gamessfmo.setBufferMaxDistance(1.0)
      gamessfmo.setup()
      gamessfmo.writeFile(filename)
      generated = ReadStringListFromFile(filename)
      fixture = ReadStringListFromFile(otherfile)

      self.assertEqual(len(generated), len(fixture))
      for i in range(len(fixture)):
        self.assertEqual(generated[i], fixture[i])

      self.delete_file(filename)