Rosetta  2020.37
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
protocols::match::Matcher Class Reference

#include <Matcher.hh>

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

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. More...
 
 ~Matcher () override
 
void set_upstream_pose (core::pose::Pose const &pose)
 Setup. More...
 
void set_downstream_pose (core::pose::Pose const &pose, utility::vector1< core::id::AtomID > orientation_atoms)
 
void set_original_scaffold_build_points (utility::vector1< core::Size > const &resids)
 
void set_original_scaffold_build_points_for_constraint (core::Size cst_id, utility::vector1< core::Size > const &resids)
 
void set_n_geometric_constraints (core::Size n_constraints)
 
core::Size n_geometric_constraints () const
 
void add_upstream_restype_for_constraint (core::Size cst_id, core::chemical::ResidueTypeCOP restype)
 
void desymmeterize_upstream_restype_for_constraint (core::Size cst_id)
 
void set_sample_startegy_for_constraint (core::Size cst_id, core::chemical::ResidueTypeCOP restype, core::Size chi, upstream::SampleStrategyData const &strat)
 
void set_fa_dun_cutoff_for_constraint (core::Size cst_id, core::chemical::ResidueTypeCOP restype, core::Real fa_dun_cutoff)
 
void add_external_geometry_samples_for_constraint (core::Size cst_id, core::chemical::ResidueTypeCOP restype, utility::vector1< std::string > const &upstream_launch_atoms, utility::vector1< core::id::AtomID > const &downstream_3atoms, utility::vector1< toolbox::match_enzdes_util::ExternalGeomSampler > const &exgeom_list, core::Size const exgeom_id, bool enumerate_ligand_rotamers=false, bool catalytic_bond=false, bool build_round1_hits_twice=false)
 
