def run_anneal_folding(sequence, name, rep, kt_anneal): # first generate a folded structure using CGFoldingAlgorithm folding_object = cg_pyrosetta.CG_folding.CGFoldingAlgorithm( sequence, energy_graph_output=True) # If running PyMOL this will ensure structure output during MC simulation # 'default' is the folding algorithm selected # this algorithn consists of: # 10x CGSmallMover # 10x CGShearMober # 10x MinMover # MC evaluation folding_object.build_fold_alg('no_min') folding_object.add_folding_move( 'no_min', pyrosetta.RepeatMover(folding_object.small, 10)) folding_object.add_folding_move( 'no_min', pyrosetta.RepeatMover(folding_object.shear, 10)) # folding_object.add_folding_move('no_min', pyrosetta.RepeatMover(folding_object.small_angle, 10)) folding_object.add_folding_move( 'no_min', pyrosetta.RepeatMover(folding_object.mini, 10)) folding_object.add_folding_move('no_min', folding_object.pymol) # Runs a folding MC simulation with 200 repeats of the 'default' folder at each kt folding_object.run_anneal_fold('no_min', 5000, kt_anneal) # Dump the lowest energy structure from the MC simulation folding_object.mc.lowest_score_pose().dump_pdb('outputs/' + name + '_example_' + str(rep) + '.pdb')
def run_anneal_folding(sequence, name, rep, kt_anneal): import cg_pyrosetta import pyrosetta # first generate a folded structure using CGFoldingAlgorithm folding_object = cg_pyrosetta.CG_folding.CGFoldingAlgorithm(sequence) # If running PyMOL this will ensure structure output during MC simulation # 'default' is the folding algorithm selected # this algorithn consists of: # 10x CGSmallMover # 10x CGShearMober # 10x MinMover # MC evaluation folding_object.build_fold_alg('no_min') folding_object.add_folding_move( 'no_min', pyrosetta.RepeatMover(folding_object.shear, 10)) folding_object.add_folding_move( 'no_min', pyrosetta.RepeatMover(folding_object.small_angle, 5)) folding_object.add_folding_move('no_min', folding_object.pymol) # Runs a folding MC simulation with 200 repeats of the 'default' folder at each kt folding_object.run_anneal_fold('no_min', 1000, kt_anneal) # Dump the lowest energy structure from the MC simulation return (folding_object.mc.total_trials())
def run(self): rep_mover = pyrosetta.RepeatMover(self.mc_trial, self._out_freq) for _ in range(int(self.n_steps / self._out_freq)): rep_mover.apply(self.pose) if self._output is True: print("Step :", self.mc.total_trials()) print("Energy : ", self.get_energy()) self.pymol.apply(self.pose) self.notifyObservers()
def run_folding_alg(self, name, iter): """ Runs any given mover object iter times as an MC trial steps useful for running multiple steps with the same parameters. name : str of folding algorithm (key of self.folding_algorithm) iter : integer of times to repeat TrialMC object """ print('Building MC Trial Mover...') self.build_trial_mc_alg(self.folding_protocols[name]) run = pyrosetta.RepeatMover(self.trial_mc, iter) print('Folding...') run.apply(self.pose) self.mc.set_last_accepted_pose(self.mc.lowest_score_pose())
def run_anneal_fold(self, name, iter, kt_range): """ Runs any specified mover object iter times as an MC trial step, while also anealling kT to achieve extremely small changes towards the end of the simulation. name : str of folding algorithm (key of self.folding_algorithm) iter : interger of times to repeat TrialMC object kt_range : array of kT values to run folding algorithm Note will run len(kt_range)*iter trial MC steps """ if self.energy_graph_output: e_graph = [] for kt in kt_range: # Updat kt in MC object self.mc.set_temperature(kt) # Rebuild trail mc object with new kT value self.build_trial_mc_alg(self.folding_protocols[name]) # Build RepeatMover with MC trial to iterate iter times run = pyrosetta.RepeatMover(self.trial_mc, iter) old_energy = self.scorefxn(self.mc.lowest_score_pose()) if self.energy_graph_output: e_graph.append(old_energy) new_energy = None counter = 0 while old_energy != new_energy or counter < 10: # new_energy == None or not math.isclose(old_energy, new_energy) and counter += 1 print('Folding at T =', kt, '...', 'Rep:', counter) old_energy = self.scorefxn(self.mc.lowest_score_pose()) run.apply(self.pose) self.mc.show_counters() new_energy = self.scorefxn(self.mc.lowest_score_pose()) print('Old Energy:', old_energy, 'New Energy:', new_energy) if self.energy_graph_output: e_graph.append(new_energy) if old_energy != new_energy: counter = 0 if self.energy_graph_output: e_graph = np.array(e_graph) count = 0 while os.path.exists(name + "_" + str(iter) + "_" + str(count) + ".npy"): count += 1 np.save(name + "_" + str(iter) + "_" + str(count) + ".npy", e_graph)
def build_seq_mover(self, mover_freq_map): seq_mover = pyrosetta.SequenceMover() movers = [ pyrosetta.RepeatMover(self.methods[mover], mover_freq_map[mover]) for mover in mover_freq_map.keys() ] for i, mover in enumerate(mover_freq_map.keys()): print(mover) if mover in self.methods.keys(): seq_mover.add_mover(movers[i]) else: warnings.warn( "Unimplemented Mover : " + mover + "\n Skipping mover", UserWarning) return (seq_mover)
sequences[i]) # If running PyMOL this will ensure structure output during MC simulation # 'default' is the folding algorithm selected # this algorithn consists of: # 10x CGSmallMover # 10x CGShearMober # 10x MinMover # MC evaluation # folding_object.add_folding_move('default', folding_object.pymol) folding_object.build_fold_alg('AngleMC') folding_object.add_folding_move( 'AngleMC', pyrosetta.RepeatMover(folding_object.small, 1)) # folding_object.add_folding_move('AngleMC', pyrosetta.RepeatMover(folding_object.shear, 5)) # Adding an angle mover to this folding algorithm small_sc_mover = cg_pyrosetta.CG_movers.CGSmallSCMover( folding_object.pose) small_sc_mover.angle = 180 # repeat_sc_mover = pyrosetta.RepeatMover(small_sc_mover, 5) # folding_object.add_folding_move('AngleMC', repeat_sc_mover) small_bb_angle_mover = cg_pyrosetta.CG_movers.CGSmallAngleMover( folding_object.pose) small_bb_angle_mover.angle = 10 # repeat_bb_angle_mover = pyrosetta.RepeatMover(small_bb_angle_mover, 2) # folding_object.add_folding_move('AngleMC', repeat_bb_angle_mover)
def main(): parser = argparse.ArgumentParser() parser.add_argument( "--model", required=False, help="Type of model that you would like to generate \ random distribution of structures and energy for", type=str, default="CG11x3", ) parser.add_argument( "--mer", required=False, help="Number of monomers for this model", type=int, default=5, ) parser.add_argument( "--kt", required=True, default=100, help="kT value used to generate a random ensemble", type=int, ) parser.add_argument("--params", required=False, type=str, help="YAML file where specific torsions are defined", default="params.yml") parser.add_argument( "--e_output", required=False, type=str, default="outputs/random_distribution.npy", help="output filename of the energies", ) parser.add_argument( "--s_output", required=False, type=str, default="outputs/random_distribution.pdb", help="output filename of the energies", ) parser.add_argument( "--steps", required=False, default=1000000, type=int, help="Number of steps to run the high T simulation", ) parser.add_argument( "--stride", required=False, default=1000, type=int, help="Number of steps to run the high T simulation", ) # Parse Arguments args = parser.parse_args() # Get parameters from .yml file param_file = open(args.params, 'r') params = yaml.load(param_file) print(params) # for param_type in params: # if param_type == "atoms": # cg_pyrosetta.change_parameters.changeAtomParameters(params["atoms"]) # if param_type == "dihedrals": # cg_pyrosetta.change_parameters.changeTorsionParameters(params["dihedrals"]) # if param_type == "angles": # cg_pyrosetta.change_parameters.changeAngleParameters(params["angles"]) # else: # print("Input YAML file had a key for", param_type+".", "This key is not a valid parameter type for this model.", file=sys.stderr) # print("Ignoring", param_type, "and continuing!", file=sys.stderr) cg_pyrosetta.init() # Build sequence for folder object monomer = "X[" + args.model + "]" sequence = monomer * args.mer # Build Folder Object folder = cg_pyrosetta.CG_folding.CGFoldingAlgorithm(sequence) # Change PDBWriter to specific outputs folder.PDB_writer.stride(args.stride) folder.PDB_writer.file_name(args.s_output) # Build MC algorithm to get unfolded ensemble folder.build_fold_alg('no_min') folder.add_folding_move('no_min', pyrosetta.RepeatMover(folder.small, 10)) folder.add_folding_move('no_min', folder.PDB_writer) # Set kT folder.kT = args.kt # Run algorithm folder.run_folding_alg('no_min', args.steps) energy_list = [] for line in open(args.s_output): if "pose" in line: # print(line) termwise_energy = line.rstrip().split(' ') energy_list.append(float(termwise_energy[1])) else: continue np.save(args.e_output, np.array(energy_list))
def __init__(self, sequence, BBB_angle=120, BBBB_dihe=180, file_name='outputs/traj.pdb', energy_graph_output=False): """ folding object used for easily implementing different movers into a single folding algorithm. Arguments --------- sequence : str Sequence of CG residues BBB_angle : float Desired angle of all B-B-B angles. Generalizes to all backbone models (not working) BBBB_angle : float Desired dihedral of all B-B-B-B torsion angles. Generalizes to all backbone models (not working) """ # Build CG model and set desired initial angles self.pose = pyrosetta.pose_from_sequence(sequence, auto_termini=False) self.energy_graph_output = energy_graph_output # self.pose = self.set_BBB_angles(self.pose, BBB_angle) # self.pose = self.set_BBBB_dihe(self.pose, BBBB_dihe) # PyMOL mover, if wanting to visualize self.pymol = pyrosetta.PyMOLMover() self.pymol.apply(self.pose) # randomizer = CG_movers.randomizeBackBone(self.pose) # randomizer.apply(self.pose) self.pymol.apply(self.pose) # Building PDBTrajWriter object, used for writing multiple structures # to a single file self.PDB_writer = pyrosetta.rosetta.protocols.canonical_sampling.PDBTrajectoryRecorder( ) # self.PDB_writer.apply(self.pose) # write initial structure self.PDB_writer.file_name('outputs/traj.pdb') self.PDB_writer.stride(100) # Define scorefunction terms self.scorefxn = pyrosetta.ScoreFunction() self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_rep, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_atr, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_intra_atr, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.fa_intra_rep, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_twist, 1) self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_bend, 1) # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_inter_rep, 1) # segfaults beware! # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_inter_atr, 1) # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_intra_rep, 1) # self.scorefxn.set_weight(pyrosetta.rosetta.core.scoring.mm_lj_intra_atr, 1) # Build standard CG 1-1 movers self.small = CG_movers.CGSmallMover(self.pose) # self.shear = CG_movers.CGShearMover(self.pose) self.small_angle = CG_movers.CGSmallAngleMover(self.pose) # Build minimization movers self.mini = pyrosetta.rosetta.protocols.minimization_packing.MinMover() self.mini.min_type('lbfgs_armijo_nonmonotone') self.movemap = pyrosetta.MoveMap() self.mini.score_function(self.scorefxn) # for atom in self.small_angle.bb_atoms: # self.movemap.set(pyrosetta.rosetta.core.id.DOF_ID(atom , pyrosetta.rosetta.core.id.THETA), True) self.movemap.set_bb_true_range(1, self.pose.size()) self.mini.movemap(self.movemap) # Build MC object + Trial Mover (empty for now) self.mc = pyrosetta.MonteCarlo(self.pose, self.scorefxn, 1) self.trial_mc = pyrosetta.TrialMover() # Building variable to store various folding algorithms self.folding_protocols = {} # Adding a default mover self.build_fold_alg('default') self.add_folding_move('default', pyrosetta.RepeatMover(self.small, 10)) # self.add_folding_move('default', pyrosetta.RepeatMover(self.shear, 10)) self.add_folding_move('default', pyrosetta.RepeatMover(self.mini, 10))
def seq_mover(): small = pyrosetta.rosetta.protocols.simple_moves.SmallMover() rep_small = pyrosetta.RepeatMover(small, 20) seq_small = pyrosetta.SequenceMover() seq_small.add_mover(rep_small) return (seq_small)
cg_folding_object = cg_pyrosetta.CG_folding.CGFoldingAlgorithm(sequence) # Create CG Movers cg_small = cg_pyrosetta.CG_movers.CGSmallMover(cg_folding_object.pose) cg_small.angle = 180 # set_bl_mover = cg_pyrosetta.CG_movers.setBondLengths(cg_folding_object.pose, {"BB1 BB2":2.0}) #set_bl_mover.apply(cg_folding_object.pose) mini = pyrosetta.rosetta.protocols.minimization_packing.MinMover() movemap = pyrosetta.MoveMap() mini.score_function(cg_folding_object.scorefxn) movemap.set_bb_true_range(1, cg_folding_object.pose.size()) mini.movemap(movemap) pymol = pyrosetta.PyMOLMover() # Add new folding moves cg_folding_object.build_fold_alg("TorsionMC") cg_folding_object.add_folding_move("TorsionMC", pyrosetta.RepeatMover(cg_small, 10)) cg_folding_object.add_folding_move("TorsionMC", pyrosetta.RepeatMover(mini, 20)) cg_folding_object.add_folding_move("TorsionMC", pymol) # Run MC Simulation cg_folding_object.run_folding_alg("TorsionMC", 10000) # Write minimum energy structure cg_folding_object.mc.lowest_score_pose().dump_pdb("outputs/min_energy.pdb")