Did I find the right examples for you? yes no      Crawl my project      Python Jobs

All Samples(32)  |  Call(23)  |  Derive(0)  |  Import(9)

src/b/i/biskit-2.4/Biskit/AmberParmBuilder.py   biskit(Download)
import Biskit.mathUtils as MU
from Biskit.LogFile import LogFile, StdLog
from Biskit.PDBModel import PDBModel
from Biskit.Errors import BiskitError
from Biskit.PDBCleaner import PDBCleaner
        @type  kw: key=value
        """
        self.m = PDBModel( model )
 
        self.leap_template = leap_template
        """
        self.log.add('Capping N-terminal of chain %i.' % chain )
        m_ace = PDBModel( self.F_ace_cap )
 
        chains_before = model.takeChains( range(chain), breaks=1 )
        """
        self.log.add('Capping C-terminal of chain %i.' % chain )
        m_nme   = PDBModel( self.F_nme_cap )
 
        chains_before = model.takeChains( range(chain), breaks=1 )
 
        ## load model with missing atoms added by leap
        m_leap = PDBModel( tmp_pdb  )
 
        ## compare atom content

src/b/i/biskit-2.4/Biskit/AmberEntropist.py   biskit(Download)
from Biskit.AmberCrdEntropist import AmberCrdEntropist, EntropistError
from Biskit.AmberParmBuilder import AmberParmBuilder
from Biskit.PDBModel import PDBModel
from Biskit.Trajectory import Trajectory
from Biskit.EnsembleTraj import EnsembleTraj
        if self.__splitFilenames( fname ):
            f1, f2 = self.__splitFilenames( fname )
            m1, m2 = PDBModel( self.__getModel(f1) ), \
                     PDBModel( self.__getModel(f2) )
 

src/b/i/biskit-2.4/Biskit/PDBCleaner.py   biskit(Download)
import Biskit.mathUtils as M
import Biskit.tools as t
from Biskit.PDBModel import PDBModel
from Biskit.LogFile import StdLog
 
        @type  verbose: bool
        """
        self.model = PDBModel( fpdb )
        self.log = log or StdLog()
        self.verbose = verbose
            Cterm_is_break = c_end[chain] not in model.chainEndIndex()
 
        m_ace = PDBModel( self.F_ace_cap )
 
        chains_before = model.takeChains( range(chain), breaks=breaks )
        if self.verbose:
            self.logWrite('Capping C-terminal of chain %i with NME.' % chain )
        m_nme   = PDBModel( self.F_nme_cap )
 
        c_start = model.chainIndex( breaks=breaks )
    def test_Capping( self ):
        """PDBCleaner.capTerminals test"""
        ## Loading PDB...
        self.model = PDBModel(t.testRoot() + '/rec/1A2P_rec_original.pdb')
 

src/b/i/biskit-2.4/scripts/Biskit/dope.py   biskit(Download)
 
import Biskit.tools as T
from Biskit.PDBModel import PDBModel
from Biskit.PDBDope import PDBDope
 
    """
 
    source = PDBModel( inFile )
 
    if wat:
def changeModel( inFile, prefix, sourceModel ):
 
    print '\nget ' + os.path.basename( inFile ) + '..',
 
    model = PDBModel( inFile )

src/b/i/biskit-2.4/Biskit/Mod/ValidationSetup.py   biskit(Download)
 
import Biskit.tools as T
from Biskit.PDBModel import PDBModel
import re
import glob
 
            for pdb in pdb_path:
                PDBModels_list.append(PDBModel('%s'%pdb))
                pdb_name.append(os.path.split(pdb)[1][:-4])
 
            if(cluster == os.path.split(pdb)[1][0:4]):
 
                model = PDBModel('%s'%pdb)
                sequence = model.sequence()
                sequence = MU.format_fasta(seq = sequence)

src/b/i/biskit-2.4/Biskit/Mod/Benchmark.py   biskit(Download)
 
import os
from Biskit.PDBModel import PDBModel
from Biskit.ModelList import ModelList
from Biskit.IcmCad import IcmCad as CAD
 
        pdb_list = T.load('%s'%model_list)
        reference = PDBModel(reference)
 
        # check with python 2.4
        pdb = T.load( self.outfolder + "/modeller/PDBModels.list" )[0]
 
        reference = PDBModel(self.outfolder  + "/reference.pdb" )
        tmp_model = pdb.clone()
 

src/b/i/biskit-2.4/scripts/Biskit/averageASA.py   biskit(Download)
import numpy.oldnumeric as N
from Biskit.PDBDope import PDBDope
from Biskit.PDBModel import PDBModel
import time, sys
import glob
 
            ## load peptide and remove waters and hydrogens
            m = PDBModel( f )
            m = m.compress( m.maskProtein() * m.maskHeavy() )
            T.flushPrint( '.')

src/b/i/biskit-2.4/Biskit/Mod/Analyse.py   biskit(Download)
 
import Biskit.tools as T
from Biskit.PDBModel import PDBModel
from Biskit.Mod.Benchmark import Benchmark
from Biskit.Mod.ValidationSetup import ValidationSetup as VS
        ##
        pdb_list = T.load(self.outFolder + self.F_MODELS)
        model = PDBModel(pdb_list[0])
 
        ## 

src/b/i/biskit-2.4/scripts/analysis/a_foldX.py   biskit(Download)
 
from Biskit.tools import *
from Biskit.PDBModel import PDBModel
import os