PyRosetta (10): HBNet

Initiation

from pyrosetta.rosetta.protocols.rosetta_scripts.XmlObjects import create_from_string

Introduction

HBNetfor hydrogen bond network

Rosetta HBNet is a protocol and scoring term designed to explicitly identify and optimize hydrogen bond networks during protein design.

It is an alternative or complement to Rosetta’s standard packing algorithms, which often favor hydrophobic interactions and can neglect complex polar networks.

HBNet was developed to address design problems where the cooperative, multi-body nature of hydrogen bond networks is critical, such as at protein-protein interfaces or in the protein core.

There are two main ways to use HBNet in Rosetta: as a Mover (HBNet or MC HBNet) or as a score term (hbnet)

HBNet Mover Introduction

The original HBNet Mover and its modern, faster Monte Carlo-based version (MC HBNet) function as a pre-design step.

Workflow

A two-stage design:

1. running the HBNet mover to establish the polar network of selected residues (and get multiple output poses)
2. and then running a standard design protocol (like FastDesignwithin aMultiplePoseMover to optimize the surrounding hydrophobic residues.

HBNet Mover Process

Methods: It conducts a stochastic search to find combinations of polar amino acid rotamers that can form extensive, self-contained hydrogen bond networks.

**Search process: **It builds a graph where nodes are possible rotamers and edges are possible hydrogen bonds. It then finds the best connected networks that satisfy certain criteria.

Evaluation (Network quality metrics):

1. Satisfaction: The fraction of a network’s hydrogen bonding capacity that is met.
2. Number of unsatisfied polar atoms (“unsats”): HBNet specifically penalizes buried polar heavy atoms that do not form hydrogen bonds.

Output: The mover returns multiple Pose objects, each with a different optimal network placed. Each one is slightly worse than the previous by HBNet’s standards, but sub-optimal poses might have the potential for lower scores after the following FastRelax.

HBNetStapleInterface class

Introduction

HBNetStapleInterface is a HBNet mover for interface packing.

Instantiation

Instantiation via XML

if setup_using_string:
    hbnet = create_from_string("""
    <MOVERS>
    <HBNetStapleInterface name="hbnet" monte_carlo="true" store_network_scores_in_pose="true"/>
    </MOVERS>
    """).get_mover("hbnet")

# We use a Monte Carlo version of HBNet by setting `monte_carlo` to "true"

'''
# The `create_from_string` is at
pyrosetta.rosetta.protocols.rosetta_scripts.XmlObjects.create_from_string
'''

Instantiation via PyRosetta HBNetStapleInterface class

hbnet = HBNetStapleInterface()

'''
`set_monte_carlo_branch` turns on Monte Carlo version of HBNet.
Same as `monte_carlo`
This is highly recommended, 
  especially for large systems like asymmetric interfaces
  see PMID: 29652499
'''
hbnet.set_monte_carlo_branch( True )

A Standard run

hbnet = HBNetStapleInterface()
hbnet.set_monte_carlo_branch( True )
hbnet.task_factory( my_task_factory )
hbnet.set_score_function( my_scorefxn )
hbnet.apply(my_pose)

Allowing chi angles

ex1ex2 = ExtraRotamersGeneric()
ex1ex2.ex1( True )
ex1ex2.ex2( True )
my_task_factory.push_back( ex1ex2 )

Get extra output poses

# there were 10 (or so) networks total, 
#  but let's just try the next 5
for x in range(0,5):
    # In each python loop, the next pose is acquired
    extra_pose = hbnet.get_additional_output()
    if extra_pose is None:
        break
    # Create a design task
    task_design = task_factory.create_task_and_apply_taskoperations( extra_pose )
    # Speed up
    task_design.or_linmem_ig( True )
    # Create a pack mover
    pack_mover = PackRotamersMover( scorefxn, task_design )
    # Apply the pack mover
    pack_mover.apply( extra_pose )
    print( "Change in score", scorefxn(extra_pose) - scorefxn(start_pose) )

'''
`or_linmmem_ig( True )`: 
Recommended.
Use the linear memory interaction graph whenever performing design. 
It's a huge speed-up.
'''

get_additional_output: this functionality can also be accessed via multistage_rosetta_scripts or the MultiplePoseMover in rosetta_scripts. See the rosetta_scripts_scripts repository for examples.

HBNetStapleInterface methods

Appoint a TaskFactory object

hbnet.task_factory( my_task_factory )

Set a score function

hbnet.set_score_function( my_scorefxn )

Show details in the output cell

hbnet.verbose( True )

At least one residue is buried

NOTICE: Highly recomended. Without it, HBNet tends to just design many surface networks that nobody really cares about.

Only branch from hbonds where at least one residue is buried.

Effectively, this results in only finding networks that have at least one buried residue.

set_monte_carlo_seed_must_be_buried does two things:

1. speeds us up by decreasing the sample space
2. ensures that our final hbond network will be at least partially buried

commenting the following line out to give us more results:

hbnet.set_monte_carlo_seed_must_be_buried( True )

At least a pair of residues is buried

Only branch from hbonds where both residues are buried.

This results in only finding networks that have at least one buried hbond but this does not prevent having additional exposed hbonds.

hbnet.set_monte_carlo_seed_must_be_fully_buried ( True )

Set total Monte Carlo runs

# We can normallly leave this as the default
#  making it smaller now to let it run faster
hbnet.set_total_num_mc_runs( 1000 )