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 []