Ejemplo n.º 1
0
class Test(BT.BiskitTest):
    """Test"""

    TAGS = [ BT.EXE, BT.OLD ]

    def test_Prosa2003(self):
        """Prosa2003 test"""
        from biskit import PDBModel
        
        ## Loading PDB...
        self.ml = PDBModel( T.testRoot()+'/lig/1A19.pdb' )
        self.ml = self.ml.compress( self.ml.maskProtein() )

        self.mr = PDBModel( T.testRoot()+'/rec/1A2P.pdb' )
        self.mr = self.mr.compress( self.mr.maskProtein() )

        ## Starting Prosa2003
        self.prosa = Prosa2003( [self.ml, self.mr], debug=0, verbose=0 )

        ## Running
        self.ene = self.prosa.run()

        self.result = self.prosa.prosaEnergy()

        if self.local:
            print("Result: ", self.result)

        self.assertTrue( N0.sum(self.result - [ -94.568,  -64.903, -159.463 ] ) \
                      < 0.0000001 )
Ejemplo n.º 2
0
    def test_model(self):
        """PDBDope test final model"""
        from biskit import PDBModel

        if self.local:
            print('\nData added to info record of model (key -- value):')
            for k in list(self.d.m.info.keys()):
                print('%s -- %s'%(k, self.d.m.info[k]))

            print('\nAdded atom profiles:')
            print(self.M.atoms)

            print('\nAdded residue  profiles:')
            print(self.M.residues)

            ## check that nothing has changed
            print('\nChecking that models are unchanged by doping ...')

        m_ref = PDBModel( self.f )
        m_ref = m_ref.compress( m_ref.maskProtein() )
        for k in list(m_ref.atoms.keys()):
            #ref = [ m_ref.atoms[i][k] for i in m_ref.atomRange() ]
            #mod = [ self.M.atoms[i][k] for i in self.M.atomRange() ]
            self.assertTrue( N.all( m_ref[k] == self.M[k]) )

        ## display in Pymol
        if self.local:
            print("Starting PyMol...")
            from biskit.exe.pymoler import Pymoler

            pm = Pymoler()
            pm.addPdb( self.M, 'm' )
            pm.colorAtoms( 'm', N0.clip(self.M.profile('relAS'), 0.0, 100.0) )
            pm.show()
Ejemplo n.º 3
0
    def test_model(self):
        """PDBDope test final model"""
        from biskit import PDBModel

        if self.local:
            print('\nData added to info record of model (key -- value):')
            for k in list(self.d.m.info.keys()):
                print('%s -- %s' % (k, self.d.m.info[k]))

            print('\nAdded atom profiles:')
            print(self.M.atoms)

            print('\nAdded residue  profiles:')
            print(self.M.residues)

            ## check that nothing has changed
            print('\nChecking that models are unchanged by doping ...')

        m_ref = PDBModel(self.f)
        m_ref = m_ref.compress(m_ref.maskProtein())
        for k in list(m_ref.atoms.keys()):
            #ref = [ m_ref.atoms[i][k] for i in m_ref.atomRange() ]
            #mod = [ self.M.atoms[i][k] for i in self.M.atomRange() ]
            self.assertTrue(N.all(m_ref[k] == self.M[k]))

        ## display in Pymol
        if self.local:
            print("Starting PyMol...")
            from biskit.exe.pymoler import Pymoler

            pm = Pymoler()
            pm.addPdb(self.M, 'm')
            pm.colorAtoms('m', N0.clip(self.M.profile('relAS'), 0.0, 100.0))
            pm.show()
Ejemplo n.º 4
0
 def test_addSecondaryNonFiltered(self):
     from biskit import PDBModel
     m = PDBModel('1R4Q')
     d = PDBDope(m)
     d.addSecondaryStructure()
     
     r = m.compress(m.maskProtein())['secondary']
     self.assertEqual(''.join(r), self.EXPECT_1RQ4 )
Ejemplo n.º 5
0
    def test_addSecondaryNonFiltered(self):
        from biskit import PDBModel
        m = PDBModel('1R4Q')
        d = PDBDope(m)
        d.addSecondaryStructure()

        r = m.compress(m.maskProtein())['secondary']
        self.assertEqual(''.join(r), self.EXPECT_1RQ4)
