Author: Bryan Der, contact Brian Kuhlman bkuhlman [at] email.unc.edu

Jan. 2013 by Bryan Der (bder [at] email.unc.edu), Kuhlman lab (bkuhlman [at] email.unc.edu)

The code lives in a single file, src/apps/public/design/supercharge.cc

Integration test: ain/tests/integration/tests/supercharge

Demo: demos/public/supercharge

Production runs are still quick and light, it just requires packrotamers for surface positions, and we recommend running the protocol several times using a variety of target net charges. Experimentally, it's hard to say what the optimal net charge will be, so a spectrum of net charges should be tested at the bench.

AvNAPSA-mode: Lawrence MS, Phillips KJ, Liu DR. Supercharging proteins can impart unusual resilience. J Am Chem Soc. 2007 Aug 22;129(33):10110-2.

Rosetta-mode: Der BS, Kluwe C, Miklos AE, Jacak R, Lyskov S, Gray JJ, Georgiou G, Ellington AD, Kuhlman B. Alternative computational protocols for supercharging protein surfaces for reversible unfolding and retention of stability. PLoS One. 2013 May 31;8(5):e64363.

Reengineering protein surfaces to have high net charge, called supercharging, can improve reversibility of unfolding by preventing aggregation of partially unfolded states. Aggregation is a common obstacle for use of proteins in biotechnology and medicine. Net charge, rather than number of charged residues, is often an indicator of aggregation propensity. Additionally, highly cationic proteins and peptides are capable of nonviral cell entry, and highly anionic proteins are filtered by kidneys more slowly than neutral or cationic proteins.

Optimal positions for incorporation of charged side chains should be determined, as numerous mutations and accumulation of like-charges can also destabilize the native state. A previously demonstrated approach deterministically mutates flexible polar residues (amino acids DERKNQ) with the fewest average neighboring atoms per side chain atom. Our approach uses Rosetta-based energy calculations to choose the surface mutations. Both automated approaches for supercharging are implemented in this protocol.

Simply put, user options govern the definition of surface residues and the packer task, then PackRotamersMover is used to redesign the surface.

In detail, the supercharge server can run in four different modes:

AvNAPSA with a target net charge

AvNAPSA with a surface cutoff

Rosetta with a target net charge

Rosetta with a surface cutoff

This is the workflow of each mode:

AvNAPSA-mode, target charge

Define surface. sort NQ and RK/DE residues by AvNAPSA value (low to high)

Next residue in sorted list: Positive: mutate DENQ–>K, Negative: mutate RKQ–>E and N–>D

If net charge = target net charge, output pdb

AvNAPSA-mode, surface cutoff

Define surface by AvNAPSA value (<100 default)

For each NQ and DE/RK residue in the surface: Positive: mutate DENQ-->K, Negative: mutate RKQ–>E and N–>D

Output pdb

Rosetta-mode, surface cutoff and target charge

Define surface. Neighbor by distance calculator (CB dist.), <16 neighbors default or Define surface by AvNAPSA value (<100 default)

Set design task

read user resfile, if provided

dont_mutate gly, pro, cys

dont_mutate h-bonded sidechains

dont_mutate correct charge residues

Set reference energies for RK/DE, starting at user input values

pack rotamers mover

check net charge, increment/decrement reference energies (back to step 3.)

Once a pack rotamers run results in the correct net charge, output pdb

Rosetta-mode, surface cutoff and input reference energies for the desired charged residue types (Arg/Lys for positive-supercharging, Asp/Glu for negative-supercharging)

Define surface. Neighbor by distance calculator (CB dist.), <16 neighbors default or Define surface by AvNAPSA value (<100 default)

Set design task

read user resfile, if provided

dont_mutate gly, pro, cys

dont_mutate h-bonded sidechains

dont_mutate correct charge residues

Set reference energies for RK/DE, using the user input values

pack rotamers mover

Output pdb

This code does NOT predict the net charge that will be sufficient to prevent aggregation and promote refolding, or to mediate nonviral cell entry of cationic proteins. The protocol should be run numerous times to achieve a spectrum of net charges, and several variants should be tested at the bench.

Two modes are implemented, these are refered to AvNAPSA supercharge (Asc) and Rosetta supercharge (Rsc). AvNAPSA supercharge philosophy (Asc): mutate the most exposed polar residues to minimize structural change or destabilization. Only DE-RK-NQ residues can be mutated. Rosetta supercharge philosophy (Rsc): mutate residue positions that preserve and/or add favorable surface interactions. Hydrophobic and small polar surface residues can also be mutated.

AvNAPSA drawbacks: mutating surface polar residues can eliminate hydrogen bonds. Helix capping, edge-strand interaction, and loop stabilization all result from surface hydrogen bonds. Furthermore, this automated protocol mutates N to D and Q to E, but N and Q sometimes act simultaneously as a donor and acceptor for hydrogen bonds.

Rosetta drawbacks: mutating less-exposed positions can lead to better computed energies, but mistakes at these positions can be destabilizing. AvNAPSA favors charge swaps, so Rosetta requires more mutations to accomplish the same net charge.

The AvNAPSA approach varies net charge by adjusting the surface cutoff. The Rosetta approach varies net charge by adjusting reference energies of the positive or negatively charged residues.

The only required input file is the PDB to be redesigned. If homology models, NMR ensembles, or relaxed crystal structures are the starting structure, -l can be used.

