 |
Rosetta Core
2014.35
|
|
Rosetta Core
2014.35
|
#include <ShortestPathInFoldTree.hh>
Public Types | |
| typedef utility::vector1< Edge > | EdgeList |
Public Member Functions | |
| virtual | ~ShortestPathInFoldTree () |
| Automatically generated virtual destructor for class deriving directly from ReferenceCount. More... | |
| ShortestPathInFoldTree (core::kinematics::FoldTree const &f) | |
| cs-tor, parses fold-tree and caches important distances: memory N^2+M*5 N: 2 x number of jumps M: number of residues More... | |
| Size | dist (Size pos1, Size pos2) const |
| returns the shortest distance of two residues going along Fold-Tree edges. More... | |
| Size | max_dist () const |
| returns the shortest distance for the two residues that are furthest apart More... | |
Private Member Functions | |
| void | build_peptide_table (core::kinematics::FoldTree const &f) |
| build table that gives for each residue the distance to the next jump(s) (1 or 2) More... | |
| void | build_jumpres_distmap (core::kinematics::FoldTree const &f) |
| build N^2 table of distances between jump-residues More... | |
| int | get_jump (Size seqpos) const |
| if seqpos is a jump_res resturn its internal number More... | |
| void | compute_dist_map (core::kinematics::FoldTree const &) |
| helper of build_jumpres_distmap More... | |
| void | init_dist_map (EdgeList const &) |
Private Attributes | |
| std::map< Size, Size > | jump_res_ |
| private data =============================== More... | |
| ObjexxFCL::FArray2D_int | node_dist_ |
| 2D array for distances between each pair of jump_residues More... | |
| ObjexxFCL::FArray2D_int | res2jumps_ |
| 1D array for distances of residue j to each of max 2 jump_residues that are on the same peptide edge in the fold-tree –> for each residue 1+2x2 entries. < edgenr > <jump1> <dist1> <jump2> <dist2> jump1 upstream jump_residue (internal numbering) jump2 downstream jump-residues no up/downstream jumps –> -1 More... | |
| Size | nres_ |
| for error checking what is nres_ in the fold-tree More... | |
| bool | simple_fold_tree_ |
| if fold-tree is simple (no jumps) don't compute anything. More... | |
| Size | max_dist_ |
| the furthest distance a query to dist() can return More... | |
|
virtual |
Automatically generated virtual destructor for class deriving directly from ReferenceCount.
Auto-generated virtual destructor
| core::kinematics::ShortestPathInFoldTree::ShortestPathInFoldTree | ( | core::kinematics::FoldTree const & | f | ) |
cs-tor, parses fold-tree and caches important distances: memory N^2+M*5 N: 2 x number of jumps M: number of residues
cs-tor
References build_jumpres_distmap(), build_peptide_table(), max_dist_, nres, nres_, core::kinematics::FoldTree::num_jump(), and simple_fold_tree_.
|
private |
build N^2 table of distances between jump-residues
the core of the distance cache is build here: node_dist_ a 2D array that knows distances for each pair of jump-residues i.e., a 10 100 1 / 100 120 -1 / 120 150 2 – fold-tree would have jump_residues 10, 100, 120 and 150. distances would be 10, 100 1 120 150 1 100 150 21 .... for the jump_residues we use internal numbering, each seqpos that is a jump-res in one or more jumps will get a individual number, starting at 1 and counting continously. thus the distance of jump_res-pair i,j is found as node_dist(i,j)
first we go through the fold-tree to find all jump_residues, and build the map: jump_res_ to keep track between mapping "seqpos<-->internal_numbering"
then assign distance 1 to each pair of jump_residues connected by a jump and using Warshall algorithm to build up full distance matrix diagonal is distance 0
References compute_dist_map(), get_jump(), init_dist_map(), core::kinematics::FoldTree::jump_edge(), jump_res_, core::kinematics::FoldTree::num_jump(), core::kinematics::FoldTree::root(), start, core::kinematics::Edge::start(), core::kinematics::Edge::stop(), and core::kinematics::tr.
Referenced by ShortestPathInFoldTree().
|
private |
build table that gives for each residue the distance to the next jump(s) (1 or 2)
build table that gives for each residue the distance to upstream and downstream jump-residues (if available)
format: <edge_nr> <jump1> <dist1> <jump2> <dist2> edge_nr is a unique number that identifes peptide-edges jump1 and jump2 refers to our internally-numbered jump-residues (entries in node_dist_ ) dist – distance in sequence to the respective jump-residues
References core::kinematics::FoldTree::begin(), dist(), core::kinematics::FoldTree::end(), get_jump(), max_dist_, core::kinematics::FoldTree::nres(), and res2jumps_.
Referenced by ShortestPathInFoldTree().
|
private |
helper of build_jumpres_distmap
References core::kinematics::FoldTree::begin(), core::kinematics::FoldTree::end(), jump_res_, and node_dist_.
Referenced by build_jumpres_distmap().
returns the shortest distance of two residues going along Fold-Tree edges.
distance between two residues with the help of our pre-computed data this only requires comparison of 4 possible pathways: go via upstream/downstream jump-residue for pos1/pos2
References node_dist_, nres_, res2jumps_, and simple_fold_tree_.
Referenced by build_peptide_table(), core::scoring::constraints::AtomPairConstraint::effective_sequence_separation(), and core::scoring::constraints::AmbiguousNMRDistanceConstraint::effective_sequence_separation().
if seqpos is a jump_res resturn its internal number
References jump_res_.
Referenced by build_jumpres_distmap(), and build_peptide_table().
|
private |
initialize dist map with dist 1 for each pair of residues connected by jumps as stored in the EdgeList
References jump_res_, and node_dist_.
Referenced by build_jumpres_distmap().
|
inline |
returns the shortest distance for the two residues that are furthest apart
References max_dist_.
private data ===============================
map from pose-numbering to internal numbering –> jump_res are counted from 1...N first: pose-numbering, second internal number
Referenced by build_jumpres_distmap(), compute_dist_map(), get_jump(), and init_dist_map().
|
mutableprivate |
the furthest distance a query to dist() can return
Referenced by build_peptide_table(), max_dist(), and ShortestPathInFoldTree().
|
private |
2D array for distances between each pair of jump_residues
Referenced by compute_dist_map(), dist(), and init_dist_map().
|
private |
for error checking what is nres_ in the fold-tree
Referenced by dist(), and ShortestPathInFoldTree().
|
private |
1D array for distances of residue j to each of max 2 jump_residues that are on the same peptide edge in the fold-tree –> for each residue 1+2x2 entries. < edgenr > <jump1> <dist1> <jump2> <dist2> jump1 upstream jump_residue (internal numbering) jump2 downstream jump-residues no up/downstream jumps –> -1
Referenced by build_peptide_table(), and dist().
|
private |
if fold-tree is simple (no jumps) don't compute anything.
Referenced by dist(), and ShortestPathInFoldTree().
1.8.7