Rosetta 3.4
Public Types | Public Member Functions
protocols::match::Matcher Class Reference

#include <Matcher.hh>

Inheritance diagram for protocols::match::Matcher:
Inheritance graph
[legend]
Collaboration diagram for protocols::match::Matcher:
Collaboration graph
[legend]

List of all members.

Public Types

typedef core::Real Real
typedef core::Size Size
typedef core::Vector Vector
typedef
numeric::geometry::BoundingBox
< Vector
BoundingBox
typedef std::list< HitHitList
typedef std::list< Hit >::iterator HitListIterator
typedef std::list< Hit >
::const_iterator 
HitListConstIterator

Public Member Functions

 Matcher ()
 Construction and Destruction.
virtual ~Matcher ()
void set_upstream_pose (core::pose::Pose const &pose)
 Setup.
void set_downstream_pose (core::pose::Pose const &pose, utility::vector1< core::id::AtomID > orientation_atoms)
void set_original_scaffold_build_points (utility::vector1< Size > const &resids)
void set_original_scaffold_build_points_for_constraint (Size cst_id, utility::vector1< Size > const &resids)
void set_n_geometric_constraints (Size n_constraints)
Size n_geometric_constraints () const
void add_upstream_restype_for_constraint (Size cst_id, core::chemical::ResidueTypeCAP restype)
void set_sample_startegy_for_constraint (Size cst_id, core::chemical::ResidueTypeCAP restype, Size chi, upstream::SampleStrategyData const &strat)
void set_fa_dun_cutoff_for_constraint (Size cst_id, core::chemical::ResidueTypeCAP restype, core::Real fa_dun_cutoff)
void add_external_geometry_samples_for_constraint (Size cst_id, core::chemical::ResidueTypeCAP restype, utility::vector1< std::string > const &upstream_launch_atoms, utility::vector1< core::id::AtomID > const &downstream_3atoms, toolbox::match_enzdes_util::ExternalGeomSampler const &exgeom, Size const exgeom_id, bool enumerate_ligand_rotamers=false, bool catalytic_bond=false)
void add_secondary_upstream_match_geometry_for_constraint (Size geom_cst_id, Size target_geom_cst_id, core::chemical::ResidueTypeCAP candidate_restype, core::chemical::ResidueTypeCAP target_restype, utility::vector1< Size > const &candidate_atids, utility::vector1< Size > const &target_atids, toolbox::match_enzdes_util::MatchConstraintFileInfoCOP mcfi, std::string SecMatchStr, core::pose::Pose const &upstream_pose)
void add_secondary_downstream_match_geometry_for_constraint (Size geom_cst_id, core::chemical::ResidueTypeCAP candidate_restype, core::chemical::ResidueTypeCAP downstream_restype, utility::vector1< Size > const &candidate_atids, utility::vector1< Size > const &target_atids, toolbox::match_enzdes_util::MatchConstraintFileInfoCOP mcfi, std::string SecMatchStr, core::pose::Pose const &upstream_pose, bool catalytic_bond)
void set_occupied_space_bounding_box (BoundingBox const &bb)
void set_hash_euclidean_bin_width (Real width)
void set_hash_euler_bin_width (Real width)
void set_hash_euclidean_bin_widths (Vector widths)
void set_hash_euler_bin_widths (Vector widths)
void set_bump_tolerance (Real permitted_overlap)
void initialize_from_task (MatcherTask const &task)
 The primary way to initialize a Matcher is through a MatcherTask.
void initialize_from_file (toolbox::match_enzdes_util::EnzConstraintIO const &enz_data, MatcherTask const &task)
 Intialize the geometric constraints from the EnzConstraionIO object.
bool find_hits ()
 Main worker function.
void process_matches (output::MatchProcessor &processor) const
 After find_hits completes, use this function to have the Matcher enerate the hit-combinations (matches) and send those matches to the specified match-processor. The match processor may do what it pleases with the matches.
core::pose::PoseCOP upstream_pose () const
 Data accessors.
