def repack_and_minimize_mutant(pose,
task_factory,
move_map,
score_function,
rounds=3):
#Copying the pose
ram_pose = pr.Pose(pose)
#preparing repack and applying
prm = PackRotamersMover()
prm.score_function(score_function)
prm.task_factory(task_factory)
#preparing minimize and applying
min_mover = MinMover()
min_mover.movemap(move_map)
min_mover.score_function(score_function)
print_out("Checking Packertask")
packer = task_factory.create_task_and_apply_taskoperations(pose)
print_out("packer task")
print_out(packer)
for rnd in range(rounds):
print_out("round " + str(rnd + 1) + " of repack and min")
prm.apply(ram_pose)
min_mover.apply(ram_pose)
return ram_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 vanillaMinimizationMovers(cleanPDBName, outname, iterations = 100):
#try using teh default movers for a set number of iterations
print ("vanilla relax")
pose = pose_from_pdb(cleanPDBName)
min_mover = MinMover()
movemapDefault = MoveMap() #standard move map
scorefxn = get_fa_scorefxn() #standard fa score function
min_mover.movemap(movemapDefault)
min_mover.score_function(scorefxn)
for i in range(0, iterations):
min_mover.apply(pose)
pose.dump_pdb(outname)
return scorefxn(pose)
def make_min_mover(scorefxn, movemap):
min_mover = MinMover()
min_mover.movemap(movemap)
min_mover.score_function(scorefxn)
return min_mover
ccst2 = DihedralConstraint(c_ca, n_ca, x_n, x_ca, chf2)
ccst3 = DihedralConstraint(n_ca, x_n, x_ca, x_c, chf3)
#ccst4 = DihedralConstraint(n_ca, x_c, x_ca, x_n, chf3)
#constratint_set = [dcst1, dcst2, acst1, acst2, ccst1, ccst2, ccst3, ccst4]
constratint_set = [dcst, acst1, acst2, ccst1, ccst2, ccst3]
for c in constratint_set:
loop.add_constraint(c)
sf = create_score_function('ref2015_cst')
mm = MoveMap()
mm.set_jump(True)
mm.set_bb(False)
mm.set_chi(False)
minmov = MinMover()
minmov.score_function(sf)
minmov.min_type('lbfgs_armijo_nonmonotone')
minmov.movemap(mm)
In[262]: int_ca_dist
Out[262]: 5.188580947619549
In[263]: out_dist
Out[263]: 20.662075700422758
In[264]: degrees(out_ang)
Out[264]: 75.4564298506566
In[265]: degrees(out_ang + pi / 2)
Out[265]: 165.45642985065658
In[266]: 180 - degrees(out_ang + pi / 2)
Out[266]: 14.543570149343424
def get_designer_mover(score_function=DEFAULT.score_function,
designable=DEFAULT.designable,
repackable=DEFAULT.repackable,
cutoff=DEFAULT.cutoff,
ligand_chain=DEFAULT.ligand_chain,
blocked_region=DEFAULT.blocked_region):
"""
Returns a design Mover.
The design mover used in this example is a SequenceMover comprised of 2
movers: a PackRotamersMover and a MinMover, in this order. For the
PackRotamersMover, extra rotamers on chi1 and chi2 are enabled. During this
step, residues on the 'designable' ResidueSelector will be subject to design
efforts, while residues on the 'repackable' ResidueSelector will only change
conformation to rotamers of the same aminoacid. During the minimization step
only the sidechains are allowed to relax. By default, when no custom
designable or repackable ResidueSelector's are provided, both designable and
repackable regions are set to 'auto', where the repackable region is defined
as all the residues of the ligand_chain (C, by default) and the designable
region is defined as the residues within a cutoff (9.0 Angstrom, by default)
from the ligand_chain. If a blocked region is provided, no design nor repack
will be performed on those residues. A blocked region is defined with the
following syntax: "start-end", where start and end are residue index
numbers. For example, blocking the region from residue 1 to 56, one would
use "1-56".
"""
# --- SCORE FUNCTION
if score_function == "auto":
try:
score_function = get_fa_scorefxn()
except:
score_function = get_fa_scorefxn()
else:
from pyrosetta.rosetta.core.scoring import ScoreFunction
assert type(score_function) == ScoreFunction, \
"Score function for relaxer mover must be of type ScoreFunction."
# --- DESIGNABLE REGION
designable = get_designable_region(designable, cutoff, ligand_chain,
blocked_region)
# --- REPACKABLE REGION
if repackable == "auto":
repackable = ChainSelector(ligand_chain)
else:
assert isinstance(repackable, ResidueSelector) or repackable == "auto",\
"Repackable selection must be a ResidueSelector or set to 'auto'"
task_factory = standard_task_factory()
blockable = NotResidueSelector(OrResidueSelector(designable, repackable))
task_factory.push_back(ExtraRotamers(0, 1, 1)) # ex1
task_factory.push_back(ExtraRotamers(0, 2, 1)) # ex2
block = PreventRepackingRLT() # NO design, NO repacking
repack = RestrictToRepackingRLT() # NO design, ONLY repacking
task_factory.push_back(OperateOnResidueSubset(block, blockable))
task_factory.push_back(OperateOnResidueSubset(repack, repackable))
pack_mover = PackRotamersMover(score_function)
pack_mover.task_factory(task_factory)
move_map = MoveMap()
move_map.set_chi(True)
min_mover = MinMover()
min_mover.movemap(move_map)
min_mover.score_function(score_function)
min_mover.min_type('lbfgs_armijo_nonmonotone')
designer = SequenceMover()
designer.add_mover(pack_mover)
designer.add_mover(min_mover)
return designer
# Define the Minimizer:
# Define the MoveMap (allowing movement in the sidechains only):
move_map = MoveMap()
move_map.set_chi(True)
# Ex. Set a single residue (1) Chi movements to False:
# Ex. move_map.set_chi(1, False)
# Ex. Set a range of residues (2 to 10) Chi movements to True:
# Ex. move_map.set_chi_true_range(2, 10)
# Note: Using the range, there's currently no function to set to False.
# Ex. Visualize the current MoveMap:
# Ex. move_map.show()
# Define the MinMover (with the current MoveMap, Score Function and set
# the minimization type to "lbfgs_armijo_nonmonotone"):
min_mover = MinMover()
min_mover.movemap(move_map)
min_mover.score_function(score_function)
min_mover.min_type('lbfgs_armijo_nonmonotone')
# Ex. Visualize the current MinMover:
# Ex. min_mover.show()
# Define the SequenceMover:
sequence_mover = SequenceMover()
sequence_mover.add_mover(pack_mover)
sequence_mover.add_mover(min_mover)
# Run the script
for i in range(args.n_cycles):
# Ex. Run each step on SequenceMover individually
# Ex. pack_mover.apply(p)
# Ex. min_mover.apply(p)