def repack_and_minimize_mutant(pose, task_factory, move_map, score_function, rounds=3): #Copying the pose ram_pose = pr.Pose(pose) #preparing repack and applying prm = PackRotamersMover() prm.score_function(score_function) prm.task_factory(task_factory) #preparing minimize and applying min_mover = MinMover() min_mover.movemap(move_map) min_mover.score_function(score_function) print_out("Checking Packertask") packer = task_factory.create_task_and_apply_taskoperations(pose) print_out("packer task") print_out(packer) for rnd in range(rounds): print_out("round " + str(rnd + 1) + " of repack and min") prm.apply(ram_pose) min_mover.apply(ram_pose) return ram_pose
def make_point_changes(pose, task_factory, score_function): """ Applies point mutations to a given pose. This is done through a PackRotamersMover, followed by minimization. Inputs are a Pose, a TaskFactory, and a ScoreFunction """ # Make PackRotamersMover pack_rotamers = PackRotamersMover() pack_rotamers.score_function(score_function) pack_rotamers.task_factory(task_factory) # Make a copy Pose and apply the PackRotamersMover mutated_pose = pr.Pose(pose) pack_rotamers.apply(mutated_pose) # Set up fixed-backbone movemap for minimization movemap = pr.MoveMap() movemap.set_bb(True) movemap.set_chi(True) movemap.set_jump(True) # Create the MinMover min_mover = MinMover() min_mover.movemap(movemap) min_mover.score_function(score_function) # Apply the MinMover to the modified Pose min_mover.apply(mutated_pose) return mutated_pose
def _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 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 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'])
tev.pdb_info().pdb2pose('A', 25) tev.pdb_info().pdb2pose('A', 28) qris = ResidueIndexSelector('24-25,28-29') sris = ResidueIndexSelector('70-71,76-77') pla.align_protein_sections(tev, qris, yol, sris) loop = Pose(yol, 70, 77) int_ca_dist = pla.get_distance(pla.find_res_ca_coords(loop, 2), pla.find_res_ca_coords(loop, size_l - 2)) / 2 out_dist1 = sqrt(int_ca_dist**2 + 20**2) out_dist2 = sqrt(int_ca_dist**2 + 21.5**2) out_ang = atan(20 / int_ca_dist) dist_hf1 = HarmonicFunc(out_dist1, 0.5) dist_hf2 = HarmonicFunc(out_dist2, 0.5) dcst1 = AtomPairConstraint(n_ca, x_n, dist_hf1) dcst2 = AtomPairConstraint(c_ca, x_n, dist_hf1) ang_hf1 = HarmonicFunc(out_ang, 0.1) ang_hf2 = HarmonicFunc(pi / 2 + out_ang, 0.5) acst1 = AngleConstraint(n_ca, x_n, x_ca, ang_hf2) acst2 = AngleConstraint(c_ca, x_n, x_ca, ang_hf2) chf1 = CircularHarmonicFunc(0, 0.01) 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, chf1) ccst3 = DihedralConstraint(n_ca, x_n, x_ca, x_c, chf3) pp = Pose(loop) for c in [dcst1, dcst2, acst2, ccst1, ccst2, ccst3]: pp.add_constraint(c) minmov.apply(pp) pmm.apply(pp) sf.show(pp)
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 []