class TestMinMover():
pose = get_pose('PYTEST')
mmap = MoveMap()
mmap.set_bb(True)
sfxn = get_score_function()
min_mv = MinMover(movemap=mmap, sfxn=sfxn)
def test_attributes(self):
assert self.min_mv.score_function() == self.min_mv.sfxn
assert self.min_mv.movemap(self.pose).get_bb(1)
def mutate_residue(pack_or_pose,
mutant_position,
mutant_aa,
pack_radius=0.,
pack_scorefxn=None):
"""Replace the residue at a single position in a Pose with a new amino acid
and repack any residues within user-defined radius of selected residue's
center using.
Args:
pack_or_pose (pyrosetta.rosetta.core.pose.Pose OR pyrosetta.distributed.packed_pose.PackedPose):
the `Pose` instance to use.
mutant_position (int): Pose-numbered position of the residue to mutate.
mutant_aa (str): The single letter name for the desired amino acid.
pack_radius (float): Radius used to define neighboring residues.
pack_scorefxn (pyrosetta.ScoreFunction): `ScoreFunction` to use when repacking the `Pose`.
Defaults to the standard `ScoreFunction`.
"""
import pyrosetta
import pyrosetta.distributed.packed_pose as packed_pose
wpose = packed_pose.to_pose(pack_or_pose)
if not wpose.is_fullatom():
raise IOError("mutate_residue only works with fullatom poses")
# create a standard scorefxn by default
if not pack_scorefxn:
pack_scorefxn = pyrosetta.get_score_function()
# the numbers 1-20 correspond individually to the 20 proteogenic amino acids
from pyrosetta.rosetta.core.chemical import aa_from_oneletter_code
mutant_aa = int(aa_from_oneletter_code(mutant_aa))
aa_bool = pyrosetta.Vector1([aa == mutant_aa for aa in range(1, 21)])
# mutation is performed by using a PackerTask with only the mutant
# amino acid available during design
task = pyrosetta.standard_packer_task(wpose)
task.nonconst_residue_task(mutant_position).restrict_absent_canonical_aas(
aa_bool)
# prevent residues from packing by setting the per-residue "options" of the PackerTask
task = restrict_non_nbrs_from_repacking(wpose, mutant_position, task,
pack_radius)
# apply the mutation and pack nearby residues
from pyrosetta.rosetta.protocols.minimization_packing import PackRotamersMover
packer = PackRotamersMover(pack_scorefxn, task)
packer.apply(wpose)
def main():
pyrosetta.init('-beta')
# making xforms
for iter in range(10):
x = rosetta.numeric.random.gaussian_random_xform(10.0, 0.5)
print("should be 10-ish", x.rotation_angle_degrees())
print('should be 0.5-ish', x.t.length())
# customizing a score function
sf = pyrosetta.get_score_function()
# do print(sf) and look for weights to see what you can modify
sf.set_weight(core.scoring.fa_dun, 0.0)
# use xform to move pose around
chem_manager = rosetta.core.chemical.ChemicalManager
rts = chem_manager.get_instance().residue_type_set("fa_standard")
gly = core.pose.Pose()
asn = core.pose.Pose()
core.pose.make_pose_from_sequence(gly, 'G', rts)
core.pose.make_pose_from_sequence(asn, 'N', rts)
gn = gly
# anchor to 1st residue, rot round CG of res 2
gn.append_pose_by_jump(asn, 1, 'CA', 'CG')
j = gn.jump(1) # only one jump in this system
j.set_translation(j.get_translation() +
numeric.xyzVector_double_t(5, 0, 0))
gn.set_jump(1, j) # move apart a bit
for i in range(10):
j = gn.jump(1)
# this is better than below, probably
print(j.gaussian_move(1, 0.0, 5.0))
# x = rosetta.numeric.random.gaussian_random_xform(5.0, 0.25)
# j.set_rotation(j.get_rotation()x.R)
# j.set_translation(j.get_translation() + x.t)
gn.set_jump(1, j)
gn.dump_pdb('test_%i.pdb' % i)
if roll >= P:
p.assign(last_pose) # reject pose and reassign previous
continue
# if new pose is accepted, store lowest score and associated pose
if new_score < low_score:
low_score = new_score
low_pose.assign(p)
# output files
p.dump_pdb("poly-A_final.pdb")
low_pose.dump_pdb("poly-A_low.pdb")
# Low-Resolution (Centroid) Scoring
ras = pose_from_file("../test/data/workshops/6Q21.clean.pdb")
score2 = get_score_function()
print(score2(ras))
print(ras.residue(5))
switch = SwitchResidueTypeSetMover("centroid")
switch.apply(ras)
print(ras.residue(5))
score3 = create_score_function("score3")
print(score3(ras))
switch2 = SwitchResidueTypeSetMover("fa_standard")
switch2.apply(ras)
print(ras.residue(5))
# Protein Fragments
def main(argv):
parser = argparse.ArgumentParser(description='Program')
parser.add_argument('-i', '--in_file', action='store', type=str,
help='input PDB scaffold file')
parser.add_argument('-d', '--loop_dir', action='store', type=str,
required=True, nargs='+',
help='directories containing loops to graft. Provide'
' directories with C-terminal-most loops first.')
parser.add_argument('-o', '--out_dir', action='store', type=str,
help='directory to write output')
args = parser.parse_args()
list_of_loop_files = [[path.join(ld, l) for l in
listdir(ld)] for ld in args.loop_dir]
# print(list_of_loop_files[0])
if not path.exists(args.out_dir):
makedirs(args.out_dir)
# user-specified scorefxn
pyrosetta.init() # extra_options='-beta_nov15')
# figure out the pdb-numbered residue ranges for the loops from the
# directory name. This is hacky, but whateva
def _get_loop_ranges(dir_name, split_char='_'):
components = dir_name.split(split_char)
res_range = list()
for c in components:
try:
res_range.append(int(c))
except ValueError:
pass
return res_range
loop = list()
start_pose = pyrosetta.pose_from_file(args.in_file)
to_centroid = pyrosetta.rosetta.protocols.simple_moves.SwitchResidueTypeSetMover('centroid')
to_centroid.apply(start_pose)
for directory in args.loop_dir:
loop_range = _get_loop_ranges(directory)
loop.append((start_pose.pdb_info().pdb2pose('A', loop_range[0]),
start_pose.pdb_info().pdb2pose('A', loop_range[1])))
assert(loop[-1][0] < loop[-1][1] and loop[-1][0] > 0)
# temporary -- I'd rather have some recursive type of thing that doesn't
# need to know how many loops we're talking about here
assert(len(list_of_loop_files) == len(loop) )
print(len(list_of_loop_files))
sf = pyrosetta.get_score_function(False) # centroid score function
score_manager = pyrosetta.rosetta.core.scoring.ScoreTypeManager()
score_term = score_manager.score_type_from_name("atom_pair_constraint")
sf.set_weight(score_term, 1.0)
print(sf)
# to avoid bookkeeping crap, we're going to smash in the downstream loop
# first.
if len(list_of_loop_files) == 1:
print("One loop!")
for i, loop_fname in enumerate(list_of_loop_files[0]):
p = insert_loop_into_scaffold(start_pose, loop_fname, loop[0], to_centroid)
if sf(p) < 0.:
scaffold_base, _ = path.splitext(path.basename(args.in_file))
l1_basename, _ = path.splitext(path.basename(loop_fname))
fname = path.join(args.out_dir,
'{}_{}.pdb'.format(scaffold_base, l1_basename))
p.dump_pdb(fname)
elif len(list_of_loop_files) == 2:
for i, loop_fname in enumerate(list_of_loop_files[0]):
p = insert_loop_into_scaffold(start_pose, loop_fname, loop[0],
to_centroid)
for i, loop2_fname in enumerate(list_of_loop_files[1]):
p = insert_loop_into_scaffold(p, loop2_fname, loop[1], to_centroid)
if sf(p) < 0.:
scaffold_base, _ = path.splitext(path.basename(args.in_file))
l1_basename, _ = path.splitext(path.basename(loop_fname))
l2_basename, _ = path.splitext(path.basename(loop2_fname))
fname = path.join(args.out_dir,
'{}_{}_{}.pdb'.format(scaffold_base,
l1_basename,
l2_basename))
p.dump_pdb(fname)
# Write the results to an outfile
if not os.path.isdir(os.path.dirname(results_file)):
os.makedirs(os.path.dirname(results_file))
print("Writing the results to the file: {0}".format(results_file))
scores_all_pdbs.to_csv(results_file)
#---------------------------------------------------------------
# Initialize relevant Movers and Filters in PyRosetta
#---------------------------------------------------------------
# Initialize a specific score function
pyrosetta.init(
extra_options=
'-beta_nov16 -holes:dalphaball /home/sheffler/bin/DAlphaBall.gcc')
scorefxn = pyrosetta.get_score_function()
# Tweak the score function so that it includes energies from
# backbone hydrogen bonds when computing per-residue energies
def fix_scorefxn(sfxn, allow_double_bb=False):
opts = sfxn.energy_method_options()
opts.hbond_options().decompose_bb_hb_into_pair_energies(True)
opts.hbond_options().bb_donor_acceptor_check(not allow_double_bb)
sfxn.set_energy_method_options(opts)
fix_scorefxn(scorefxn)
# Import the content of the input XML files, and store them in a dictionary
# of the form {metric name : script contents}
add_single_cutpoint_variant(pose, loop1)
ccd = protocols.loops.loop_closure.ccd.CCDLoopClosureMover(loop1, movemap)
ccd.apply(pose)
set_single_loop_fold_tree(pose, loop1)
# Multiple Loops
loop2 = protocols.loops.Loop(78, 83, 80)
loops = protocols.loops.Loops()
loops.add_loop(loop1)
loops.add_loop(loop2)
# Loop Building
reference_pose = pose_from_file("../test/data/test_in.pdb")
score = get_score_function()
import tempfile
output = tempfile.mkstemp()[1]
jd = PyJobDistributor(output, 1, score)
lrms = loop_rmsd(pose, reference_pose, loops, True)
jd.additional_decoy_info = " LRMSD: " + str(lrms)
# High-Resolution Loop Protocol
loop_refine = LoopMover_Refine_CCD(loops)
# loop_refine.apply(pose) # takes too long
# KIC
def main(argv):
parser = argparse.ArgumentParser(description='Program')
parser.add_argument('-i',
'--in_file',
action='store',
type=str,
help='input PDB scaffold file')
parser.add_argument('-d',
'--loop_dir',
action='store',
type=str,
required=True,
nargs='+',
help='directories containing loops to graft. Provide'
' directories with C-terminal-most loops first.')
parser.add_argument('-o',
'--out_dir',
action='store',
type=str,
help='directory to write output')
#added by gabi
parser.add_argument('-a1',
'--anchor_res_pair1',
nargs='+',
type=int,
help='first pair of anchor residues')
parser.add_argument('-a2',
'--anchor_res_pair2',
nargs='+',
type=int,
help='second pair of anchor residues',
default=0)
args = parser.parse_args()
# print(list_of_loop_files[0])
#added by gabi
anchor_list = [args.anchor_res_pair1, args.anchor_res_pair2]
if not path.exists(args.out_dir):
makedirs(args.out_dir)
# user-specified scorefxn
pyrosetta.init() # extra_options='-beta_nov15')
# figure out the pdb-numbered residue ranges for the loops from the
# directory name. This is hacky, but whateva
def _get_loop_ranges(dir_name, split_char='_'):
components = dir_name.split(split_char)
res_range = list()
for c in components:
try:
res_range.append(int(c))
except ValueError:
pass
return res_range
def _get_loop_size(dir_name):
dir_path = path.join(dir_name)
loop_file = next(
path.join(dir_path, f) for f in listdir(dir_path)
if path.isfile(path.join(dir_path, f)))
loop_pose = pyrosetta.pose_from_file(loop_file)
loop_size = loop_pose.total_residue()
return loop_size
loop = list()
start_pose = pyrosetta.pose_from_file(args.in_file)
#added by gabi
loops_length = list()
for directory in args.loop_dir:
loop_res = _get_loop_size(directory)
loops_length.append(loop_res)
edited_pose = renum_pose_and_loop(args, anchor_list, loops_length)
#pose_anchor_res = get_anchor_for_renum(args,len(list_of_loop_files))
#moved down here by gabi
list_of_loop_files = [[path.join(ld, l) for l in listdir(ld)]
for ld in args.loop_dir]
to_centroid = pyrosetta.rosetta.protocols.simple_moves.SwitchResidueTypeSetMover(
'centroid')
to_centroid.apply(edited_pose)
for size in loops_length:
loop_range = _get_loop_ranges(directory)
loop.append((edited_pose.pdb_info().pdb2pose('A', loop_range[0]),
edited_pose.pdb_info().pdb2pose('A', loop_range[1])))
assert (loop[-1][0] < loop[-1][1] and loop[-1][0] > 0)
# temporary -- I'd rather have some recursive type of thing that doesn't
# need to know how many loops we're talking about here
assert (len(list_of_loop_files) == len(loop))
print(len(list_of_loop_files))
sf = pyrosetta.get_score_function(False) # centroid score function
score_manager = pyrosetta.rosetta.core.scoring.ScoreTypeManager()
score_term = score_manager.score_type_from_name("atom_pair_constraint")
sf.set_weight(score_term, 1.0)
#added by gabi
score_term = score_manager.score_type_from_name("vdw")
sf.set_weight(score_term, 1.0)
score_term = score_manager.score_type_from_name("hbond_sr_bb")
sf.set_weight(score_term, 1.0)
score_term = score_manager.score_type_from_name("hbond_lr_bb")
sf.set_weight(score_term, 0.5)
score_term = score_manager.score_type_from_name("dihedral_constraint")
sf.set_weight(score_term, 10.0)
score_term = score_manager.score_type_from_name("rama")
sf.set_weight(score_term, 0.1)
score_term = score_manager.score_type_from_name("omega")
sf.set_weight(score_term, 1.0)
score_term = score_manager.score_type_from_name("rg")
sf.set_weight(score_term, 1.0)
score_term = score_manager.score_type_from_name("linear_chainbreak")
sf.set_weight(score_term, 2.778)
score_term = score_manager.score_type_from_name("cart_bonded")
sf.set_weight(score_term, 0.5)
print(sf)
# to avoid bookkeeping crap, we're going to smash in the downstream loop
# first.
if len(list_of_loop_files) == 1:
print("One loop!")
for i, loop_fname in enumerate(list_of_loop_files[0]):
p = insert_loop_into_scaffold(edited_pose, loop_fname, loop[0],
to_centroid)
#try to filter based on the cartbonded score, misses one or two usually
if sf.score_by_scoretype(p, score_term, True) < 180.:
scaffold_base, _ = path.splitext(path.basename(args.in_file))
l1_basename, _ = path.splitext(path.basename(loop_fname))
fname = path.join(
args.out_dir, '{}_{}.pdb'.format(scaffold_base,
l1_basename))
p.dump_pdb(fname)
elif len(list_of_loop_files) == 2:
for i, loop_fname in enumerate(list_of_loop_files[0]):
p = insert_loop_into_scaffold(edited_pose, loop_fname, loop[0],
to_centroid)
for i, loop2_fname in enumerate(list_of_loop_files[1]):
p2 = insert_loop_into_scaffold(p, loop2_fname, loop[1],
to_centroid)
#may need to work on the best filter score
if sf.score_by_scoretype(p, score_term, True) < 180.:
scaffold_base, _ = path.splitext(
path.basename(args.in_file))
l1_basename, _ = path.splitext(path.basename(loop_fname))
l2_basename, _ = path.splitext(path.basename(loop2_fname))
fname = path.join(
args.out_dir,
'{}_{}_{}.pdb'.format(scaffold_base, l1_basename,
l2_basename))
p2.dump_pdb(fname)
def main(argv):
parser = ArgumentParser()
parser.add_argument('-s',type=str) # Allow for input file to be specified at initialization
args=parser.parse_args()
input_pdb=args.s
pdbfile=str(input_pdb) #duplicated string?
pdb = os.path.split(str( pdbfile ))[-1]
pdbname=str((pdb).split('.',)[0])
print (str(pdbname))
#initialize pyrosetta. output virtual atoms as they are the hack to centre the ligand params files specific to situation
pyrosetta.init('-extra_res_fa DRD.params DRE.params -out:file:output_virtual true')
pose = pyrosetta.pose_from_file(input_pdb)
sf = pyrosetta.get_score_function()
surface_selector = pyrosetta.rosetta.core.select.residue_selector.LayerSelector()
surface_selector.set_layers(False, False, True)
surface_residue_indexes = pyrosetta.rosetta.core.select.get_residues_from_subset(surface_selector.apply(pose))
print(surface_residue_indexes)
#For both modified amino acids
#For each surface residue
#For each rotamer
for h in 'DRD', 'DRE':
ncaa = h
print "Residue ", h
# Iterating all residue position indexes
for i in surface_residue_indexes:
pose_clone = pose.clone()
# Mutate to target residue
pyrosetta.rosetta.protocols.simple_moves.MutateResidue(i, ncaa).apply(pose_clone)
# Set native rotamers - needed?
# if ncaa == 'DRD':
# pose_clone.set_chi(1, i, 170.459) # Update for Asp
# pose_clone.set_chi(2, i, -89.397)
# elif ncaa == 'DRE':
# pose_clone.set_chi(1, i, 170.459) # Update for Glu
# pose_clone.set_chi(2, i, -89.397)
# pose_clone.set_chi(3, i, 180.000)
trm = pyrosetta.rosetta.protocols.protein_interface_design.movers.TryRotamers(resnum=i, scorefxn=sf, explosion=0, jump_num=0, clash_check=True, solo_res=False, include_current=True)
trm.setup_rotamer_set(pose_clone)
rotamer_set = trm.rotamer_set()
#print trm
#print rotamer_set
#print(rotamer_set.num_rotamers())
#For every rotamer that doesn't clash
for j in pyrosetta.rrange(int(rotamer_set.num_rotamers())):
pose_clone2 = pose_clone.clone()
pose_clone2.replace_residue(i, rotamer_set.rotamer(j), True)
angle_error, distance_error1, distance_error2 = check_alignment(pose_clone2, i) # ,dihedral1,angle1,chi2
if (angle_error < 4 or angle_error > 176) and distance_error1 < 0.5 and distance_error2 < 0.5: #and abs(dihedral1)>30 and abs(dihedral1)<120 and angle1>90 and angle1<125 and abs(chi2)>45:
#print "Hit found!"
hitlist = open("output/hitlist.txt", "a")
print >>hitlist, str(pdbname) + " residue " + str(i) + " rotamer " + str(j) + " of " + str(h)
hitlist.close()
#print "pdb " + str(pdbname) + " residue " + str(i) + " rotamer " + str(j) + " supports residue " + str(h) + " in the appropriate position"
pose_clone3 = pose_clone2.clone()
sfsm_c4 = pyrosetta.rosetta.protocols.simple_moves.symmetry.SetupForSymmetryMover('./C4_Z.sym')
sfsm_c4.apply(pose_clone3)
# export a pdb file of the symmetric molecule
pose_clone3.dump_pdb('output/' + str(pdbname) + '_' + str(h) + '_' + str(i) + '_' + str(j) + '.pdb')
movemap.set_bb(True)
movemap.set_bb(10, False)
print('outputting movemap')
movemap.show(pose.total_residue())
fragset3mer = core.fragment.ConstantLengthFragSet(
3, "../test/data/test3_fragments") # "aatestA03_05.200_v1_3")
fragset9mer = core.fragment.ConstantLengthFragSet(
9, "../test/data/test9_fragments") # "aatestA09_05.200_v1_3")
print('mover: ClassicFragmentMover, 3mer')
movemap.set_bb(True)
mover_3mer = protocols.simple_moves.ClassicFragmentMover(fragset3mer, movemap)
mover_3mer.apply(pose_frag)
print('Creating standard score function with patch and scoring')
scorefxn = get_score_function()
scorefxn(pose)
print('mover: SmallMover')
movemap.set_bb(True)
smallmover = protocols.simple_moves.SmallMover(movemap, kT, n_moves)
smallmover = protocols.simple_moves.SmallMover()
smallmover.angle_max('L', 50)
smallmover.apply(pose_frag)
print(smallmover)
# TODO: fix printout. show mover params (temp, nmoves, anglemax) and last output status
# TODO: mover base class printout with name, last output status, brief description(?)
print('mover: ShearMover')
shearmover = protocols.simple_moves.ShearMover(movemap, kT, n_moves)