def measure_affinity(pose,
target_residue,
interacting_residues,
score_function="auto"):
"""
"""
assert type(target_residue) == int, \
"'target_residue' should be an int with the residue ID"
if score_function == "auto":
score_function = get_fa_scorefxn()
if type(interacting_residues) == int:
interacting_residues = [interacting_residues]
hbonds_number, hbonds_energy = measure_hbonds_number(
pose, target_residue, interacting_residues)
target = ResidueIndexSelector(str(target_residue))
interface = ResidueIndexSelector(ID2Rank(pose, interacting_residues))
try:
interaction_energy_metric = InteractionEnergyMetric(target, interface)
except:
from pyrosetta.rosetta.core.simple_metrics.metrics import \
InteractionEnergyMetric
interaction_energy_metric = InteractionEnergyMetric(target, interface)
results = {}
results["total_energy"] = score_function(pose)
results["hbonds_number"] = hbonds_number
results["hbonds_energy"] = hbonds_energy
results["inter_energy"] = interaction_energy_metric.calculate(pose)
return results
def interaction_energy_addition(pose, lig_res_selector, sf, add_to_dict,
cisortrans):
not_lig = NotResidueSelector()
not_lig.set_residue_selector(lig_res_selector)
interact_metric = InteractionEnergyMetric()
interact_metric.set_scorefunction(sf)
interact_metric.set_residue_selectors(lig_res_selector, not_lig)
add_to_dict['interE_' + cisortrans] = interact_metric.calculate(pose)
def interaction_energy(pose, score_function, selection_1, selection_2):
"""
Given a Rosetta pose, score function, and two residue selectors,
calculates the interaction energy between the selections.
"""
interact_metric = InteractionEnergyMetric()
interact_metric.set_scorefunction(score_function)
interact_metric.set_residue_selectors(selection_1, selection_2)
return interact_metric.calculate(pose)
def calc_interaction(self):
ie = InteractionEnergyMetric()
c1 = ChainSelector()
c2 = ChainSelector()
vec1 = vector1_std_string()
vec2 = vector1_std_string()
for chain in self.antibody:
vec1.append(chain)
for chain in self.antigen:
vec2.append(chain)
c2.set_chain_strings(vec2)
c1.set_chain_strings(vec1)
ie.set_residue_selectors(c1, c2)
ie.apply(self.pose)
return self.pose.scores['interaction_energy']
def calc_interaction(pose,partners):
chains = partners.split('_')
chains_a = chains[0]
chains_b = chains[1]
ie = InteractionEnergyMetric()
ca = ChainSelector()
cb = ChainSelector()
vec1 = vector1_std_string()
vec2 = vector1_std_string()
for chain in chains_a:
vec1.append(chain)
for chain in chains_b:
vec2.append(chain)
cb.set_chain_strings(vec2)
ca.set_chain_strings(vec1)
ie.set_residue_selectors(ca,cb)
ie.apply(pose)
return pose.scores['interaction_energy']
prem.set_scorefunction(sf)
tem = TotalEnergyMetric()
tem.set_scorefunction(sf)
results = []
for p in pdbs:
pp = pose_from_pdb(p)
results.append([p, tem.calculate(pp), prem.calculate(pp)])
s = prem.calculate(pose)
with open('res_results.txt', 'w') as w:
for r in results:
res_scores = []
for i in range(1, 116):
res_scores.append(r[2][i])
ol = [r[0], r[1]] + res_scores
w.write(','.join([str(x) for x in ol]) + '\n')
csb = ChainSelector('B')
with open('res_interactions.csv', 'w') as w:
for p in pdbs:
pp = pose_from_pdb(p)
tot_e = tem.calculate(pp)
this_res = [p, tot_e]
for i in range(1, 115):
ris = ResidueIndexSelector(str(i))
inte = InteractionEnergyMetric()
inte.set_scorefunction(sf)
inte.set_residue_selectors(ris, csb)
this_res.append(inte.calculate(pp))
w.write(','.join([str(x) for x in this_res]) + '\n')
def design_protease_analysis(self):
"""
Set of commands only appliccable for design_protease decoys
"""
# Make selectors
selectors = self.make_selectors(design_type)
# Get peptide residues list and peptide sequences
self.peptide_residues = dp.selector_to_list(self.wt,
selectors['peptide'])
for sr in self.peptide_residues:
self.original_peptide_sequence += self.wt.residue(sr).name1()
self.final_peptide_sequence += self.design.residue(sr).name1()
# Get designable residues list (both pose and PDB)
self.mutable_residues_pose = dp.selector_to_list(
self.wt, selectors['mutable'])
rlx_inf = self.wt.pdb_info()
mrp = [rlx_inf.pose2pdb(er) for er in self.mutable_residues_pose]
# pose2pdb outputs a string with the res number then the chain letter
self.mutable_residues_pdb = [int(i.split()[0]) for i in mrp]
# Identify changes in protease sequence
#for n, i in enumerate(self.mutable_residues_pose):
# orig_aa = self.wt.residue(i).name1()
# final_aa = self.design.residue(i).name1()
# if final_aa == orig_aa:
# self.mutated_residues[self.mutable_residues_pdb[n]] = \
# [orig_aa, 'unchanged']
# else:
# self.mutated_residues[self.mutable_residues_pdb[n]] = \
# [orig_aa, final_aa]
# Protease energies
sf_default = dp.get_score_function(constraints=False)
tem = TotalEnergyMetric()
tem.set_scorefunction(sf_default)
tem.set_residue_selector(selectors['protease'])
self.protease_total_energy = tem.calculate(self.design)
self.protease_total_energy_change = \
self.protease_total_energy - tem.calculate(self.wt)
# Peptide energies
tem.set_residue_selector(selectors['peptide'])
self.peptide_total_energy = tem.calculate(self.design)
self.peptide_total_energy_change = \
self.peptide_total_energy - tem.calculate(self.wt)
# Interaction energies
iem = InteractionEnergyMetric(selectors['protease'],
selectors['peptide'])
self.interaction_energy = iem.calculate(self.design)
self.interaction_energy_change = \
self.interaction_energy - iem.calculate(self.wt)
# SASA burial
sasa = SasaMetric()
sasa.set_residue_selector(selectors['peptide'])
d_docked_sasa = sasa.calculate(self.design)
d_undocked_sasa = sasa.calculate(self.design.split_by_chain()[2])
self.sasa_burial = d_undocked_sasa - d_docked_sasa
r_docked_sasa = sasa.calculate(self.wt)
r_undocked_sasa = sasa.calculate(self.wt.split_by_chain()[2])
r_sasa_burial = r_undocked_sasa - r_docked_sasa
self.sasa_burial_change = self.sasa_burial - r_sasa_burial
# Sequence similarities
ssm = SequenceSimilarityMetric()
ssm.set_native_pose(self.wt)
ssm.set_residue_selector(selectors['peptide'])
self.peptide_sequence_similarity = ssm.calculate(self.design)
ssm.set_residue_selector(selectors['mutable'])
self.protease_sequence_similarity = ssm.calculate(self.design)
def calc_residue_interaction(pose, sf, res, int_target):
ris = ResidueIndexSelector(str(res))
inte = InteractionEnergyMetric()
inte.set_scorefunction(sf)
inte.set_residue_selectors(ris, int_target)
return inte.calculate(pose)
# 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]
print("\n\n%30s %10s\n %s" % ("Metric", "Value", "-" * 40))
print("%30s %10.3f" % ("Total energy", total_energy))