예제 #1
0
class Test(BT.BiskitTest):
    """Test class"""

    TAGS = [ BT.EXE, BT.LONG ]
    
    def test_bindingE( self ):
        """bindingEnergyDelphi test (Barnase:Barstar)"""
        self.com = T.load( T.testRoot() + '/com/ref.complex' )
        self.dG = DelphiBindingEnergy( self.com, log=self.log, scale=1.2,
                                       verbose=self.local )
        self.r = self.dG.run()

##        self.assertAlmostEqual( self.r['dG_kt'], 21., 0 )
        self.assertTrue( abs(self.r['dG_kt'] - 24.6) < 4 )

        if self.local:
            self.log.add(
                '\nFinal result: dG = %3.2f kcal/mol'%self.r['dG_kcal'])
            
    def test_errorcase1( self ):
        """bindinEnergyDelphi test (error case 01)"""
        self.m = PDBModel( T.testRoot() + '/delphi/case01.pdb' )
        rec = self.m.takeChains( [0,1] )
        lig = self.m.takeChains( [2] )
        self.com = Complex( rec, lig )
        
        self.dG = DelphiBindingEnergy( self.com, log = self.log, scale=0.5,
                                       verbose=self.local )
        self.r = self.dG.run()

        if self.local:
            self.log.add(
                '\nFinal result: dG = %3.2f kcal/mol'%self.r['dG_kcal'])
예제 #2
0
파일: pdbCleaner.py 프로젝트: graik/biskit
class FailingTest(BT.BiskitTest):
    """Test class """
    
    TAGS = [BT.NORMAL, BT.FAILS]
        
    def test_capping_extra( self ):
        """PDBCleaner.capTerminals extra challenge"""
        self.m2 = PDBModel( t.testRoot() + '/pdbclean/foldx_citche.pdb' )
        self.c = PDBCleaner( self.m2, verbose=self.local, log=self.log)
        self.assertRaises(CappingError, self.c.capTerminals, auto=True)
        if self.local:
            self.log.add('OK: CappingError has been raised indicating clash.' )
        
        self.assertEqual( len(self.m2.takeChains([1]).chainBreaks()), 1 )
예제 #3
0
class FailingTest(BT.BiskitTest):
    """Test class """

    TAGS = [BT.NORMAL, BT.FAILS]

    def test_capping_extra(self):
        """PDBCleaner.capTerminals extra challenge"""
        self.m2 = PDBModel(t.testRoot() + '/pdbclean/foldx_citche.pdb')
        self.c = PDBCleaner(self.m2, verbose=self.local, log=self.log)
        self.assertRaises(CappingError, self.c.capTerminals, auto=True)
        if self.local:
            self.log.add('OK: CappingError has been raised indicating clash.')

        self.assertEqual(len(self.m2.takeChains([1]).chainBreaks()), 1)
예제 #4
0
class Test(BT.BiskitTest):
    """Test class"""

    TAGS = [BT.EXE, BT.LONG]

    def test_bindingE(self):
        """bindingEnergyDelphi test (Barnase:Barstar)"""
        self.com = T.load(T.testRoot() + '/com/ref.complex')
        self.dG = DelphiBindingEnergy(self.com,
                                      log=self.log,
                                      scale=1.2,
                                      verbose=self.local)
        self.r = self.dG.run()

        ##        self.assertAlmostEqual( self.r['dG_kt'], 21., 0 )
        self.assertTrue(abs(self.r['dG_kt'] - 24.6) < 4)

        if self.local:
            self.log.add('\nFinal result: dG = %3.2f kcal/mol' %
                         self.r['dG_kcal'])

    def test_errorcase1(self):
        """bindinEnergyDelphi test (error case 01)"""
        self.m = PDBModel(T.testRoot() + '/delphi/case01.pdb')
        rec = self.m.takeChains([0, 1])
        lig = self.m.takeChains([2])
        self.com = Complex(rec, lig)

        self.dG = DelphiBindingEnergy(self.com,
                                      log=self.log,
                                      scale=0.5,
                                      verbose=self.local)
        self.r = self.dG.run()

        if self.local:
            self.log.add('\nFinal result: dG = %3.2f kcal/mol' %
                         self.r['dG_kcal'])