Ejemplo n.º 6
0
class LongTest( BT.BiskitTest ):

    TAGS = [ BT.EXE, BT.LONG ]


    def prepare(self):
        from biskit import PDBModel
        self.f = T.testRoot() + '/com/1BGS.pdb'

        self.M = PDBModel( self.f )
        self.M = self.M.compress( self.M.maskProtein() )

        self.d = PDBDope( self.M )

    ## test de-activated as we don't have a running Hmmer module any longer
    def __test_conservation(self):
        """PDBDope.addConservation (Hmmer) test"""
        if self.local: print("Adding conservation data...", end=' ')
        self.d.addConservation()
        if self.local: print('Done.')

        ## display in Pymol
        if self.local:
            print("Starting PyMol...")
            from biskit.exe.pymoler import Pymoler

            pm = Pymoler()
            pm.addPdb( self.M, 'm' )
            pm.colorAtoms( 'm', N0.clip(self.M.profile('cons_ent'), 0.0, 100.0) )
            pm.show()

    def test_delphi(self):
        """PDBDope.addDelphi test"""
        if self.local:
            self.log.add( 'Calculating Delphi electrostatic potential' )
            self.log.add( '' )

        self.d.addDelphi( scale=1.2 )
        
        self.assertAlmostEqual( self.M['delphi']['scharge'], 0.95, 1 )
                

    ## EXPECT_1RQ4 = '.EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEE.SS.EEEEE..SS...EEEEEEE.SSTTT.....EEEEEESSS..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS.SSHHHHHHHHTS.STT.EE.HHHHHHHHHHHHT..SS...HHHHHHHHHHHHHTHHHHH.HHHHHHHHGGGT.TT...EE..HHHHHHHTTHHHHHHHGGG.SS.SEEEETTEEESSHHHHHTT..EE.......SS.SSSS..EEEETTEEEEHHHHHHH.....EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEEETTEEEEEE...S...EEEEEEE.SSSSS.....EEEEEETTT..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS..SHHHHHHHS...TTT.EE.TTHHHHHHHHHHT..SS...HHHHHHHHHHHHHHHHHHH.HHHHHHHGGGSS.TT...EE..HHHHHHHHTHHHHHHHGGG.SS.SEEEETTEEE.SHHHHHTT..EE........S.STTSS.EEESSSEEEEHHHHHHH.......EEEEE.EEEEEE.TTS.EEEEESS.EEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE...EEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHHT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..HHHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.TTS.EEEEETTB..EE..TTHHHHHHHHHHHT..EEEE.SS.STT.B..EEEE.....EEE.EEEEEE.TTS.EEEEETTEEEEE..THHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..TTHHHHHHHHHTTT..EEEE.S..STT.B..EEEE.'
    EXPECT_1RQ4 = '.EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEE.SS.EEEEE..SS...EEEEEEE.SSTTT.....EEEEEESSS..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS.SSHHHHHHHHTS.STT.EE.HHHHHHHHHHHHT..SS...HHHHHHHHHHHIIIIIHHH.HHHHHHHHGGGT.TT...EE..HHHHHHHTTHHHHHHHGGG.SS.SEEEETTEEESSHHHHHTT..EE.......SS.SSSS..EEEETTEEEEHHHHHHH.....EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEEETTEEEEEE...S...EEEEEEE.SSSSS.....EEEEEETTT..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS..SHHHHHHHS...TTT.EE.TTHHHHHHHHHHT..SS...HHHHHHHHHHHIIIIIHHH.HHHHHHHGGGSS.TT...EE..HHHHHHHHTHHHHHHHGGG.SS.SEEEETTEEE.SHHHHHTT..EE........S.STTSS.EEESSSEEEEHHHHHHH.......EEEEE.EEEEEE.TTS.EEEEESS.EEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE...EEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHHT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..HHHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.TTS.EEEEETTB..EE..TTHHHHHHHHHHHT..EEEE.SS.STT.B..EEEE.....EEE.EEEEEE.TTS.EEEEETTEEEEE..THHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..TTHHHHHHHHHTTT..EEEE.S..STT.B..EEEE.'
    def test_addSecondaryNonFiltered(self):
        from biskit import PDBModel
        m = PDBModel('1R4Q')
        d = PDBDope(m)
        d.addSecondaryStructure()
        
        r = m.compress(m.maskProtein())['secondary']
        self.assertEqual(''.join(r), self.EXPECT_1RQ4 )