void add_secondary_upstream_match_geometry_for_constraint (core::Size geom_cst_id, core::Size target_geom_cst_id, core::chemical::ResidueTypeCOP candidate_restype, core::chemical::ResidueTypeCOP target_restype, utility::vector1< core::Size > const &candidate_atids, utility::vector1< core::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 (core::Size geom_cst_id, core::chemical::ResidueTypeCOP candidate_restype, core::chemical::ResidueTypeCOP downstream_restype, utility::vector1< core::Size > const &candidate_atids, utility::vector1< core::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. More...
 
void initialize_from_file (toolbox::match_enzdes_util::EnzConstraintIO const &enz_data, MatcherTask const &task)
 Intialize the geometric constraints from the EnzConstraionIO object. More...
 
bool find_hits ()
 Main worker function. More...
 
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. More...
 
core::pose::PoseCOP upstream_pose () const
 Data accessors. More...
 
core::pose::PoseCOP downstream_pose () const
 
upstream::ScaffoldBuildPointCOP build_point (core::Size index) const
 
upstream::UpstreamBuilderCOP upstream_builder (core::Size cst_id) const
 
utility::vector1< core::Size >
const & 
get_pose_build_resids () const
 
downstream::DownstreamBuilderCOP downstream_builder (core::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. More...
 
std::list
< downstream::DownstreamAlgorithmCOP
downstream_algorithms (core::Size cst_id) const
 
downstream::DownstreamAlgorithmCOP representative_downstream_algorithm (core::Size cst_id) const
 
HitList const & hits (core::Size cst_id) const
 
OccupiedSpaceHashCOP occ_space_hash () const
 
utility::vector1
< upstream::ScaffoldBuildPointCOP >
const & 
per_constraint_build_points (core::Size cst_id) const
 
upstream::ScaffoldBuildPointOP build_point (core::Size index)
 Non-const access. More...
 
upstream::UpstreamBuilderOP upstream_builder (core::Size cst_id)
 
bool has_upstream_only_geomcsts () const
 
downstream::DownstreamBuilderOP downstream_builder (core::Size)
 Return non-const access to a representative downstream builder for a particular geometric constraint. More...
 
std::list
< downstream::DownstreamBuilderOP >
const & 
downstream_builders (core::Size cst_id) const
 Return non-const access to all of the downstream builders for a particular geometric constraint. More...
 
std::list
< downstream::DownstreamAlgorithmOP >
const & 
nonconst_downstream_algorithms (core::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. More...
 
OccupiedSpaceHashOP occ_space_hash ()
 
HitListIterator hit_list_begin (core::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. More...
 
HitListIterator hit_list_end (core::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() More...
 
void erase_hit (downstream::DownstreamAlgorithm const &dsalg, core::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. More...
 

Private Member Functions

bool generate_hits ()
 
void prepare_for_hit_generation_for_constraint (core::Size cst_id)
 
void generate_hits_for_constraint (core::Size cst_id)
 
void regenerate_round1_hits ()
 
bool finish_hit_generation_for_constraint (core::Size cst_id)
 
bool initialize_scaffold_build_points ()
 
void initialize_bump_grids ()
 
void initialize_active_site_grid ()
 
void initialize_occupied_space_hash ()
 
void initialize_downstream_algorithms ()
 
downstream::DownstreamBuilderOP create_ds_builder (core::Size const cst_id, core::chemical::ResidueTypeCOP restype, utility::vector1< std::string > const &upstream_launch_atoms, utility::vector1< core::id::AtomID > const &downstream_3atoms, bool enumerate_ligand_rotamers, bool catalytic_bond)
 
void select_hit_representatives (utility::vector1< utility::vector1< Hit const * > > const &hit_vectors, utility::vector1< core::Size > &n_hits_per_geomcst, utility::vector1< utility::vector1< core::Size > > &reps) const
 Selects a subset of all possible hit combinations (e.g. by clustering hits) for a particular bin. Useful if there are too many matches found. More...
 
bool check_non_upstream_only_hit_incompatibility (match_dspos1 const &m1, utility::LexicographicalIterator &lex, output::MatchProcessor const &processor) const
 Returns false if all non-upstream-only hits are compatible. Returns true if any non-upstream-only hits are incompatible, and increments the lexicographical iterator at the most-significant dimension possible. More...
 
bool check_downstream_hit_incompatibility (match const &m, utility::LexicographicalIterator &lex) const
 very similar to above function, the difference being that in checks whether all the downstream builders agree that their hits are compatible with each other flo sep'13 there was a problem with this in that for secondary downstream matching the mather doesn't have downstream builders i.e., compatibility can't be checked. bugfix is to also as the downstream algorithm for its dsbuilder another potential fix could be to set the dsbuilders in the matcher itself when the algorithms are created, but i'm not sure if this would interfere with other things? More...
 
bool test_upstream_only_hit_incompatibility (match const &m, utility::vector1< HitPtrListCOP > const &upstream_only_hits, utility::vector1< std::list< Hit const * >::const_iterator > &upstream_only_hit_iterators, core::Size &last_upstream_only_geomcst_advanced, output::MatchProcessor const &processor) const
 
bool test_upstream_only_hit_incompatibility (match_dspos1 const &m1, utility::vector1< HitPtrListCOP > const &upstream_only_hits, utility::vector1< std::list< Hit const * >::const_iterator > &upstream_only_hit_iterators, core::Size &last_upstream_only_geomcst_advanced, output::MatchProcessor const &processor) const
 
bool increment_upstream_only_hit_combination (utility::vector1< HitPtrListCOP > const &upstream_only_hits, core::Size starting_point, utility::vector1< std::list< Hit const * >::const_iterator > &upstream_only_hit_iterators, core::Size &last_upstream_only_geomcst_advanced) const
 
void process_matches_main_loop_enumerating_all_hit_combos (output::MatchProcessor &processor) const
 
utility::vector1< std::list
< Hit const * > > 
refine_grid_and_subsample_for_hit_subsets (Vector &good_euclidean_bin_widths, Vector &good_euler_bin_widths, utility::vector1< std::list< Hit const * > > const &neighbor_hits) const
 
utility::vector1< std::list
< Hit const * > > 
subsample_hits (Vector const &euclidean_bin_widths, Vector const &euler_bin_widths, utility::vector1< std::list< Hit const * > > const &neighbor_hits) const
 
core::Size estimate_n_matches_for_hit_subsets (Vector const &euclidean_bin_widths, Vector const &euler_bin_widths, utility::vector1< std::list< Hit const * > > const &neighbor_hits, core::Size accuracy_threshold) const
 
MatcherOutputStats process_matches_all_hit_combos_for_hit_subsets (output::MatchProcessor &processor, HitHasher &hit_hasher, utility::vector1< std::list< Hit const * > > const &neighbor_hits) const
 
void process_matches_where_one_geomcst_defines_downstream_location (output::MatchProcessor &processor) const
 
void note_primary_change_to_geom_csts_hitlist (core::Size geom_cst_id)
 Note that a change has occurred for a particular hit list. More...
 
 Matcher (Matcher const &)
 uncopyable – unimplemented More...
 
Matcher const & operator= (Matcher const &rhs)
 

Private Attributes

core::pose::PoseOP upstream_pose_
 
core::pose::PoseOP downstream_pose_
 
utility::vector1
< core::id::AtomID
downstream_orientation_atoms_
 
bool same_build_resids_for_all_csts_
 
utility::vector1< core::Sizepose_build_resids_
 
utility::vector1
< utility::vector1< core::Size > > 
per_cst_build_resids_
 
utility::vector1
< upstream::ScaffoldBuildPointOP
all_build_points_
 
utility::vector1
< utility::vector1
< upstream::ScaffoldBuildPointCOP > > 
per_constraint_build_points_
 
core::Size n_geometric_constraints_
 
utility::vector1< HitListhits_
 
utility::vector1
< upstream::UpstreamBuilderOP
upstream_builders_
 
utility::vector1< std::map
< std::string, core::Size > > 
build_set_id_for_restype_
 
utility::vector1
< downstream::DownstreamAlgorithmOP
representative_downstream_algorithm_
 
utility::vector1< std::list
< downstream::DownstreamAlgorithmOP > > 
downstream_algorithms_
 
utility::vector1< boolgeomcst_is_upstream_only_
 
std::list< core::Sizegeom_csts_with_primary_hitlist_modificiations_
 
utility::vector1< boolgeom_cst_has_primary_modification_
 
utility::vector1< std::list
< downstream::DownstreamBuilderOP > > 
downstream_builders_
 
std::list
< downstream::DownstreamBuilderOP
all_downstream_builders_
 
std::list
< downstream::DownstreamAlgorithmOP
all_downstream_algorithms_
 
BumpGridOP bb_grid_
 
utility::vector1< BumpGridOPoriginal_scaffold_residue_bump_grids_
 
BoundingBox occ_space_bounding_box_
 
Vector euclidean_bin_widths_
 
Vector euler_bin_widths_
 
OccupiedSpaceHashOP occ_space_hash_
 
downstream::ActiveSiteGridOP active_site_grid_
 
bool read_gridlig_file_
 
std::string gridlig_fname_
 
std::list< std::pair
< core::Size, Real > > 
upstream_resids_and_radii_defining_active_site_
 
std::list< core::id::AtomIDdownstream_atoms_required_inside_active_site_
 
utility::vector1
< core::id::AtomID
relevant_downstream_atoms_
 
bool use_input_sc_
 
bool dynamic_grid_refinement_
 
bool output_matches_as_singular_downstream_positioning_
 
bool check_potential_dsbuilder_incompatibility_
 
utility::vector1< booloutput_match_dspos1_for_geomcst_
 
bool build_round1_hits_twice_
 

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,

  1. 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.

References relevant_downstream_atoms_.

protocols::match::Matcher::~Matcher ( )
overridedefault
protocols::match::Matcher::Matcher ( Matcher const &  )
private

uncopyable – unimplemented

Member Function Documentation

void protocols::match::Matcher::add_external_geometry_samples_for_constraint ( core::Size  cst_id,
core::chemical::ResidueTypeCOP  restype,
utility::vector1< std::string > const &  upstream_launch_atoms,
utility::vector1< core::id::AtomID > const &  downstream_3atoms,
utility::vector1< toolbox::match_enzdes_util::ExternalGeomSampler > const &  exgeom_list,
core::Size const  exgeom_id,
bool  enumerate_ligand_rotamers = false,
bool  catalytic_bond = false,
bool  build_round1_hits_twice = false 
)
void protocols::match::Matcher::add_secondary_downstream_match_geometry_for_constraint ( core::Size  geom_cst_id,
core::chemical::ResidueTypeCOP  candidate_restype,
core::chemical::ResidueTypeCOP  downstream_restype,
utility::vector1< core::Size > const &  candidate_atids,
utility::vector1< core::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 ( core::Size  geom_cst_id,
core::Size  target_geom_cst_id,
core::chemical::ResidueTypeCOP  candidate_restype,
core::chemical::ResidueTypeCOP  target_restype,
utility::vector1< core::Size > const &  candidate_atids,
utility::vector1< core::Size > const &  target_atids,
toolbox::match_enzdes_util::MatchConstraintFileInfoCOP  mcfi,
std::string  sec_match_str,
core::pose::Pose const &  upstream_pose 
)

Initialize a secondary matcher object based on the geometry from the upstream to the downstream residue types.

References all_downstream_algorithms_, build_set_id_for_restype_, downstream_algorithms_, core::sequence::end, representative_downstream_algorithm_, and upstream_builders_.

Referenced by initialize_from_file().

void protocols::match::Matcher::add_upstream_restype_for_constraint ( core::Size  cst_id,
core::chemical::ResidueTypeCOP  restype 
)
upstream::ScaffoldBuildPointCOP protocols::match::Matcher::build_point ( core::Size  index) const

References all_build_points_.

Referenced by subsample_hits().

upstream::ScaffoldBuildPointOP protocols::match::Matcher::build_point ( core::Size  index)

Non-const access.

References all_build_points_.

bool protocols::match::Matcher::check_downstream_hit_incompatibility ( match const &  m,
utility::LexicographicalIterator &  lex 
) const
private

very similar to above function, the difference being that in checks whether all the downstream builders agree that their hits are compatible with each other flo sep'13 there was a problem with this in that for secondary downstream matching the mather doesn't have downstream builders i.e., compatibility can't be checked. bugfix is to also as the downstream algorithm for its dsbuilder another potential fix could be to set the dsbuilders in the matcher itself when the algorithms are created, but i'm not sure if this would interfere with other things?

References downstream_builders_, geomcst_is_upstream_only_, n_geometric_constraints_, and representative_downstream_algorithm_.

Referenced by process_matches_all_hit_combos_for_hit_subsets().

bool protocols::match::Matcher::check_non_upstream_only_hit_incompatibility ( match_dspos1 const &  m1,
utility::LexicographicalIterator &  lex,
output::MatchProcessor const &  processor 
) const
private

Returns false if all non-upstream-only hits are compatible. Returns true if any non-upstream-only hits are incompatible, and increments the lexicographical iterator at the most-significant dimension possible.

References all_build_points_, protocols::match::fake_hit(), geomcst_is_upstream_only_, n_geometric_constraints_, protocols::match::output::MatchProcessor::up_coll_filt(), upstream_builders_, and protocols::match::match_dspos1::upstream_hits.

Referenced by process_matches_all_hit_combos_for_hit_subsets(), and process_matches_where_one_geomcst_defines_downstream_location().

downstream::DownstreamBuilderOP protocols::match::Matcher::create_ds_builder ( core::Size const  cst_id,
core::chemical::ResidueTypeCOP  restype,
utility::vector1< std::string > const &  upstream_launch_atoms,
utility::vector1< core::id::AtomID > const &  downstream_3atoms,
bool  enumerate_ligand_rotamers,
bool  catalytic_bond 
)
private
void protocols::match::Matcher::desymmeterize_upstream_restype_for_constraint ( core::Size  cst_id)
std::list< downstream::DownstreamAlgorithmCOP > protocols::match::Matcher::downstream_algorithms ( core::Size  cst_id) const
downstream::DownstreamBuilderCOP protocols::match::Matcher::downstream_builder ( core::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.

References downstream_builders_.

Referenced by protocols::match::downstream::SecondaryMatcherToDownstreamResidue::prepare_for_hit_generation_for_geomcst(), and process_matches().

downstream::DownstreamBuilderOP protocols::match::Matcher::downstream_builder ( core::Size  cst_id)

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

References downstream_builders_.

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

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

References downstream_builders_.

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

core::pose::PoseCOP protocols::match::Matcher::downstream_pose ( ) const

References downstream_pose_.

void protocols::match::Matcher::erase_hit ( downstream::DownstreamAlgorithm const &  dsalg,
core::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(), hits_, and note_primary_change_to_geom_csts_hitlist().

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

Matcher::Size protocols::match::Matcher::estimate_n_matches_for_hit_subsets ( Vector const &  euclidean_bin_widths,
Vector const &  euler_bin_widths,
utility::vector1< std::list< Hit const * > > const &  neighbor_hits,
core::Size  accuracy_threshold 
) const
private
bool protocols::match::Matcher::find_hits ( )
bool protocols::match::Matcher::finish_hit_generation_for_constraint ( core::Size  cst_id)
private
bool protocols::match::Matcher::generate_hits ( )
private
void protocols::match::Matcher::generate_hits_for_constraint ( core::Size  cst_id)
private
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 ( core::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.

References hits_.

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

Matcher::HitListIterator protocols::match::Matcher::hit_list_end ( core::Size  geom_cst_id)
Matcher::HitList const & protocols::match::Matcher::hits ( core::Size  cst_id) const
bool protocols::match::Matcher::increment_upstream_only_hit_combination ( utility::vector1< HitPtrListCOP > const &  upstream_only_hits,
core::Size  starting_point,
utility::vector1< std::list< Hit const * >::const_iterator > &  upstream_only_hit_iterators,
core::Size last_upstream_only_geomcst_advanced 
) const
private

returns true if more upstream-only hit combinations remain, and false if there are no upstream-only hit cominbations remaining

References core::sequence::end, geomcst_is_upstream_only_, and protocols::hybridization::val.

Referenced by process_matches_all_hit_combos_for_hit_subsets(), and process_matches_where_one_geomcst_defines_downstream_location().

void protocols::match::Matcher::initialize_active_site_grid ( )
private
void protocols::match::Matcher::initialize_bump_grids ( )
private
void protocols::match::Matcher::initialize_downstream_algorithms ( )
private
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</h1> <h1>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</h1> <h1>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 2010 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 2010 Dunbrack library must be active.

(the -dun10 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).

#or DESYMMETERIZE

the line above instructs the DunbrackSCSampler to expand the sampling for the symmetric amino acids

around the final (symmetric) chi angle for ASP/GLU/PHE/TYR. For example, it would treat ASP's sampling

as if there's a difference between OD1 and OD2.

ALGORITHM_INFO::END

References protocols::cluster::calibur::aa, 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::build_round1_hits_twice(), desymmeterize_upstream_restype_for_constraint(), downstream_pose_, protocols::match::MatcherTask::enumerate_ligand_rotamers(), core::pack::rotamers::SingleResidueRotamerLibraryFactory::get(), core::pack::task::is_rot_sample_name(), protocols::toolbox::match_enzdes_util::EnzConstraintIO::mcfi_list(), protocols::toolbox::match_enzdes_util::EnzConstraintIO::mcfi_lists_size(), n_geometric_constraints_, protocols::match::upstream::no_samples, protocols::match::upstream::nonrotameric_chi_sample_wi_nrchi_bin, protocols::sic_dock::range(), 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(), core::id::to_string(), protocols::match::TR(), and upstream_pose_.

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::build_round1_hits_twice(), build_round1_hits_twice_, protocols::match::MatcherTask::consolidate_matches(), protocols::match::MatcherTask::define_match_by_single_downstream_positioning(), protocols::match::MatcherTask::downstream_atoms_required_inside_active_site(), downstream_atoms_required_inside_active_site_, protocols::match::MatcherTask::downstream_orientation_atoms(), protocols::match::MatcherTask::downstream_pose(), protocols::match::MatcherTask::dynamic_grid_refinement(), 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(), gridlig_fname_, initialize_from_file(), n_geometric_constraints_, protocols::match::MatcherTask::occ_space_bounding_box(), protocols::match::MatcherTask::only_enumerate_non_match_redundant_ligand_rotamers(), output_match_dspos1_for_geomcst_, output_matches_as_singular_downstream_positioning_, protocols::match::MatcherTask::permitted_overlap(), read_gridlig_file_, protocols::match::MatcherTask::relevant_downstream_atoms(), 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(), upstream_builders_, 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(), upstream_resids_and_radii_defining_active_site_, protocols::match::MatcherTask::use_input_sc(), and use_input_sc_.

void protocols::match::Matcher::initialize_occupied_space_hash ( )
private
bool protocols::match::Matcher::initialize_scaffold_build_points ( )
private

this function returns false in case there are no build points for a certain cst. this can happen if MPMs in the MatcherTask ruled out all user defined build points

References all_build_points_, per_cst_build_resids_, pose_build_resids_, same_build_resids_for_all_csts_, protocols::match::TR(), and upstream_pose_.

Referenced by find_hits().

core::Size protocols::match::Matcher::n_geometric_constraints ( ) const
inline
std::list< downstream::DownstreamAlgorithmOP > const & protocols::match::Matcher::nonconst_downstream_algorithms ( core::Size  cst_id)
void protocols::match::Matcher::note_primary_change_to_geom_csts_hitlist ( core::Size  geom_cst_id)
private

Note that a change has occurred for a particular hit list.

References geom_cst_has_primary_modification_, and geom_csts_with_primary_hitlist_modificiations_.

Referenced by erase_hit(), and generate_hits_for_constraint().

OccupiedSpaceHashCOP protocols::match::Matcher::occ_space_hash ( ) const
OccupiedSpaceHashOP protocols::match::Matcher::occ_space_hash ( )

References occ_space_hash_.

Matcher const& protocols::match::Matcher::operator= ( Matcher const &  rhs)
private
utility::vector1< upstream::ScaffoldBuildPointCOP > const & protocols::match::Matcher::per_constraint_build_points ( core::Size  cst_id) const
void protocols::match::Matcher::prepare_for_hit_generation_for_constraint ( core::Size  cst_id)
private

Update the per_constraint_build_points_ array for the given constraint before beginning hit generation. This follows one of two paths depending on whether same_build_resids_for_all_csts_ is active or not. I cannot see any reason that this function could not be called earlier than immediately before hit generation for a particular constraint.

References all_build_points_, per_constraint_build_points_, per_cst_build_resids_, pose_build_resids_, and same_build_resids_for_all_csts_.

Referenced by generate_hits().

void protocols::match::Matcher::process_matches ( output::MatchProcessor processor) const
MatcherOutputStats protocols::match::Matcher::process_matches_all_hit_combos_for_hit_subsets ( output::MatchProcessor processor,
HitHasher hit_hasher,
utility::vector1< std::list< Hit const * > > const &  neighbor_hits 
) const
private

This loop iterates across all 64 origin definitions (loop "ii"), inserts the "neighbor hits" into each of the hashes. It then iterates across all the bins in the hash map (loop "iter"), and then enumerates all combinations of hits (loop "lex") for the non-upstream-only geometric constraints. For each combination of hits (a partial match if there are any upstream-only geometric constraints), it then retrieves all upstream-only hits, and iterates across all cominbations of upstream-only hits for this match (loop "true"). Then, for every fully-constructed match,

References protocols::match::MatcherOutputStats::all_lex_states, protocols::match::HitHasher::binner(), check_downstream_hit_incompatibility(), check_non_upstream_only_hit_incompatibility(), check_potential_dsbuilder_incompatibility_, protocols::match::HitHasher::clear_hash_map(), core::sequence::end, geomcst_is_upstream_only_, protocols::match::HitHasher::hit_hash_begin(), protocols::match::HitHasher::hit_hash_end(), increment_upstream_only_hit_combination(), protocols::match::HitHasher::insert_hit(), n_geometric_constraints_, protocols::match::MatcherOutputStats::num_ds_hit_incompatible, protocols::match::MatcherOutputStats::num_empty_uplist, protocols::match::MatcherOutputStats::num_non_up_only_incompatible, protocols::match::MatcherOutputStats::num_potential_matches, protocols::match::MatcherOutputStats::num_sent_to_proc, protocols::match::MatcherOutputStats::num_up_only_incompatible, protocols::match::output::MatchProcessor::process_match(), representative_downstream_algorithm_, select_hit_representatives(), test_upstream_only_hit_incompatibility(), protocols::match::TR(), and protocols::match::match_dspos1::upstream_hits.

Referenced by process_matches_main_loop_enumerating_all_hit_combos().

void protocols::match::Matcher::process_matches_main_loop_enumerating_all_hit_combos ( output::MatchProcessor processor) const
private
void protocols::match::Matcher::process_matches_where_one_geomcst_defines_downstream_location ( output::MatchProcessor processor) const
private
utility::vector1< std::list< Hit const * > > protocols::match::Matcher::refine_grid_and_subsample_for_hit_subsets ( Vector good_euclidean_bin_widths,
Vector good_euler_bin_widths,
utility::vector1< std::list< Hit const * > > const &  neighbor_hits 
) const
private
void protocols::match::Matcher::regenerate_round1_hits ( )
private

just like generate_hits_for_constraint, but without calling not_primary_change_to_geom_csts_hitlist. Used with the "build round-1 hits twice" scheme.

References core::sequence::end, hits(), hits_, and representative_downstream_algorithm_.

Referenced by finish_hit_generation_for_constraint().

downstream::DownstreamAlgorithmCOP protocols::match::Matcher::representative_downstream_algorithm ( core::Size  cst_id) const
void protocols::match::Matcher::select_hit_representatives ( utility::vector1< utility::vector1< Hit const * > > const &  hit_vectors,
utility::vector1< core::Size > &  n_hits_per_geomcst,
utility::vector1< utility::vector1< core::Size > > &  reps 
) const
private

Selects a subset of all possible hit combinations (e.g. by clustering hits) for a particular bin. Useful if there are too many matches found.

Subsample all the available hits for a single voxel in 6D to select 10 or fewer hits for each geometric constraint. If there are already 10 or fewer hits for geom-cst ii, then it takes them all. Otherwise, it selects 10 representatives for each upstream conformation. For example, if all the hits in this voxel come from a single rotamer of the upsteram hit, then exactly 10 upstream hits will be chosen. The purpose of this code is to speed up match enumeration when it might otherwise get very bogged down by the combinatorics

References dynamic_grid_refinement_, n_geometric_constraints_, and core::scoring::pair.

Referenced by process_matches_all_hit_combos_for_hit_subsets().

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 
)
void protocols::match::Matcher::set_fa_dun_cutoff_for_constraint ( core::Size  cst_id,
core::chemical::ResidueTypeCOP  restype,
core::Real  fa_dun_cutoff 
)
void protocols::match::Matcher::set_hash_euclidean_bin_width ( Real  width)

References euclidean_bin_widths_.

void protocols::match::Matcher::set_hash_euclidean_bin_widths ( Vector  widths)

References euclidean_bin_widths_.

Referenced by initialize_from_task().

void protocols::match::Matcher::set_hash_euler_bin_width ( Real  width)

References euler_bin_widths_.

void protocols::match::Matcher::set_hash_euler_bin_widths ( Vector  widths)

References euler_bin_widths_.

Referenced by initialize_from_task().

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

Setup.

References upstream_pose_.

Referenced by initialize_from_task().

utility::vector1< std::list< Hit const * > > protocols::match::Matcher::subsample_hits ( Vector const &  euclidean_bin_widths,
Vector const &  euler_bin_widths,
utility::vector1< std::list< Hit const * > > const &  neighbor_hits 
) const
private
bool protocols::match::Matcher::test_upstream_only_hit_incompatibility ( match const &  m,
utility::vector1< HitPtrListCOP > const &  upstream_only_hits,
utility::vector1< std::list< Hit const * >::const_iterator > &  upstream_only_hit_iterators,
core::Size last_upstream_only_geomcst_advanced,
output::MatchProcessor const &  processor 
) const
private

returns false if all upstream-only hits in a particular combination are compatible with each other and with the non-upstream-only hits. Returns true if any are incompatible. Ignores compatibility between non-upstream-only hits. If there is an incompatibility, the upstream_only_hit_iterators are advanced. In the event that this increment beyond the incompatible upstream-only-hit combinations advance the most-significant upstream-only geometric-constraint's iterator to its list end, then this function sets the value of last_upstream_only_geomcst_advanced to zero. update flo nov 10: this function now also checks whether upstream only csts clash with any of the downstream objects. it's faster to do this here than in the filters

References all_build_points_, geomcst_is_upstream_only_, n_geometric_constraints_, representative_downstream_algorithm_, protocols::match::output::MatchProcessor::up_coll_filt(), protocols::match::output::MatchProcessor::up_down_filt(), upstream_builders_, and protocols::hybridization::val.

Referenced by process_matches_all_hit_combos_for_hit_subsets(), and process_matches_where_one_geomcst_defines_downstream_location().

bool protocols::match::Matcher::test_upstream_only_hit_incompatibility ( match_dspos1 const &  m1,
utility::vector1< HitPtrListCOP > const &  upstream_only_hits,
utility::vector1< std::list< Hit const * >::const_iterator > &  upstream_only_hit_iterators,
core::Size last_upstream_only_geomcst_advanced,
output::MatchProcessor const &  processor 
) const
private
upstream::UpstreamBuilderCOP protocols::match::Matcher::upstream_builder ( core::Size  cst_id) const
upstream::UpstreamBuilderOP protocols::match::Matcher::upstream_builder ( core::Size  cst_id)

References upstream_builders_.

core::pose::PoseCOP protocols::match::Matcher::upstream_pose ( ) const

Data accessors.

References upstream_pose_.

Member Data Documentation

downstream::ActiveSiteGridOP protocols::match::Matcher::active_site_grid_
private
utility::vector1< upstream::ScaffoldBuildPointOP > protocols::match::Matcher::all_build_points_
private
std::list< downstream::DownstreamAlgorithmOP > protocols::match::Matcher::all_downstream_algorithms_
private
std::list< downstream::DownstreamBuilderOP > protocols::match::Matcher::all_downstream_builders_
private
BumpGridOP protocols::match::Matcher::bb_grid_
private
bool protocols::match::Matcher::build_round1_hits_twice_
private
utility::vector1< std::map< std::string, core::Size > > protocols::match::Matcher::build_set_id_for_restype_
private
bool protocols::match::Matcher::check_potential_dsbuilder_incompatibility_
mutableprivate
utility::vector1< std::list< downstream::DownstreamAlgorithmOP > > protocols::match::Matcher::downstream_algorithms_
private
std::list< core::id::AtomID > protocols::match::Matcher::downstream_atoms_required_inside_active_site_
private
utility::vector1< std::list< downstream::DownstreamBuilderOP > > protocols::match::Matcher::downstream_builders_
private
utility::vector1< core::id::AtomID > protocols::match::Matcher::downstream_orientation_atoms_
private
core::pose::PoseOP protocols::match::Matcher::downstream_pose_
private
bool protocols::match::Matcher::dynamic_grid_refinement_
private
Vector protocols::match::Matcher::euclidean_bin_widths_
private
Vector protocols::match::Matcher::euler_bin_widths_
private
utility::vector1< bool > protocols::match::Matcher::geom_cst_has_primary_modification_
private
std::list< core::Size > protocols::match::Matcher::geom_csts_with_primary_hitlist_modificiations_
private
utility::vector1< bool > protocols::match::Matcher::geomcst_is_upstream_only_
private
std::string protocols::match::Matcher::gridlig_fname_
private
utility::vector1< HitList > protocols::match::Matcher::hits_
private
core::Size protocols::match::Matcher::n_geometric_constraints_
private
BoundingBox protocols::match::Matcher::occ_space_bounding_box_
private
OccupiedSpaceHashOP protocols::match::Matcher::occ_space_hash_
private
utility::vector1< BumpGridOP > protocols::match::Matcher::original_scaffold_residue_bump_grids_
private

Referenced by initialize_bump_grids().

utility::vector1< bool > protocols::match::Matcher::output_match_dspos1_for_geomcst_
private
bool protocols::match::Matcher::output_matches_as_singular_downstream_positioning_
private
utility::vector1< utility::vector1< upstream::ScaffoldBuildPointCOP > > protocols::match::Matcher::per_constraint_build_points_
private
utility::vector1< utility::vector1< core::Size > > protocols::match::Matcher::per_cst_build_resids_
private
utility::vector1< core::Size > protocols::match::Matcher::pose_build_resids_
private
bool protocols::match::Matcher::read_gridlig_file_
private
utility::vector1< core::id::AtomID > protocols::match::Matcher::relevant_downstream_atoms_
private
utility::vector1< downstream::DownstreamAlgorithmOP > protocols::match::Matcher::representative_downstream_algorithm_
private
bool protocols::match::Matcher::same_build_resids_for_all_csts_
private
utility::vector1< upstream::UpstreamBuilderOP > protocols::match::Matcher::upstream_builders_
private
core::pose::PoseOP protocols::match::Matcher::upstream_pose_
private
std::list< std::pair< core::Size, Real > > protocols::match::Matcher::upstream_resids_and_radii_defining_active_site_
private
bool protocols::match::Matcher::use_input_sc_
private

The documentation for this class was generated from the following files: