def testLoadStruct(self):
""" Test load_rosetta against read_PDB"""
init()
pose = pose_from_sequence(3*'A')
struct = load_rosetta(pose)
pdb = read_PDB(get_fn('ala_ala_ala.pdb'))
self.assertEqual(len(struct.atoms), len(pdb.atoms))
self.assertEqual(len(struct.residues), len(pdb.residues))
def test_loaded_topology(self):
""" Test load_rosetta against OpenMM topology"""
init()
pose = pose_from_sequence(3 * 'A')
struct = load_rosetta(pose)
pdb = PDBFile(get_fn('ala_ala_ala.pdb'))
self.assertEqual(len(list(struct.topology.atoms())),
len(list(pdb.topology.atoms())))
self.assertEqual(len(list(struct.topology.bonds())),
len(list(pdb.topology.bonds())))
self.assertEqual(len(list(struct.topology.residues())),
len(list(pdb.topology.residues())))
def test_loaded_positions(self):
""" Test that positions were properly loaded"""
init()
seq = 3 * 'A'
pose = pose_from_sequence(seq)
struct = load_rosetta(pose)
posexyz = list(
chain(*[[tuple(atom.xyz()) for atom in res.atoms()] for res in
[pose.residue(idx) for idx in range(1,
len(seq) + 1)]]))
structxyz = [(atom.xx, atom.xy, atom.xz) for atom in struct.atoms]
self.assertEqual(posexyz, structxyz)
def testLoadedTopology(self):
""" Test load_rosetta against OpenMM topology"""
init()
pose = pose_from_sequence(3*'A')
struct = load_rosetta(pose)
pdb = PDBFile(get_fn('ala_ala_ala.pdb'))
self.assertEqual(_unpackLen(struct.topology.atoms()),
_unpackLen(pdb.topology.atoms()))
self.assertEqual(_unpackLen(struct.topology.bonds()),
_unpackLen(pdb.topology.bonds()))
self.assertEqual(_unpackLen(struct.topology.residues()),
_unpackLen(pdb.topology.residues()))
def testLoadedPositions(self):
""" Test that positions were properly loaded"""
init()
seq = 3*'A'
pose = pose_from_sequence(seq)
struct = load_rosetta(pose)
posexyz = list(
chain(*[[tuple(atom.xyz()) for atom in res.atoms()]
for res in [pose.residue(idx)
for idx in range(1, len(seq)+1)]]))
structxyz = [(atom.xx, atom.xy, atom.xz) for atom in struct.atoms]
self.assertEqual(posexyz, structxyz)
def insert_single_internal_residue(self, chain, anchors, seq, pre_flank_seq):
info = self.scaffold_pose.pdb_info()
start_res = info.pdb2pose(chain,anchors[0])
seq_overhang = pre_flank_seq + seq
overhang_len = len(pre_flank_seq)
if overhang_len == 2:
scaffold_range = [start_res]
else:
scaffold_range = [start_res -1, start_res]
frag_range = range(1,overhang_len + 1)
frag_pose = rosetta.pose_from_sequence(seq_overhang,self.res_type, auto_termini=False)
aligned_frag = salign.kabsch_alignment(self.scaffold_pose, frag_pose, scaffold_range, frag_range)
for i in range(2):
aligned_frag.delete_residue_range_slow(1,1)
self.scaffold_pose.append_polymer_residue_after_seqpos(aligned_frag.residue(1),start_res, False)
self.scaffold_pose.pdb_info.set_resinfo(start_res + 1, chain, anchors[0] + 1)
self.scaffold_pose.pdb_info().obsolete(False)
loop = rosetta.Loop(start_res, start_res+2, start_res+1)
return loop
from simtk.unit import *
# ParmEd imports
from parmed import load_rosetta
# PyRosetta imports
from toolbox import mutate_residue
from rosetta import init, pose_from_sequence
# Initialize PyRosetta
init()
# Create Ala12
print('Creating Ala12...')
seq = 12*'A'
pose = pose_from_sequence(seq)
# Mutate residue 5 to K
print('Mutating Fifth Ala to Lys...')
mutant = mutate_residue(pose, 5, 'K')
# Load mutant into ParmEd
print('Loading into ParmEd...')
struct = load_rosetta(mutant)
# Load AMBER-99SBildn and TIP3P parameters
print('Loading AMBER parameters...')
ff = ForceField('amber99sbildn.xml', 'tip3p.xml')
# Solvate Structure
print('Solvating...')
def graft_n_terminal_loop(self, chain, anchors, seq, post_flank_seq):
"""
Graft a N-terminal loop to self.scaffold_structure.
Requires at least one flanking residue to be given.
@todo: Check if we need the replacement shenanigans used for
C-terminal additions
@type chain: string
@param chain: Chain into which loop will be grafted
@type anchors: list
@param anchors: Resids before and after region to be inserted
@type seq: string
@param seq: Sequence of the inserted fragment
@type post_flank_seq: string
@param post_flank_seq: Sequence of the residues following the inserted fragment
@rtype: Pyrosetta Loop
@return: Loop describing the region added/remodelled
"""
logger = self.logger
logger.info("N-terminal Loop modelling")
frag_seq = seq + post_flank_seq
frag_pose = rosetta.pose_from_sequence(frag_seq, 'fa_standard', auto_termini=False)
logger.info("Fragment built")
# PDB resid of anchor
start_anchor = anchors[1]
# PyRosetta indices of the pre_flank_seq
#frag_range = range(1,len(post_flank_seq) + 1)
last_frag_resid = len(frag_seq)
frag_range = [last_frag_resid-1,last_frag_resid]
# PyRosetta index of the first residue
# The terminal residue of the scaffold structure will be deleted and
# replaced from the fragment
original_term = self.get_first_residue_id_chain(self.scaffold_pose,chain)
# If two flanking residues available use for alignment range
if len(frag_range) == 1:
scaffold_range = [original_term]
else:
scaffold_range = [original_term, original_term + 1]
logger.info("Anchor alignment setup complete")
aligned_frag = salign.kabsch_alignment(self.scaffold_pose, frag_pose,
scaffold_range, frag_range)
logger.info("Fragment aligned")
#self.scaffold_pose.delete_polymer_residue(original_term)
self.scaffold_pose.delete_residue_range_slow(original_term,original_term)
logger.info("Anchor deleted")
loop_length = len(frag_seq)
# Generated with default chain label 'A'
frag_term = self.get_last_residue_id_chain(aligned_frag, 'A')
# In most cases we should have two flanking residues
# First is used for alignment only - so delete now
if len(frag_range) != 1:
aligned_frag.delete_residue_range_slow(frag_term,frag_term)
loop_length -= 1
logger.info("Delete alignment residue")
count = 0
for ii in range(loop_length, 0 , -1):
print "add residue " + str(ii)
self.scaffold_pose.prepend_polymer_residue_before_seqpos(frag_pose.residue(ii),1,False)
pdb_res = start_anchor - count
self.scaffold_pose.pdb_info().set_resinfo(1,chain,pdb_res)
count += 1
self.scaffold_pose.pdb_info().obsolete(False)
if len(frag_range) == 1:
loop = rosetta.Loop(1 ,original_term, (1 + original_term)/2)
else:
loop = rosetta.Loop(1 ,original_term + 1, (1 + original_term + 1)/2)
logger.info("Loops generated")
return loop
def graft_c_terminal_loop(self, chain, anchors, seq, pre_flank_seq):
"""
Graft a C-terminal loop to self.scaffold_structure.
Requires at least one flanking residue to be given.
@type chain: string
@param chain: Chain into which loop will be grafted
@type anchors: list
@param anchors: Resids before and after region to be inserted
@type seq: string
@param seq: Sequence of the inserfed fragment
@type pre_flank_seq: string
@param pre_flank_seq: Sequence of the residues preceding the inserted fragment
@rtype: Pyrosetta Loop
@return: Loop describing the region added/remodelled
"""
frag_seq = pre_flank_seq + seq
frag_pose = rosetta.pose_from_sequence(frag_seq, 'fa_standard', auto_termini=False)
# PDB resid of anchor
start_anchor = anchors[0]
# PyRosetta indices of the pre_flank_seq
frag_range = range(1,len(pre_flank_seq) + 1)
# PyRosetta index of the final residue
# The terminal residue of the scaffold structure will be deleted and
# replaced from the fragment
#original_end = self.scaffold_pose.total_residue()
original_end = self.get_last_residue_id_chain(self.scaffold_pose,chain)
# If we can it helps to use an idealized residue in the overlap
# so delete the original residue and generate replacement
# The chain isn't built this way as it produces overlapping conformations
if len(pre_flank_seq) > 1:
self.scaffold_pose.delete_polymer_residue(original_end)
self.scaffold_pose.append_polymer_residue_after_seqpos(frag_pose.residue(1),original_end -1, True)
self.scaffold_pose.pdb_info().set_resinfo(original_end,chain,start_anchor)
# If two flanking residues available use for alignment range
if len(frag_range) == 1:
scaffold_range = [original_end]
else:
scaffold_range = [original_end -1, original_end]
aligned_frag = salign.kabsch_alignment(self.scaffold_pose, frag_pose,
scaffold_range, frag_range)
self.scaffold_pose.delete_polymer_residue(original_end)
loop_length = len(frag_seq)
# In most cases we should have two flanking residues
# First is used for alignment only - so delete now
if len(frag_range) != 1:
aligned_frag.delete_residue_range_slow(1,1)
loop_length -= 1
post_edit_end = self.get_last_residue_id_chain(self.scaffold_pose, chain)
#self.scaffold_pose.append_pose_by_jump(aligned_frag, post_edit_end)
for ii in range(loop_length):
frag_res = ii + 1
new_res = post_edit_end + 1
pdb_res = start_anchor + ii
self.scaffold_pose.append_polymer_residue_after_seqpos(aligned_frag.residue(frag_res),post_edit_end, False)
post_edit_end += 1
self.scaffold_pose.pdb_info().set_resinfo(new_res,chain,pdb_res)
# for ii in range(loop_length):
#
# res = original_end + ii
# pdb_res = start_anchor + ii
# self.scaffold_pose.pdb_info().set_resinfo(res,chain,pdb_res)
self.scaffold_pose.pdb_info().obsolete(False)
end_res = self.get_last_residue_id_chain(self.scaffold_pose, chain)
if len(frag_range) == 1:
loop = rosetta.Loop(original_end ,end_res-1, (original_end + end_res)/2)
else:
loop = rosetta.Loop(original_end-1 ,end_res-1, (original_end + end_res)/2)
return loop
def graft_loop_double_end(self, chain, anchors, seq, pre_flank_seq, post_flank_seq):
"""
Graft a loop fragment into a gap in the self.scaffold_structure.
Requires flanking residues to be present at both ends.
@type chain: string
@param chain: Chain into which loop will be grafted
@type anchors: list
@param anchors: Resids before and after region to be inserted
@type seq: string
@param seq: Sequence of the inserfed fragment
@type pre_flank_seq: string
@param pre_flank_seq: Sequence of the residues preceding the inserted fragment
@type post_flank_seq: string
@param post_flank_seq: Sequence of the residues following the inserted fragment
@rtype: Pyrosetta Loop
@return: Loop describing the region added/remodelled
"""
loop_length = len(seq)
if loop_length == 1:
loop = self.insert_single_internal_residue(chain, anchors, seq, pre_flank_seq)
else:
info = self.scaffold_pose.pdb_info()
start_res = info.pdb2pose(chain,anchors[0])
end_res = info.pdb2pose(chain,anchors[1])
#nter_overlap_length = len(pre_flank_seq)
#cter_overlap_length = len(post_flank_seq)
if loop_length < 4:
seq = pre_flank_seq[-1] + seq + pre_flank_seq[0]
loop_length = len(seq)
pre_flank_seq = pre_flank_seq[:-1]
post_flank_seq = post_flank_seq[1:]
self.scaffold_pose.delete_polymer_residue(end_res)
self.scaffold_pose.delete_polymer_residue(start_res)
self.scaffold_pose.pdb_info().obsolete(False)
anchors[0] = anchors[0] - 1
anchors[1] = anchors[1] + 1
start_res = info.pdb2pose(chain,anchors[0])
end_res = info.pdb2pose(chain,anchors[1])
flex_length_nter = 1
flex_length_cter = 1
elif loop_length == 4:
flex_length_nter = 1
flex_length_cter = 1
elif loop_length > 12:
flex_len = int((loop_length/2) - 4)
flex_length_nter = flex_len
flex_length_cter = flex_len
else:
flex_length_nter = 2
flex_length_cter = 2
seq_overhang = pre_flank_seq + seq + post_flank_seq
nter_overlap_length = len(pre_flank_seq)
cter_overlap_length = len(post_flank_seq)
frag_pose = rosetta.pose_from_sequence(seq_overhang,self.res_type, auto_termini=False)
mover = CCDEndsGraftMover(start_res, end_res, frag_pose, nter_overlap_length, cter_overlap_length)
mover.set_insert_flexibility(flex_length_nter,flex_length_cter)
mover.apply(self.scaffold_pose)
# Give grafted residues correct chain and numbering info
for ii in range(loop_length):
res = start_res + 1 + ii
pdb_res = anchors[0] + 1 + ii
self.scaffold_pose.pdb_info().set_resinfo(res,chain,pdb_res)
# Needed for updated information to be accessible
self.scaffold_pose.pdb_info().obsolete(False)
# Setup loop object for later refinement
loop_begin = self.scaffold_pose.pdb_info().pdb2pose(chain, anchors[0]) + 1
loop_end = self.scaffold_pose.pdb_info().pdb2pose(chain,anchors[1]) - 1
loop = rosetta.Loop(loop_begin,loop_end,(loop_begin + loop_end)/2)
return loop
def __init__(self, pdb, centroid=False, pdb_file='', frag=False, nine_mer=False, local=False, local_size=3,
full=False, rosetta_refinement=False):
""" :param pdb: :type string: pdb ID of the protein to be folded
:param centroid: :type boolean: Option for use of centroid model
"""
self.loops = 0 # Stores generation for which energy score was last calculated
self.scores = {} # Dictionary container for current gen genomes/scores
self.scores_list = [] # List container of current gen scores for search
self.gen_added = 0 # Last gen in which a point was added to novelty archive
self.threshold = 10 # Novelty threshold for which point is added to archive
self.acceptance_threshold = 100 # Novelty threshold for which move is accepted automatically
self.num_added = 0 # Number of points added to novelty archive
self.switch = False # All atom switch
self.temperature = 5 # Monte Carlo temperature
self.mover_range = 10 # +-range of the angle in degrees in which mover moves residue
self.local_size = local_size # For local mover, size of fragment to move
self.local = local # Whether to use local mover
self.novelty_archive = deque() # Initialize novelty archive
self.centroid = centroid # If true use centroid scoring
self.last_lowest = 0 # For use in novelty loop
self.last_lowest_10 = 0 # For use in clear main loop
self.frag = frag # If true use frag mover
self.rosetta_refinement = rosetta_refinement # If true refine rosetta fold
# Rosetta inits
rosetta.init() # Initialize rosetta libraries
pose_native = pose_from_rcsb(pdb) # Create rosetta pose of natively folded protein from pdb file
sequence = pose_native.sequence() # Get sequence of protein
self.scorefxn = rosetta.get_fa_scorefxn() # Create the rosetta energy score function for all atom
if pdb_file != '':
self.pose = rosetta.pose_from_pdb(pdb_file) # If a starting pdb is given search from this pose
elif rosetta_refinement: # If rosetta refinement, start from fastrelax structure
self.pose = rosetta.pose_from_sequence(sequence)
relax = rosetta.FastRelax()
relax.set_scorefxn(self.scorefxn)
relax.apply(self.pose)
else:
self.pose = rosetta.pose_from_sequence(sequence) # Create the rosetta pose that will be manipulated
if centroid: # Switch pose to centroid if centroid option is true
switch = rosetta.SwitchResidueTypeSetMover("centroid")
switch.apply(self.pose)
self.c_size = len(sequence)*2 # Number of residues * 2 (phi and psi for each residue)
self.native_energy = self.scorefxn(pose_native) # Energy of the natively folded protein
if centroid: # Switch rosetta score function if centroid
self.scorefxn = rosetta.create_score_function('score3')
self.conformation = []
i = 1
while i <= len(sequence):
self.conformation.append(self.pose.phi(i))
self.conformation.append(self.pose.psi(i))
i += 1
self.mc_energy = self.scorefxn(self.pose) + 500 # Energy to be used as minimal criteria
self.lowest = self.scorefxn(self.pose) # Lowest energy in archive
if frag:
if nine_mer:
fragset = rosetta.ConstantLengthFragSet(9)
fragset.read_fragment_file("aat000_09_05-1.200_v1_3")
else:
fragset = rosetta.ConstantLengthFragSet(3)
fragset.read_fragment_file("aat000_03_05-1.200_v1_3")
movemap = rosetta.MoveMap()
movemap.set_bb(True)
self.mover_3mer = rosetta.ClassicFragmentMover(fragset, movemap)
if local: # For local, initialize na with appropriate number of deques
self.novelty_archive = [deque() for i in range(self.c_size/2/self.local_size)]
self.full = full # If true use full mover
#!/usr/bin/env python
# :noTabs=true:
import rosetta
rosetta.init()
pose = rosetta.pose_from_sequence('EVAAAVAT')
pymol = rosetta.PyMOL_Mover()
pymol.apply(pose)
scorefxn = rosetta.get_fa_scorefxn(
) # rosetta.create_score_function('standard')
scorefxn(pose)
pymol.send_energy(pose)
pymol.send_energy(pose, label=True)
pymol.send_colors(pose, {}, default_color="orange")
colors = {2: "red", 5: "white"}
pymol.send_colors(pose, colors, default_color="blue")
pymol.label_energy(pose, "fa_atr")
pymol.send_hbonds(pose)
pymol.send_ss(pose)
pymol.send_polars(pose)
mm = rosetta.MoveMap()
initialize_rosetta() # create pose object, assign info object, and send pose to pymol native_pose = load_pose( "/Users/Research/pyrosetta_dir/structures_from_jazz/3ay4_Fc_FcgRIIIa/fresh_start/project_structs/lowest_E_double_pack_and_min_only_native_crystal_struct_3ay4_Fc_FcgRIII.pdb" ) native_pose.pdb_info().name( "native_pose" ) info = native_pose.pdb_info() #pmm.apply( native_pose ) # instantiate full atom score function and score pose sf = get_fa_scorefxn() nat_E = sf( native_pose ) # create some constant data AA = 'ALA' PACK_RADIUS = 5.0 ALA_pose = pose_from_sequence( "AAA" ) nat_interface_E = get_interface_score( 2, sf, native_pose ) nat_nhbonds = get_hbonds( native_pose ).nhbonds() # insantiate lists for data (will be put into pandas dataframe) orig_AA = [] pose_position = [] pdb_position = [] pdb_chain = [] within_10A_of_Fc_glycan_res = [] within_10A_of_FcR_interface = [] mut_E = [] native_E = [] ddG = [] mut_E_res = []
## @brief binaries on windows.
## @author Sergey Lyskov
import rosetta
from rosetta import *
rosetta.init()
print version()
pose = pose_from_pdb("test/data/test_in.pdb")
scorefxn = getScoreFunction()
scorefxn(pose)
pose2 = Pose()
make_pose_from_sequence(pose2, "ARNDCEQGHILKMFPSTWYV", 'fa_standard')
scorefxn = getScoreFunction()
scorefxn(pose2)
pose3 = Pose()
make_pose_from_sequence(pose3, "DSEEKFLRRIGRFGYGYGPYE", 'centroid')
# Creating standard centroid score function and scoring
scorefxn = create_score_function('score3')
scorefxn(pose3)
pose_fs = rosetta.pose_from_sequence("DSEEKFLRRIGRFGYGYGPYE")
pose_fs.delete_polymer_residue(
2) # Testing that attached PDB info have right size...
