def repack_neighbors(self) -> None: """ Repacking is done by relax... :return: """ cc = self.coordinate_constraint self.coordinate_constraint = 0 scorefxn = self._get_scorefxn("ref2015") self.coordinate_constraint = cc # the distance depends on the size of the ligand. vlig = self._get_selector(ligand_only=True).apply(self.pose) lig = self.pose.residues[pyrosetta.rosetta.core.select. residue_selector.ResidueVector(vlig).pop()] lig_size = lig.nbr_radius() # get neighbourhood NeighborhoodResidueSelector = pyrosetta.rosetta.core.select.residue_selector.NeighborhoodResidueSelector ns = NeighborhoodResidueSelector(self._get_selector(ligand_only=True), distance=lig_size + 3, include_focus_in_subset=False) movemap = pyrosetta.MoveMap() movemap.set_bb(False) movemap.set_chi(False) movemap.set_chi(allow_chi=ns.apply(self.pose)) #print(pyrosetta.rosetta.core.select.residue_selector.ResidueVector(ns.apply(self.pose))) relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn, 2) relax.set_movemap(movemap) relax.set_movemap_disables_packing_of_fixed_chi_positions(True) relax.apply(self.pose)
def make_point_changes(pose, task_factory, score_function): """ Applies point mutations to a given pose. This is done through a PackRotamersMover, followed by minimization. Inputs are a Pose, a TaskFactory, and a ScoreFunction """ # Make PackRotamersMover pack_rotamers = PackRotamersMover() pack_rotamers.score_function(score_function) pack_rotamers.task_factory(task_factory) # Make a copy Pose and apply the PackRotamersMover mutated_pose = pr.Pose(pose) pack_rotamers.apply(mutated_pose) # Set up fixed-backbone movemap for minimization movemap = pr.MoveMap() movemap.set_bb(True) movemap.set_chi(True) movemap.set_jump(True) # Create the MinMover min_mover = MinMover() min_mover.movemap(movemap) min_mover.score_function(score_function) # Apply the MinMover to the modified Pose min_mover.apply(mutated_pose) return mutated_pose
def correct_and_relax(self, pose: pyrosetta.Pose): altered = self.correct(pose) movemap = pyrosetta.MoveMap() NeighborhoodResidueSelector = pyrosetta.rosetta.core.select.residue_selector.NeighborhoodResidueSelector neigh_sele = NeighborhoodResidueSelector(altered, distance=15, include_focus_in_subset=True) n = neigh_sele.apply(pose) movemap.set_bb(allow_bb=n) movemap.set_chi(allow_chi=n) scorefxn = pyrosetta.get_fa_scorefxn() # cartesian scorefxn_cart = pyrosetta.create_score_function('ref2015_cart') relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn_cart, 5) relax.cartesian(True) relax.minimize_bond_angles(True) relax.minimize_bond_lengths(True) relax.set_movemap_disables_packing_of_fixed_chi_positions(True) relax.set_movemap(movemap) relax.apply(pose) # dual relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn, 5) relax.set_movemap_disables_packing_of_fixed_chi_positions(True) relax.set_movemap(movemap) relax.apply(pose)
def mutation_operator(self, fragment_length, fragment_file): """Constructs a mutation operator to perform Molecular Fragment Replacements. The operator is a pyrosetta Mover, which can be used to introduce mutation on a population or a conformation. Args: fragment_length: An integer indicating the fragment length. fragment_file: A string defining the path of the file containing the fragments. Raises: ValueError: if fragment_file path is empty. Returns: A pyrosetta ClassicFragmentMover object that defines each move to be a Molecular Fragment Replacement. """ if not fragment_file: raise ValueError("Fragment file path cannot be empty.") fragset = pr.rosetta.core.fragment.ConstantLengthFragSet( fragment_length) fragset.read_fragment_file(fragment_file) movemap = pr.MoveMap() movemap.set_bb(True) return pr.rosetta.protocols.simple_moves.ClassicFragmentMover( fragset, movemap)
def _get_movemap(self) -> pyrosetta.MoveMap: movemap = pyrosetta.MoveMap() selector = self._get_selector() x = selector.apply(self.pose) movemap.set_bb(allow_bb=x) movemap.set_chi(allow_chi=x) movemap.set_jump(True) return movemap
def fragment_mover_init(frag_file, frag_length=3): fragset = fragment.ConstantLengthFragSet(frag_length) fragset.read_fragment_file(frag_file) movemap = pyrosetta.MoveMap() movemap.set_bb(True) fragment_mover = simple_moves.ClassicFragmentMover(fragset, movemap) return fragment_mover
def refine_pose(self): n_vector = self.get_neighbour_vector() movemap = pyrosetta.MoveMap() movemap.set_bb(allow_bb=n_vector) movemap.set_chi(allow_chi=n_vector) scorefxn = pyrosetta.get_fa_scorefxn() print(scorefxn) relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn, 3) relax.set_movemap(movemap) relax.apply(self.pose)
def build_move_map(chi=False, bb=False, jump=False): """ Building movemap - by default, everything is Off """ mm = pr.MoveMap() print_out("chi: " + str(chi)) print_out("bb: " + str(bb)) print_out("jump: " + str(jump)) mm.set_chi(chi) mm.set_bb(bb) mm.set_jump(jump) return mm
def do_chainwise_relax(pose: pyrosetta.Pose, scorefxn: Optional[pyrosetta.ScoreFunction] = None, cycles: int = 5) -> None: if scorefxn is None: scorefxn = pyrosetta.get_fa_scorefxn() for chain_i in range(1, pose.num_chains() + 1): chain_sele = pyrosetta.rosetta.core.select.residue_selector.ChainSelector(chain_i) chain_vector = chain_sele.apply(pose) movemap = pyrosetta.MoveMap() movemap.set_bb(allow_bb=chain_vector) movemap.set_chi(allow_chi=chain_vector) relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn, cycles) relax.set_movemap(movemap) relax.apply(pose)
def relax_around_mover(self, pose: pyrosetta.Pose, mutation: Optional[Mutation] = None, resi: int = None, chain: str = None, cycles=5, distance=5, cartesian=False, own_chain_only=False) -> None: """ Relaxes pose ``distance`` around resi:chain or mutation :param resi: PDB residue number. :param chain: :param pose: :param cycles: of relax (3 quick, 15 thorough) :param distance: :param cartesian: :return: """ if mutation is None and resi is None: raise ValueError('mutation or resi+chain required') elif mutation is not None: resi = mutation.pose_resi chain = None else: pass if pose is None: pose = self.pose movemap = pyrosetta.MoveMap() #### n = self.get_neighbour_vector(pose=pose, resi=resi, chain=chain, distance=distance, own_chain_only=own_chain_only) # print(pyrosetta.rosetta.core.select.residue_selector.ResidueVector(n)) movemap.set_bb(False) movemap.set_bb(allow_bb=n) movemap.set_chi(False) movemap.set_chi(allow_chi=n) movemap.set_jump(False) relax = pyrosetta.rosetta.protocols.relax.FastRelax( self.scorefxn, cycles) relax.set_movemap(movemap) relax.set_movemap_disables_packing_of_fixed_chi_positions(True) relax.cartesian(cartesian) relax.apply(pose)
def relax_around_mover(self, pose: pyrosetta.Pose, resi: int, chain: str, scorefxn=None, cycles=5, distance=5, cartesian=False) -> None: """ Relaxes pose ``distance`` around resi:chain. :param resi: PDB residue number. :param chain: :param pose: :param scorefxn: :param cycles: of relax (3 quick, 15 thorough) :param distance: :param cartesian: :return: """ if scorefxn is None: scorefxn = pyrosetta.get_fa_scorefxn() #self._cst_score(scorefxn) movemap = pyrosetta.MoveMap() #### resi_sele = pyrosetta.rosetta.core.select.residue_selector.ResidueIndexSelector( ) resi_sele.set_index(pose.pdb_info().pdb2pose(chain=chain, res=resi)) NeighborhoodResidueSelector = pyrosetta.rosetta.core.select.residue_selector.NeighborhoodResidueSelector neigh_sele = NeighborhoodResidueSelector(resi_sele, distance=distance, include_focus_in_subset=True) n = neigh_sele.apply(pose) movemap.set_bb(allow_bb=n) movemap.set_chi(allow_chi=n) relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn, cycles) relax.set_movemap_disables_packing_of_fixed_chi_positions(True) relax.set_movemap(movemap) relax.cartesian(cartesian) relax.apply(pose)
rosetta.std.map_int_int(), default_color=rosetta.protocols.moves.XC_orange) #colors = {2: "red", 5: "white"} colors = rosetta.std.map_int_int() colors[2] = rosetta.protocols.moves.XC_red colors[5] = rosetta.protocols.moves.XC_white pymol.send_colors(pose, colors, default_color=rosetta.protocols.moves.XC_blue) #pymol.label_energy(pose, "fa_atr") DEPRECATED: needed to be ported to C++ version #pymol.send_hbonds(pose) DEPRECATED: needed to be ported to C++ version #pymol.send_ss(pose) DEPRECATED: needed to be ported to C++ version #pymol.send_polars(pose) DEPRECATED: needed to be ported to C++ version mm = pyrosetta.MoveMap() #pymol.send_movemap(pose, mm) DEPRECATED: needed to be ported to C++ version #pymol.send_foldtree(pose) DEPRECATED: needed to be ported to C++ version #pymol.view_foldtree_diagram(pose) DEPRECATED: needed to be ported to C++ version #pymol.plot_graph("Line", "white", [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]) DEPRECATED: needed to be ported to C++ version #pymol.send_point("Line", "white", 5, 10) DEPRECATED: needed to be ported to C++ version observer = rosetta.protocols.moves.AddPyMOLObserver(pose) pose.set_psi(3, 10) scorefxn(pose) rosetta.protocols.moves.AddPyMOLObserver(pose, keep_history=True) pose.set_psi(2, 10)
def __init__(self, sequence, BBB_angle=120, BBBB_dihe=180, file_name='outputs/traj.pdb', energy_graph_output=False): """ folding object used for easily implementing different movers into a single folding algorithm. Arguments --------- sequence : str Sequence of CG residues BBB_angle : float Desired angle of all B-B-B angles. Generalizes to all backbone models (not working) BBBB_angle : float Desired dihedral of all B-B-B-B torsion angles. Generalizes to all backbone models (not working) """ # Build CG model and set desired initial angles self.pose = pyrosetta.pose_from_sequence(sequence, auto_termini=False) self.energy_graph_output = energy_graph_output # self.pose = self.set_BBB_angles(self.pose, BBB_angle) # self.pose = self.set_BBBB_dihe(self.pose, BBBB_dihe) # PyMOL mover, if wanting to visualize self.pymol = pyrosetta.PyMOLMover() self.pymol.apply(self.pose) # randomizer = CG_movers.randomizeBackBone(self.pose) # randomizer.apply(self.pose) self.pymol.apply(self.pose) # Building PDBTrajWriter object, used for writing multiple structures # to a single file self.PDB_writer = pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder( ) # self.PDB_writer.apply(self.pose) # write initial structure self.PDB_writer.file_name('outputs/traj.pdb') self.PDB_writer.stride(100) # Define scorefunction terms self.scorefxn = pyrosetta.ScoreFunction() self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_rep, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_atr, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_intra_atr, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_intra_rep, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_twist, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_bend, 1) # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_inter_rep, 1) # segfaults beware! # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_inter_atr, 1) # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_intra_rep, 1) # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_intra_atr, 1) # Build standard CG 1-1 movers self.small = CG_movers.CGSmallMover(self.pose) # self.shear = CG_movers.CGShearMover(self.pose) self.small_angle = CG_movers.CGSmallAngleMover(self.pose) # Build minimization movers self.mini = pyrosetta.rosetta.protocols.minimization_packing.MinMover() self.mini.min_type('lbfgs_armijo_nonmonotone') self.movemap = pyrosetta.MoveMap() self.mini.score_function(self.scorefxn) # for atom in self.small_angle.bb_atoms: # self.movemap.set(pyrosetta.rosetta.core.id.DOF_ID(atom , pyrosetta.rosetta.core.id.THETA), True) self.movemap.set_bb_true_range(1, self.pose.size()) self.mini.movemap(self.movemap) # Build MC object + Trial Mover (empty for now) self.mc = pyrosetta.MonteCarlo(self.pose, self.scorefxn, 1) self.trial_mc = pyrosetta.TrialMover() # Building variable to store various folding algorithms self.folding_protocols = {} # Adding a default mover self.build_fold_alg('default') self.add_folding_move('default', pyrosetta.RepeatMover(self.small, 10)) # self.add_folding_move('default', pyrosetta.RepeatMover(self.shear, 10)) self.add_folding_move('default', pyrosetta.RepeatMover(self.mini, 10))
def dock_pose(self): ## constraints def add_weights(scorefxn): stm = pyrosetta.rosetta.core.scoring.ScoreTypeManager() scorefxn.set_weight( stm.score_type_from_name("atom_pair_constraint"), 20) scorefxn.set_weight(stm.score_type_from_name("angle_constraint"), 20) setup = pyrosetta.rosetta.protocols.constraint_movers.ConstraintSetMover( ) setup.constraint_file(self.constraint_filename) setup.apply(self.pose) scorefxn = pyrosetta.get_fa_scorefxn() add_weights(scorefxn) ### First relax movemap = pyrosetta.MoveMap() v = self.get_ligand_selector().apply(self.pose) n = self.get_neighbour_selector().apply(self.pose) movemap.set_bb(allow_bb=n) movemap.set_chi(allow_chi=n) relax = pyrosetta.rosetta.protocols.relax.FastRelax(scorefxn, 10) relax.set_movemap_disables_packing_of_fixed_chi_positions(True) relax.set_movemap(movemap) print(f'FastRelax 2: {self.name}') #this one is non cartesian. self.pose.dump_pdb( f'{self.work_path}/{self.name}/min2_{self.name}.pdb') self.notebook['post-min2'] = self.calculate_score() ## repack # operation = pyrosetta.rosetta.core.pack.task.operation # allow = operation.RestrictToRepackingRLT() # restrict_to_focus = operation.OperateOnResidueSubset(allow,self.get_ligand_selector(), True) # tf = pyrosetta.rosetta.core.pack.task.TaskFactory() # tf.push_back(operation.PreventRepacking()) # tf.push_back(restrict_to_focus) # packer = pyrosetta.rosetta.protocols.minimization_packing.PackRotamersMover(scorefxn) # packer.task_factory(tf) # packer.apply(self.pose) # self.pose.dump_pdb(f'{self.work_path}/{self.name}/repacked_{self.name}.pdb') ### Docking pyrosetta.rosetta.protocols.docking.setup_foldtree( self.pose, 'A_B', pyrosetta.Vector1([1])) scorefxn = pyrosetta.create_score_function('ligand') add_weights(scorefxn) restrict_to_focus = pyrosetta.rosetta.core.pack.task.operation.OperateOnResidueSubset( pyrosetta.rosetta.core.pack.task.operation.RestrictToRepackingRLT( ), self.get_neighbour_selector(), True) tf = pyrosetta.rosetta.core.pack.task.TaskFactory() tf.push_back( pyrosetta.rosetta.core.pack.task.operation.RestrictToRepacking()) tf.push_back(restrict_to_focus) docking = pyrosetta.rosetta.protocols.docking.DockMCMProtocol() docking.set_task_factory(tf) docking.set_ignore_default_task(True) #docking.set_move_map() docking.set_scorefxn(scorefxn) docking.apply(self.pose) print(f'Dock: {self.name}') self.notebook['docked'] = self.calculate_score() self.pose.dump_pdb( f'{self.work_path}/{self.name}/docked_{self.name}.pdb')
# Setup CGFoldingAlgorithm object sequence = "X[CG11x3:CGLower]X[CG11x3]X[CG11x3]X[CG11x3:CGUpper]" kt = 1 cg_folding_object = cg_pyrosetta.CG_folding.CGFoldingAlgorithm(sequence) # Create CG Movers cg_small = cg_pyrosetta.CG_movers.CGSmallMover(cg_folding_object.pose) cg_small.angle = 180 # set_bl_mover = cg_pyrosetta.CG_movers.setBondLengths(cg_folding_object.pose, {"BB1 BB2":2.0}) #set_bl_mover.apply(cg_folding_object.pose) mini = pyrosetta.rosetta.protocols.minimization_packing.MinMover() movemap = pyrosetta.MoveMap() mini.score_function(cg_folding_object.scorefxn) movemap.set_bb_true_range(1, cg_folding_object.pose.size()) mini.movemap(movemap) pymol = pyrosetta.PyMOLMover() # Add new folding moves cg_folding_object.build_fold_alg("TorsionMC") cg_folding_object.add_folding_move("TorsionMC", pyrosetta.RepeatMover(cg_small, 10)) cg_folding_object.add_folding_move("TorsionMC", pyrosetta.RepeatMover(mini, 20)) cg_folding_object.add_folding_move("TorsionMC", pymol) # Run MC Simulation