def get_pose_with_ligand(filepath, LIGAND_PARAMS=[]):
pose = Pose()
ligand_params = Vector1(LIGAND_PARAMS)
res_set = pose.conformation().modifiable_residue_type_set_for_conf()
res_set.read_files_for_base_residue_types(ligand_params)
pose.conformation().reset_residue_type_set_for_conf(res_set)
return pose_from_file(filepath)
def pose_from_params(filename, params_list):
pose = Pose()
rts = pose.conformation().modifiable_residue_type_set_for_conf(
core.chemical.FULL_ATOM_t)
rts.read_files_for_base_residue_types(Vector1(params_list))
pose.conformation().reset_residue_type_set_for_conf(rts)
pose_from_file(pose, pose.residue_type_set_for_pose(), filename)
return pose
def add_residuetype(
self, pose: pyrosetta.Pose
) -> pyrosetta.rosetta.core.chemical.ResidueTypeSet:
rts = pose.conformation().modifiable_residue_type_set_for_conf(
pyrosetta.rosetta.core.chemical.FULL_ATOM_t)
buffer = pyrosetta.rosetta.std.stringbuf(self.dumps())
stream = pyrosetta.rosetta.std.istream(buffer)
new = pyrosetta.rosetta.core.chemical.read_topology_file(
stream, self.NAME, rts) # no idea what the second argument does
rts.add_base_residue_type(new)
return rts
def pose_from_pubchem(cid, name, temporary=True):
pose = Pose()
if temporary:
# the temporary solution, create an ephemeral ResidueSet
params_from_pubchem(cid, name)
# Add the new ResidueType to the pose
rts = pose.conformation().modifiable_residue_type_set_for_conf(
core.chemical.FULL_ATOM_t)
rts.add_base_residue_type(name)
pose.conformation().reset_residue_type_set_for_conf(rts)
# fill the pose
pose_from_file(pose, pose.residue_type_set_for_pose(),
name + "_0001.pdb")
else:
# permanent solution, add to .params list
add_cid_to_database(cid, name)
# fill the pose
pose_from_file(pose, name + "_0001.pdb")
return pose
def sample_ligand_interface(pdb_filename,
partners,
ligand_params=[''],
jobs=1,
job_output='ligand_output'):
"""
Performs ligand-protein docking using Rosetta fullatom docking
(DockingHighRes) on the ligand-protein complex in <pdb_filename>
using the relative chain <partners> .
If the ligand parameters (a .params file, see below) are not defaultly
loaded into PyRosetta, <ligand_params> must supply the list of files
including the ligand parameters.
<jobs> trajectories are performed with output structures named
<job_output>_(job#).pdb.
"""
# 1. creates a pose from the desired PDB file
pose = Pose()
if len(ligand_params
) != 0 and ligand_params[0] != '': # the params list has contents
ligand_params = Vector1(ligand_params)
res_set = pose.conformation().modifiable_residue_type_set_for_conf()
res_set.read_files_for_base_residue_types(ligand_params)
pose.conformation().reset_residue_type_set_for_conf(res_set)
pose_from_file(pose, pdb_filename)
# 2. setup the docking FoldTree
# using this method, the jump number 1 is automatically set to be the
# inter-body jump
dock_jump = 1
# the exposed method setup_foldtree takes an input pose and sets its
# FoldTree to have jump 1 represent the relation between the two docking
# partners, the jump points are the residues closest to the centers of
# geometry for each partner with a cutpoint at the end of the chain,
# the second argument is a string specifying the relative chain orientation
# such as "A_B" of "LH_A", ONLY TWO BODY DOCKING is supported and the
# partners MUST have different chain IDs and be in the same pose (the
# same PDB), additional chains can be grouped with one of the partners,
# the "_" character specifies which bodies are separated
# the third argument...is currently unsupported but must be set (it is
# supposed to specify which jumps are movable, to support multibody
# docking...but Rosetta doesn't currently)
# the FoldTrees setup by this method are for TWO BODY docking ONLY!
protocols.docking.setup_foldtree(pose, partners, Vector1([dock_jump]))
# 3. create a copy of the pose for testing
test_pose = Pose()
test_pose.assign(pose)
# 4. create ScoreFunctions for centroid and fullatom docking
scorefxn = create_score_function('ligand')
#### global docking, a problem solved by the Rosetta DockingProtocol,
#### requires interface detection and refinement
#### as with other protocols, these tasks are split into centroid (interface
#### detection) and high-resolution (interface refinement) methods
#### without a centroid representation, low-resolution ligand-protein
#### prediction is not possible and as such, only the high-resolution
#### ligand-protein interface refinement is available
#### WARNING: if you add a perturbation or randomization step, the
#### high-resolution stages may fail (see Changing Ligand Docking
#### Sampling below)
#### a perturbation step CAN make this a global docking algorithm however
#### the rigid-body sampling preceding refinement requires extensive
#### sampling to produce accurate results and this algorithm spends most
#### of its effort in refinement (which may be useless for the predicted
#### interface)
# 5. setup the high resolution (fullatom) docking protocol (DockMCMProtocol)
# ...as should be obvious by now, Rosetta applications have no central
# standardization, the DockingProtocol object can be created and
# applied to perform Rosetta docking, many of its options and settings
# can be set using the DockingProtocol setter methods
# there is currently no centroid representation of an arbitrary ligand in
# the chemical database, although you can check to see if it is already
# present or make your own (see "Obtaining Params Files" below), and
# without a centroid representation, the low-resolution docking stages
# are not useful for ligand docking
docking = protocols.docking.DockMCMProtocol()
docking.set_scorefxn(scorefxn)
# 6. setup the PyJobDistributor
jd = PyJobDistributor(job_output, jobs, scorefxn)
# 7. setup a PyMOL_Observer (optional)
# the PyMOL_Observer object owns a PyMOLMover and monitors pose objects for
# structural changes, when changes are detected the new structure is
# sent to PyMOL
# fortunately, this allows investigation of full protocols since
# intermediate changes are displayed, it also eliminates the need to
# manually apply the PyMOLMover during a custom protocol
# unfortunately, this can make the output difficult to interpret (since you
# aren't explicitly telling it when to export) and can significantly slow
# down protocols since many structures are output (PyMOL can also slow
# down if too many structures are provided and a fast machine may
# generate structures too quickly for PyMOL to read, the
# "Buffer clean up" message
# uncomment the line below to use PyMOL_Observer
## AddPyMOLObserver(test_pose, True)
# 8. perform protein-protein docking
counter = 0 # for pretty output to PyMOL
while not jd.job_complete:
# a. set necessary variables for this trajectory
# -reset the test pose to original (centroid) structure
test_pose.assign(pose)
# -change the pose name, for pretty output to PyMOL
counter += 1
test_pose.pdb_info().name(job_output + '_' + str(counter))
# b. perform docking
docking.apply(test_pose)
# c. output the decoy structure:
# to PyMOL
test_pose.pdb_info().name(job_output + '_' + str(counter) + '_fa')
# to a PDB file
jd.output_decoy(test_pose)
at5C = res5.atom("C")
print(at5N)
# TODO: above should print atom type key not magic number
# 2/23/9: hm, not sure this is possible b/c atom does not know which AtomTypeSet to use!
print('xyz of at5N:', at5N.xyz().x, at5N.xyz().y, at5N.xyz().z)
print('norm of xyz at5N:', at5N.xyz().norm)
print(res5.atoms()) # <-- Still missing
atomN = AtomID(1, 5)
atomCA = AtomID(2, 5)
atomC = AtomID(3, 5)
print('bond length of N-CA in residue 5 is ')
print(pose.conformation().bond_length(atomN, atomCA))
print('bond angle of N-CA-C in residue 5 is ')
print(pose.conformation().bond_angle(atomN, atomCA, atomC))
print('setting bond length of N-CA in residue 5 to 1.5A ')
pose.conformation().set_bond_length(atomN, atomCA, 1.5)
print('setting bond angle of N-CA-C in residue 5 to 90 ')
pose.conformation().set_bond_angle(atomN, atomCA, atomC, 90)
# TODO: make the above work with atom objects instead of atomIDs
print('pose was generated from this pdb file: ', pose.pdb_info().name())
print('pose numbering for chain A, residue 5, is ',
pose.pdb_info().pdb2pose('A', 5))
print('pdb chain letter and residue number for residue 5, is ',
pose.pdb_info().pose2pdb(5))
# TODO: pdb_info.* does not tab-complete
from __future__ import print_function
import pyrosetta
import pyrosetta.rosetta as rosetta
from pyrosetta import init, Pose, Vector1, create_score_function
from pyrosetta.rosetta import core, protocols
init(extra_options = "-constant_seed") # WARNING: option '-constant_seed' is for testing only! MAKE SURE TO REMOVE IT IN PRODUCTION RUNS!!!!!
import os; os.chdir('.test.output')
print('testing ligand modeling')
ligand_p = Pose()
params_list = ['../test/data/ligand.params']
rts = ligand_p.conformation().modifiable_residue_type_set_for_conf( core.chemical.FULL_ATOM_t )
rts.read_files_for_base_residue_types( Vector1(params_list) )
ligand_p.conformation().reset_residue_type_set_for_conf( rts )
core.import_pose.pose_from_file(ligand_p, "../test/data/ligand_test.pdb")
scorefxn = create_score_function("ligand")
scorefxn(ligand_p)
print('testing DNA modeling')
dna_p = Pose()
core.import_pose.pose_from_file(dna_p, "../test/data/dna_test.pdb")
scorefxn = create_score_function("dna")
scorefxn(dna_p)
