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 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'])