예제 #5
0
파일: pdbCleaner.py 프로젝트: graik/biskit
class Test(BT.BiskitTest):
    """Test class """

    def prepare(self):
        from biskit import LogFile
        import tempfile


    def test_PDBCleaner( self ):
        """PDBCleaner general test"""
        
        ## Loading PDB...
        self.c = PDBCleaner( t.testRoot() + '/rec/1A2P_rec_original.pdb',
                             log=self.log,
                             verbose=self.local)
        
        self.m = self.c.process()

        self.assertAlmostEqual( self.m.mass(), 34029.0115499993, 7 )
        
    def test_DNACleaning( self ):
        """PDBCleaner DNA test"""
        ## Loading PDB...
        self.c = PDBCleaner( t.testRoot() + 'amber/entropy/0_com.pdb',
                             log=self.log, verbose=self.local )
        
        self.dna = self.c.process(amber=True)

        self.assertAlmostEqual( self.dna.mass(), 26953.26, 1 )
        
        
    def test_Capping( self ):
        """PDBCleaner.capTerminals test"""
        ## Loading PDB...
        self.model = PDBModel(t.testRoot() + '/rec/1A2P_rec_original.pdb')

        self.c = PDBCleaner( self.model, log=self.log, verbose=self.local )       
        self.m2 = self.c.capTerminals( breaks=True )
        self.assertTrue( self.m2.atomNames() == self.model.atomNames() )
        
        self.m3 = self.model.clone()
        self.m3.removeRes( [10,11,12,13,14,15] )
        self.m4 = self.m3.clone()
        
        self.c = PDBCleaner( self.m3, log=self.log, verbose=self.local )
        self.m3 = self.c.capTerminals( breaks=True, capC=[0], capN=[0,1])
        self.assertEqual( self.m3.takeChains([0]).sequence()[:18], 
                          'XVINTFDGVADXXKLPDN' )
        
        if self.local:
            self.log.add( '\nTesting automatic chain capping...\n' )
        
        self.c = PDBCleaner( self.m4, log=self.log, verbose=self.local )
        self.m4 = self.c.capTerminals( auto=True )
        self.assertEqual( self.m4.takeChains([0]).sequence()[:18], 
                          'XVINTFDGVADXXKLPDN' )
        
        
    def test_capping_internal(self):
        self.m3 = PDBModel(t.testRoot('pdbclean/foldx_citche.pdb'))
        self.m3 = self.m3.takeChains([1])  # pick second chain; has chain break
        self.c3 = PDBCleaner(self.m3, verbose=self.local, log=self.log) 
        
        m = self.c3.capACE(self.m3, 1, checkgap=False)
        
        self.assertEqual(m.lenChains(breaks=True) -1, 
                         self.m3.lenChains(breaks=True))
예제 #6
0
class Test(BT.BiskitTest):
    """Test class """
    def prepare(self):
        from biskit import LogFile
        import tempfile

    def test_PDBCleaner(self):
        """PDBCleaner general test"""

        ## Loading PDB...
        self.c = PDBCleaner(t.testRoot() + '/rec/1A2P_rec_original.pdb',
                            log=self.log,
                            verbose=self.local)

        self.m = self.c.process()

        self.assertAlmostEqual(self.m.mass(), 34029.0115499993, 7)

    def test_DNACleaning(self):
        """PDBCleaner DNA test"""
        ## Loading PDB...
        self.c = PDBCleaner(t.testRoot() + 'amber/entropy/0_com.pdb',
                            log=self.log,
                            verbose=self.local)

        self.dna = self.c.process(amber=True)

        self.assertAlmostEqual(self.dna.mass(), 26953.26, 1)

    def test_Capping(self):
        """PDBCleaner.capTerminals test"""
        ## Loading PDB...
        self.model = PDBModel(t.testRoot() + '/rec/1A2P_rec_original.pdb')

        self.c = PDBCleaner(self.model, log=self.log, verbose=self.local)
        self.m2 = self.c.capTerminals(breaks=True)
        self.assertTrue(self.m2.atomNames() == self.model.atomNames())

        self.m3 = self.model.clone()
        self.m3.removeRes([10, 11, 12, 13, 14, 15])
        self.m4 = self.m3.clone()

        self.c = PDBCleaner(self.m3, log=self.log, verbose=self.local)
        self.m3 = self.c.capTerminals(breaks=True, capC=[0], capN=[0, 1])
        self.assertEqual(
            self.m3.takeChains([0]).sequence()[:18], 'XVINTFDGVADXXKLPDN')

        if self.local:
            self.log.add('\nTesting automatic chain capping...\n')

        self.c = PDBCleaner(self.m4, log=self.log, verbose=self.local)
        self.m4 = self.c.capTerminals(auto=True)
        self.assertEqual(
            self.m4.takeChains([0]).sequence()[:18], 'XVINTFDGVADXXKLPDN')

    def test_capping_internal(self):
        self.m3 = PDBModel(t.testRoot('pdbclean/foldx_citche.pdb'))
        self.m3 = self.m3.takeChains([1])  # pick second chain; has chain break
        self.c3 = PDBCleaner(self.m3, verbose=self.local, log=self.log)

        m = self.c3.capACE(self.m3, 1, checkgap=False)

        self.assertEqual(
            m.lenChains(breaks=True) - 1, self.m3.lenChains(breaks=True))