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 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 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 _minimize_step(sf, pose):
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(False)
mmap.set_jump(True)
min_mover = MinMover(mmap, sf, "lbfgs_armijo_nonmonotone", 0.0001, True)
min_mover.max_iter(1000)
min_mover.apply(pose)
def Fold(pose, ncycles=1000, tolerance=0.0001, UseNBList=True, UsePerturbation=False):
assert pose is not None
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(False)
mmap.set_jump(True)
mmap.show()
scriptdir = os.path.dirname(os.path.realpath(__file__))
sf = ScoreFunction()
sf.add_weights_from_file(scriptdir + '/params/scorefxn.wts')
sf1 = ScoreFunction()
sf1.add_weights_from_file(scriptdir + '/params/scorefxn1.wts')
sf_vdw = ScoreFunction()
sf_vdw.add_weights_from_file(scriptdir + '/params/scorefxn_vdw.wts')
sf_cart = ScoreFunction()
sf_cart.add_weights_from_file(scriptdir + '/params/scorefxn_cart.wts')
min_mover = MinMover(mmap, sf, 'lbfgs_armijo_nonmonotone', tolerance, True)
min_mover.max_iter(ncycles)
min_mover1 = MinMover(mmap, sf1, 'lbfgs_armijo_nonmonotone', tolerance, True)
min_mover1.max_iter(ncycles)
min_mover_vdw = MinMover(mmap, sf_vdw, 'lbfgs_armijo_nonmonotone', tolerance, True)
min_mover_vdw.max_iter(500)
min_mover_cart = MinMover(mmap, sf_cart, 'lbfgs_armijo_nonmonotone', tolerance, True)
min_mover_cart.max_iter(ncycles)
min_mover_cart.cartesian(True)
## remove clash in the initial pose
RemoveClash(sf_vdw, min_mover_vdw, pose)
repeat_mover = RepeatMover(min_mover, 4)
repeat_mover.apply(pose)
if UsePerturbation:
pose = MinimizeEnergyByPerturbation(pose, min_mover, sf, sigmas=[10, 7.5, 3, 2])
min_mover_cart.apply(pose)
RemoveClash(sf_vdw, min_mover1, pose)
sf.show(pose)
switch = SwitchResidueTypeSetMover("fa_standard")
switch.apply(pose)
return pose
def generateOneStructure(
fastaName,
npzName,
modelName,
):
#generates one pdb structure from a npz, returns score function score
#Namespace(FASTA='T1008.fasta', NPZ='T1008.npz', OUT='model.pdb', fastrelax=True, mode=2, pcut=0.05, steps=1000, use_orient=True, wdir='/dev/shm')
timeRunningFile = open(
fastaName.replace(".fasta", "") + "timeToProcess.txt", "w")
startTime = time.time()
########################################################
# process inputs
########################################################
# read params
scriptdir = os.path.dirname(os.path.realpath(__file__))
with open(scriptdir + '/data/params.json') as jsonfile:
params = json.load(jsonfile)
# get command line arguments
args = set_args(params, fastaName, npzName, modelName)
print(args)
# Create temp folder to store all the restraints
tmpdir = tempfile.TemporaryDirectory(prefix=args.wdir + '/')
params['TDIR'] = tmpdir.name
print('temp folder: ', tmpdir.name)
# read and process restraints & sequence
npz = np.load(args.NPZ)
seq = read_fasta(args.FASTA)
L = len(seq)
timeRunningFile.write("LENGTH," + str(L) + "\n")
params['seq'] = seq
rst = gen_rst(npz, tmpdir, params)
seq_polyala = 'A' * len(seq)
timeRunningFile.write("SETUP," + str(time.time() - startTime) + "\n")
startTime = time.time()
########################################################
# Scoring functions and movers
########################################################
sf = ScoreFunction()
sf.add_weights_from_file(scriptdir + '/data/scorefxn.wts')
sf1 = ScoreFunction()
sf1.add_weights_from_file(scriptdir + '/data/scorefxn1.wts')
sf_vdw = ScoreFunction()
sf_vdw.add_weights_from_file(scriptdir + '/data/scorefxn_vdw.wts')
sf_cart = ScoreFunction()
sf_cart.add_weights_from_file(scriptdir + '/data/scorefxn_cart.wts')
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(False)
mmap.set_jump(True)
min_mover = MinMover(mmap, sf, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover.max_iter(1000)
min_mover1 = MinMover(mmap, sf1, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover1.max_iter(1000)
min_mover_vdw = MinMover(mmap, sf_vdw, 'lbfgs_armijo_nonmonotone', 0.0001,
True)
min_mover_vdw.max_iter(500)
min_mover_cart = MinMover(mmap, sf_cart, 'lbfgs_armijo_nonmonotone',
0.0001, True)
min_mover_cart.max_iter(1000)
min_mover_cart.cartesian(True)
repeat_mover = RepeatMover(min_mover, 3)
timeRunningFile.write("MOVERS," + str(time.time() - startTime) + "\n")
startTime = time.time()
########################################################
# initialize pose
########################################################
pose = pose_from_sequence(seq, 'centroid')
# mutate GLY to ALA
for i, a in enumerate(seq):
if a == 'G':
mutator = rosetta.protocols.simple_moves.MutateResidue(
i + 1, 'ALA')
mutator.apply(pose)
print('mutation: G%dA' % (i + 1))
set_random_dihedral(pose)
remove_clash(sf_vdw, min_mover_vdw, pose)
timeRunningFile.write("INTIALIZE," + str(time.time() - startTime) + "\n")
startTime = time.time()
########################################################
# minimization
########################################################
if args.mode == 0:
# short
print('short')
add_rst(pose, rst, 1, 12, params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# medium
print('medium')
add_rst(pose, rst, 12, 24, params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# long
print('long')
add_rst(pose, rst, 24, len(seq), params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
elif args.mode == 1:
# short + medium
print('short + medium')
add_rst(pose, rst, 3, 24, params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# long
print('long')
add_rst(pose, rst, 24, len(seq), params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
elif args.mode == 2:
# short + medium + long
print('short + medium + long')
add_rst(pose, rst, 1, len(seq), params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# mutate ALA back to GLY
for i, a in enumerate(seq):
if a == 'G':
mutator = rosetta.protocols.simple_moves.MutateResidue(
i + 1, 'GLY')
mutator.apply(pose)
print('mutation: A%dG' % (i + 1))
timeRunningFile.write("MINIMIZATION," + str(time.time() - startTime) +
"\n")
startTime = time.time()
########################################################
# full-atom refinement
########################################################
if args.fastrelax == True:
sf_fa = create_score_function('ref2015')
sf_fa.set_weight(rosetta.core.scoring.atom_pair_constraint, 5)
sf_fa.set_weight(rosetta.core.scoring.dihedral_constraint, 1)
sf_fa.set_weight(rosetta.core.scoring.angle_constraint, 1)
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(True)
mmap.set_jump(True)
relax = rosetta.protocols.relax.FastRelax()
relax.set_scorefxn(sf_fa)
relax.max_iter(200)
relax.dualspace(True)
relax.set_movemap(mmap)
pose.remove_constraints()
switch = SwitchResidueTypeSetMover("fa_standard")
switch.apply(pose)
print('relax...')
params['PCUT'] = 0.15
add_rst(pose, rst, 1, len(seq), params, True)
relax.apply(pose)
timeRunningFile.write("FASTRELAX," + str(time.time() - startTime) + "\n")
startTime = time.time()
########################################################
# save final model
########################################################
pose.dump_pdb(args.OUT)
#return final energy score
scorefxn = get_fa_scorefxn()
finalScore = scorefxn(pose)
timeRunningFile.write("SCORE," + str(finalScore) + "\n")
timeRunningFile.close()
return finalScore
def make_min_mover(scorefxn, movemap):
min_mover = MinMover()
min_mover.movemap(movemap)
min_mover.score_function(scorefxn)
return min_mover
def do_dock(pdb_file, res_file, OUT, thre):
file_name = os.path.basename(res_file)
res_name = file_name.split('.')[0]
target_id = res_name.split('_')[0]
pose = pyrosetta.pose_from_pdb(pdb_file)
add_cons_to_pose(pose, res_file, thre)
scorefxn = ScoreFunction()
scorefxn.add_weights_from_file(weight_file)
scorefxn.set_weight(atom_pair_constraint, 1)
sw = SwitchResidueTypeSetMover("centroid")
switch = SwitchResidueTypeSetMover("fa_standard")
dock_jump = 1
partners = 'A_B'
slide = rosetta.protocols.docking.DockingSlideIntoContact(dock_jump)
pert_mover = rigid_moves.RigidBodyPerturbMover(dock_jump, 40, 20)
scorefxn_low = create_score_function("interchain_cen")
scorefxn_low.set_weight(atom_pair_constraint, 1)
dock_lowres = rosetta.protocols.docking.DockingLowRes(scorefxn_low, 1)
sw1 = SwitchResidueTypeSetMover("fa_standard")
scorefxn_dock = create_score_function("docking", "docking_min")
scorefxn_dock.set_weight(atom_pair_constraint, 1)
dock_hires = rosetta.protocols.docking.DockMCMProtocol()
dock_hires.set_scorefxn(scorefxn_dock)
dock_hires.set_scorefxn_pack(scorefxn)
dock_hires.set_partners('A_B')
movemap = MoveMap()
movemap.set_jump(dock_jump, True)
#min_mover = MinMover(movemap, scorefxn, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover = MinMover(movemap, scorefxn, 'lbfgs', 0.0001, True)
min_mover.max_iter(1000)
repeat_mover = RepeatMover(min_mover, 3)
relax = rosetta.protocols.relax.FastRelax()
relax.set_scorefxn(scorefxn)
relax.max_iter(200)
relax.dualspace(True)
relax.set_movemap(movemap)
move_map = MoveMap()
move_map.set_jump(dock_jump, True)
move_map.set_chi(True)
min_mover1 = MinMover(movemap, scorefxn, 'lbfgs', 0.0001, True)
min_mover1.max_iter(3000)
jd = PyJobDistributor(target_id, 40, scorefxn)
temp_pose = Pose()
temp_pose.assign(pose)
jd.native_pose = temp_pose
counter = 0
while not jd.job_complete:
test_pose = Pose(pose)
pmm.apply(test_pose)
rosetta.protocols.docking.setup_foldtree(test_pose, partners,
Vector1([dock_jump]))
randomize_upstream = RigidBodyRandomizeMover(test_pose, dock_jump,
partner_upstream)
randomize_downstream = RigidBodyRandomizeMover(test_pose, dock_jump,
partner_downstream)
pert_mover.apply(test_pose)
pmm.apply(test_pose)
randomize_upstream.apply(test_pose)
randomize_downstream.apply(test_pose)
slide.apply(test_pose)
min_mover.apply(test_pose)
print(scorefxn.show(test_pose))
min_mover.apply(test_pose)
print(scorefxn.show(test_pose))
min_mover.apply(test_pose)
print(scorefxn.show(test_pose))
repeat_mover.apply(test_pose)
print(scorefxn.show(test_pose))
switch.apply(test_pose)
#relax.apply(test_pose)
min_mover1.apply(test_pose)
counter = counter + 1
test_pose.pdb_info().name(target_id + '_' + str(counter))
jd.output_decoy(test_pose)
print(scorefxn.show(test_pose))
score_scorefxn_file = working_dir + '/' + 'score.txt'
with open(score_scorefxn_file, 'a') as f:
f.write(test_pose.pdb_info().name())
f.write(' ')
f.write(str(scorefxn(test_pose)))
f.write('\n')
generated_output = []
score_results = []
score_file = working_dir + '/' + target_id + '.fasc'
with open(score_file) as f:
for line in f:
splited_line = line.strip().split(',')
file_name = splited_line[1].split(':')[1]
score = splited_line[21].split(':')[1]
generated_output.append(file_name)
score_results.append(float(score[:-1]))
print(file_name, score)
print(generated_output[score_results.index(min(score_results))])
pdb_name = generated_output[score_results.index(min(score_results))][2:-1]
target = pdb_name.split('_')[0]
best_pdb = working_dir + '/' + pdb_name
print(best_pdb)
print(working_dir)
cmd = "cp " + best_pdb + " " + OUT + "/" + target + "_GD.pdb"
os.system(cmd)
print(cmd)
cmd = 'rm -rf ' + working_dir + '/' + '*.pdb'
os.system(cmd)
cmd = 'rm -rf ' + working_dir + '/' + '*.fasc'
os.system(cmd)
def main():
########################################################
# process inputs
########################################################
# read params
scriptdir = os.path.dirname(os.path.realpath(__file__))
with open(scriptdir + '/data/params.json') as jsonfile:
params = json.load(jsonfile)
# get command line arguments
args = get_args(params)
print(args)
if os.path.exists(args.OUT):
return
# init PyRosetta
init_cmd = list()
init_cmd.append("-multithreading:interaction_graph_threads 1 -multithreading:total_threads 1")
init_cmd.append("-hb_cen_soft")
init_cmd.append("-detect_disulf -detect_disulf_tolerance 2.0") # detect disulfide bonds based on Cb-Cb distance (CEN mode) or SG-SG distance (FA mode)
init_cmd.append("-relax:dualspace true -relax::minimize_bond_angles -default_max_cycles 200")
init_cmd.append("-mute all")
init_cmd.append("-unmute core.scoring.ScoreFunction")
#init_cmd.append("-unmute protocol")
init_cmd.append("-ex1 -ex2aro")
init_cmd.append("-mh:path:scores_BB_BB %s/../fold_and_dock.h**o/motif_dock/xh_16_"%scriptdir)
init_cmd.append("-mh:score:use_ss1 false")
init_cmd.append("-mh:score:use_ss2 false")
init_cmd.append("-mh:score:use_aa1 true")
init_cmd.append("-mh:score:use_aa2 true")
init(" ".join(init_cmd))
########################################################
# Scoring functions and movers
########################################################
sf = ScoreFunction()
sf.add_weights_from_file(scriptdir + '/data/scorefxn.wts')
sf1 = ScoreFunction()
sf1.add_weights_from_file(scriptdir + '/data/scorefxn1.wts')
sf_vdw = ScoreFunction()
sf_vdw.add_weights_from_file(scriptdir + '/data/scorefxn_vdw.wts')
sf_cart = ScoreFunction()
sf_cart.add_weights_from_file(scriptdir + '/data/scorefxn_cart.wts')
sf_dock = create_score_function('motif_dock_score')
sf_dock.set_weight(rosetta.core.scoring.atom_pair_constraint, 1.0)
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(False)
mmap.set_jump(True)
mmap_rb = MoveMap()
mmap_rb.set_bb(False)
mmap_rb.set_chi(False)
mmap_rb.set_jump(True)
min_mover1 = MinMover(mmap, sf1, 'lbfgs_armijo_nonmonotone', 0.001, True)
min_mover1.max_iter(1000)
min_mover_vdw = MinMover(mmap, sf_vdw, 'lbfgs_armijo_nonmonotone', 0.001, True)
min_mover_vdw.max_iter(500)
min_mover_vdw_rb = MinMover(mmap_rb, sf_vdw, 'lbfgs_armijo_nonmonotone', 0.001, True)
min_mover_vdw_rb.max_iter(500)
min_mover_cart = MinMover(mmap, sf_cart, 'lbfgs_armijo_nonmonotone', 0.000001, True)
min_mover_cart.max_iter(300)
min_mover_cart.cartesian(True)
# read and process restraints & sequence
seq = read_fasta(args.FASTA)
L1 = seq.index('/')
L = len(seq) - seq.count('/')
params['seq'] = seq.replace('/', '')
rst = gen_rst(params, L1)
########################################################
# initialize pose
########################################################
pose0 = pose_from_sequence(seq, 'centroid')
setup_foldtree(pose0, "A_B", Vector1([1]))
if (args.bb == ''):
print('setting random (phi,psi,omega)...')
set_random_dihedral(pose0, L)
else:
print('setting predicted (phi,psi,omega)...')
bb = np.load(args.bb)
set_predicted_dihedral(pose0,bb['phi'],bb['psi'],bb['omega'])
remove_clash(sf_vdw, min_mover_vdw, pose0)
#
rst_user = None
if os.path.exists(args.rsr):
rst_user = rosetta.protocols.constraint_movers.ConstraintSetMover()
rst_user.add_constraints(True)
rst_user.constraint_file(args.rsr)
Emin = 99999.9
########################################################
# minimization
########################################################
for run in range(params['NRUNS']):
# define repeat_mover here!! (update vdw weights: weak (1.0) -> strong (10.0)
sf.set_weight(rosetta.core.scoring.vdw, vdw_weight.setdefault(run, 10.0))
sf.set_weight(rosetta.core.scoring.atom_pair_constraint, rsr_dist_weight.setdefault(run, 1.0))
sf.set_weight(rosetta.core.scoring.dihedral_constraint, rsr_orient_weight.setdefault(run, 0.5))
sf.set_weight(rosetta.core.scoring.angle_constraint, rsr_orient_weight.setdefault(run, 0.5))
min_mover = MinMover(mmap, sf, 'lbfgs_armijo_nonmonotone', 0.001, True)
min_mover.max_iter(1000)
repeat_mover = RepeatMover(min_mover, 3)
#
pose = Pose()
pose.assign(pose0)
pose.remove_constraints()
if rst_user != None:
rst_user.apply(pose)
if run > 0:
# diversify backbone
dphi = np.random.uniform(-10,10,L)
dpsi = np.random.uniform(-10,10,L)
for i in range(1,L+1):
pose.set_phi(i,pose.phi(i)+dphi[i-1])
pose.set_psi(i,pose.psi(i)+dpsi[i-1])
# remove clashes
remove_clash(sf_vdw, min_mover_vdw, pose)
# Save checkpoint
if args.save_chk:
pose.dump_pdb("%s_run%d_init.pdb"%('.'.join(args.OUT.split('.')[:-1]), run))
if args.mode == 0:
# short
print('short')
add_rst(pose, rst, 3, 12, params)
repeat_mover.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
min_mover_cart.apply(pose)
if args.save_chk:
pose.dump_pdb("%s_run%d_mode%d_step%d.pdb"%('.'.join(args.OUT.split('.')[:-1]), run, args.mode, 0))
# medium
print('medium')
add_rst(pose, rst, 12, 24, params)
repeat_mover.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
min_mover_cart.apply(pose)
if args.save_chk:
pose.dump_pdb("%s_run%d_mode%d_step%d.pdb"%('.'.join(args.OUT.split('.')[:-1]), run, args.mode, 1))
# long
print('long')
add_rst(pose, rst, 24, len(seq), params)
repeat_mover.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
min_mover_cart.apply(pose)
if args.save_chk:
pose.dump_pdb("%s_run%d_mode%d_step%d.pdb"%('.'.join(args.OUT.split('.')[:-1]), run, args.mode, 2))
elif args.mode == 1:
# short + medium
print('short + medium')
add_rst(pose, rst, 3, 24, params)
repeat_mover.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
min_mover_cart.apply(pose)
if args.save_chk:
pose.dump_pdb("%s_run%d_mode%d_step%d.pdb"%('.'.join(args.OUT.split('.')[:-1]), run, args.mode, 0))
# long
print('long')
add_rst(pose, rst, 24, len(seq), params)
repeat_mover.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
min_mover_cart.apply(pose)
if args.save_chk:
pose.dump_pdb("%s_run%d_mode%d_step%d.pdb"%('.'.join(args.OUT.split('.')[:-1]), run, args.mode, 1))
elif args.mode == 2:
# short + medium + long
print('short + medium + long')
add_rst(pose, rst, 3, len(seq), params)
repeat_mover.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
min_mover_cart.apply(pose)
if args.save_chk:
pose.dump_pdb("%s_run%d_mode%d_step%d.pdb"%('.'.join(args.OUT.split('.')[:-1]), run, args.mode, 0))
#rigidbody_pert(pose)
dock_low_res(pose, sf_dock)
repeat_mover.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
min_mover_cart.apply(pose)
if args.save_chk:
pose.dump_pdb("%s_run%d_dock.pdb"%('.'.join(args.OUT.split('.')[:-1]), run))
# check whether energy has decreased
pose.conformation().detect_disulfides() # detect disulfide bonds
E = sf_cart(pose)
if E < Emin:
print("Energy(iter=%d): %.1f --> %.1f (accept)"%(run, Emin, E))
Emin = E
pose0 = pose.clone()
#pose0.assign(pose)
else:
print("Energy(iter=%d): %.1f --> %.1f (reject)"%(run, Emin, E))
## mutate ALA back to GLY
#for i,a in enumerate(seq_symm):
# if a == 'G':
# mutator = rosetta.protocols.simple_moves.MutateResidue(i+1,'GLY')
# mutator.apply(pose0)
# print('mutation: A%dG'%(i+1))
########################################################
# fix backbone geometry
########################################################
pose0.remove_constraints()
# apply more strict criteria to detect disulfide bond
# Set options for disulfide tolerance -> 1.0A
print (rosetta.basic.options.get_real_option('in:detect_disulf_tolerance'))
rosetta.basic.options.set_real_option('in:detect_disulf_tolerance', 1.0)
print (rosetta.basic.options.get_real_option('in:detect_disulf_tolerance'))
pose0.conformation().detect_disulfides()
# Converto to all atom representation
switch = SwitchResidueTypeSetMover("fa_standard")
switch.apply(pose0)
# idealize problematic local regions if exists
idealize = rosetta.protocols.idealize.IdealizeMover()
poslist = rosetta.utility.vector1_unsigned_long()
scorefxn=create_score_function('empty')
scorefxn.set_weight(rosetta.core.scoring.cart_bonded, 1.0)
scorefxn.score(pose0)
emap = pose0.energies()
print("idealize...")
for res in range(1,L+1):
cart = emap.residue_total_energy(res)
if cart > 50:
poslist.append(res)
print( "idealize %d %8.3f"%(res,cart) )
if len(poslist) > 0:
idealize.set_pos_list(poslist)
try:
idealize.apply(pose0)
except:
print('!!! idealization failed !!!')
# Save checkpoint
if args.save_chk:
pose0.dump_pdb("%s_before_relax.pdb"%'.'.join(args.OUT.split('.')[:-1]))
########################################################
# full-atom refinement
########################################################
if args.fastrelax == True:
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(True)
mmap.set_jump(True)
# First round: Repeat 2 torsion space relax w/ strong disto/anglogram constraints
sf_fa_round1 = create_score_function('ref2015_cart')
sf_fa_round1.set_weight(rosetta.core.scoring.atom_pair_constraint, 3.0)
sf_fa_round1.set_weight(rosetta.core.scoring.dihedral_constraint, 1.0)
sf_fa_round1.set_weight(rosetta.core.scoring.angle_constraint, 1.0)
sf_fa_round1.set_weight(rosetta.core.scoring.pro_close, 0.0)
relax_round1 = rosetta.protocols.relax.FastRelax(sf_fa_round1, "%s/data/relax_round1.txt"%scriptdir)
relax_round1.set_movemap(mmap)
print('relax: First round... (focused on torsion space relaxation)')
params['PCUT'] = 0.15
pose0.remove_constraints()
if rst_user != None:
rst_user.apply(pose0)
add_rst(pose0, rst, 1, len(seq), params, nogly=True)
#add_rst(pose0, rst, 3, len(seq), params, nogly=True, use_orient=True)
relax_round1.apply(pose0)
# Set options for disulfide tolerance -> 0.5A
print (rosetta.basic.options.get_real_option('in:detect_disulf_tolerance'))
rosetta.basic.options.set_real_option('in:detect_disulf_tolerance', 0.5)
print (rosetta.basic.options.get_real_option('in:detect_disulf_tolerance'))
sf_dock = create_score_function("ref2015")
sf_dock.set_weight(rosetta.core.scoring.atom_pair_constraint, 1.0)
sf_dock.set_weight(rosetta.core.scoring.dihedral_constraint, 0.0)
sf_dock.set_weight(rosetta.core.scoring.angle_constraint, 0.0)
dock_high_res(pose0, sf_dock)
sf_fa = create_score_function('ref2015_cart')
sf_fa.set_weight(rosetta.core.scoring.atom_pair_constraint, 0.1)
sf_fa.set_weight(rosetta.core.scoring.dihedral_constraint, 0.0)
sf_fa.set_weight(rosetta.core.scoring.angle_constraint, 0.0)
relax_round2 = rosetta.protocols.relax.FastRelax(sf_fa, "%s/data/relax_round2.txt"%scriptdir)
relax_round2.set_movemap(mmap)
relax_round2.cartesian(True)
relax_round2.dualspace(True)
print('relax: Second round... (cartesian space)')
params['PCUT'] = 0.30 # To reduce the number of pair restraints..
pose0.remove_constraints()
pose0.conformation().detect_disulfides() # detect disulfide bond again w/ stricter cutoffs
add_rst(pose0, rst, 3, len(seq), params, nogly=True, use_orient=False)
if rst_user != None:
rst_user.apply(pose0)
relax_round2.apply(pose0)
# Re-evaluate score w/o any constraints
scorefxn_min=create_score_function('ref2015')
scorefxn_min.score(pose0)
########################################################
# save final model
########################################################
pose0.dump_pdb(args.OUT)
def fulltrRosettaPyRosettaRelaxProtocol(pose, outname):
# score function and movers
sf = ScoreFunction()
sf.add_weights_from_file('./trRosettaPyRosetta/data/scorefxn.wts')
sf1 = ScoreFunction()
sf1.add_weights_from_file('./trRosettaPyRosetta/data/scorefxn1.wts')
sf_vdw = ScoreFunction()
sf_vdw.add_weights_from_file('./trRosettaPyRosetta/data/scorefxn_vdw.wts')
sf_cart = ScoreFunction()
sf_cart.add_weights_from_file('./trRosettaPyRosetta/data/scorefxn_cart.wts')
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(False)
mmap.set_jump(True)
min_mover = MinMover(mmap, sf, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover.max_iter(1000)
min_mover1 = MinMover(mmap, sf1, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover1.max_iter(1000)
min_mover_vdw = MinMover(mmap, sf_vdw, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover_vdw.max_iter(500)
min_mover_cart = MinMover(mmap, sf_cart, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover_cart.max_iter(1000)
min_mover_cart.cartesian(True)
repeat_mover = RepeatMover(min_mover, 3)
# mutate GLY to ALA
for i, a in enumerate(seq):
if a == 'G':
mutator = rosetta.protocols.simple_moves.MutateResidue(i + 1, 'ALA')
mutator.apply(pose)
print('mutation: G%dA' % (i + 1))
# remove initial clashes
remove_clash(sf_vdw, min_mover_vdw, pose)
print('short + medium + long')
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# mutate ALA back to GLY
for i, a in enumerate(seq):
if a == 'G':
mutator = rosetta.protocols.simple_moves.MutateResidue(i + 1, 'GLY')
mutator.apply(pose)
print('mutation: A%dG' % (i + 1))
########################################################
# full-atom refinement
########################################################
sf_fa = create_score_function('ref2015')
sf_fa.set_weight(rosetta.core.scoring.atom_pair_constraint, 5)
sf_fa.set_weight(rosetta.core.scoring.dihedral_constraint, 1)
sf_fa.set_weight(rosetta.core.scoring.angle_constraint, 1)
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(True)
mmap.set_jump(True)
relax = rosetta.protocols.relax.FastRelax()
relax.set_scorefxn(sf_fa)
relax.max_iter(200)
relax.dualspace(True)
relax.set_movemap(mmap)
switch = SwitchResidueTypeSetMover("fa_standard")
switch.apply(pose)
print('relax...')
params['PCUT'] = 0.15
# add_rst(pose, rst, 1, len(seq), params, True) #remove restrains
relax.apply(pose)
########################################################
# save final model
########################################################
pose.dump_pdb(outname)
def generatePDB(fasta, npz, out):
########################################################
# process inputs
########################################################
# read params
#scriptdir = os.path.dirname(os.path.realpath(__file__))
with open('./trRosettaPyRosetta/data/params.json') as jsonfile:
params = json.load(jsonfile)
args = {
'pcut': params['PCUT'],
'mode': 2,
'wdir': params['WDIR'],
'steps': 1000,
'use_orient': True,
'fast_relax': True
}
#set FASTA, NPZ, OUT
args['FASTA'] = fasta
args['NPZ'] = npz
args['OUT'] = out
params['PCUT'] = args['pcut']
params['USE_ORIENT'] = args['use_orient']
# init PyRosetta
init(
'-hb_cen_soft -relax:default_repeats 5 -default_max_cycles 200 -out:level 100'
)
# Create temp folder to store all the restraints
tmpdir = tempfile.TemporaryDirectory(prefix=args['wdir'] + '/')
params['TDIR'] = tmpdir.name
print('temp folder: ', tmpdir.name)
# read and process restraints & sequence
npz = np.load(args['NPZ'])
print(type(npz))
seq = read_fasta(args['FASTA'])
L = len(seq)
print(L)
params['seq'] = seq
rst = gen_rst(npz, tmpdir, params)
seq_polyala = 'A' * len(seq)
########################################################
# Scoring functions and movers
########################################################
sf = ScoreFunction()
sf.add_weights_from_file('./trRosettaPyRosetta/data/scorefxn.wts')
sf1 = ScoreFunction()
sf1.add_weights_from_file('./trRosettaPyRosetta/data/scorefxn1.wts')
sf_vdw = ScoreFunction()
sf_vdw.add_weights_from_file('./trRosettaPyRosetta/data/scorefxn_vdw.wts')
sf_cart = ScoreFunction()
sf_cart.add_weights_from_file(
'./trRosettaPyRosetta/data/scorefxn_cart.wts')
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(False)
mmap.set_jump(True)
min_mover = MinMover(mmap, sf, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover.max_iter(1000)
min_mover1 = MinMover(mmap, sf1, 'lbfgs_armijo_nonmonotone', 0.0001, True)
min_mover1.max_iter(1000)
min_mover_vdw = MinMover(mmap, sf_vdw, 'lbfgs_armijo_nonmonotone', 0.0001,
True)
min_mover_vdw.max_iter(500)
min_mover_cart = MinMover(mmap, sf_cart, 'lbfgs_armijo_nonmonotone',
0.0001, True)
min_mover_cart.max_iter(1000)
min_mover_cart.cartesian(True)
repeat_mover = RepeatMover(min_mover, 3)
########################################################
# initialize pose
########################################################
pose = pose_from_sequence(seq, 'centroid')
# mutate GLY to ALA
for i, a in enumerate(seq):
if a == 'G':
mutator = rosetta.protocols.simple_moves.MutateResidue(
i + 1, 'ALA')
mutator.apply(pose)
print('mutation: G%dA' % (i + 1))
set_random_dihedral(pose)
remove_clash(sf_vdw, min_mover_vdw, pose)
########################################################
# minimization
########################################################
if args['mode'] == 0:
# short
print('short')
add_rst(pose, rst, 1, 12, params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# medium
print('medium')
add_rst(pose, rst, 12, 24, params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# long
print('long')
add_rst(pose, rst, 24, len(seq), params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
elif args['mode'] == 1:
# short + medium
print('short + medium')
add_rst(pose, rst, 3, 24, params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# long
print('long')
add_rst(pose, rst, 24, len(seq), params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
elif args['mode'] == 2: #default behavior
# short + medium + long
print('short + medium + long')
add_rst(pose, rst, 1, len(seq), params)
repeat_mover.apply(pose)
min_mover_cart.apply(pose)
remove_clash(sf_vdw, min_mover1, pose)
# mutate ALA back to GLY
for i, a in enumerate(seq):
if a == 'G':
mutator = rosetta.protocols.simple_moves.MutateResidue(
i + 1, 'GLY')
mutator.apply(pose)
print('mutation: A%dG' % (i + 1))
########################################################
# full-atom refinement
########################################################
if args['fast_relax'] == True:
sf_fa = create_score_function('ref2015')
sf_fa.set_weight(rosetta.core.scoring.atom_pair_constraint, 5)
sf_fa.set_weight(rosetta.core.scoring.dihedral_constraint, 1)
sf_fa.set_weight(rosetta.core.scoring.angle_constraint, 1)
mmap = MoveMap()
mmap.set_bb(True)
mmap.set_chi(True)
mmap.set_jump(True)
relax = rosetta.protocols.relax.FastRelax()
relax.set_scorefxn(sf_fa)
relax.max_iter(200)
relax.dualspace(True)
relax.set_movemap(mmap)
pose.remove_constraints()
switch = SwitchResidueTypeSetMover("fa_standard")
switch.apply(pose)
print('relax...')
params['PCUT'] = 0.15
add_rst(pose, rst, 1, len(seq), params, True)
relax.apply(pose)
########################################################
# save final model
########################################################
pose.dump_pdb(args['OUT'])
chf2 = CircularHarmonicFunc(pi, 0.01)
chf3 = CircularHarmonicFunc(pi / 2, 0.01)
ccst1 = DihedralConstraint(r_ca, c_ca, n_ca, x_n, chf1)
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
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
pack_mover.task_factory(task_factory)
# 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)
def filter_clash_minimize(pose,
hits,
clash_cutoff=35.0,
rmsd_cutoff=0.5,
sfx=None,
mmap=None,
limit=0):
"""Filter match output for clashes, then minimize the remaining
structures against the target pose.
Parameters
----------
pose : pyrosetta.Pose
Target structure.
hits : np.ndarray
Set of functional group matches against positions in the target.
clash_cutoff : float
Maximum tolerated increase in score terms during clash checking.
sfx : pyrosetta.rosetta.core.scoring.ScoreFunction, optional
Scorefunction to use during minimization. If left as None, a
default scorefunction is constructed.
mmap : pyrosetta.rosetta.protocols.minimization_packing.MinMover, optional
Movemap to use during minimization. If left as None, a default
movemap is constructed.
Yields
------
pyrosetta.Pose
Next target structure and matched functional group, minimized
and in complex.
"""
if (not sfx):
sfx = scoring.ScoreFunctionFactory.create_score_function("beta_nov16")
sfx.set_weight(scoring.hbond_bb_sc, 2.0)
sfx.set_weight(scoring.hbond_sc, 2.0)
if (not mmap):
mmap = MoveMap()
mmap.set_bb(False)
mmap.set_chi(False)
mmap.set_jump(1, True)
minmov = MinMover(mmap, sfx, "dfpmin_armijo_nonmonotone", 0.01, False)
for n, (hash, match) in enumerate(hits):
proto_pose = pose.clone()
proto_pose.append_pose_by_jump(match, len(proto_pose.residues))
sfx(proto_pose)
fa_rep = proto_pose.energies().total_energies()[scoring.fa_rep]
fa_elec = proto_pose.energies().total_energies()[scoring.fa_elec]
if (fa_rep + fa_elec > clash_cutoff):
continue
minmov.apply(proto_pose)
minimized = proto_pose.split_by_chain(proto_pose.num_chains())
ori_coords = np.array(
[atom.xyz() for res in match.residues for atom in res.atoms()])
min_coords = np.array(
[atom.xyz() for res in minimized.residues for atom in res.atoms()])
if (rmsd(ori_coords, min_coords) < rmsd_cutoff):
yield (hash, minimized)
if (limit and n + 1 >= limit):
break
return []