Ejemplo n.º 7
0
class LongTest(BT.BiskitTest):

    TAGS = [BT.EXE, BT.LONG]

    def prepare(self):
        from biskit import PDBModel
        self.f = T.testRoot() + '/com/1BGS.pdb'

        self.M = PDBModel(self.f)
        self.M = self.M.compress(self.M.maskProtein())

        self.d = PDBDope(self.M)

    ## test de-activated as we don't have a running Hmmer module any longer
    def __test_conservation(self):
        """PDBDope.addConservation (Hmmer) test"""
        if self.local: print("Adding conservation data...", end=' ')
        self.d.addConservation()
        if self.local: print('Done.')

        ## display in Pymol
        if self.local:
            print("Starting PyMol...")
            from biskit.exe.pymoler import Pymoler

            pm = Pymoler()
            pm.addPdb(self.M, 'm')
            pm.colorAtoms('m', N0.clip(self.M.profile('cons_ent'), 0.0, 100.0))
            pm.show()

    def test_delphi(self):
        """PDBDope.addDelphi test"""
        if self.local:
            self.log.add('Calculating Delphi electrostatic potential')
            self.log.add('')

        self.d.addDelphi(scale=1.2)

        self.assertAlmostEqual(self.M['delphi']['scharge'], 0.95, 1)

    ## EXPECT_1RQ4 = '.EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEE.SS.EEEEE..SS...EEEEEEE.SSTTT.....EEEEEESSS..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS.SSHHHHHHHHTS.STT.EE.HHHHHHHHHHHHT..SS...HHHHHHHHHHHHHTHHHHH.HHHHHHHHGGGT.TT...EE..HHHHHHHTTHHHHHHHGGG.SS.SEEEETTEEESSHHHHHTT..EE.......SS.SSSS..EEEETTEEEEHHHHHHH.....EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEEETTEEEEEE...S...EEEEEEE.SSSSS.....EEEEEETTT..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS..SHHHHHHHS...TTT.EE.TTHHHHHHHHHHT..SS...HHHHHHHHHHHHHHHHHHH.HHHHHHHGGGSS.TT...EE..HHHHHHHHTHHHHHHHGGG.SS.SEEEETTEEE.SHHHHHTT..EE........S.STTSS.EEESSSEEEEHHHHHHH.......EEEEE.EEEEEE.TTS.EEEEESS.EEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE...EEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHHT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..HHHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.TTS.EEEEETTB..EE..TTHHHHHHHHHHHT..EEEE.SS.STT.B..EEEE.....EEE.EEEEEE.TTS.EEEEETTEEEEE..THHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..TTHHHHHHHHHTTT..EEEE.S..STT.B..EEEE.'
    EXPECT_1RQ4 = '.EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEE.SS.EEEEE..SS...EEEEEEE.SSTTT.....EEEEEESSS..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS.SSHHHHHHHHTS.STT.EE.HHHHHHHHHHHHT..SS...HHHHHHHHHHHIIIIIHHH.HHHHHHHHGGGT.TT...EE..HHHHHHHTTHHHHHHHGGG.SS.SEEEETTEEESSHHHHHTT..EE.......SS.SSSS..EEEETTEEEEHHHHHHH.....EEEEE.SSHHHHHHHHHHHHHHHEEEEEEEEETTEEEEEE...S...EEEEEEE.SSSSS.....EEEEEETTT..EEEEEETTTTEEEE.GGGTT...TT.EEEE.SS..SHHHHHHHS...TTT.EE.TTHHHHHHHHHHT..SS...HHHHHHHHHHHIIIIIHHH.HHHHHHHGGGSS.TT...EE..HHHHHHHHTHHHHHHHGGG.SS.SEEEETTEEE.SHHHHHTT..EE........S.STTSS.EEESSSEEEEHHHHHHH.......EEEEE.EEEEEE.TTS.EEEEESS.EEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE...EEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHHT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..HHHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..HHHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEEEEEEEEE.TTS.EEEEETTEEEEE..TTHHHHHHHHHHTT.EEEEE.S..STT.B..EEEE...EEEEE.EEEEEE.TTS.EEEEETTB..EE..TTHHHHHHHHHHHT..EEEE.SS.STT.B..EEEE.....EEE.EEEEEE.TTS.EEEEETTEEEEE..THHHHHHHHHHHHT..EEEE.S..STT.B..EEEE...EEEEE.EEEEEE.SSS.EEEEETTEEEEE..TTHHHHHHHHHTTT..EEEE.S..STT.B..EEEE.'

    def test_addSecondaryNonFiltered(self):
        from biskit import PDBModel
        m = PDBModel('1R4Q')
        d = PDBDope(m)
        d.addSecondaryStructure()

        r = m.compress(m.maskProtein())['secondary']
        self.assertEqual(''.join(r), self.EXPECT_1RQ4)
