Hi,
I have a couple questions about fold-trees and how interfaces are calculated in pyrosetta (or rosetta). I have a structure of an antibody-antigen that I have prepared using rosetta (attached). A visual inspection shows that residue B:TYR210 is making a number of close contacts with residues in Chain C (the antigen). However, when I construct an Interface object in pyrosetta, this residue is not identified as being in the interface (using a cutoff of 5.0A):
from rosetta import *
from rosetta.protocols.scoring import Interface
rosetta.init(extra_options=”-ex1 -ex2 -use_input_sc”)
pose = pose_from_pdb(“1ahw_cmplx.pdb”)
scorefxn = get_score_function()
scorefxn.score(pose)
dock_jump=1
myinterface = Interface(dock_jump)
myinterface.distance(5.0)
myinterface.calculate(pose)
myinterface.is_interface(210)
myinterface.is_interface(211)
This returns False for residue 210 being in the interface when I use dock_jump=1 or dock_jump=2. (while residue 211 is True for dock_jump=2).
I’ve tried setting up the fold_tree differently using the following code:
movable_jumps = Vector1([dock_jump])
setup_foldtree(pose, “AB_C”, movable_jumps)
However, even with this modified fold_tree, I still don’t get residue 210 in the interface (after recalculating the Interface).
I have a couple questions:
- Is the interface defined based on backbone (CA?) distances between residues, or does it find the closest pairs of atoms that are within a distance cutoff? If it’s the former, is there an easy way in pyrosetta get neighbors for a given residue at a given distance cutoff (without having to explicitly double loop over pairs of residues)?
- Is there a way to modify the fold_tree so that interface residues are only identified if the interaction is between my antibody (chains A and B) and the antigen? Right now interface residues are being identified even if the interaction is only between chains A and B.
- How can I use the “closest_interface_residue” function in the Interface class? I’ve tried the following code:
myinterface.closest_interface_residue(pose, 211, 8.0)
and get an error about not matching the C++ signature. It looks like I need to pass in the residue number as an unsigned long, and the distance as a double. How do I do this in python? I tried to cast the 211 to long, but haven’t been able to cast the 8.0 to double.
(Note, I’m using the 2015.25 release)
Thanks,
R
EDIT: I had to trim ~13 residues from the antigen N-terminus due to file size restrictions, which is why the numbering for chain C is off.
| Attachment | Size |
|---|---|
 1ahw_cmplx.pdb | 501.9 KB |
To answer question #2, the Inteface class which you are using defines an interface (via Interface.calculate()) by first splitting the pose into two partners across the given jump. If you print the pose fold tree (print pose.fold_tree()) you will see that chains A and B are connected by jump 1 whereas chains B and C are connected by jump 2. So, defining the interface across jump 2 will set one partner as chains A+B and the other as chain C. This should yield only antibody-antigen interactions.
To answer question #1, once the partners are defined, residue pairs across partners are compared by Ca-Ca distance and this is evaluated against the cutoff set by Interface.distance(). In your particular case, Y210 has no other residue's Ca within 5 Angstroms of its Ca. This is why it is not part of the interface. I'm not sure there is an easy way (than looping over residue pairs) to identify neighboring residues (but others are welcome to chime in).
I'm not sure how to approach question #3. Both of those types refer to C++ types, so simply casting in Python is insufficient.
Regarding #3, if everything is working correctly, Python floating point numbers should be automatically converted to Reals (doubles), and Python integers should automatically be converted to Size (unsigned long).