core::pose::PoseCOP downstream_pose () const
upstream::ScaffoldBuildPointCOP build_point (Size index) const
upstream::UpstreamBuilderCOP upstream_builder (Size cst_id) const
utility::vector1< Size > const & get_pose_build_resids () const
downstream::DownstreamBuilderCOP downstream_builder (Size cst_id) const
 Return const access to a representative downstream builder for a particular geometric constraint. All downstream builders for a single geometric constraint are required to behave the same when reconstructing the coordinates of the downstream partner from a hit; therefore, a single representative is sufficient to recover hit coordinates for any hit from a particular geometric constraint.
std::list
< downstream::DownstreamAlgorithmCOP
downstream_algorithms (Size cst_id) const
downstream::DownstreamAlgorithmCOP representative_downstream_algorithm (Size cst_id) const
HitList const & hits (Size cst_id) const
OccupiedSpaceHashCOP occ_space_hash () const
utility::vector1
< upstream::ScaffoldBuildPointCOP >
const & 
per_constraint_build_points (Size cst_id) const
upstream::ScaffoldBuildPointOP build_point (Size index)
 Non-const access.
upstream::UpstreamBuilderOP upstream_builder (Size cst_id)
bool has_upstream_only_geomcsts () const
downstream::DownstreamBuilderOP downstream_builder (Size)
 Return non-const access to a representative downstream builder for a particular geometric constraint.
std::list
< downstream::DownstreamBuilderOP >
const & 
downstream_builders (Size cst_id) const
 Return non-const access to all of the downstream builders for a particular geometric constraint.
std::list
< downstream::DownstreamAlgorithmOP >
const & 
nonconst_downstream_algorithms (Size cst_id)
 Non-const access to the set of downstream algorithms for a particular geometric constraint -- note that the list containing these algorithms is itself const.
OccupiedSpaceHashOP occ_space_hash ()
HitListIterator hit_list_begin (Size geom_cst_id)
 Return a non-constant iterator to a HitList for a particular geometric constraint. DANGER DANGER DANGER. This access is intended to allow a DownstreamAlgorithm to delete its own non-viable hits and also to allow a DownstreamAlgorithm to delete another algorithm's non-viable hits; Actual deletion requires invoking the method Matcher::erase_hit(). This non-const access is not intended for any other class.
HitListIterator hit_list_end (Size geom_cst_id)
 Return a non-constant iterator to the end position for a HitList for a particular geometric constraint. See comments for hit_list_begin()
void erase_hit (downstream::DownstreamAlgorithm const &dsalg, Size geom_cst_id_for_hit, HitListIterator const &iter)
 To be invoked by a downstream algorithm. Downstream algorithms may prune their old, inviable hits, through this method -- they should pass themselves in as an argument.

Detailed Description

Overview: The matcher algorithm was originally concieved of within the domain of enzyme design. The transition state for the desired reqction is contacted by several amino acids each with a particular geometry. The goal of the matcher is to find a set of backbone positions on a given protein-backbone scaffold where those amino acids could be grafted such that they would contact the ligand in the desired geometry.

Consider a case where the transition state is contacted by an asparagine, an aspartate and a histadine. The user designing an enzyme for this transition state knows the geometry that describes the orientation of the transition state with respect to each of these side chains; what they do not know is into what protein and at what positions they should introduce these amino acids. The user will give the matcher a description of the geometry between the amind acids and the transition state. This geometry is in the form of 6 parameters: 3 diherals, 2 angles, and 1 distance (more on these later). Given the coordinates of a particular side chain and the geometry describing the transition state relative to the side chain, the coordinates of the transition state may be computed. In a sense, the transition state may be grown off of the end of a side chain in the desired geoemtry.

(Usually, the user will specify many different possible values for each of the 6 parameters, and the matcher will then consider all combinations of those values. E.g. the ideal distance might be 2.0 A, but the user might ask the matcher to consider the values 1.95 and 2.05 A additionally. Each assignment of values to these 6 parameters fully specifies the coordinates of the transition state.)