Ejemplo n.º 8
0
class Test(BT.BiskitTest):
    """Test case"""
    def test_surfaceRacerTools(self):
        """surfaceRacerTools test"""
        from biskit import PDBModel
        import biskit.tools as T

        ## load a structure
        self.m = PDBModel(T.testRoot() + '/lig/1A19.pdb')
        self.m = self.m.compress(self.m.maskProtein())
        self.m = self.m.compress(self.m.maskHeavy())

        ## some fake surface data
        surf = N0.ones(self.m.lenAtoms()) * 10.0

        relExp = relExposure(self.m, surf)

        ##         if self.local:
        ##             globals().update( locals() )

        self.assertAlmostEqual(N0.sum(relExp), 44276.86085222386, 8)
Ejemplo n.º 9
0
class Test(BT.BiskitTest):
    """Test case"""

    def test_surfaceRacerTools(self):
        """surfaceRacerTools test"""
        from biskit import PDBModel
        import biskit.tools as T
        
        ## load a structure
        self.m = PDBModel( T.testRoot()+'/lig/1A19.pdb' )
        self.m = self.m.compress( self.m.maskProtein() )
        self.m = self.m.compress( self.m.maskHeavy() )
        
        ## some fake surface data
        surf = N0.ones( self.m.lenAtoms()) * 10.0

        relExp = relExposure( self.m, surf )
        
##         if self.local:
##             globals().update( locals() )
            
        self.assertAlmostEqual( N0.sum(relExp), 44276.86085222386, 8 )
Ejemplo n.º 10
0
    def test_SurfaceRacer(self):
        """SurfaceRacer test"""

        from biskit import PDBModel
        import biskit.mathUtils as MA
        import numpy as N

        if self.local: print('Loading PDB...')
        f = T.testRoot('/lig/1A19.pdb')
        m = PDBModel(f)
        m = m.compress(m.maskProtein())

        if self.local: print('Starting SurfaceRacer')

        self.x = SurfaceRacer(m, 1.4, vdw_set=1, debug=self.DEBUG, verbose=0)

        if self.local:
            print('Running ...')

        self.r = self.x.run()

        c = self.r['curvature']
        ms = self.r['MS']

        if self.local:
            print("Curvature: weighted mean %.6f and standard deviation %.3f"\
                  %(MA.wMean(c,ms), MA.wSD(c,ms)))

            print('Relative MS of atoms 10 to 20:', self.r['relMS'][10:20])

            print('Relative AS of atoms 10 to 20:', self.r['relAS'][10:20])

        self.e = (N0.sum(self.r['relMS'][10:20]),
                  N0.sum(self.r['relAS'][10:20]),
                  N0.sum(self.r['curvature'][10:20]))

        delta = N.sum(N.abs(N.array(self.e) - N.array(self.EXPECT)))
        self.assertAlmostEqual(delta, 0.0, 5)
Ejemplo n.º 11
0
    def test_SurfaceRacer(self):
        """SurfaceRacer test"""

        from biskit import PDBModel
        import biskit.mathUtils as MA
        import numpy as N

        if self.local: print('Loading PDB...')
        f = T.testRoot('/lig/1A19.pdb')
        m = PDBModel(f)
        m = m.compress( m.maskProtein() )

        if self.local: print('Starting SurfaceRacer')

        self.x = SurfaceRacer( m, 1.4, vdw_set=1, debug=self.DEBUG, verbose=0 )

        if self.local:
            print('Running ...')

        self.r = self.x.run()

        c= self.r['curvature']
        ms= self.r['MS']

        if self.local:
            print("Curvature: weighted mean %.6f and standard deviation %.3f"\
                  %(MA.wMean(c,ms), MA.wSD(c,ms)))

            print('Relative MS of atoms 10 to 20:',self.r['relMS'][10:20])

            print('Relative AS of atoms 10 to 20:',self.r['relAS'][10:20])

        self.e = ( N0.sum(self.r['relMS'][10:20]), N0.sum(self.r['relAS'][10:20]),
              N0.sum(self.r['curvature'][10:20]) )

        delta = N.sum(N.abs(N.array(self.e) - N.array(self.EXPECT)))
        self.assertAlmostEqual( delta, 0.0, 5 )
