Did I find the right examples for you? yes no

All Samples(43)  |  Call(0)  |  Derive(0)  |  Import(43)

src/p/e/PEATDB-2.3/Protool/example_mut.py   PEATDB(Download)
# Dublin 4, Ireland
 
import Protool
X=Protool.structureIO()
print 'Reading PDB file'

src/p/e/PEATDB-2.3/PEATSA/Core/Data.py   PEATDB(Download)
 
	#Create a protool instance of the pdb
	import Protool
	try:
		pdb = Protool.structureIO()
def CreateCompleteScanList(pdbFile):
 
	#Create a protool instance of the pdb
	import Protool
	try:
		Raises Exceptions.FileFormatError if there is a problem with the pdb'''
 
		import Protool
 
		try:
 
		#Check the pdb file has the correct format using protool.
		import Protool
		try:
			pdb = Protool.structureIO()
 
		#Create a protool instance of the pdb and check if it has a vaid format
		import Protool
		try:
			self.pdb = Protool.structureIO()

src/p/e/PEATDB-2.3/Protool/mutate.py   PEATDB(Download)
    def read_aa_defs(self):
        """Read the amino acid defininition file"""
        import Protool, os
        location=os.path.split(Protool.__file__)[0]
        location=os.path.join(location,'AA.DAT')
    # Read PDB file
    #
    import Protool
    P=Protool.structureIO()
    P.readpdb(pdbfile)
    if store_mutation_operations:
        mut_lines=FFF_instance.PI.make_pdblines('PDB')
        import Protool
        WT=Protool.structureIO()
        WT.parsepdb(wt_lines)
    # Read PDB file
    #
    import Protool
    P=Protool.structureIO()
    P.readpdb(pdbfile)
        # Test the modelling of PDB files by FFF and compare it to Protool
        #
        import Protool
        X=Protool.structureIO()
        X.readpdb(options.pdbfile)

src/p/e/PEATDB-2.3/PEATDB/sequence_alignment.py   PEATDB(Download)
def pir2Protool(sequence):
    """ Reformats a regular one-letter sequence (e.g. 'ASDDE') to
        the protool type sequence ( [[':0001','ALA'], [':0002','SER'] ...)
    """
    import Protool, string
def Protool2pir(sequence):
    """ Reformats a protool style sequence to a regular one-letter sequence"""
    import Protool
    X=Protool.structureIO()
    seq=''

src/p/e/PEATDB-2.3/PEATDB/PE.py   PEATDB(Download)
            if DB.tmp_3Dmodels.has_key(str(operations)):               
                pdblines = DB.tmp_3Dmodels[str(operations)]              
                import Protool
                X=Protool.structureIO()
                X.parsepdb(pdblines)
                return pdblines,X
 
            # Read parent structure
            pdblines = parentrec.Structure
            import Protool

src/p/e/PEATDB-2.3/PEATDB/Actions.py   PEATDB(Download)
        if X == None:
            #we need to also provide the ref structure
            import Protool
            X=Protool.structureIO()
            X.parsepdb(DB.get(ref).Structure)
        if pdbfile:    
            pdbname = os.path.basename(pdbfile)
        import Protool
        self.X=Protool.structureIO()
        # Extracting PDB_code from pdbfile
 
        #Create protool oinstance for ref pdb
        import Protool
        Xref = Protool.structureIO()
        Xref.parsepdb(refpdb)
            pdblines = parentrec.Structure
            # Load the pdb file
            import Protool
            X=Protool.structureIO()
            X.parsepdb(pdblines)
        refpdb = DB[refprot].Structure
        #Create protool oinstance for ref pdb
        import Protool
        Xref = Protool.structureIO()
        Xref.parsepdb(refpdb)        

src/p/e/PEATDB-2.3/PEATDB/Ekin/Titration.py   PEATDB(Download)
        if type(peatDB[protein]['Structure']) is types.ListType:
            # Real X-ray structure
            import Protool
            X = Protool.structureIO_fast()
            pdblines = peatDB[protein]['Structure']
    def getPDBfromFile(cls, filename):
        """Get pdblines from a PDB file"""
        import Protool
        X=Protool.structureIO_fast()
        X.readpdb(filename)

src/p/e/PEATDB-2.3/pKaTool/pKacalc_interface.py   PEATDB(Download)
        # Load the PDB file in Protool
        #
        import Protool
        self.Protool_instance=Protool.structureIO()
        self.Protool_instance.readpdb(self.pdbfilename)
        # Start the pKa calculation
        #
        import Protool
        import Protool.errors
        P=Protool.structureIO()

src/p/e/PEATDB-2.3/pKaTool/make_pKaSens_table.py   PEATDB(Download)
def get_net_charge(pdbfile,HIS):
    """Get the net charge within 20 A of the HIS"""
    import Protool
    X=Protool.structureIO()
    X.readpdb(pdbfile)
def get_HIS(pdbfilename,PD,Nuc):
    #
    # find the residue number of the HIS
    #
    import Protool

src/p/e/PEATDB-2.3/pKaTool/Do_Sensitivity_analysis.py   PEATDB(Download)
    import os
    if len(PD.split(':'))!=3:
        import Protool
        P=Protool.structureIO()
        P.readpdb(pdbfile)
            # get the residue name
            #
            import Protool
            X=Protool.structureIO()
            X.readpdb(filename)

  1 | 2 | 3  Next