The matcher examines each geometric constraint one at a time. It builds rotamers for one or more amino acids capable of satisfying a desired geometry (e.g. both ASP and GLU if an acid group is needed) at each of several active-site positions, and for each rotamer, it grows the transition state. The matcher does a quick collision check between the atoms of the transition state and the backbone of the protein, rejecting transition-state conformations that collide. If the conformation is collision-free, then the matcher measures the coordinates of the transition state as a point in a 6-dimensional space. (It is no coincidence that there are 6 geometric parameters and that there are 6 dimensions in the space describing the transition state's coordinates). With this 6-dimensional coordinate, the matcher can recover the coordinates for the transition state -- the 6-D coordinate and the full euclidean coordinates of the transition state are interconvertable. The matcher can also bin the coordinate. If two coordinates in 6-D are close, they will be assigned to the same bin. This is the fundamental insight of the matching algorithm: the matcher will grow the transition state from different catalytic residues, and when the 6-d coordinates from different catalytic residues are assigned to the same bin, then the matcher has found a set of conformations of the transition state that are compatible with more than one catalytic geometry.

Each collision-free placement of the transition state is called a "hit". If there are N geometric-constrains that the matcher is asked to satisfy, then a set of N hits, one per constraint, that fall into the same bin are called a "match".

In the general case, the Matcher builds hits for each of several geometric constraints. The protein scaffold in the enzyme-design example generalizes to any macro-molecular polymer scaffold. The protein rotamers in the enzyme-design example generalizes to a set of conformations for the "upstream" partner. The transition state gene in the enzyme-design example generalizes to a "downstream" partner, which itself may have multiple conformations. "Upstream" and "Downstream" refer to the order in which the coordinates of the two partners are computed. The upstream coordinates are built first, the downstream coordinates second. Changes to the coordinates of the upstream partner propagate to the coordinates of the downstream partner. In the enzyme-design example, the transition state is considered to be rigid; in the general case the transition state may have multiple conformations. The downstream partner could also be an entire protein -- and may have it's own set of rotameric states. E.G. one might want to match a hydrogen-bond donor on the scaffold to a serine side-chain on the target (downstream) protein. The downstream partner should then be able to examine many serine rotamers for each conformation of the upstream rotamer.

A hit is represented in two parts: a discrete part and a continuous part. The discrete portion consists of four integers: 1. the build-point index on the scaffold, 2. the rotamer index on the upstream partner, 3. the external-geometry index, and 4. the rotamer index on the downstream partner. The continuous portion consists of 6 double-precision values representing the coordinate of the downstream partner in 6D. The first three values are the x,y and z coordinates of a particular atom in the downstream partner. The second three values are the phi, psi, and theta values describing the coordinate frame at this atom. These three "Euler angle" parameters describe three rotations: Z(psi) * X(theta) * Z(phi) * I. They are described in greater detail in src/numeric/HomogeneousTransform.hh. "Phi" and "psi" here have nothing to do with the protein-backbone angles. When a hit is binned, there are two sets of parameters that describe how wide the bins in each dimension should be: the Euclidean bin widths are for the xyz coordinates, and the Euler bin widths are for the Euler angles. The Euclidean bin widths are in Angstroms and the Euler bin widths are in degrees.

A Matcher object should be initialized from a MatcherTask object through the intialize_from_task() method. A MatcherTask will contain an EnzConstraintIO object, and the function Matcher::initialize_from_file() will be invoked as the Matcher is intialied from a MatcherTask. The documentation for Matcher::inialize_from_file() describes the format of extra data that may be included in the enzyme-design constraint file. This data should live within a ALGORITHM_INFO:: match ... ALGORITHM::END block inside a CST::BEGIN ... CST::END block in the constraint file.

find_hits() is the main worker function. After the matcher finishes find_hits(), the matches can be read by a MatchProcessor in a call to process_matches.


Member Typedef Documentation

typedef numeric::geometry::BoundingBox< Vector > protocols::match::Matcher::BoundingBox
typedef std::list< Hit >::const_iterator protocols::match::Matcher::HitListConstIterator
typedef std::list< Hit >::iterator protocols::match::Matcher::HitListIterator

Constructor & Destructor Documentation

protocols::match::Matcher::Matcher ( )

Construction and Destruction.

protocols::match::Matcher::~Matcher ( ) [virtual]

Member Function Documentation

void protocols::match::Matcher::add_external_geometry_samples_for_constraint ( Size  cst_id,
core::chemical::ResidueTypeCAP  restype,
utility::vector1< std::string > const &  upstream_launch_atoms,
utility::vector1< core::id::AtomID > const &  downstream_3atoms,
toolbox::match_enzdes_util::ExternalGeomSampler const &  exgeom,
Size const  exgeom_id,
bool  enumerate_ligand_rotamers = false,
bool  catalytic_bond = false 
)
void protocols::match::Matcher::add_secondary_downstream_match_geometry_for_constraint ( Size  geom_cst_id,
core::chemical::ResidueTypeCAP  candidate_restype,
core::chemical::ResidueTypeCAP  downstream_restype,
utility::vector1< Size > const &  candidate_atids,
utility::vector1< Size > const &  target_atids,
toolbox::match_enzdes_util::MatchConstraintFileInfoCOP  mcfi,
std::string  SecMatchStr,
core::pose::Pose const &  upstream_pose,
bool  catalytic_bond 
)
void protocols::match::Matcher::add_secondary_upstream_match_geometry_for_constraint ( Size  geom_cst_id,
Size  target_geom_cst_id,
core::chemical::ResidueTypeCAP  candidate_restype,
core::chemical::ResidueTypeCAP  target_restype,
utility::vector1< Size > const &  candidate_atids,
utility::vector1< Size > const &  target_atids,
toolbox::match_enzdes_util::MatchConstraintFileInfoCOP  mcfi,
std::string  SecMatchStr,
core::pose::Pose const &  upstream_pose 
)
void protocols::match::Matcher::add_upstream_restype_for_constraint ( Size  cst_id,
core::chemical::ResidueTypeCAP  restype 
)
upstream::ScaffoldBuildPointOP protocols::match::Matcher::build_point ( Size  index)

Non-const access.

upstream::ScaffoldBuildPointCOP protocols::match::Matcher::build_point ( Size  index) const
std::list< downstream::DownstreamAlgorithmCOP > protocols::match::Matcher::downstream_algorithms ( Size  cst_id) const
downstream::DownstreamBuilderOP protocols::match::Matcher::downstream_builder ( Size  cst_id)

Return non-const access to a representative downstream builder for a particular geometric constraint.

downstream::DownstreamBuilderCOP protocols::match::Matcher::downstream_builder ( Size  cst_id) const

Return const access to a representative downstream builder for a particular geometric constraint. All downstream builders for a single geometric constraint are required to behave the same when reconstructing the coordinates of the downstream partner from a hit; therefore, a single representative is sufficient to recover hit coordinates for any hit from a particular geometric constraint.

std::list< downstream::DownstreamBuilderOP > const & protocols::match::Matcher::downstream_builders ( Size  cst_id) const

Return non-const access to all of the downstream builders for a particular geometric constraint.

Referenced by protocols::match::downstream::ClassicMatchAlgorithm::build_hits_at_all_positions().

core::pose::PoseCOP protocols::match::Matcher::downstream_pose ( ) const
void protocols::match::Matcher::erase_hit ( downstream::DownstreamAlgorithm const &  dsalg,
Size  geom_cst_id_for_hit,
HitListIterator const &  iter 
)

To be invoked by a downstream algorithm. Downstream algorithms may prune their old, inviable hits, through this method -- they should pass themselves in as an argument.

-- and they may also prune this hits for other rounds. If the should prune other-round hits, then they will trigger an update to the hit_lists_with_primary_modificiations_ list, leading to an additional pass over the geometric constraints in a primary/peripheral pattern.

References protocols::match::downstream::DownstreamAlgorithm::geom_cst_id().

Referenced by protocols::match::downstream::SecondaryMatcherToUpstreamResidue::respond_to_peripheral_hitlist_change(), protocols::match::downstream::SecondaryMatcherToDownstreamResidue::respond_to_peripheral_hitlist_change(), protocols::match::downstream::ClassicMatchAlgorithm::respond_to_peripheral_hitlist_change(), and protocols::match::downstream::SecondaryMatcherToUpstreamResidue::respond_to_primary_hitlist_change().

bool protocols::match::Matcher::find_hits ( )

Main worker function.

utility::vector1< core::Size > const & protocols::match::Matcher::get_pose_build_resids ( ) const
bool protocols::match::Matcher::has_upstream_only_geomcsts ( ) const
Matcher::HitListIterator protocols::match::Matcher::hit_list_begin ( Size  geom_cst_id)

Return a non-constant iterator to a HitList for a particular geometric constraint. DANGER DANGER DANGER. This access is intended to allow a DownstreamAlgorithm to delete its own non-viable hits and also to allow a DownstreamAlgorithm to delete another algorithm's non-viable hits; Actual deletion requires invoking the method Matcher::erase_hit(). This non-const access is not intended for any other class.

Referenced by protocols::match::downstream::SecondaryMatcherToUpstreamResidue::respond_to_peripheral_hitlist_change(), protocols::match::downstream::SecondaryMatcherToDownstreamResidue::respond_to_peripheral_hitlist_change(), protocols::match::downstream::ClassicMatchAlgorithm::respond_to_peripheral_hitlist_change(), and protocols::match::downstream::SecondaryMatcherToUpstreamResidue::respond_to_primary_hitlist_change().

Matcher::HitListIterator protocols::match::Matcher::hit_list_end ( Size  geom_cst_id)
Matcher::HitList const & protocols::match::Matcher::hits ( Size  cst_id) const
void protocols::match::Matcher::initialize_from_file ( toolbox::match_enzdes_util::EnzConstraintIO const &  enz_data,
MatcherTask const &  mtask 
)

Intialize the geometric constraints from the EnzConstraionIO object.

Inside the CST::BEGIN blocks, The following ALGORITHM_INFO:: match input data may be provided to give additional data to the matcher. Rotamer building instructions for particular geometric constraints may be given. Here is an example of the kinds of geometric data. Each CHI_STRATEGY line is appropriate on it's own, but they are not appropriate together. Lines beginning with "#" are comments describing the meaning of each of the lines.

ALGORITHM_INFO:: match # If your upstream residue includes a proton chi (e.g. SER/THR/TYR) but the geometry # of the downstream partner does not depend on the location of the proton, then # use the following line to avoid enumerating rotamers that differ only in their proton coordinate. IGNORE_UPSTREAM_PROTON_CHI

# Secondary Matching: # You can activate secondary matching, a continuous version of the classic discrete algorithm, # by adding the line SECONDARY_MATCH: DOWNSTREAM

#or SECONDARY_MATCH: UPSTREAM_CST 2

# which instead of building its own hits and hashing them examines the hits generated in # previous rounds for compatibility with the geometry that you're seeking. # When performing secondary matching, it is not required that you specify all 6 degrees # of freedom. If you specify only a subset the geometry of only the subset you've specified # will be examined (e.g. if you don't care about torsion_AB, don't specify it # in the CST::BEGIN/CST::END block. # You can perform secondary matching to the ligand (the downstream target) or to an upstream # residue whose geometry was constructed by an earlier geometric constraint. In the example # above, the geometric constraint pointed to is #2. # The first geometric constraint cannot use secondary matching, it must always use the discrete # classic match algorithm. (A later geometric constraint may of course perform secondary # matching to the hits produced by the first geometric constraint. At that point the first # constraint is playing the same role in upstream matching as the ligand plays in downstream matching) # END Secondary Matching comments.

# Below: chi sample strategies -- "1" is for chi-1 # These are the traditional ex?::level options ( ? == 1, 2, 3 or 4 ) CHI_STRATEGY:: CHI 1 EX_ONE_STDDEV CHI_STRATEGY:: CHI 1 EX_ONE_HALF_STEP_STDDEV CHI_STRATEGY:: CHI 1 EX_TWO_FULL_STEP_STDDEVS CHI_STRATEGY:: CHI 1 EX_TWO_HALF_STEP_STDDEVS CHI_STRATEGY:: CHI 1 EX_FOUR_HALF_STEP_STDDEVS CHI_STRATEGY:: CHI 1 EX_THREE_THIRD_STEP_STDDEVS CHI_STRATEGY:: CHI 1 EX_SIX_QUARTER_STEP_STDDEVS

# Below: The "AA" field, followed by the 3-letter AA code gives the sub-specification for # a block that contains multiple amino acids. If this block allowed both an ASN and a GLN, then # the first line would apply to GLN rotamers only and the second line to ASN rotamers only. # "AA" fields may be included with # any of the CHI_STRATEGY options listed here. CHI_STRATEGY:: AA GLN CHI 2 EX_SIX_QUARTER_STEP_STDDEVS CHI_STRATEGY:: AA ASN CHI 2 EX_ONE_STDDEV

# Everything below: additional chi sample strategies unique to the matcher.

CHI_STRATEGY:: CHI 1 STEP_WITHIN_SD_RANGE STEP 3.0 # the above line says "step by 3 degrees within a single standard deviation # to the left and right of the mean for chi 1"

CHI_STRATEGY:: CHI 1 STEP_WITHIN_SD_RANGE STEP 3.0 SD_RANGE 2.5 # the above line says "step by 3 degrees within 2.5 standard deviations to # the left and the right of the mean for chi 1"

CHI_STRATEGY:: CHI 2 AA HIS NON_ROTAMERIC_CHI_EXPANSION N_SAMPLES 3 REQUISIT_PROBABILITY 0.10 # the line above says that "for histidine chi 2 (which is non-rotameric in the 2008 Dunbrak library) # take 3 extra samples to the left and right of the median chi value inside the non-rotameric chi well # for rotamer wells that have a probability at least 0.1". The 2008 Dunbrack library must be active. # (the -dun08 flag should be on the command line).

CHI_STRATEGY:: CHI 2 AA HIS NON_ROTAMERIC_CHI_EXPANSION N_SAMPLES 3 # the line above is similar for the previous command, but leaves off the REQUISIT_PROBABILITY # which sets a default REQUISIT_PROBABILITY of 2 / #chi-bins. For HIS, this is # 2 / 36th, since there are 12 bins for chi 2 and 3 bins for chi1 (36 chi bins total).

ALGORITHM_INFO::END

References core::chemical::aa_from_name(), add_external_geometry_samples_for_constraint(), add_secondary_downstream_match_geometry_for_constraint(), add_secondary_upstream_match_geometry_for_constraint(), add_upstream_restype_for_constraint(), protocols::match::MatcherTask::enumerate_ligand_rotamers(), core::pack::dunbrack::RotamerLibrary::get_instance(), core::pack::dunbrack::RotamerLibrary::get_rsd_library(), core::pack::task::is_rot_sample_name(), protocols::toolbox::match_enzdes_util::EnzConstraintIO::mcfi_list(), protocols::toolbox::match_enzdes_util::EnzConstraintIO::mcfi_lists_size(), make_table_of_pilot_apps::name, protocols::match::upstream::no_samples, protocols::match::upstream::nonrotameric_chi_sample_wi_nrchi_bin, core::pack::task::rot_sample_from_name(), protocols::match::upstream::rotameric_chi_mimic_EX_flags, protocols::match::upstream::rotameric_chi_step_wi_sd_range, set_fa_dun_cutoff_for_constraint(), set_n_geometric_constraints(), protocols::match::upstream::SampleStrategyData::set_sample_level(), set_sample_startegy_for_constraint(), protocols::match::upstream::SampleStrategyData::set_sd_range(), protocols::match::upstream::SampleStrategyData::set_step_size(), protocols::match::upstream::SampleStrategyData::set_strategy(), and protocols::match::TR().

Referenced by initialize_from_task().

void protocols::match::Matcher::initialize_from_task ( MatcherTask const &  task)

The primary way to initialize a Matcher is through a MatcherTask.

References protocols::match::MatcherTask::consolidate_matches(), protocols::match::MatcherTask::define_match_by_single_downstream_positioning(), protocols::match::MatcherTask::downstream_atoms_required_inside_active_site(), protocols::match::MatcherTask::downstream_orientation_atoms(), protocols::match::MatcherTask::downstream_pose(), protocols::match::MatcherTask::dynamic_grid_refinement(), protocols::match::MatcherTask::enz_input_data(), protocols::match::MatcherTask::euclidean_bin_widths(), protocols::match::MatcherTask::euler_bin_widths(), protocols::match::MatcherTask::geom_csts_downstream_output(), protocols::match::MatcherTask::gridlig_active_site_definition(), protocols::match::MatcherTask::gridlig_file_name(), initialize_from_file(), protocols::match::MatcherTask::occ_space_bounding_box(), protocols::match::MatcherTask::only_enumerate_non_match_redundant_ligand_rotamers(), protocols::match::MatcherTask::permitted_overlap(), protocols::match::MatcherTask::relevant_downstream_atoms(), set_bump_tolerance(), set_downstream_pose(), set_hash_euclidean_bin_widths(), set_hash_euler_bin_widths(), set_occupied_space_bounding_box(), set_original_scaffold_build_points_for_constraint(), set_upstream_pose(), protocols::match::MatcherTask::upstream_pose(), protocols::match::MatcherTask::upstream_pose_build_resids_for_geometric_constraint(), protocols::match::MatcherTask::upstream_resids_and_radii_defining_active_site(), and protocols::match::MatcherTask::use_input_sc().

Size protocols::match::Matcher::n_geometric_constraints ( ) const [inline]
std::list< downstream::DownstreamAlgorithmOP > const & protocols::match::Matcher::nonconst_downstream_algorithms ( Size  cst_id)

Non-const access to the set of downstream algorithms for a particular geometric constraint -- note that the list containing these algorithms is itself const.

OccupiedSpaceHashCOP protocols::match::Matcher::occ_space_hash ( ) const
OccupiedSpaceHashOP protocols::match::Matcher::occ_space_hash ( )
utility::vector1< upstream::ScaffoldBuildPointCOP > const & protocols::match::Matcher::per_constraint_build_points ( Size  cst_id) const
void protocols::match::Matcher::process_matches ( output::MatchProcessor processor) const

After find_hits completes, use this function to have the Matcher enerate the hit-combinations (matches) and send those matches to the specified match-processor. The match processor may do what it pleases with the matches.

References protocols::match::output::MatchProcessor::begin_processing(), protocols::match::output::MatchProcessor::end_processing(), and protocols::match::TR().

downstream::DownstreamAlgorithmCOP protocols::match::Matcher::representative_downstream_algorithm ( Size  cst_id) const
void protocols::match::Matcher::set_bump_tolerance ( Real  permitted_overlap)
void protocols::match::Matcher::set_downstream_pose ( core::pose::Pose const &  pose,
utility::vector1< core::id::AtomID orientation_atoms 
)

Referenced by initialize_from_task().

void protocols::match::Matcher::set_fa_dun_cutoff_for_constraint ( Size  cst_id,
core::chemical::ResidueTypeCAP  restype,
core::Real  fa_dun_cutoff 
)
void protocols::match::Matcher::set_hash_euclidean_bin_width ( Real  width)
void protocols::match::Matcher::set_hash_euclidean_bin_widths ( Vector  widths)

Referenced by initialize_from_task().

void protocols::match::Matcher::set_hash_euler_bin_width ( Real  width)
void protocols::match::Matcher::set_hash_euler_bin_widths ( Vector  widths)

Referenced by initialize_from_task().

void protocols::match::Matcher::set_n_geometric_constraints ( Size  n_constraints)

Referenced by initialize_from_file().

void protocols::match::Matcher::set_occupied_space_bounding_box ( BoundingBox const &  bb)

References protocols::match::TR().

Referenced by initialize_from_task().

void protocols::match::Matcher::set_original_scaffold_build_points ( utility::vector1< Size > const &  resids)
void protocols::match::Matcher::set_original_scaffold_build_points_for_constraint ( Size  cst_id,
utility::vector1< Size > const &  resids 
)
void protocols::match::Matcher::set_sample_startegy_for_constraint ( Size  cst_id,
core::chemical::ResidueTypeCAP  restype,
Size  chi,
upstream::SampleStrategyData const &  strat 
)
void protocols::match::Matcher::set_upstream_pose ( core::pose::Pose const &  pose)

Setup.

Referenced by initialize_from_task().

upstream::UpstreamBuilderCOP protocols::match::Matcher::upstream_builder ( Size  cst_id) const
upstream::UpstreamBuilderOP protocols::match::Matcher::upstream_builder ( Size  cst_id)
core::pose::PoseCOP protocols::match::Matcher::upstream_pose ( ) const

Data accessors.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines