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")
