def redock(pose,partners): dock_jump = 1 # jump number 1 is the inter-body jump pyrosetta.rosetta.protocols.docking.setup_foldtree(pose,partners,Vector1([dock_jump])) # Create ScoreFunctions for centroid and fullatom docking scorefxn = pyrosetta.create_score_function("ref2015.wts") # Setup the high resolution (fullatom) docking protocol using DockMCMProtocol. docking = pyrosetta.rosetta.protocols.docking.DockMCMProtocol() # Many of its options and settings can be set using the setter methods. docking.set_scorefxn(scorefxn) # # Set the native pose so that the output scorefile contains the pose rmsd metric # native_pose = pose # # Optional: setup a PyMOLObserver # # pyrosetta.rosetta.protocols.moves.AddPyMOLObserver(test_pose, True) # # Perform protein-ligand docking # # counter = 0 # for pretty output to PyMOLObserver # test_pose = pose.clone() # Reset test pose to original structure # counter += 1 # Change the pose name, for pretty output to PyMOLObserver # test_pose.pdb_info().name(job_output + '_' + str(counter)) # Perform docking and output to PyMOL: # print('DOCKING'*100) docking.apply(pose)
def redock(self, hires=True, perturb=False, TRANS_PERT=0.05, ROT_PERT=1): # setup the docking FoldTree # using this method, the jump number 1 is automatically set to be the # inter-body jump dock_jump = 1 protocols.docking.setup_foldtree(self.pose, self.partners, Vector1([dock_jump])) # create ScoreFunctions for centroid and fullatom docking self.scorefxn = create_score_function('ref2015') # setup the high resolution (fullatom) docking protocol (DockMCMProtocol) hiresdocker = protocols.docking.DockMCMProtocol() hiresdocker.set_scorefxn(self.scorefxn) hiresdocker.set_first_cycle(4) hiresdocker.set_second_cycle(20) self.hiresdocker = hiresdocker # Setup perturber dockperturb = RigidBodyPerturbMover(dock_jump, TRANS_PERT, ROT_PERT) self.perturber = dockperturb if hires: self.hiresdocker.apply(self.pose) elif perturb: self.perturber.apply(self.pose)
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 sample_dna_interface(pdb_filename, partners, jobs=1, job_output='dna_output'): """ Performs DNA-protein docking using Rosetta fullatom docking (DockingHighRes) on the DNA-protein complex in <pdb_filename> using the relative chain <partners> . <jobs> trajectories are performed with output structures named <job_output>_(job#).pdb. """ # 1. creates a pose from the desired PDB file pose = Pose() 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('dna') scorefxn.set_weight(core.scoring.fa_elec, 1) # an "electrostatic" term #### 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 DNA-protein #### prediction is not possible and as such, only the high-resolution #### DNA-protein interface refinement is available #### WARNING: if you add a perturbation or randomization step, the #### high-resolution stages may fail (see Changing DNA Docking #### Sampling below) #### a perturbation step CAN make this a global docking algorithm however #### the rigid-body sampling preceding refinement will require 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 # as there is currently no centroid representation of DNA in the chemical # database, the low-resolution docking stages are not useful for # DNA docking # instead, create an instance of just the high-resolution docking stages 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 the 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)
ex.ex1(True) ex.ex2(True) ex.extrachi_cutoff(1) tf = core.pack.task.TaskFactory() tf.push_back(core.pack.task.operation.RestrictToRepacking()) tf.push_back( core.pack.task.operation.OperateOnResidueSubset(ex, protein_interface_sele)) task = tf.create_task_and_apply_taskoperations(pose) rotsets = core.pack.rotamer_set.RotamerSetsFactory.create_rotamer_sets(pose) ig = core.pack.interaction_graph.AnnealableGraphBase() basic.options.set_string_vector_option( 'out:levels', Vector1(['core.pack.rotamer_set.RotamerSet_.extra_rotamers:500'])) core.pack.pack_rotamers_setup(pose, sfxn, task, rotsets, ig) print('*' * 80) print('*' * 80) print('*' * 80) basic.options.set_string_vector_option( 'out:levels', Vector1(['core.pack.rotamer_set.RotamerSet_.extra_rotamers:100'])) #basic.options.set_string_vector_option('out:mute', Vector1(['core.pack.rotamer_set.RotamerSet_.extra_rotamers'])) core.pack.pack_rotamers_setup(pose, sfxn, task, rotsets, ig)
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) print('Done!')
# :noTabs=true: # (c) Copyright Rosetta Commons Member Institutions. # (c) This file is part of the Rosetta software suite and is made available under license. # (c) The Rosetta software is developed by the contributing members of the Rosetta Commons. # (c) For more information, see http://www.rosettacommons.org. Questions about this can be # (c) addressed to University of Washington CoMotion, email: [email protected]. ## @author Sergey Lyskov from __future__ import print_function import pyrosetta from pyrosetta import Vector1, version print(Vector1([1, 2, 3, 4])) print(Vector1([1, 2, 3, 4.5])) print(Vector1(['a', 'b', 'c', 'd'])) print('Testing Python bindings for Rosetta...') print('Init...') pyrosetta.init() print(pyrosetta._version_string()) print(version())
def sample_docking(pdb_filename, partners, translation = 3.0, rotation = 8.0, jobs = 1, job_output = 'dock_output'): """ Performs protein-protein docking using the Rosetta standard DockingProtocol on the proteins in <pdb_filename> using the relative chain <partners> with an initial perturbation using <translation> Angstroms and <rotation> degrees. <jobs> trajectories are performed with output structures named <job_output>_(job#).pdb. structures are exported to a PyMOL instance. """ # 1. creates a pose from the desired PDB file pose = Pose() 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 partners # 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 centroid <--> fullatom conversion Movers to_centroid = SwitchResidueTypeSetMover('centroid') to_fullatom = SwitchResidueTypeSetMover('fa_standard') # and a Mover to recover sidechain conformations # when a protocol samples backbone torsion space in centroid, # the sidechain conformations are neglected, when it is transferred # to fullatom, we typically set the sidechain conformations to their # "original" values and perform sidechain packing, # a ReturnSidechainMover saves a pose's sidechains (in this case # staring_pose) and when applied, inserts these conformations # into the input pose recover_sidechains = protocols.simple_moves.ReturnSidechainMover(pose) # 4. convert to centroid to_centroid.apply(pose) # 5. create a (centroid) test pose test_pose = Pose() test_pose.assign(pose) # 6. create ScoreFunctions for centroid and fullatom docking scorefxn_low = create_score_function('interchain_cen') scorefxn_high = create_score_function('docking') # PyRosetta3: scorefxn_high_min = create_score_function_ws_patch('docking', 'docking_min') scorefxn_high_min = create_score_function('docking', 'docking_min') # 7. create Movers for producing an initial perturbation of the structure # the DockingProtocol (see below) can do this but several Movers are # used to demonstrate their syntax # these Movers randomize the orientation (rotation) of each docking partner randomize_upstream = RigidBodyRandomizeMover(pose, dock_jump, partner_upstream) randomize_downstream = RigidBodyRandomizeMover(pose, dock_jump, partner_downstream) # this Mover translates one docking partner away from the other in a random # direction a distance specified by the second argument (in Angstroms) # and rotates this partner randomly by the third argument (in degrees) dock_pert = RigidBodyPerturbMover(dock_jump, translation, rotation) # this Mover randomizes a pose's partners (rotation) spin = RigidBodySpinMover(dock_jump) # this Mover uses the axis defined by the inter-body jump (jump 1) to move # the docking partners close together slide_into_contact = protocols.docking.DockingSlideIntoContact(dock_jump) # 8. setup the MinMover # the MoveMap can set jumps (by jump number) as degrees of freedom movemap = MoveMap() movemap.set_jump(dock_jump, True) # the MinMover can minimize score based on a jump degree of freedom, this # will find the distance between the docking partners which minimizes # the score minmover = protocols.minimization_packing.MinMover() minmover.movemap(movemap) minmover.score_function(scorefxn_high_min) # 9. create a SequenceMover for the perturbation step perturb = protocols.moves.SequenceMover() perturb.add_mover(randomize_upstream) perturb.add_mover(randomize_downstream) perturb.add_mover(dock_pert) perturb.add_mover(spin) perturb.add_mover(slide_into_contact) perturb.add_mover(to_fullatom) perturb.add_mover(recover_sidechains) perturb.add_mover(minmover) # 10. setup the DockingProtocol # ...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 # here, on instance is created with all default values and the movable jump # is manually set to jump 1 (just to be certain), the centroid docking # ScoreFunction is set and the fullatom docking ScoreFunction is set dock_prot = protocols.docking.DockingProtocol() # contains many docking functions dock_prot.set_movable_jumps(Vector1([1])) # set the jump to jump 1 dock_prot.set_lowres_scorefxn(scorefxn_low) dock_prot.set_highres_scorefxn(scorefxn_high_min) #### you can alternatively access the low and high resolution sections of #### the DockingProtocol, both are applied by the DockingProtocol but #### a novel protocol may only require centroid (DockingLowRes) or #### fullatom (DockingHighRes), uncomment the lines below and their #### application below #docking_low = DockingLowRes() #docking_low.set_movable_jumps(Vector1([1])) #docking_low.set_scorefxn(scorefxn_low) #docking_high = DockingHighRes() #docking_high.set_movable_jumps(Vector1([1])) #docking_high.set_scorefxn(scorefxn_high) # 11. setup the PyJobDistributor jd = PyJobDistributor(job_output, jobs, scorefxn_high) temp_pose = Pose() # a temporary pose to export to PyMOL temp_pose.assign(pose) to_fullatom.apply(temp_pose) # the original pose was fullatom recover_sidechains.apply(temp_pose) # with these sidechains jd.native_pose = temp_pose # for RMSD comparison # 12. 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 the PyMOL_Observer ## AddPyMOLObserver(test_pose, True) # 13. 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. perturb the structure for this trajectory perturb.apply(test_pose) # c. perform docking dock_prot.apply(test_pose) #### alternate application of the DockingProtocol pieces #docking_low.apply(test_pose) #docking_high.apply(test_pose) # d. output the decoy structure to_fullatom.apply(test_pose) # ensure the output is fullatom # to PyMOL test_pose.pdb_info().name(job_output + '_' + str( counter ) + '_fa') # to a PDB file jd.output_decoy(test_pose)
def scanning(pdb_filename, partners, mutant_aa='A', interface_cutoff=8.0, output=False, trials=1, trial_output=''): """ Performs "scanning" at an interface within <pdb_filename> between <partners> by mutating relevant residues to <mutant_aa> and repacking residues within <pack_radius> Angstroms, further repacking all residues within <interface_cutoff> of the interface residue, scoring the complex and subtracting the score of a pose with the partners separated by 500 Angstroms. <trials> scans are performed (to average results) with summaries written to <trial_output>_(trial#).txt. Structures are exported to a PyMOL instance. """ # 1. create a pose from the desired PDB file pose = Pose() pose_from_file(pose, pdb_filename) # 2. setup the docking FoldTree and other related parameters dock_jump = 1 movable_jumps = Vector1([dock_jump]) protocols.docking.setup_foldtree(pose, partners, movable_jumps) # 3. create ScoreFuncions for the Interface and "ddG" calculations # the pose's Energies objects MUST be updated for the Interface object to # work normally scorefxn = get_fa_scorefxn() # create_score_function('standard') scorefxn(pose) # needed for proper Interface calculation # setup a "ddG" ScoreFunction, custom weights ddG_scorefxn = ScoreFunction() ddG_scorefxn.set_weight(core.scoring.fa_atr, 0.44) ddG_scorefxn.set_weight(core.scoring.fa_rep, 0.07) ddG_scorefxn.set_weight(core.scoring.fa_sol, 1.0) ddG_scorefxn.set_weight(core.scoring.hbond_bb_sc, 0.5) ddG_scorefxn.set_weight(core.scoring.hbond_sc, 1.0) # 4. create an Interface object for the pose interface = Interface(dock_jump) interface.distance(interface_cutoff) interface.calculate(pose) # 5. create a PyMOLMover for sending output to PyMOL (optional) pymover = PyMOLMover() pymover.keep_history(True) # for multiple trajectories pymover.apply(pose) pymover.send_energy(pose) # 6. perform scanning trials # the large number of packing operations introduces a lot of variability, # for best results, perform several trials and average the results, # these score changes are useful to QUALITATIVELY defining "hotspot" # residues # this script does not use a PyJobDistributor since no PDB files are output for trial in range(trials): # store the ddG values in a dictionary ddG_mutants = {} for i in range(1, pose.total_residue() + 1): # for residues at the interface if interface.is_interface(i) == True: # this way you can TURN OFF output by providing False arguments # (such as '', the default) filename = '' if output: filename = pose.pdb_info().name()[:-4] + '_' +\ pose.sequence()[i-1] +\ str(pose.pdb_info().number(i)) + '->' + mutant_aa # determine the interace score change upon mutation ddG_mutants[i] = interface_ddG(pose, i, mutant_aa, movable_jumps, ddG_scorefxn, interface_cutoff, filename) # output results print('=' * 80) print('Trial', str(trial + 1)) print( 'Mutants (PDB numbered)\t\"ddG\" (interaction dependent score change)' ) residues = list(ddG_mutants.keys() ) # list(...) conversion is for python3 compatbility residues.sort() # easier to read display = [ pose.sequence()[i - 1] + str(pose.pdb_info().number(i)) + mutant_aa + '\t' + str(ddG_mutants[i]) + '\n' for i in residues ] print(''.join(display)[:-1]) print('=' * 80) # write to file f = open(trial_output + '_' + str(trial + 1) + '.txt', 'w') f.writelines(display) f.close() #### alternate output using scanning_analysis (see below), only display #### mutations with "deviant" score changes print('Likely Hotspot Residues') for hotspot in scanning_analysis(trial_output): print(hotspot) print('=' * 80)
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') ''' for _i in range(10): try: ''' # Docking Moves in Rosetta pose = pose_from_file("../test/data/workshops/complex.start.pdb") print( pose.fold_tree() ) protocols.docking.setup_foldtree(pose, "A_B", Vector1([1])) print( pose.fold_tree() ) jump_num = 1 print( pose.jump(jump_num).get_rotation() ) print( pose.jump(jump_num).get_translation() ) print( "_____ Check point 1" ) pert_mover = rigid_moves.RigidBodyPerturbMover(jump_num, 8, 3) #pert_mover.apply(pose) randomize1 = rigid_moves.RigidBodyRandomizeMover(pose, jump_num, rigid_moves.partner_upstream) randomize2 = rigid_moves.RigidBodyRandomizeMover(pose, jump_num, rigid_moves.partner_downstream) print( "_____ Check point 2" ) #randomize1.apply(pose)