Ejemplo n.º 12
0
class Test( BT.BiskitTest ):
    """Test AmberParmBuilder"""

    TAGS = [ BT.EXE ]

    def prepare(self):
        root = T.testRoot('amber/leap/')
        self.ref = PDBModel( T.testRoot('amber/leap/1HPT_solvated.pdb'))
        self.refdry = root + '1HPT_dry.pdb'

        self.dryparm = tempfile.mktemp('.parm', 'dry_')
        self.drycrd  = tempfile.mktemp('.crd', 'dry_')
        self.drypdb  = tempfile.mktemp('.pdb', 'dry_')
        self.wetparm = tempfile.mktemp('.parm', 'wet_')
        self.wetcrd  = tempfile.mktemp('.crd', 'wet_')
        self.wetpdb  = tempfile.mktemp('.pdb', 'wet_')
        self.leapout = tempfile.mktemp('.out', 'leap_')

    def cleanUp(self):
        if not self.DEBUG:
            T.tryRemove( self.dryparm )
            T.tryRemove( self.drycrd )
            T.tryRemove( self.drypdb )
            T.tryRemove( self.wetparm )
            T.tryRemove( self.wetcrd )
            T.tryRemove( self.wetpdb )
            T.tryRemove( self.leapout )
        

    def test_AmberParmMirror(self):
        """AmberParmBuilder.parmMirror test"""
        ref = self.ref
        mask = N0.logical_not( ref.maskH2O() ) ## keep protein and Na+ ion
        self.mdry = ref.compress( mask )

        self.a = AmberParmBuilder( self.mdry, verbose=self.local,
                                   leap_out=self.leapout,
                                   debug=self.DEBUG )

        self.a.parmMirror(f_out=self.dryparm,
                          f_out_crd=self.drycrd )

        self.a.parm2pdb( self.dryparm, self.drycrd, self.drypdb )

        self.m1 = PDBModel(self.drypdb)
        self.m2 = PDBModel(self.refdry)

        eq = N0.array( self.m1.xyz == self.m2.xyz )
        self.assertTrue( eq.all() )


    def test_AmberParmSolvated( self ):
        """AmberParmBuilder.parmSolvated test"""
        ## remove waters and hydrogens
        self.mdry = self.ref.compress( self.ref.maskProtein() )
        self.mdry = self.mdry.compress( self.mdry.maskHeavy() )

        self.a = AmberParmBuilder( self.mdry,
                                   leap_out=self.leapout,
                                   verbose=self.local, debug=self.DEBUG)

        self.a.parmSolvated( self.wetparm, f_out_crd=self.wetcrd,
                             f_out_pdb=self.wetpdb,
                             box=2.5 )

        self.m3 = PDBModel( self.wetpdb )

        m3prot = self.m3.compress( self.m3.maskProtein() )
        refprot= self.ref.compress( self.ref.maskProtein() )
        refprot.xplor2amber()
        
        self.assertEqual( self.ref.lenChains(), self.m3.lenChains() )
        self.assertEqual( refprot.atomNames(), m3prot.atomNames() )
Ejemplo n.º 13
0
class Test(BT.BiskitTest):
    """DSSP test"""

    TAGS = [BT.EXE]

    def prepare(self):
        self.f = T.testRoot()+"/com/1BGS.pdb"
        
    def generic_test(self, pdb, expected=None, proteinonly=False):
        """generic DSSP test"""

        from biskit import PDBModel

        if self.local: print('Loading PDB...')
        self.m = PDBModel(pdb)
        
        if proteinonly:
            self.m = self.m.compress( self.m.maskProtein() )

        if self.local:  print('Starting DSSP')
        self.dssp = Dssp( self.m, verbose=self.local, debug=self.DEBUG )

        if self.local: print('Running DSSP')

        self.result = self.dssp.run()  ## returns modified PDBModel
        self.result = self.result.compress( self.result.maskProtein() )
        self.result = ''.join(self.result['dssp'])

        if self.local:
            print("Sequence :", self.m.sequence())
            print("Secondary:", self.result)            
        
        if expected:
            self.assertEqual( self.result, expected)        


    EXPECTED =  '.....SHHHHHHHHHHHSS..TTEE.HHHHHHHT..GGGT.HHHHSTT.EEEEEEE..TT..S...TT..EEEEE.S..SSS..S.EEEEETT..EEEESSSSSS.EE...EEEEETTT..SHHHHHHHHHHHHT..TT..SSHHHHHHHHHHT..SSEEEEEE.HHHHHHHTTTTHHHHHHHHHHHHHHT..EEEEE.'
    def test_DSSP( self ):
        """DSSP test"""
        self.generic_test(self.f, expected=self.EXPECTED, proteinonly=False)

    def test_DSSP_2W3A( self ):
        """DSSP test 2W3A"""
        self.generic_test('2W3A', proteinonly=False)

    def test_DSSP_3TGI( self ):
        """DSSP test 3TGI"""
        ## handling of residues with insertion code (184A, 186A, 221A)
        self.generic_test('3TGI', proteinonly=False)

    def test_DSSP_1R4Q( self ):
        """DSSP test"""
        self.generic_test('1R4Q', proteinonly=False)    

    def test_DSSP_1AM7(self):
        self.generic_test('1AM7')

    def test_DSSP_5FB8(self):
        self.generic_test('5fb8')
        
    def test_DSSP_3j4q(self):
        self.generic_test(T.testRoot('dssp') + '/3j4q.pdb')
Ejemplo n.º 14
0
class Test( BT.BiskitTest ):
    """Test AmberParmBuilder"""

    TAGS = [ BT.EXE ]

    def prepare(self):
        root = T.testRoot('amber/leap/')
        self.ref = PDBModel( T.testRoot('amber/leap/1HPT_solvated.pdb'))
        self.refdry = root + '1HPT_dry.pdb'

        self.dryparm = tempfile.mktemp('.parm', 'dry_')
        self.drycrd  = tempfile.mktemp('.crd', 'dry_')
        self.drypdb  = tempfile.mktemp('.pdb', 'dry_')
        self.wetparm = tempfile.mktemp('.parm', 'wet_')
        self.wetcrd  = tempfile.mktemp('.crd', 'wet_')
        self.wetpdb  = tempfile.mktemp('.pdb', 'wet_')
        self.leapout = tempfile.mktemp('.out', 'leap_')

    def cleanUp(self):
        if not self.DEBUG:
            T.tryRemove( self.dryparm )
            T.tryRemove( self.drycrd )
            T.tryRemove( self.drypdb )
            T.tryRemove( self.wetparm )
            T.tryRemove( self.wetcrd )
            T.tryRemove( self.wetpdb )
            T.tryRemove( self.leapout )
        

    def test_AmberParmMirror(self):
        """AmberParmBuilder.parmMirror test"""
        ref = self.ref
        mask = N0.logical_not( ref.maskH2O() ) ## keep protein and Na+ ion
        self.mdry = ref.compress( mask )

        self.a = AmberParmBuilder( self.mdry, verbose=self.local,
                                   leap_out=self.leapout,
                                   debug=self.DEBUG )

        self.a.parmMirror(f_out=self.dryparm,
                          f_out_crd=self.drycrd )

        self.a.parm2pdb( self.dryparm, self.drycrd, self.drypdb )

        self.m1 = PDBModel(self.drypdb)
        self.m2 = PDBModel(self.refdry)

        eq = N0.array( self.m1.xyz == self.m2.xyz )
        self.assertTrue( eq.all() )


    def test_AmberParmSolvated( self ):
        """AmberParmBuilder.parmSolvated test"""
        ## remove waters and hydrogens
        self.mdry = self.ref.compress( self.ref.maskProtein() )
        self.mdry = self.mdry.compress( self.mdry.maskHeavy() )

        self.a = AmberParmBuilder( self.mdry,
                                   leap_out=self.leapout,
                                   verbose=self.local, debug=self.DEBUG)

        self.a.parmSolvated( self.wetparm, f_out_crd=self.wetcrd,
                             f_out_pdb=self.wetpdb,
                             box=2.5 )

        self.m3 = PDBModel( self.wetpdb )

        m3prot = self.m3.compress( self.m3.maskProtein() )
        refprot= self.ref.compress( self.ref.maskProtein() )
        refprot.xplor2amber()
        
        self.assertEqual( self.ref.lenChains(), self.m3.lenChains() )
        self.assertEqual( refprot.atomNames(), m3prot.atomNames() )