Optionally, the user can use a resfile to specify residue positions to NOT mutate (NATAA or NATRO). This would be useful to preserve a known binding surface, for example. The default for the input resfile should be ALLAA and the supercharge protocol restricts the allowed residues at designable positions. For example, Gly, Pro, Cys residues and hbonded sidechains are not allowed to mutate by default.

If there are any special input file types, describe them here.

No special input file types.

target_net_charge_active BOOL def(false); // supercharge will mutate the surface to achieve the target net charge value (below). Boolean control for ROSIE implementation (instead of .user() )

target_net_charge SIGNED_INT def(0); //AvNAPSA: Residue positions are mutated one at a time from most exposed to least exposed until the target net charge is achieved. Rosetta: reference energies of Arg/Lys/Asp/Glu are incremented until PackRotamers gives the target net charge.

surface_atom_cutoff UNSIGNED_INT def(100); // this is how AvNAPSA defines surface, can be used in either approach

compare_residue_energies_all BOOL def(false); //prints a full residue-by-residue energy analysis in the log file

compare_residue_energies_mut BOOL def(true); //only includes mutated residues in the energy analysis

resfile FILE; this is how you can specify which residues to not mutate. Default setting must be ALLAA, and residue-by-residue settings should be NATAA, as shown below:

if the default were NATRO, for example, no design would occur!

AvNAPSA_positive BOOL def(false); //run positive-charge AvNAPSA

AvNAPSA_negative BOOL def(false); //run negative-charge AvNAPSA

surface_atom_cutoff UNSIGNED_INT def(100); // this is how AvNAPSA defines surface, can be used in either AvNAPSA or Rosetta modes. <100 is good for light supercharging, <150 is good for heavy supercharging. Rosetta typically defines surface according to number of residue neighbors (<16 default). The atom-based and residue-based surface definitions correlate with an R-squared of 0.85, so they are moderately similar.

surface_residue_cutoff UNSIGNED_INT def(16); //residues with <16 neighboring residues within 10 Å are considered part of the surface

include_arg BOOL def(false); //use arginine in Rosetta supercharge

include_lys BOOL def(false); //use lysine in Rosetta supercharge

include_asp BOOL def(false); //use aspartate in Rosetta supercharge

include_glu BOOL def(false); //use glutamate in Rosetta supercharge

the reference energies of the charged residue types will govern the net charge of Rosetta designs. Rosetta can choose between the allowed charged residue types and the native residue. More negative reference energies will result in more charge mutations. The user can increment reference energy values to vary the resulting net charge. For positive-charging, refweight_asp and refweight_glu values will be ignored. For negative-charging, refweight_lys and refweight_arg values will be ignored.

refweight_arg FLOAT def(-0.98);

refweight_lys FLOAT def(-0.65);

refweight_asp FLOAT def(-0.67);

refweight_glu FLOAT def(-0.81);

dont_mutate_glyprocys BOOL def(true); //glycine, proline, and cysteine often serve special structural roles in proteins, these are not mutated by default.

dont_mutate_correct_charge BOOL def(true); //i.e., Don’t mutate arginine to lysine. Don't mutate aspartate to glutamate.

dont_mutate_hbonded_sidechains BOOL def(true); //don’t mutate residues with sidechains forming a hydrogen bond

pre_packminpack BOOL def(false); //Packrotamers is always done as the first step. This option will go one step further and run packrotamers, sidechain+backbone minimization, packrotamers on the input structure before performing the supercharge design step.

nstruct UNSIGNED_INT def(1); //Monte Carlo sequence design of a protein surface is often convergent but it is still stochastic, multiple design runs can be performed if desired.

ex1 and ex2 are not very important since this protocol only redesigns the surface. For homology model ensembles or NMR ensembles, we recommend supercharging all the input structures and choosing consensus mutations. For supercharging a single crystal structure, or ensembles, we recommend generating designs with a spectrum of net charges. Since repacking the surface converges on similar sequences, we do not recommend using nstruct > 10 (actually, nstruct is not used for AvNAPSA-mode because the sequence is deterministic). When positive-supercharging, you can bias the choice of Arg vs. Lys by giving different reference energies for the two residues. Likewise for negative-supercharging. The protocol dumps output PDBs with customized self-documenting names, so I use jd2:no_output.

Output 1: PDB

Output 2: resfile. This is an output resfile (rather than input) so the user can see what the design task looked like.

Output 3: log. The output includes net charge, number of mutations, what the mutations are, pymol selection for convenient viewing of mutated residues, and a residue-by-residue energy comparison of the designed vs. starting structures.

Here are some of the lines you'll find in the log file:

Post-processing typically involves checking the change in energy of each mutated residue (in the log file), and viewing the mutated residue positions in pymol (pymol selection of mutated residues in the log file). Also, if designing an ensemble of NMR structures, post-processing should include determining which mutations were made in all or most of the input structures, in other words, determine a consensus sequence.

If you've made improvements, note them here.

The net charge of a protein surface can also be controlled during the design process using the netcharge score term, which penalizes deviations from a desired net charge and guides the sequence design algorithms towards solutinos with the desired net charge. Net charge constraints can be applied with the AddNetChargeConstraintMover to impose a desired net charge in a selected sub-region such as the surface of a protein. This is a newer approach that has the advantage of efficiency: rather than producing many designs and only writing out those with the desired charge (the approach taken by the supercharge application), the netcharge score term guides all designs toward the desired net charge.