def create_design_task_factory(designable_res_indexes: list, active_site_positions: list = list(), \
neighborhood: float = 0, cystine: bool = True, noncanonical_amino_acids: list = list()):
task_factory = TaskFactory()
if len(noncanonical_amino_acids) > 0:
ncaa_palette = CustomBaseTypePackerPalette()
for ncaa in noncanonical_amino_acids:
ncaa_palette.add_type(ncaa)
task_factory.set_packer_palette(ncaa_palette)
task_factory.push_back(IncludeCurrent())
# Mutatable
designable_selector = ResidueIndexSelector(','.join(
str(designable_res_index)
for designable_res_index in designable_res_indexes))
if not cystine:
restriction = RestrictAbsentCanonicalAASRLT()
restriction.aas_to_keep('AGILPVFWYDERHKSTMNQ') # AGILPVFWYDERHKSTCMNQ
task_factory.push_back(
OperateOnResidueSubset(restriction, designable_selector))
# Repack
repack = RestrictToRepackingRLT()
prevent = PreventRepackingRLT()
if neighborhood > 0:
if len(active_site_positions) > 0:
enzdes_cst_selector = ResidueIndexSelector(','.join(
str(enzdes_cst_index)
for enzdes_cst_index in active_site_positions))
designable_repacking_selector = NeighborhoodResidueSelector()
designable_repacking_selector.set_focus_selector(
OrResidueSelector(designable_selector, enzdes_cst_selector))
designable_repacking_selector.set_distance(neighborhood)
designable_repacking_selector.set_include_focus_in_subset(True)
repacking_selector = AndResidueSelector(
designable_repacking_selector,
NotResidueSelector(designable_selector))
task_factory.push_back(
OperateOnResidueSubset(repack, repacking_selector))
task_factory.push_back(
OperateOnResidueSubset(prevent, designable_repacking_selector,
True))
else:
repacking_selector = NeighborhoodResidueSelector()
repacking_selector.set_focus_selector(designable_selector)
repacking_selector.set_distance(neighborhood)
repacking_selector.set_include_focus_in_subset(False)
task_factory.push_back(
OperateOnResidueSubset(repack, repacking_selector))
task_factory.push_back(OperateOnResidueSubset(prevent, \
OrResidueSelector(designable_selector, repacking_selector), True))
else:
task_factory.push_back(
OperateOnResidueSubset(repack, designable_selector, True))
return task_factory
def index_interface(pose, substrate_indices, d=10):
"""This function takes a pose and a number of interface/substrate to consider and returns interface indices. The
value k and pose are not used..."""
# Selection for neighbor residues
focus_res = ','.join([str(j) for j in substrate_indices])
focus_selector = ResidueIndexSelector(focus_res)
interface = NeighborhoodResidueSelector()
interface.set_focus_selector(focus_selector)
interface.set_distance(d)
interface.set_include_focus_in_subset(False)
interface_indices = selector_to_list(pose, interface)
interface_indices.sort()
return interface_indices
def get_pose_discrimination_scores(pdb):
fix_file(pdb)
nam = basename(pdb)
pose = pose_from_pdb(pdb)
# Enzdes constraints
cstm = AddOrRemoveMatchCsts()
cstm.set_cst_action(ADD_NEW)
cstm.apply(pose)
sf = create_score_function('ref2015_cst')
sf(pose)
#pep_res = selector_to_list(pose, ChainSelector('B'))
pep_res = selector_to_list(pose, ResidueIndexSelector('212-218'))
neigh = NeighborhoodResidueSelector()
neigh.set_distance(8)
neigh.set_focus_selector(ChainSelector('B'))
neigh.set_include_focus_in_subset(False)
prot_res = selector_to_list(pose, neigh)
pep_score = 0
for i in pep_res:
pep_score += pose.energies().residue_total_energies(i)[st.total_score]
prot_score = 0
for i in prot_res:
prot_score += pose.energies().residue_total_energies(i)[st.total_score]
cst_score = 0
for i in [st.atom_pair_constraint, st.coordinate_constraint,
st.angle_constraint, st.dihedral_constraint]:
cst_score += pose.energies().total_energies()[i]
discriminator = 1 * prot_score + 1 * pep_score + 3.5 * cst_score
print(nam, prot_score, pep_score, cst_score, discriminator)
return [nam, prot_score, pep_score, cst_score, discriminator]
def create_relax_task_factory(point_mutations: list = list(),
active_site_positions: list = list(),
neighborhood: float = 0):
task_factory = TaskFactory()
task_factory.push_back(IncludeCurrent())
repack = RestrictToRepackingRLT()
prevent = PreventRepackingRLT()
if len(point_mutations) > 0:
# Mutate
mutated_selector = OrResidueSelector()
for point_mutation in point_mutations:
mutation_info = point_mutation.split(',')
restriction = RestrictAbsentCanonicalAASRLT()
restriction.aas_to_keep(mutation_info[1])
point_mutation_selector = ResidueIndexSelector(mutation_info[0])
task_factory.push_back(
OperateOnResidueSubset(restriction, point_mutation_selector))
mutated_selector.add_residue_selector(point_mutation_selector)
# Repack and static
if neighborhood > 0:
if len(active_site_positions) > 0:
# Repack
enzyme_core_selector = ResidueIndexSelector(','.join(
str(active_site_position)
for active_site_position in active_site_positions))
designable_repacking_selector = NeighborhoodResidueSelector()
designable_repacking_selector.set_focus_selector(
OrResidueSelector(mutated_selector, enzyme_core_selector))
designable_repacking_selector.set_distance(neighborhood)
designable_repacking_selector.set_include_focus_in_subset(True)
repacking_selector = AndResidueSelector(
designable_repacking_selector,
NotResidueSelector(mutated_selector))
task_factory.push_back(
OperateOnResidueSubset(repack, repacking_selector))
# Static
task_factory.push_back(
OperateOnResidueSubset(prevent,
designable_repacking_selector,
True))
else:
# Repack
repacking_selector = NeighborhoodResidueSelector()
repacking_selector.set_focus_selector(mutated_selector)
repacking_selector.set_distance(args.neighborhood)
repacking_selector.set_include_focus_in_subset(False)
task_factory.push_back(
OperateOnResidueSubset(repack, repacking_selector))
# Static
mutated_and_repacking_selector = OrResidueSelector(
mutated_selector, repacking_selector)
task_factory.push_back(
OperateOnResidueSubset(prevent,
mutated_and_repacking_selector,
True))
else:
# Repack
task_factory.push_back(
OperateOnResidueSubset(repack, mutated_selector, True))
else:
if neighborhood > 0:
if len(active_site_positions) > 0:
# Repack
enzyme_core_selector = ResidueIndexSelector(','.join(
str(active_site_position)
for active_site_position in active_site_positions))
repacking_selector = NeighborhoodResidueSelector()
repacking_selector.set_focus_selector(enzyme_core_selector)
repacking_selector.set_distance(neighborhood)
repacking_selector.set_include_focus_in_subset(True)
task_factory.push_back(
OperateOnResidueSubset(repack, repacking_selector))
# Static
task_factory.push_back(
OperateOnResidueSubset(prevent, repacking_selector, True))
else:
# Static
task_factory.push_back(PreventRepacking())
else:
# Repack
task_factory.push_back(RestrictToRepacking())
return task_factory
def get_cat_res(in_pose):
"""
For an input pose (presently assumed to be a serine protease), several
steps are performed to determine the catalytic triad residues.
Firstly, the pose is stripped down to the largest chain, which should be
the main. This is to eliminate substrate chains that might falsly appear to
be part of the triad.
Secondly, selections of ser, his, and acid (asp and glu) residues are
collected.
Thirdly, a crude screen is conducted to weed out obviously false residues.
The set of histidines is collected and scanned through individually. For
each histidine, the set of neighboring residues within 10 A is checked for
overlap with the sets of serines and acids, and if either set intersection
is empty, which means that there is no nearby serine and/or acid, then that
histidine cannot be part of the triad and is eliminated. Remaining
histidines are collected with the lists of their potential ser and acid
counterparts.
Fourthly, the geometry of potential triads are examined. The atom distances
are checked between the ND's of the histidine and the respective CB of
serine and OD of the acid residue. The ND-CB distance should be 3.3 +/-
0.5 A, and the ND-OD distance should be 2.6 +/- 0.5 A.
"""
# 1. Isolate the protease main chain (no substrate)
pose = isolate_main_chain(in_pose)
# 2. Get selectors of serines, histidines, and acidic residues (aspartic and glutamic)
target_res = ['SER', 'HIS', 'ASP,GLU']
name_selectors = {}
for tr in target_res:
# Need to set name3 in selectors to get terminal residues, HIS_D, etc.
rns = ResidueNameSelector()
rns.set_residue_name3(tr)
name_selectors[tr] = rns
# 3. Scan through list of histidines to weed out any that don't have nearby
# serine and acid residues within 10 A
potential_his = selector_to_list(pose, name_selectors['HIS'])
potential_triads = {}
for h in potential_his:
# Make selector for all residues with CA within 10 A, excluding self
nrs = NeighborhoodResidueSelector(ResidueIndexSelector(str(h)), 10)
nrs.set_include_focus_in_subset(False)
# Select intersection of neighbors and serines
no_match, potential_ser = \
check_selector_nonzero_intersections([nrs, name_selectors['SER']], pose)
if no_match:
# If there are no nearby serines, this can't be catalytic hist
continue
# Select intersection of neighbors and acid residues
no_match, potential_ac = \
check_selector_nonzero_intersections([nrs, name_selectors['ASP,GLU']], pose)
if no_match:
# If there are no nearby acid residues, this can't be catalytic hist
continue
# Histidine has both requisite neighbors. Collect that residue and the
# lists of neighbors.
potential_triads[h] = [potential_ser, potential_ac]
# 4. Examine rotamer geometry of potential triads
for h, [sers, acids] in potential_triads.items():
for s in sers:
for a in acids:
pass
def make_residue_changes(pose, sf, subst_seq, subst_start, cat_res,
manual_muts):
"""
Applies substrate sequence changes and manual mutations to a given pose.
This is done through repacking, so unlike SimpleThreadingMover, the side
chains don't begin clashing. This means that the residue selectors will be
more accurate, and that design can begin without an initial relax step.
pose is a Rosetta pose
sf is a Rosetta scorefunction
subst_seq is a string (doesn't need to be uppercase)
subst_start is an integer corresponding to the first of a contiguous block
of residues to re-sequence
manual_muts is a list of two-member lists, of the following form:
[site, single-letter residue name]
"""
# Create dict of {res: AA} for changes to make
res_changes = {}
# Add manual mutations list
if manual_muts:
print("\nApplying point substitutions:")
for m in manual_muts:
res_changes[int(m[0])] = m[1].upper()
print(m[0], m[1].upper())
# Add substrate threading to list of res changes
print("\nInserting substrate sequence:\n{}".format(subst_seq))
subst_range = range(subst_start, subst_start + len(subst_seq))
for n, i in enumerate(subst_range):
res_changes[i] = subst_seq[n].upper()
# Make TaskFactory to input changes
mobile_residues = OrResidueSelector() # Keep list of mobile residues
tf = TaskFactory()
# Force packing to target residue for each desired change
for r, aa in res_changes.items():
res_selection = ResidueIndexSelector(str(r))
restriction = RestrictAbsentCanonicalAASRLT()
restriction.aas_to_keep(aa.upper())
tf.push_back(OperateOnResidueSubset(restriction, res_selection))
mobile_residues.add_residue_selector(res_selection)
# Repack nearby residues to accommodate substitutions
shell = NeighborhoodResidueSelector()
shell.set_focus_selector(mobile_residues)
shell.set_include_focus_in_subset(False)
shell.set_distance(8)
# Exclude catalytic residues
if cat_res:
catalytic = ResidueIndexSelector(','.join([str(i) for i in cat_res]))
not_catalytic = NotResidueSelector(catalytic)
shell = selector_intersection(shell, not_catalytic)
restrict = RestrictToRepackingRLT()
tf.push_back(OperateOnResidueSubset(restrict, shell))
# Prevent repacking of all other residues
unchanging = NotResidueSelector(OrResidueSelector(mobile_residues, shell))
prevent = PreventRepackingRLT()
tf.push_back(OperateOnResidueSubset(prevent, unchanging))
# Apply changes with PackRotamersMover
pt = tf.create_task_and_apply_taskoperations(pose)
prm = PackRotamersMover(sf, pt)
mutated_pose = Pose(pose)
prm.apply(mutated_pose)
return mutated_pose
pose = pose_from_pdb(args.input_file)
score_function = get_fa_scorefxn()
# 1. Total Energy
# This needs to be the first step, as the score needs to be scored, for
# example, for the InteractionEnergyMetric calculation.
total_energy = score_function(pose)
# 3. Interaction Energy Metric
# This should only be calculated if a chain C is present on the pose.
ligand_residues, interface_residues = [], []
interaction_energy = None
ligand = ChainSelector(args.chain)
interface = NeighborhoodResidueSelector(ligand,
args.cutoff,
include_focus_in_subset=False)
if len(get_residues_from_selector(ligand, pose)) > 0:
interaction_energy_metric = InteractionEnergyMetric(ligand, interface)
interaction_energy = interaction_energy_metric.calculate(pose)
# 2. Individual Residues Energy per Selection
ligand_residues = get_residue_energies_from_selector(ligand, pose)
interface_residues = get_residue_energies_from_selector(
interface, pose)
# 4. Hydrogen Bonding Network Energy
hydrogen_bonding_energy = 0.0
score_terms = [hbond_sr_bb, hbond_lr_bb, hbond_bb_sc, hbond_sc]
for score_term in score_terms:
hydrogen_bonding_energy += pose.energies().total_energies()[score_term]
def main(args):
init()
sf = create_score_function('ref2015_cst')
sf.set_weight(ScoreType(1).atom_pair_constraint,
2) # Increasing repulsion weight
sf.set_weight(ScoreType(1).dihedral_constraint,
0.5) # Reducing dihedral weight
def_score = get_fa_scorefxn()
if not isdir(args.outdir):
makedirs(args.outdir)
# Reading in PDB, determining middle chain
pose = pose_from_pdb(args.start_struct)
chain_count = pose.num_chains()
chain_no = chain_count / 2
# Determining which sites to tug
if args.test_single:
tug_sites = [args.test_single]
else:
chain_residues = selector_to_list(pose, get_mobile_range(chain_no))
tug_sites = chain_residues[1::args.frame] # First res will error
# Error because dihedrals are calculated using the upstream residue
# Making decoy set for each sliding frame on the tau middle monomer
for site in tug_sites:
in_res = int(pose.pdb_info().pose2pdb(site).split()[0])
site_name = join(args.outdir, 'tau_fibril_distort_' + str(in_res))
# Determining backbone-mobile section of pose
if args.mobile_range:
mobile_selection = get_mobile_range(chain_no, \
central_res=in_res, range_from_tug=args.mobile_range)
else:
mobile_selection = get_mobile_range(chain_no)
# Selecting repackable shell within 18A of the target (includes target)
ris = ResidueIndexSelector(str(site))
nrs = NeighborhoodResidueSelector(ris, 18)
# Combining selections
combined_selection = OrResidueSelector()
combined_selection.add_residue_selector(mobile_selection)
combined_selection.add_residue_selector(nrs)
# Making move map and task factory for FastRelax
mm = make_move_map(pose, mobile_selection, combined_selection)
tf = make_task_factory(combined_selection)
# Making FastRelax
fr = FastRelax()
fr.set_scorefxn(sf)
fr.set_movemap(mm)
fr.set_task_factory(tf)
# Making constraints
csts = make_constraints(pose, chain_no, site, args.tug_distance)
# Making ten decoys
jd = PyJobDistributor(site_name, args.num_decoys, sf)
while not jd.job_complete:
p = Pose()
p.assign(pose)
# Add constraints
for c in csts:
p.add_constraint(c)
fr.apply(p)
print("\n" * 5, jd.current_name)
print(sf.show(p), "\n" * 5)
jd.output_decoy(p)
def residue_pairs(
self,
primary_residue_selector=TrueResidueSelector(),
secondary_residue_selector=TrueResidueSelector(),
neighborhood_distance_maximum=None,
sequence_distance_minimum=None,
):
"""Iterate the permutations of residue pairs from two selections which are
within a cartesian and/or outside a sequence distance cutoff.
The method uses the PrimarySequenceNeighborhoodSelector and
NeighborhoodResidueSelector under the hood. Note that all _permutations_ of
residues are yielded, not _combinations_. If you prefer combinations simply
check `if residue_pair[0].sequence_position() > residue_pair[1].sequence_position():`.
primary_residue_selector - ResidueSelector
secondary_residue_selector - ResidueSelector
neighborhood_distance - float
sequence_distance - int
return - iterator(tuple(Residue, Residue))
"""
primary_residue_selection = primary_residue_selector.apply(self)
primary_residue_indices = get_residues_from_subset(primary_residue_selection)
for primary_residue_index in primary_residue_indices:
temp_secondary_residue_selector = secondary_residue_selector
primary_residue_index_selector = ResidueIndexSelector(primary_residue_index)
temp_secondary_residue_selector = AndResidueSelector(
temp_secondary_residue_selector,
NotResidueSelector(primary_residue_index_selector),
)
if (
neighborhood_distance_maximum
): # Select residues within cartesian neighborhood distance
neighborhood_residue_selector = NeighborhoodResidueSelector(
primary_residue_index_selector, neighborhood_distance_maximum, False
)
temp_secondary_residue_selector = AndResidueSelector(
temp_secondary_residue_selector, neighborhood_residue_selector
)
if (
sequence_distance_minimum
): # Select residues outside sequence neighborhood distance
sequence_residue_selector = PrimarySequenceNeighborhoodSelector(
sequence_distance_minimum,
sequence_distance_minimum,
primary_residue_index_selector,
)
temp_secondary_residue_selector = AndResidueSelector(
temp_secondary_residue_selector,
NotResidueSelector(sequence_residue_selector),
)
secondary_residue_selection = temp_secondary_residue_selector.apply(self)
secondary_residue_indices = get_residues_from_subset(
secondary_residue_selection
)
for secondary_residue_index in secondary_residue_indices:
yield tuple(
[
self.residues[primary_residue_index],
self.residues[secondary_residue_index],
]
)
}
start_pdb = {
'Y382W': 'pdz_relaxed_1.pdb_designed_62.pdb',
'R386V': 'pdz_relaxed_2.pdb_designed_13.pdb',
'R386V-M388R-K394V': 'pdz_relaxed_2.pdb_designed_13.pdb',
'I415K': 'pdz_relaxed_2.pdb_designed_13.pdb',
'I415K-E416Y': 'pdz_relaxed_2.pdb_designed_13.pdb',
'R386V-M388R-K394V-T415K-E416Y': 'pdz_relaxed_2.pdb_designed_13.pdb',
'Y382W-R386V-M388R-K394V-T415K-E416Y': 'pdz_relaxed_2.pdb_designed_13.pdb',
'S389D-S444R-N446Q': 'pdz_relaxed_3.pdb_designed_47.pdb',
'N446E': 'pdz_relaxed_2.pdb_designed_9.pdb'
}
for des, muts in res_changes.items():
pp = pose_from_pdb('pdz_designs/examples/' + start_pdb[des])
peptide = ChainSelector('B')
shell = NeighborhoodResidueSelector()
shell.set_focus_selector(peptide)
shell.set_include_focus_in_subset(True)
shell.set_distance(12)
mobile_residues = OrResidueSelector()
tf = TaskFactory()
tf.push_back(IncludeCurrent())
tf.push_back(ExtraRotamers(0, 1, 1))
tf.push_back(ExtraRotamers(0, 2, 1))
for r, aa in muts.items():
res_selection = ResidueIndexSelector(str(r))
restriction = RestrictAbsentCanonicalAASRLT()
restriction.aas_to_keep(aa.upper())
tf.push_back(OperateOnResidueSubset(restriction, res_selection))
mobile_residues.add_residue_selector(res_selection)
packable = AndResidueSelector(shell, NotResidueSelector(mobile_residues))