Python Read.buildBondsByDistance方法代码示例

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
def autodock_scoring(receptor, ligand):
    receptorfilename =  receptor
    ligandfilename =  ligand
    write_file_mode = False
    parameter_library_filename = None
    exclude_torsFreeEnergy = False
    verbose = None
    ad_scorer = AutoDock41Scorer(exclude_torsFreeEnergy=exclude_torsFreeEnergy)
    supported_types = ad_scorer.supported_types
    receptor = Read(receptorfilename)[0]
    receptor.buildBondsByDistance()
    ligand = Read(ligandfilename)[0]
    ligand.buildBondsByDistance()

    ms = MolecularSystem()
    ms.add_entities(receptor.allAtoms)
    ms.add_entities(ligand.allAtoms)
    ad_scorer.set_molecular_system(ms)
    #get the scores, score per term:
    [estat, hb, vdw ,dsolv] = ad_scorer.get_score_per_term()
    torsEnrg = ligand.TORSDOF * ad_scorer.tors_weight
    score = estat +hb +vdw +dsolv +torsEnrg
    output_score = {'score':score, 'estat':estat, 'hb':hb, 'vdw':vdw, 'dsolv,':dsolv, 'torsEnrg':torsEnrg}
    
    return output_score

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
def get_best_energy_info(d, rms_tolerance, build_hydrogen_bonds=False, \
                                report_energy_breakdown=False,
                                report_unbound_energy=False,
                                receptor_filename=None):
    ostr = "" 
    clust0 = d.clusterer.clustering_dict[rms_tolerance][0]
    c = clust0[0]
    #find the filename of the best result
    dlo_filename = get_filename(d, c)
    if verbose: print "set dlo_filename to ", dlo_filename
    ostr = dlo_filename + ", "
    ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," %(len(d.clusterer.data), num_clusters, len(clust0),  c.binding_energy, c.getRMSD())
    d.ch.set_conformation(c)
    receptor = None
    if build_hydrogen_bonds:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
            return 
        receptor = Read(receptor_filename)[0] 
        receptor.buildBondsByDistance()
        ostr += construct_hydrogen_bonds(receptor.allAtoms, d.ligMol.allAtoms)
    if report_energy_breakdown:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
        if not receptor:
            receptor = Read(receptor_filename)[0] 
            receptor.buildBondsByDistance()
        ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c)
    if report_unbound_energy:
        if c.unbound_energy is not None: 
            ostr += "% 8.4f," %c.unbound_energy
        else:
            if verbose: print "conformation's unbound energy is None!"
            ostr += "%    0.0," 
    return ostr

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
 def set_types_from_directory(self, directory):
     if self.verbose: 
         print "reading directory ", directory
     filelist = glob.glob(directory + "/*.pdb*")
     if self.verbose: 
         print "len(filelist)=", len(filelist)
     ad4_typer = AutoDock4_AtomTyper()
     type_dict = {}
     for f in filelist:
         m = Read(f)[0]
         m.buildBondsByDistance()
         ad4_typer.setAutoDockElements(m)
         for a in m.allAtoms:
             type_dict[a.autodock_element] = 1
         self.getSideLengths(m) #sets ligand.center
         npts = m.npts
         #only make the box bigger, do NOT make it smaller
         for ix, val in enumerate(self.gpo['npts']['value']):
             if npts[ix]>val:
                 self.gpo['npts']['value'][ix] =  npts[ix]
                 if self.verbose: 
                     print m.name, " increased grid dimension ", ix, " to ", npts[ix]
     d_types = type_dict.keys()
     if self.verbose: 
         print "found ", d_types, " atom types in directory ", directory
     self.gpo['ligand_types']['value'] =  string.join(d_types)
     if self.verbose: 
         print "now ligand_types is ", self.gpo['ligand_types']['value']

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
def test_buildBondsByDistance_1():
    """
    Test the buildBondsByDistance for 1crn.pdb with one chain
    
    """
    from MolKit import Read
    mol = Read('Data/1crn.pdb')[0]
    mol.buildBondsByDistance()
    bonds, nobonds = mol.allAtoms.bonds[0], mol.allAtoms.bonds[1]
    assert len(bonds) == 337 and len(nobonds) == 0

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
def get_largest_cluster_info(d, rms_tolerance, build_hydrogen_bonds=False, \
                                    report_energy_breakdown=False,
                                    report_unbound_energy=False,
                                    receptor_filename=None, refCoords=None,
                                    subtract_internal_energy=False):
    global be_lc
    largest = d.clusterer.clustering_dict[rms_tolerance][0]
    if verbose: print "set largest to ", len(largest)
    for clust in d.clusterer.clustering_dict[rms_tolerance]:
        if verbose: print "current largest cluster len= ", len(clust)
        if len(clust)>len(largest): 
            if verbose: print "resetting largest clust: now len=", len(clust)
            largest = clust
    c = largest[0]   #print info about the lowest energy member of this cluster
    ostr = " "
    dlo_filename = get_filename(d, c)
    ostr += dlo_filename + ","
    be_lc = c.binding_energy
    if subtract_internal_energy:
        be_lc = c.binding_energy - c.total_internal
    if refCoords:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," %(len(d.clusterer.data), num_clusters, len(largest),  be_lc, c.getRMSD(refCoords=refCoords))
    else:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," %(len(d.clusterer.data), num_clusters, len(largest),  be_lc, c.getRMSD())
    if verbose: print "set dlo_filename to ", dlo_filename
    #update the coords only if you need to?
    d.ch.set_conformation(c)
    receptor = None
    if build_hydrogen_bonds:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
            return 
        receptor = Read(receptor_filename)[0] 
        receptor.buildBondsByDistance()
        ostr += construct_hydrogen_bonds(receptor.allAtoms, d.ligMol.allAtoms, verbose=verbose)
    if report_energy_breakdown:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
            return 
        if not receptor:
            receptor = Read(receptor_filename)[0] 
            receptor.buildBondsByDistance()
        #ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c)
        ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c.getCoords()[:])
    if report_unbound_energy: 
        if c.unbound_energy is not None:
            ostr += ",% 8.4f" %c.unbound_energy
        else:
            if verbose: print "conformation's unbound energy is None!"
            ostr += ", 0.0" 
    return ostr

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
def get_largest_cluster_info(
    d, rms_tolerance, build_hydrogen_bonds=False, report_energy_breakdown=False, receptor_filename=None, refCoords=None
):
    largest = d.clusterer.clustering_dict[rms_tolerance][0]
    if verbose:
        print "set largest to ", len(largest)
    for clust in d.clusterer.clustering_dict[rms_tolerance]:
        if verbose:
            print "current largest cluster len= ", len(clust)
        if len(clust) > len(largest):
            if verbose:
                print "resetting largest clust: now len=", len(clust)
            largest = clust
    c = largest[0]  # print info about the lowest energy member of this cluster
    ostr = " "
    dlo_filename = get_filename(d, c)
    ostr += dlo_filename + ","
    de = c.docking_energy
    if refCoords:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," % (
            len(d.clusterer.data),
            num_clusters,
            len(largest),
            de,
            c.getRMSD(refCoords=refCoords),
        )
    else:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," % (len(d.clusterer.data), num_clusters, len(largest), de, c.getRMSD())
    if verbose:
        print "set dlo_filename to ", dlo_filename
    # update the coords only if you need to?
    d.ch.set_conformation(c)
    receptor = None
    if build_hydrogen_bonds:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
            return
        receptor = Read(receptor_filename)[0]
        receptor.buildBondsByDistance()
        ostr += construct_hydrogen_bonds(receptor.allAtoms, d.ligMol.allAtoms)
    if report_energy_breakdown:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
            return
        if not receptor:
            receptor = Read(receptor_filename)[0]
            receptor.buildBondsByDistance()
        # ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c)
        ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c.getCoords()[:])
    return ostr

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
def get_best_energy_info(d, rms_tolerance, build_hydrogen_bonds=False, \
                                report_energy_breakdown=False,
                                report_unbound_energy=False,
                                receptor_filename=None, refCoords=None,
                                subtract_internal_energy=False):
    global be
    ostr = "" 
    clust0 = d.clusterer.clustering_dict[rms_tolerance][0]
    c = clust0[0]
    #find the filename of the best result
    dlo_filename = get_filename(d, c)
    if verbose: print "set dlo_filename to ", dlo_filename
    ostr = dlo_filename + ", "
    be = c.binding_energy
    if subtract_internal_energy:
        be = c.binding_energy - c.total_internal
    if refCoords:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," %(len(d.clusterer.data), num_clusters, len(clust0),  be, c.getRMSD(refCoords=refCoords))
        #ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," %(len(d.clusterer.data), num_clusters, len(clust0),  c.binding_energy, c.getRMSD(refCoords=refCoords))
    else:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," %(len(d.clusterer.data), num_clusters, len(clust0),  be, c.getRMSD())
        #ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," %(len(d.clusterer.data), num_clusters, len(clust0),  c.binding_energy, c.getRMSD())
    d.ch.set_conformation(c)
    receptor = None
    if build_hydrogen_bonds:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
            return 
        receptor = Read(receptor_filename)[0] 
        receptor.buildBondsByDistance()
        d.ligMol.buildBondsByDistance()
        ostr += construct_hydrogen_bonds(receptor.allAtoms, d.ligMol.allAtoms, verbose=verbose)
    if report_energy_breakdown:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
        if not receptor:
            receptor = Read(receptor_filename)[0] 
            receptor.buildBondsByDistance()
        #build bonds if necessary 
        d.ligMol.buildBondsByDistance()
        #ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c)
        ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c.getCoords()[:])
    if report_unbound_energy:
        if c.unbound_energy is not None: 
            ostr += ",% 8.4f" %c.unbound_energy
        else:
            if verbose: print "conformation's unbound energy is None!"
            ostr += ", 0.0" 
    return ostr

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
class BaseTests(unittest.TestCase):
    def setUp(self):
        from MolKit import Read
        self.mol = Read('Data/1crn.pdb')[0]
        self.mol.buildBondsByDistance()
    

    def tearDown(self):
        """
        clean-up
        """
        del(self.mol)


    def test_constructor(self):
        """
        instantiate an HydrogenBuilder
        """
        h_builder = HydrogenBuilder()
        self.assertEquals(h_builder.__class__, HydrogenBuilder)


    def test_constructorOptions(self):
        """
         test possible constructor options
            options = htype, renumber, method
        """
    
        h_builder = HydrogenBuilder(htype='polarOnly')
        self.assertEquals(h_builder.__class__, HydrogenBuilder)
        h_builder = HydrogenBuilder(renumber=0)
        self.assertEquals(h_builder.__class__, HydrogenBuilder)
        h_builder = HydrogenBuilder(method='withBondOrder')
        self.assertEquals(h_builder.__class__, HydrogenBuilder)


    def test_addHydrogens(self):
        """
         test addHydrogens 
        """
        beforeLen = len(self.mol.allAtoms)
        h_builder = HydrogenBuilder()
        h_builder.addHydrogens(self.mol)
        afterLen = len(self.mol.allAtoms)
        #print "beforeLen=", beforeLen, ' afterLen=', afterLen
        self.assertEquals(beforeLen<afterLen, True)

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
def get_best_energy_info(
    d, rms_tolerance, build_hydrogen_bonds=False, report_energy_breakdown=False, receptor_filename=None, refCoords=None
):
    ostr = ""
    clust0 = d.clusterer.clustering_dict[rms_tolerance][0]
    c = clust0[0]
    # find the filename of the best result
    dlo_filename = get_filename(d, c)
    if verbose:
        print "set dlo_filename to ", dlo_filename
    ostr = dlo_filename + ", "
    de = c.docking_energy
    if refCoords:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," % (
            len(d.clusterer.data),
            num_clusters,
            len(clust0),
            de,
            c.getRMSD(refCoords=refCoords),
        )
    else:
        ostr += "%3d,%3d,%3d,% 8.4f,% 8.4f," % (len(d.clusterer.data), num_clusters, len(clust0), de, c.getRMSD())
    d.ch.set_conformation(c)
    receptor = None
    if build_hydrogen_bonds:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
            return
        receptor = Read(receptor_filename)[0]
        receptor.buildBondsByDistance()
        d.ligMol.buildBondsByDistance()
        ostr += construct_hydrogen_bonds(receptor.allAtoms, d.ligMol.allAtoms)
    if report_energy_breakdown:
        if not receptor_filename:
            print "receptor_filename must be specified in order to build_hydrogen_bonds"
        if not receptor:
            receptor = Read(receptor_filename)[0]
            receptor.buildBondsByDistance()
        # build bonds if necessary
        d.ligMol.buildBondsByDistance()
        # ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c)
        ostr += get_energy_breakdown(receptor.allAtoms, d.ligMol.allAtoms, c.getCoords()[:])

    return ostr

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
class BaseTests(unittest.TestCase):
    def setUp(self):
        from MolKit import Read

        self.mol = Read("Data/2plv_no_oxt.pdb")[0]
        self.mol.buildBondsByDistance()

    def tearDown(self):
        """
        clean-up
        """
        del (self.mol)

    def test_constructor(self):
        """
        instantiate an HydrogenBuilder
        """
        oxt_builder = OxtBuilder()
        self.assertEquals(oxt_builder.__class__, OxtBuilder)

    #    def test_constructorOptions(self):
    #        """
    #         test possible constructor options
    #            options = NONE!!
    #        """
    #
    #        oxt_builder = OxtBuilder(???=???)
    #        self.assertEquals(oxt_builder.__class__, OxtBuilder)

    def test_add_oxt(self):
        """
         test add_oxt 
        """
        beforeLen = len(self.mol.allAtoms)
        oxt_builder = OxtBuilder()
        # the last chain is all waters so skip it
        for ch in self.mol.chains[:-1]:
            catom = ch.residues[-1].atoms[2]
            new_at = oxt_builder.add_oxt(catom)
            # print "added ", new_at.full_name()
        afterLen = len(self.mol.allAtoms)
        # print "beforeLen=", beforeLen, ' afterLen=', afterLen
        self.assertEquals(beforeLen + len(self.mol.chains[:-1]), afterLen)

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
 def set_ligand4(self, ligand_filename, types=None):
     #this should set ligand_types
     #print "in set_ligand4: types=", types
     if types is None:
         ligand = Read(ligand_filename)[0]
         ligand.buildBondsByDistance()
         ad4_typer = AutoDock4_AtomTyper()
         ad4_typer.setAutoDockElements(ligand)
         dict = {}
         for a in ligand.allAtoms:
             dict[a.autodock_element] = 1
         d_types = dict.keys()
         d_types.sort()
         types = d_types[0]
         for t in d_types[1:]:
             types = types + " " + t
     self['ligand_types']['value'] = types
     #print "set_ligand4: self['ligand_types']['value']=", self['ligand_types']['value']
     self.ligand_filename = os.path.basename(ligand_filename)
     #print "GPO: set ligand_filename to ", self.ligand_filename
     self.ligand_stem = os.path.splitext(self.ligand_filename)[0]

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
class PdbqtWriterAtomLinesTest(PdbWriterTest):

    def setUp(self):
        from MolKit import Read
        self.mol = Read('Data/hsg1.pdbqt')[0]
        self.mol.buildBondsByDistance()
    

    def tearDown(self):
        del(self.mol)


    def test_write(self):
        """
        test writing a pdbqs file
        """
        writer = PdbqtWriter()
        writer.write('test_pdbqtWriter.pdbqt', self.mol, bondOrigin=('File',))
        ans, errors = self.compare('Data/hsg1.pdbqt', 'test_pdbqtWriter.pdbqt') 
        self.assertEquals(errors, None)
        self.assertEquals(ans, True)

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
 def set_receptor4(self, receptor_filename, types=None):
     #this should set receptor_types
     if types is None:
         receptor = Read(receptor_filename)[0]
         receptor.buildBondsByDistance()
         ad4_typer = AutoDock4_AtomTyper()
         ad4_typer.setAutoDockElements(receptor)
         dict = {}
         for a in receptor.allAtoms:
             dict[a.autodock_element] = 1
         d_types = dict.keys()
         d_types.sort()
         types = d_types[0]
         for t in d_types[1:]:
             types = types + " " + t
     self['receptor_types']['value'] = types
     basename = os.path.basename(receptor_filename)
     self.receptor_filename = basename
     self.receptor_stem = os.path.splitext(basename)[0]
     if receptor_filename!='':
         self['receptor']['value'] = basename
         self['gridfld']['value'] = self.receptor_stem + '.maps.fld'
         self['elecmap']['value'] = self.receptor_stem + '.e.map'
         self['dsolvmap']['value'] = self.receptor_stem + '.d.map'

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
            sys.exit()


    if not  receptor_filename:
        print 'prepare_flexreceptor4: receptor filename must be specified!\n'
        usage()
        sys.exit()

    if not  residues_to_move:
        print 'prepare_flexreceptor4: residues to move must be specified!\n'
        usage()
        sys.exit()


    r = Read(receptor_filename)[0]
    r.buildBondsByDistance()
    if verbose: print 'read ', receptor_filename

    all_res = ResidueSet()
    res_names = residues_to_move.split('_')
    for n in res_names:
        res = r.chains.residues.get(lambda x: x.name==n)
        if verbose: print "adding ", res.name, " to ", all_res
        all_res += res
    if verbose:
        print "all_res=", all_res.full_name(), 'all_res.__class__=', all_res.__class__
    #?check for duplicates
    d = {}
    for res in all_res: d[res] = 1
    all_res = d.keys()
    all_res = ResidueSet(all_res)

# 需要导入模块: from MolKit import Read [as 别名]
# 或者: from MolKit.Read import buildBondsByDistance [as 别名]
        sys.exit()
    if ligandfilename is None:
        print "trilinterp_atoms.py: ligand filename must be specified."
        usage()
        sys.exit()
    #OPTIONAL:
    if mapstem is None and verbose:
        print "trilinterp_atoms.py: map stem set from receptorfilename"
    if outputfilename is None: 
        if verbose: print "trilinterp_atoms.py: output to screen"
    else:
        print 'writing output to %s' %outputfilename

    #Start to work:
    rec = Read(receptorfilename)[0]
    rec.buildBondsByDistance() #[email protected]@??
    #setup mapstem
    if mapstem is None: 
        mapstem = rec.name

    lig = Read(ligandfilename)[0]
    lig.buildBondsByDistance()
    #get atoms for trilinterp
    if indicies is None or indicies=='':
        indicies = range(len(lig.allAtoms))
    else:
        indicies = map(int, indicies.split(','))
    if verbose: print "now indicies=", indicies

    total = 0
    pts = []