TaskOperations (RosettaScripts)

Return To RosettaScripts

This section defines instances of the TaskOperation class hierarchy when used in the context of the Parser/RosettaScripts. They become available in the DataMap.

TaskOperation classes are used by TaskFactory to configure the behavior of PackerTask when it is generated on-demand for routines that use the "packer" to reorganize/mutate sidechains. When used by certain Movers (at present, the PackRotamersMover and its subclasses), the TaskOperations control what happens during packing, usually by restriction "masks."

_TOC_

Example

...
<TASKOPERATIONS>
  <ReadResfile name=rrf/>
  <ReadResfile name=rrf2 filename=resfile2/>
  <PreventRepacking name=NotBeingUsedHereButPresenceOkay/>
  <RestrictResidueToRepacking name=restrict_Y100 resnum=100/>
  <RestrictToRepacking name=rtrp/>
  <OperateOnCertainResidues name=NoPackNonProt>
    <PreventRepackingRLT/>
    <ResidueLacksProperty property=PROTEIN/>
  </OperateOnCertainResidues>
</TASKOPERATIONS>
...
<MOVERS>
  <PackRotamersMover name=packrot scorefxn=sf task_operations=rrf,NoPackNonProt,rtrp,restrict_Y100/>
</MOVERS>
...

In the rosetta code, the TaskOperation instances are registered with and then later created by a TaskOperationFactory. The factory calls parse_tag() on the base class virtual function, with no result by default. However, some TaskOperation classes (e.g. OperateOnCertainResidues and ReadResfile above) do implement parse_tag, and therefore their behavior can be configured using additional options in the "XML"/Tag definition.

ResidueSelection

ResidueSelectors

ResidueSelectors define a subset of residues from a Pose. Their apply() method takes a Pose and a ResidueSubset (a utility::vector1< bool >), and modifies the ResidueSubset. Unlike a PackerTask, a ResidueSubset does not have a commutativity requirement, so the on/off status for residue i can be changed as many times as necessary. Once a ResidueSubset has been constructed, a ResLevelTaskOperation (see below ) may be applied to the ResidueLevelTasks which have a "true" value in the ResidueSubset. ResidueSelectors should be declared in their own block and named, or declared as subtags of other ResidueSelectors or of TaskOperations that accept ResidueSelectors (such as the OperateOnResidueSubset task operation).

The purpose of separating the residue selection logic from the modifications that TaskOperations perform on a PackerTask is to make available the complicated logic of selecting residues that often lives in TaskOperations. If you have a complicated TaskOperation, consider splitting it into a ResidueSelector and operations on the residues it selects.

ResidueSelectors can be declared in their own block, outside of the TaskOperation block. For example:

<RESIDUE_SELECTORS>
   <Chain name=chA chains=A/>
   <Index name=res1to10 resnums=1-10/>
</RESIDUE_SELECTORS>

Logical ResidueSelectors

NotResidueSelector

<Not name=(&string) selector=(&string)>

or

<Not name=(&string)>
    <(Selector) .../>
</Not>

AndResidueSelector

<And name=(&string) selectors=(&string)>
   <(Selector1)/>
   <(Selector2)/>
    ...
</And>

OrResidueSelector

<Or name=(&string) selectors=(&string)>
   <(Selector1)/>
   <(Selector2)/>
    ...
</Or>

Conformation Independent Residue Selectors

ChainSelector

<Chain chains=(&string)/>

JumpDownstreamSelector

<JumpDownstream jump=(&int)/>

JumpUpstreamSelector

<JumpUpstream jump=(&int)/>

ResidueIndexSelector

<Index resnums=(&string)/>

Conformation Dependent Residue Selectors

InterGroupInterfaceByVector

<InterfaceByVector name=(%string) cb_dist_cut=(11.0&float) nearby_atom_cut=(5.5%float) vector_angle_cut=(75.0&float) vector_dist_cut=(9.0&float) grp1_selector=(%string) grp2_selector=(%string)/>

or

<InterfaceByVector name=(%string) cb_dist_cut=(11.0&float) nearby_atom_cut=(5.5%float) vector_angle_cut=(75.0&float) vector_dist_cut=(9.0&float)>
   <(Selector1)/>
   <(Selector2/>
</InterfaceByVector>

NeighborhoodResidueSelector

<Neighborhood name=(%string) resnums=(%string) distance=(10.0%float)/>

or

<Neighborhood name=(%string) selector=(%string) distance=(10.0%float)/>

or

<Neighborhood name=(%string) distance=(10.0%float)>
   <Selector ... />
</Neighborhood>

NumNeighborsSelector

<NumNeighbors name=(%string) count_water=(false&bool) threshold=(17%integer) distance_cutoff=(10.0&float)/>

Per Residue Specification

OperateOnResidueSubset

<OperateOnResidueSubset name=(%string) selector=(%string) >
   <(ResLvlTaskOperation)/>
</OperateOnResidueSubset/>

or

<OperateOnResidueSubset name=(%string)>
   <(Selector)/>
   <(ResLvlTaskOperation)/>
</OperateOnResidueSubset/>

OperateOnCertainResidues Operation

Allows specification of Residue Level Task Operations based on residue properties specified with ResFilters .

Example:

<OperateOnCertainResidues name=PROTEINnopack>
  <PreventRepackingRLT/> //Only one Residue level task per OperateOnCertainResidues block
  <ResidueHasProperty property=PROTEIN/> //Only one ResFilter per OperateOnCertainResidues block
</OperateOnCertainResidues>

Residue Level TaskOperations

Use these as a subtag for special OperateOnCertainResidues TaskOperation. Only one may be used per OperateOnCertainResidues

RestrictToRepackingRLT

Turn off design on the positions selected by the accompanying ResFilter.

<RestrictToRepackingRLT/>

PreventRepackingRLT

Turn off design and repacking on the positions selected by the accompanying ResFilter.

<PreventRepackingRLT/>

RestrictAbsentCanonicalAASRLT

Do not allow design to amino acid identities that are not listed (i.e. permit only those listed) at the positions selected by the accompanying ResFilter.

<RestrictAbsentCanonicalAASRLT aas=(&string)/>

AddBehaviorRLT

Add the given "behavior" to the positions selected by the accompanying ResFilter.

<AddBehaviorRLT behavior=(&string)/>

ResFilters

Use these as a subtag for special OperateOnCertainResidues TaskOperation. Only one may be used per OperateOnCertainResidues, however a compound filter (Any/All/None) may be used to combine multiple filters in a single operation.

CompoundFilters

AnyResFilter, AllResFilter, NoResFilter combine the results of specified subfilters with the given boolean operation. Any number of subfilters may be declared.

e.g.

  <AnyResFilter>
    <ChainIs chain=A/>
    <ChainIs chain=B/>
  </AnyResFilter>

As task operations produce restriction masks, and therefor only prevent targets from repacking/designing, the most effective way to specify a set of residues for design or repack is the use of a double-negative task operation:

 <OperateOnCertainResidues name=aromatic_apolar>
   <PreventRepackingRLT/>
   <NoResFilter>
     <ResidueType aromatic=1 apolar=1/>
   </NoResFilter>
 </OperateOnCertainResidues>

Restricts repacking to aromatic and apolar residues.

ResidueType

Convenience filter selects residues by type.

 <ResidueType aromatic=(0 &bool) apolar=(0 &bool) polar=(0 &bool) charged=(0 &bool)/>

ResidueHasProperty

ResidueLacksProperty

Selects or excludes residues based on the given residue property.

 e.g. <ResidueHasProperty property=POLAR/>

ChainIs

ChainIsnt

set of residues based on their chain letter in the original PDB.

 e.g. <ChainIs chain=A/>

ResidueName3Is

ResidueName3Isnt

 e.g. <ResidueName3Is name3=ARG,LYS,GUA/>

ResidueIndexIs

ResidueIndexIsnt

 e.g. <ResidueIndexIs indices=1,2,3,4,33/>

ResiduePDBIndexIs

ResiduePDBIndexIsnt

 e.g. <ResiduePDBIndexIs indices=A.2,C.100,D.-10/>

Specialized TaskOperations

List of current TaskOperation classes in the core library (* indicates use-at-own-risk/not sufficiently tested/still under development):

Position/Identity Specification

SelectResiduesWithinChain

Selects a list of residues within a chain for design/repacking according to internal chain numbering. If modify_unselected_residues is true all other residues are set to norepack.

<SelectResiduesWithinChain name=(&string) chain=(1&Integer) resid=(&comma-separated integer list) allow_design=(1&bool) allow_repacking=(1&bool) modify_unselected_residues=(1&bool)/>

SeqprofConsensus

Read PSSM sequence profiles and at each position allow only identities that pass a certain threshold in the PSSM. The code mentions symmetry-support, but I haven't tested this.

<SeqprofConsensus name=(&string) filename=(""&string) min_aa_probability=(0.0 &Real) probability_larger_than_current=(1 &bool) ignore_pose_profile_length_mismatch=(0 &bool) convert_scores_to_probabilities=(1&bool)/>

SeqprofConsensus can also be operated with ProteinInterfaceDesign and RestrictToAlignedSegments task operations contained within it. In that case, three different threshold can be set, one for the protein interface (where residues are marked for design), one for RestrictToAlignedSegments (again, where residues are marked for design), and one for the remainder of the protein. The reasoning is that you may want to be less 'consensus-like' at the active site than away from it. The three cutoffs would then be set by: conservation_cutoff_protein_interface_design, conservation_cutoff_aligned_segments, and min_aa_probability (for the remainder of the protein). The subtags, ProteinInterfaceDesign and RestrictToAlignedSegments are expected to be subtags of SeqprofConsensus and all of the options open to these task operations can be set the same way (the option name is not expected and if you specify it you would generate failure).

ReadResfile

Read a resfile. If a filename is given, read from that file. Otherwise, read the file specified on the commandline with -packing:resfile.

 <ReadResfile name=(&string) filename=(&string) />

ReadResfileFromDB

Lookup the resfile in the supplied relational database. This is useful for processing different structures with different resfiles in the same protocol. The database db should have a table table_name with the following schema:

    CREATE TABLE <table_name> (
        tag TEXT,
        resfile TEXT,
        PRIMARY KEY(tag));

When this task operation is applied, it tries to look up the resfile string associated with the tag defined by

    JobDistributor::get_instance()->current_job()->input_tag()

This task operation takes the following parameters:

RestrictIdentitiesAtAlignedPositions

Restricts user-specified positions, which are aligned with positions in a source-pdb, to the identities observed in the source pdb. Can be used to revert pre-specified residues to their identities in a wild-type progenitor. Can also be used to modify a task factory to only consider the identities in the source pdb for the target positions (while not changing the packer task for other positions). Note that the pose and the source pose must be aligned for this to work. Residues that have no aligned residue on the target pdb are ignored.

RestrictToAlignedSegments

(This is a devel TaskOperation and not available in released versions.)

Restricts design to segments that are aligned to the segments in source pdb files. The pdbs should have been pre-aligned. The start and stop residues must be at most 2A from a residue on the input pose, or else the alignment fails (the segment will not be aligned). The segments that are not aligned will be turned to restrict to repacking.

 <RestrictToAlignedSegments name=(&string) source_pdb=(&string) start_res=(&string) stop_res=(&string) repack_outside=(1&bool)>
<Add source_pdb=(&string) start_res=(&string) stop_res=(&string)/>
.
.
.
</RestrictToAlignedSegments>

RestrictChainToRepacking

Do not allow design in a particular chain

  <RestrictChainToRepacking name=(&string) chain=(1 &int)/>

RestrictToRepacking

Only allow residues to repack. No design.

 <RestrictToRepacking name=(&string) />

RestrictResidueToRepacking

Restrict a single residue to repacking. No design.

 <RestrictResidueToRepacking name=(&string) resnum=(0 &integer)/>

RestrictResiduesToRepacking

Restrict a string of comma-delimited residues to repacking. No design.

 <RestrictResiduesToRepacking name=(&string) residues=(0 &integer "," separated)/>

PreventRepacking

Do not allow repacking at all for the specified residue. Freezes residues.

<PreventRepacking name=(&string) resnum=(0 &int) />

PreventResiduesFromRepacking

Do not allow repacking at all for a string of residues to repacking. Use comma-delimited list of residues

 <PreventResiduesFromRepacking name=(&string) residues=(0 &integer,"," separated)/>

NoRepackDisulfides

Do not allow disulfides to repack.

 <NoRepackDisulfides name=(&string) />

DatabaseThread

This task operation uses a database of sequences and a template pdb to find on the pose a user defined start and end residues. A sequence length and threading start position are calculated and then a correct length sequence is randomly chosen from the database and threaded onto the pose.

<DatabaseThread name=(&string) database=(&string) template_file=(&string) start_res=(&int) end_res=(&int) allow_design_around=(1&bool) design_residues=(comma-delimited list) keep_original_identity=(comma-delimited list)/>

To actually change the sequence of the pose, you have to call something like PackRotamersMover on the pose using this task operation. Notice that this only packs the threaded sequence, holding everything else constant.

This task operation builds off of ThreadSequence so the same logic applies: 'X' means mark position for design, while ' ' or '_' means mark pose residue to repacking only.

DesignAround

Designs in shells around a user-defined list of residues. Restricts all other residues to repacking.

<DesignAround name=(&string) design_shell=(8.0 &real) resnums=(comma-delimited list) repack_shell=(8.0&Real) allow_design=(1 &bool) resnums_allow_design=(1 &bool)/>

RestrictToTermini

Restrict to repack only one or both termini on the specified chain.

<RestrictToTermini chain=(1 &size) repack_n_terminus=(1 &bool) repack_c_terminus=(1 &bool) />

LayerDesign

Design residues with selected amino acids depending on the enviroment(accessible surface area). The layer of each residue is assigned to one of the three basic layers(core, boundary or surface) depending on the accessible surface area of mainchain + CB.

Aditional layers can be defined in the xml file by passing another taskoperation to get the residue selection. Only the residues that are marked as designable in the packer task are taken into consideration, any information about the available amino acids/rotamers selected by the taskoperation are not going to be considered. The amino acids to be used in each of this new layers has to be specified in the xml. Several taskoperations can be combined to the intersection between the different sets of designable residues.

If a resfile is read before calling this operation, this operation is not applied for the residues defined by PIKAA, NATAA or NATRO. Note that this task is ligand compatible, the ligand is simply set to be repackable but not designable. Optionally allow all amino acids to select residue subsets by SASA cutoffs.

    <LayerDesign name=(&string layer) layer=(&string core_boundary_surface) pore_radius=(&real 2.0) core=(&real 20.0) surface=(&real 40.0) repack_non_design=(&bool 1) make_rasmol_script=(&bool 0) make_pymol_script=(&bool 0)   >
        <ATaskOperation name=task1 >
            <all copy_layer=(&string layer) append=(&string) exclude=(&string)  specification=(&string "designable")  operation=(&string "design") />
            <SecStructType aas=(&string) append(&string) exclude=(&string) />            
        </ATaskOperation >
    </LayerDesign>

Option list

TaskOperations can be combined together using the CombinedTasks tag, the nested tasks don't need to be named, just declared with type and parameters.

    <CombinedTasks name=combined_task>
         <ATaskOperation />
         <AnotherTaskOperation />
    </CombinedTasks>

**Currently Deprecated, new syntax for residue assignment coming soon! ** After you combined tasks you need to assign residues, you can use the 'all' tag to assign residues for all the different secondary structure elements.

    <combined_task>
        <all copy_layer=(&string) append=(&string) exclude=(&string)  specification=(&string "designable")  operation=(&string "design")/>
    </combine_task>

The options for the "all" tag are the following:

After an all operation other definitions can be performed, for example:

    <combined_task>
        <all copy_layer=surface/>
        <Strand append="F"/>
    </combine_task>

copies the layer definition from surface and adds Phe to the available residue types only to the residues on the strands.

Below are the selected amino acid types for each layer, this can be overwritten in the xml:

core

boundary

surface

Nterm

Cterm

 This example creates a new layer that combines BuildingBlockInterface(symmetric interface with SelectBySasa picking up the core of the complex
 since applying task operations returns the intersection of the sets this combined task will return the buried residues of the symmetric  interface.

<LayerDesign name=layer layer=other >

    <CombinedTasks name=symmetric_interface_core>
        <BuildingBlockInterface  />
        <SelectBySASA state=bound core=1 />
    </CombinedTasks>

     assign to the new layer for the interface core the same residues as for the surface and append for all possible secondary structures , append  phe and a leu to all ss types.

    <symmetric_interface_core>
        <all copy_layer=surface append="FL"/>
    </symmetric_interface_core>

</LayerDesign>

SelectBySASA

Select residues by their solvent accessible surface area in either the monomeric, bound, or unbound state of the pose. Accessible surface area cutoffs can be set for positions to be considered core, boundary or surface as follows: residues with accessible surface areas less than core_asa are considered core, those with areas greater than surface_asa are considered surface, and those between the core_asa and surface_asa cutoffs are considered boundary. These SASAs can be assessed in either the monomeric, bound, our unbound state, and either on all mainchain and CBeta atoms or on all sidechain heavyatoms. All residues that do not match the user-specified criteria are prevented from repacking. Works with asymmetric or asymmetric poses, as well as poses with symmetric-building blocks. Can be used to implement custom "layer design" protocols. For de novo designs, it is likely best to use mode="mc" rather than mode="sc". To set the parameters to be the same as the defaults for the LayerDesign task operation use: mode="mc", state="bound", probe_radius=2.0, core_asa=20, surface_asa=40.

 <SelectBySASA name=(&string) mode=("sc" &string) state=("monomer" &string) probe_radius=(2.2 &Real) core_asa=(0 &Real) surface_asa=(30 &Real) jumps=(1 &Size "," separated) sym_dof_names=("" &string "," separated) core=(0 &bool) boundary=(0 &bool) surface=(0 &bool) verbose=(0 &bool) />

Examples:

Only allow repacking at the core positions in the bound state. Useful in combination with other tasks such as RestrictToInterface in order to select just the core of the interface for design.

 <SelectBySASA name=core mode="sc" state="bound" probe_radius=2.2 core_asa=0 surface_asa=30 core=1 boundary=0 surface=0 verbose=1 />

Only allow repacking at the boundary and surface positions in the bound state.

 <SelectBySASA name=core mode="sc" state="bound" probe_radius=2.2 core_asa=0 surface_asa=30 core=0 boundary=1 surface=1 verbose=1 />

Prevent the core of the monomers (each chain) from repacking. Useful in combination with other tasks to ensure that one does not design core positions.

 <SelectBySASA name=no_core_mono_repack mode="sc" state="monomer" probe_radius=2.2 core_asa=0 surface_asa=30 core=0 boundary=1 surface=1 verbose=1 />

Option list

RestrictToInterface

Restricts to interface between two protein chains along a specified jump and with a given radius.

 <RestrictToInterface name=(&string) jump=(&integer, 1) distance=(&Real, 8.0) />

RestrictToInterfaceVector

Restricts the task to residues defined as interface by core/pack/task/operation/util/interface_vector_calculate.cc Calculates the residues at an interface between two protein chains or jump. The calculation is done in the following manner. First the point graph is used to find all residues within some big cutoff(CB_dist_cutoff) of residues on the other chain. For these residues near the interface, two metrics are used to decide if they are actually possible interface residues. The first metric is to itterate through all the side chain atoms in the residue of interest and check to see if their distance is less than the nearby atom cutoff (nearby_atom_cutoff), if so then they are an interface residue. If a residue does not pass that check, then two vectors are drawn, a CA-CB vector and a vector from CB to a CB atom on the neighboring chain. The dot product between these two vectors is then found and if the angle between them (vector_angle_cutoff) is less than some cutoff then they are classified as interface. The vector cannot be longer than some other distance (vector_dist_cutoff).

There are two ways of using this task, first way is to use jumps:

<RestrictToInterfaceVector name=(& string) jump=(1 & int,int,int... ) CB_dist_cutoff=(10.0 & Real) nearby_atom_cutoff=(5.5 & Real) vector_angle_cutoff=(75.0 & Real) vector_dist_cutoff=(9.0 & Real)/>

OR you can use chains instead

<RestrictToInterfaceVector name=(& string) chain1_num=(1 & int) chain2_num=(2 & int) CB_dist_cutoff=(10.0 & Real) nearby_atom_cutoff=(5.5 & Real) vector_angle_cutoff=(75.0 & Real) vector_dist_cutoff=(9.0 & Real)/>

Common tags, see descriptions above:

Note that if you specify a list of chain numbers for the chain1_num and chain2_num options, the interface will be calculated between the two sets. In other words, if chain1_num=1,2 and chain2_num=3,4 the interface will be calculated between chains 1 and 3, 1 and 4, 2 and 3, and 2 and 4. The interface between chains 1 and 2 and between 3 and 4 will not be calculated.

ProteinInterfaceDesign

Restricts to the task that is the basis for protein-interface design. Default behavior:

- prevent mutation of native pro/gly/cys
- prevent design of nonnative pro/gly/cys
- allow design of chain2 non-pro/gly/cys positions with Cbeta within 8.0Å of chain1
- allow repack of chain1 non-pro/gly/cys positions with Cbeta within 8.0Å of chain2

Note: When using this taskop on a pose with more than 2 chains, everything before the indicated jump is treated as "chain1", everything after as "chain2".

modify before/after jump determine whether the taskoperation will change residues before/after the jump. For instance, if you want set repack on chain2 interfacial residues to true, and the rest of chain2 to false, and yet not change the task for chain1, then use this taskoperation with modify_before_jump=0

DetectProteinLigandInterface

Setup packer task based on the detect design interface settings from enzyme design.

<DetectProteinLigandInterface name=(&string) cut1=(6.0 &Real) cut2=(8.0 &Real) cut3=(10.0 &Real) cut4=(12.0 &Real) 
design=(1 &bool) resfile=("" &string) design_to_cys=(0 &bool) catres_interface=(0 &bool) catres_only_interface=(0 &bool) 
arg_sweep_interface =(0 &bool) target_cstids=("" &string)/>

The task will set to design all residues with a Calpha within cut1 of the ligand (specifically the last ligand), or within cut2 of the ligand, where the Calpha-Cbeta vector points toward the ligand. Those residues within cut3 or within cut4 pointing toward the ligand will be set to repack. All others will be set to be fixed. Setting design to false will turn off design at all positions.

If resfile is specified, the listed resfile will be read in the settings therein applied to the task. Any positions set to "AUTO" (and only those set to AUTO) will be subjected the detect design interface procedure as described above. Note that design=0 will turn off design even for positions where it is permitted in the resfile (use "cut1=0.0 cut2=0.0 design=1" to allow design at resfile-permitted positions while disabling design at all AUTO positions).

By default, the DetectProteinLigandInterface will turns off design at disulfide cysteines, and will not permit designing to cysteine. (Positions which start off as cysteine can remain as cysteine if use input sidechains is turned on, or if design is turned off at that position, for example for enzdes catalytic residues). If you wish to allow design to cysteine at designable positions, set design_to_cys=1.

catres_interface: consider catalytic residues (if present) to determine interface (i.e. residues less than cut1 to these residues will be made designable etc.)

catres_only_interface: consider only neighbors of catalytic residues (not ligand) for defining interface

arg_sweep_interface: use arginine-reachability to interface as the criterion for defining designable positions instead of distance

target_cstids: comma-separated list of particular constrained residues to be considered as exclusive targets for interface detection (e.g. 1B,2B,3B)

SetCatalyticResPackBehavior

Ensures that catalytic residues as specified in a match/constraint file do not get designed. If no option is specified the constrained residues will be set to repack only (not design).

If the option fix_catalytic_aa=1 is set in the tag (or on the commandline), catalytic residues will be set to non-repacking.

If the option -enzdes::ex_catalytic_rot <number> is active, the extra_sd sampling for every chi angle of the catalytic residues will be according to <number>, i.e. one can selectively oversample the catalytic residues

RestrictAbsentCanonicalAAS

Restrict design to user-specified residues. If resnum is left as 0, the restriction will apply throughout the pose.

 <RestrictAbsentCanonicalAAS name=(&string) resnum=(0 &integer) keep_aas=(&string) />

DisallowIfNonnative

Restrict design to not include a residue as an possibility in the task at a position unless it is the starting residue. If resnum is left as 0, the restriction will apply throughout the pose.

 <DisallowIfNonnative name=(&string) resnum=(0 &integer) disallow_aas=(&string) />

This task is useful when you are designing in a region that has Gly and Pro and you do not want to include them at other positions that aren't already Gly or Pro.

ThreadSequence

Threads a single letter sequence onto the source pdb.

<ThreadSequence name=(&string) target_sequence=(&string) start_res=(1&int) allow_design_around=(1&bool)/>

To actually change the sequence of the pose, you have to call something like PackRotamersMover on the pose using this task operation. Notice that this only packs the threaded sequence, holding everything else constant.

The target sequence can contain two types of 'wildcards'. Placing 'x' in the sequence results in design at this position: target_sequence="TFYxxxHFS" will thread the two specified tripeptides and allow design in the intervening tripeptide. Placing ' ' (space) or '_' (underscore), however, restricts this position to repacking: the string "TFY HFS" (three spaces between the two triplets) will thread the two tripeptides and will repack the pose's original intervening tripeptide. The string "TFY___HFS" (three underscores between the two triplets) will also only repack the original intervening tripeptide.

allow_design_around: if set to false, only design the region that is threaded. The rest is set to repack.

JointSequence

<JointSequence use_current=(true &bool)  use_native=(false &bool) filename=(&string) native=(&string) use_natro=(false &bool) 
use_fasta=(false &bool) chain=( &integer) use_chain=(&integer) />

Prohibit designing to residue identities that aren't found at that position in any of the listed structures:

If use_natro is true, the task operation also adds the rotamers from the native structures (use_native/native) in the rotamer library.

RestrictDesignToProteinDNAInterface

Restrict Design and repacking to protein residues around the defined DNA bases

<RestrictDesignToProteinDNAInterface name=(&string) dna_defs=(chain.pdb_num.base) base_only=(1, &bool) z_cutoff=(0.0, &real) />

RestrictNativeResidues

Restrict or prevent repacking of native residues. Accepts a native pose (reference pose) from the command line (via in:file:native) or via the pdbname tag. Loops over all residues and compares the current amino acid at each position to the amino acid in the same position in the reference pose. If the identity is the same, then the residue is either prevented from repacking (if prevent_repacking option is set to true) or restricted to repacking.

 <RestrictNativeResidues name=(&string) prevent_repacking=(0 &bool) verbose=(0 &bool) pdbname=("" &string) />

Example: Only allow design at non-native positions (prevent repacking of all native residues).

 <RestrictNativeResidues name=non_native prevent_repacking=1 verbose=1 pdbname="input/native.pdb" />

Option list

ProteinCore

(This is a devel TaskOperation and not available in released versions.)

Restricts design of residues that are in the core (e.g. to prevent charges). To determine which residues are core, it counts spatial neighbors (distance between Cb). To avoid confusion in turns on the protein surface, neighbors in sequence are omitted, similar to the way used in Choi & Deane, Mol Biosyst(2011) 7(12):3327-3334 DOI: 10.1039/c1mb05223c

 <ProteinCore name=(&string) distance_threshold=(8.0 &real) bound=(0 &bool) jump=(1 &Size) neighbor_cutoff=(10 &Size) neighbor_count_cutoff=(6 &Size) />

Option list

HighestEnergyRegion

Selects residues that have the highest per-residue energy. This task operation is stochastic to allow for variation in design regions. Residues are selected by this task operation as follows. First, all residues are ranked in order of total score of a region which consists of a sphere around the residue. Next, the first residue is selected based on a random number generator. The first residue in the list (the one with highest (worst) score) has a 50% probability of being selected, the second residue has 25% probability, and so on. If regions_to_design is > 1, additional residues are selected using the same process, except with previously chosen residues removed from consideration.

<HighestEnergyRegion name=(&string) region_shell=(&real) regions_to_design=(&int) repack_non_selected=(&bool) scorefxn=(&string) />

Example The following example redesigns a sphere of 8 A radius centered in a poorly scoring region of the pose. Residues outside of the sphere are fixed.

<TASKOPERATIONS>
    <HighestEnergyRegion name="des_high_energy" region_shell="8.0" regions_to_design="1" repack_non_selected="0" />
</TASKOPERATIONS>
<MOVERS>
    <PackRotamersMover name="design" task_operations="des_high_energy" />
</MOVERS>
<PROTOCOLS>
    <Add mover_name="design" />
</PROTOCOLS>

DesignByResidueCentrality

Selects residues for design that have the highest value of residue centrality. Centrality is determined by the intra-protein interaction network. Residues are defined as interacting and receive an edge in the network if they have atoms that are <= 4 angstroms apart. The residue centrality is the average of the average shortest path from each node to all other nodes, and can be used to identify residues that are structurally or functionally important.

This task operation is stochastic to allow for variation in design regions. Residues are selected by this task operation as follows. First, all residues are ranked in order of network centrality. Next, the first residue is selected based on a random number generator. The first residue in the list (the one with highest centrality) has a 50% probability of being selected, the second residue has 25% probability, and so on. If regions_to_design is > 1, additional residues are selected using the same process, except with previously chosen residues removed from consideration.

<DesignByResidueCentrality name=(&string) region_shell=(8.0 &real) regions_to_design=(1 &int) repack_non_selected=(0 &bool) />

Example The following example redesigns a sphere of 8 A radius centered at a residue of high centrality. Residues outside of the sphere are fixed.

<TASKOPERATIONS>
    <DesignByResidueCentrality name="des_by_centrality" region_shell="8.0" regions_to_design="1" repack_non_selected="0" />
</TASKOPERATIONS>
<MOVERS>
    <PackRotamersMover name="design" task_operations="des_by_centrality" />
</MOVERS>
<PROTOCOLS>
    <Add mover_name="design" />
</PROTOCOLS>

DesignRandomRegion

Simply chooses random residues from the pose. This task operation is stochastic to allow for variation in design regions. Each call to this operation results in a new randomly selected set of residues chosen for design.

<DesignRandomRegion name=(&string) region_shell=(&real) regions_to_design=(&int) repack_non_selected=(&bool) />

Example The following example redesigns a sphere of 8 A radius centered at a randomly selected residue. Residues outside of the sphere are fixed.

<TASKOPERATIONS>
    <DesignRandomRegion name="des_random" region_shell="8.0" regions_to_design="1" repack_non_selected="0" />
</TASKOPERATIONS>
<MOVERS>
    <PackRotamersMover name="design" task_operations="des_random" />
</MOVERS>
<PROTOCOLS>
    <Add mover_name="design" />
</PROTOCOLS>

DesignCatalyticResidues

Sets catalytic residues to designable. Prior to being called, this task operation REQUIRES that enzdes constraints be added to the pose. This can be accomplished using the <AddOrRemoveMatchCsts /> mover as shown in the example. This could be combined with the <SetCatalyticResPackBehavior /> task operation to set the catalytic residues to repack and design the spheres around them.

<DesignCatalyticResidues name=(&string) region_shell=(&real) regions_to_design=(&int) repack_non_selected=(&bool) />

Example The following example redesigns a sphere of 8 A radius centered at catalytic residues. Residues outside of the sphere are fixed.

<TASKOPERATIONS>
    <SetCatalyticResPackBehavior name="repack_cat" fix_catalytic_aa="0" />
    <DesignCatalyticResidues name="des_catalytic" region_shell="8.0" regions_to_design="1" repack_non_selected="0" />
</TASKOPERATIONS>
<MOVERS>
    <AddOrRemoveMatchCsts name="add_csts" cstfile="my_csts.cst" cst_instruction="add_new" />
    <PackRotamersMover name="design" task_operations="des_catalytic,repack_cat" />
</MOVERS>
<PROTOCOLS>
    <Add mover_name="add_csts" />
    <Add mover_name="design" />
</PROTOCOLS>

DesignByCavityProximity

This task operations scans the protein to identify intra-protein voids, and selects residues for design based on their proximity to the voids. Residues are scored by the metric (distance_to_cavity_center)/(volume_of_cavity) and the lowest scoring residues are selected for design.

<DesignByCavityProximity name=(&string) region_shell=(8.0 &real) regions_to_design=(1 &int) repack_non_selected=(0 &bool) />

Example The following example redesigns a sphere of 8 A radius centered at a residue near an intra-protein cavity. Residues outside of the sphere are fixed.

<TASKOPERATIONS>
    <DesignByCavityProximity name="des_cavity" region_shell="8.0" regions_to_design="1" repack_non_selected="0" />
</TASKOPERATIONS>
<MOVERS>
    <PackRotamersMover name="design" task_operations="des_cavity" />
</MOVERS>
<PROTOCOLS>
    <Add mover_name="design" />
</PROTOCOLS>

DesignBySecondaryStructure

Selects residues for design based on agreement with psipred secondary structure prediction. Residues which disagree with the secondary structure prediction are selected for design. This mover is stochastic in that residues which disagree in secondary structure prediction are selected randomly every time the task operation is called.

<DesignBySecondaryStructure name=(&string) region_shell=(8.0 &real) regions_to_design=(1 &int) repack_non_selected=(0 &bool) blueprint=("" &string) cmd=(&string) />

Example The following example redesigns a sphere of 8 A radius centered at a residue with secondary structure prediction that disagrees with actual secondary structure. Residues outside of the sphere are fixed.

<TASKOPERATIONS>
    <DesignBySecondaryStructure name="des_by_sspred" region_shell="8.0" regions_to_design="1" repack_non_selected="0" cmd="/path/to/runpsipred_single" />
</TASKOPERATIONS>
<MOVERS>
    <PackRotamersMover name="design" task_operations="des_by_sspred" />
</MOVERS>
<PROTOCOLS>
    <Add mover_name="design" />
</PROTOCOLS>

Rotamer Specification

InitializeFromCommandline

Reads commandline options. For example, -ex1 -ex2 (does not read resfile from command line options) This taskoperation will complain about an unimplemented method, but you can safely ignore the message.

 <InitializeFromCommandline name=(&string) />

IncludeCurrent

Includes current rotamers (eg - from input pdb) in the rotamer set. These rotamers will be lost after a packing run, so they are only effective upon initial loading of a pdb!

 <IncludeCurrent name=(&string) />

ExtraRotamersGeneric

During packing, extra rotamers can be used to increase sampling. Use this TaskOperation to specify for all residues at once what extra rotamers should be used. Note: The extrachi_cutoff is used to determine how many neighbors a residue must have before the extra rotamers are applied. For example of you want to apply extra rotamers to all residues, set extrachi_cutoff=0 . See the Extra Rotamer Commands section on the resfiles page for additional details.

 <ExtraRotamersGeneric name=(&string)
ex1=(0 &boolean) ex2=(0 &boolean) ex3=(0 &boolean) ex4=(0 &boolean)
ex1aro=(0 &boolean) ex2aro=(0 &boolean) ex1aro_exposed=(0 &boolean) ex2aro_exposed=(0 &boolean)
ex1_sample_level=(7 &Size) ex2_sample_level=(7 &Size) ex3_sample_level=(7 &Size) ex4_sample_level=(7 &Size)
ex1aro_sample_level=(7 &Size) ex2aro_sample_level=(7 &Size) ex1aro_exposed_sample_level=(7 &Size) ex2aro_exposed_sample_level=(7 &Size) 
exdna_sample_level=(7 &Size)
extrachi_cutoff=(18 &Size)/>

RotamerExplosion

Sample residue chi angles much more finely during packing. Currently hardcoded to use three 1/3 step standard deviation.

Note: This might actually need to be called as RotamerExplosionCreator in the xml

 <RotamerExplosionCreator name=(&string) resnum=(&Integer) chi=(&Integer) />

LimitAromaChi2

Prevent to use the rotamers of PHE, TYR and HIS that have chi2 far from 90.

AddLigandMotifRotamers

Using a library of protein-ligand interactions, identify possible native-like interactions to the ligand and add those rotamers to the packer, possibly with a bonus.

<AddLigandMotifRotamers name=(&string)/>

Since it only makes sense to run AddLigandMotifRotamers once (it takes a very long time), I have not made the options parseable. You can however read in multiple weight files in order to do motif weight ramping.

ImportUnboundRotamers

Import unbound rotamers from a given PDB file. Specify the unbound/native PDB file using the flag: -packing::unboundrot

Note: This task operation was developed to favor unbound rotamers (in particular, native rotamers) from an imported PDB file. If this is what you want, make sure that you use the load_unbound_rot mover (no parameters, and currently undocumented), which changes the rotamer Dunbrack scoring term (fa_dun), such that the scores for your imported unbound rotamers are equal to the best scoring rotamers in your currently used library. This will favor the imported unbound rotamers at the time you design/repack sidechains. This task operation should be used with your favorite sidechain designing/packing mover (for example: GreedyOptMutationMover, RepackMinimize, or PackRotamersMover).

<ImportUnboundRotamers name=(&string)/>

Packer Behavior Modification

ModifyAnnealer

Allows modification of the temperatures and quench used by the annealer during packing.

<ModifyAnnealer name=(&string) high_temp=(100.0 &Real) low_temp=(0.3 &Real) disallow_quench=(0 &bool)/>

ProteinLigandInterfaceUpweighter

Specifically upweight the strength of the protein-ligand interaction energies by a given factor.

<ProteinLigandInterfaceUpweighter name=(&string) interface_weight=(1.0 &Real) catres_interface_weight=(1.0 &Real)/>

interface_weight: upweight ligand interactions by this weight

catres_interface_weight: upweight catatlytic residue interactions by this weight

Development/Testing

InitializeExtraRotsFromCommandline

Under development and untested. Use at your own risk.

SetRotamerCouplings

Under development and untested. Use at your own risk.

AppendRotamer

Under development and untested. Use at your own risk.

AppendRotamerSet

Under development and untested. Use at your own risk.

PreserveCBeta

Under development and untested. Use at your own risk.

RestrictYSDesign

Restrict amino acid choices during design to Tyr and Ser. This is similar to the restricted YS alphabet used by Sidhu's group during in vitro evolution experiments. Under development and untested. Use at your own risk.

Currently Undocumented

The following TaskOperations are available through RosettaScripts, but are not currently documented. See the code (particularly the respective parse_tag() and apply() functions) for details. (Some may be undocumented as they are experimental/not fully functional.)

AddRigidBodyLigandConfs, DisableZnCoordinationResiduesTaskOp, ExtraChiCutoff, ExtraRotamers, OptCysHG, OptH, PreventChainFromRepacking, ReadResfileAndObeyLengthEvents, RemodelRotamerLinks, ReplicateTask, RestrictByCalculators, RestrictConservedLowDdg, RestrictInterGroupVectorOperation, RestrictNonSurfaceToRepacking, RestrictToCDRH3Loop, RestrictToInterfaceOperation, RestrictToLoopsAndNeighbors, RestrictToNeighborhood, SeqprofConsensus, SetIGType, SetRotamerLinks, WatsonCrickRotamerCouplings

Residue Level TaskOperations: