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